fabiocaccamo /
python-benedict
| Total Complexity | 20 |
| Total Lines | 496 |
| Duplicated Lines | 0 % |
| Changes | 0 | ||
| 1 | # -*- coding: utf-8 -*- |
||
| 2 | |||
| 3 | from benedict.dicts import UtilityDict |
||
| 4 | from datetime import datetime |
||
| 5 | from decimal import Decimal |
||
| 6 | |||
| 7 | import unittest |
||
| 8 | |||
| 9 | |||
| 10 | class UtilityDictTestCase(unittest.TestCase): |
||
| 11 | |||
| 12 | def test_clean(self): |
||
| 13 | d = { |
||
| 14 | 'a': {}, |
||
| 15 | 'b': { 'x': 1 }, |
||
| 16 | 'c': [], |
||
| 17 | 'd': [0, 1], |
||
| 18 | 'e': 0.0, |
||
| 19 | 'f': '', |
||
| 20 | 'g': None, |
||
| 21 | 'h': '0' |
||
| 22 | } |
||
| 23 | |||
| 24 | b = UtilityDict(d) |
||
| 25 | b.clean() |
||
| 26 | r = { |
||
| 27 | 'b': { 'x': 1 }, |
||
| 28 | 'd': [0, 1], |
||
| 29 | 'e': 0.0, |
||
| 30 | 'h': '0', |
||
| 31 | } |
||
| 32 | self.assertEqual(b, r) |
||
| 33 | |||
| 34 | b = UtilityDict(d) |
||
| 35 | b.clean(dicts=False) |
||
| 36 | r = { |
||
| 37 | 'a': {}, |
||
| 38 | 'b': { 'x': 1 }, |
||
| 39 | 'd': [0, 1], |
||
| 40 | 'e': 0.0, |
||
| 41 | 'h': '0' |
||
| 42 | } |
||
| 43 | self.assertEqual(b, r) |
||
| 44 | |||
| 45 | b = UtilityDict(d) |
||
| 46 | b.clean(lists=False) |
||
| 47 | r = { |
||
| 48 | 'b': { 'x': 1 }, |
||
| 49 | 'c': [], |
||
| 50 | 'd': [0, 1], |
||
| 51 | 'e': 0.0, |
||
| 52 | 'h': '0' |
||
| 53 | } |
||
| 54 | self.assertEqual(b, r) |
||
| 55 | |||
| 56 | b = UtilityDict(d) |
||
| 57 | b.clean(strings=False) |
||
| 58 | r = { |
||
| 59 | 'b': { 'x': 1 }, |
||
| 60 | 'd': [0, 1], |
||
| 61 | 'e': 0.0, |
||
| 62 | 'f': '', |
||
| 63 | 'h': '0', |
||
| 64 | } |
||
| 65 | self.assertEqual(b, r) |
||
| 66 | |||
| 67 | def test_clone(self): |
||
| 68 | d = { |
||
| 69 | 'a': { |
||
| 70 | 'b': { |
||
| 71 | 'c': 1 |
||
| 72 | } |
||
| 73 | } |
||
| 74 | } |
||
| 75 | b = UtilityDict(d) |
||
| 76 | c = b.clone() |
||
| 77 | self.assertEqual(b, c) |
||
| 78 | self.assertFalse(c is b) |
||
| 79 | c['a']['b']['c'] = 2 |
||
| 80 | self.assertEqual(b['a']['b']['c'], 1) |
||
| 81 | self.assertEqual(c['a']['b']['c'], 2) |
||
| 82 | |||
| 83 | def test_deepcopy(self): |
||
| 84 | d = { |
||
| 85 | 'a': { |
||
| 86 | 'b': { |
||
| 87 | 'c': 1 |
||
| 88 | } |
||
| 89 | } |
||
| 90 | } |
||
| 91 | b = UtilityDict(d) |
||
| 92 | c = b.deepcopy() |
||
| 93 | self.assertEqual(b, c) |
||
| 94 | self.assertFalse(c is b) |
||
| 95 | c['a']['b']['c'] = 2 |
||
| 96 | self.assertEqual(b['a']['b']['c'], 1) |
||
| 97 | self.assertEqual(c['a']['b']['c'], 2) |
||
| 98 | |||
| 99 | def test_deepupdate_with_single_dict(self): |
||
| 100 | d = { |
||
| 101 | 'a': 1, |
||
| 102 | 'b': 1, |
||
| 103 | } |
||
| 104 | a = { |
||
| 105 | 'b': 2, |
||
| 106 | 'c': 3, |
||
| 107 | } |
||
| 108 | d = UtilityDict(d) |
||
| 109 | d.deepupdate(a) |
||
| 110 | r = { |
||
| 111 | 'a': 1, |
||
| 112 | 'b': 2, |
||
| 113 | 'c': 3, |
||
| 114 | } |
||
| 115 | self.assertEqual(d, r) |
||
| 116 | |||
| 117 | def test_deepupdate_with_multiple_dicts(self): |
||
| 118 | d = { |
||
| 119 | 'a': 1, |
||
| 120 | 'b': 1, |
||
| 121 | } |
||
| 122 | a = { |
||
| 123 | 'b': 2, |
||
| 124 | 'c': 3, |
||
| 125 | 'd': 3, |
||
| 126 | } |
||
| 127 | b = { |
||
| 128 | 'd': 5, |
||
| 129 | 'e': 5, |
||
| 130 | } |
||
| 131 | c = { |
||
| 132 | 'd': 4, |
||
| 133 | 'f': 6, |
||
| 134 | } |
||
| 135 | d = UtilityDict(d) |
||
| 136 | d.deepupdate(a, b, c) |
||
| 137 | r = { |
||
| 138 | 'a': 1, |
||
| 139 | 'b': 2, |
||
| 140 | 'c': 3, |
||
| 141 | 'd': 4, |
||
| 142 | 'e': 5, |
||
| 143 | 'f': 6, |
||
| 144 | } |
||
| 145 | self.assertEqual(d, r) |
||
| 146 | |||
| 147 | def test_deepupdate(self): |
||
| 148 | d = { |
||
| 149 | 'a': 1, |
||
| 150 | 'b': { |
||
| 151 | 'c': { |
||
| 152 | 'x': 2, |
||
| 153 | 'y': 3, |
||
| 154 | }, |
||
| 155 | 'd': { |
||
| 156 | 'x': 4, |
||
| 157 | 'y': 5, |
||
| 158 | }, |
||
| 159 | 'e': { |
||
| 160 | 'x': 6, |
||
| 161 | 'y': 7, |
||
| 162 | }, |
||
| 163 | }, |
||
| 164 | } |
||
| 165 | a = { |
||
| 166 | 'a': 0, |
||
| 167 | 'b': { |
||
| 168 | 'c': 1, |
||
| 169 | 'd': { |
||
| 170 | 'y': 1, |
||
| 171 | 'z': 2, |
||
| 172 | }, |
||
| 173 | 'e': { |
||
| 174 | 'f': { |
||
| 175 | 'x': 2, |
||
| 176 | 'y': 3, |
||
| 177 | }, |
||
| 178 | 'g': { |
||
| 179 | 'x': 4, |
||
| 180 | 'y': 5, |
||
| 181 | }, |
||
| 182 | }, |
||
| 183 | }, |
||
| 184 | } |
||
| 185 | d = UtilityDict(d) |
||
| 186 | d.deepupdate(a) |
||
| 187 | r = { |
||
| 188 | 'a': 0, |
||
| 189 | 'b': { |
||
| 190 | 'c': 1, |
||
| 191 | 'd': { |
||
| 192 | 'x': 4, |
||
| 193 | 'y': 1, |
||
| 194 | 'z': 2, |
||
| 195 | }, |
||
| 196 | 'e': { |
||
| 197 | 'f': { |
||
| 198 | 'x': 2, |
||
| 199 | 'y': 3, |
||
| 200 | }, |
||
| 201 | 'g': { |
||
| 202 | 'x': 4, |
||
| 203 | 'y': 5, |
||
| 204 | }, |
||
| 205 | 'x': 6, |
||
| 206 | 'y': 7, |
||
| 207 | }, |
||
| 208 | }, |
||
| 209 | } |
||
| 210 | self.assertEqual(d, r) |
||
| 211 | |||
| 212 | def test_dump(self): |
||
| 213 | d = { |
||
| 214 | 'a': { |
||
| 215 | 'b': { |
||
| 216 | 'c': 1 |
||
| 217 | } |
||
| 218 | } |
||
| 219 | } |
||
| 220 | b = UtilityDict(d) |
||
| 221 | expected_output = """{ |
||
| 222 | "a": { |
||
| 223 | "b": { |
||
| 224 | "c": 1 |
||
| 225 | } |
||
| 226 | } |
||
| 227 | }""" |
||
| 228 | output = UtilityDict.dump(b) |
||
| 229 | self.assertEqual(output, expected_output) |
||
| 230 | output = b.dump() |
||
| 231 | self.assertEqual(output, expected_output) |
||
| 232 | |||
| 233 | def test_dump_with_datetime(self): |
||
| 234 | d = { |
||
| 235 | 'datetime': datetime(2019, 6, 11), |
||
| 236 | } |
||
| 237 | b = UtilityDict(d) |
||
| 238 | expected_output = """{ |
||
| 239 | "datetime": "2019-06-11 00:00:00" |
||
| 240 | }""" |
||
| 241 | output = b.dump() |
||
| 242 | self.assertEqual(output, expected_output) |
||
| 243 | |||
| 244 | def test_dump_with_decimal(self): |
||
| 245 | d = { |
||
| 246 | 'decimal': Decimal('1.75'), |
||
| 247 | } |
||
| 248 | b = UtilityDict(d) |
||
| 249 | expected_output = """{ |
||
| 250 | "decimal": "1.75" |
||
| 251 | }""" |
||
| 252 | output = b.dump() |
||
| 253 | self.assertEqual(output, expected_output) |
||
| 254 | |||
| 255 | def test_filter(self): |
||
| 256 | d = { |
||
| 257 | 'a': 1, |
||
| 258 | 'b': 2, |
||
| 259 | 'c': '4', |
||
| 260 | 'e': '5', |
||
| 261 | 'f': 6, |
||
| 262 | 'g': 7, |
||
| 263 | } |
||
| 264 | b = UtilityDict(d) |
||
| 265 | with self.assertRaises(ValueError): |
||
| 266 | f = b.filter(True) |
||
| 267 | f = b.filter(lambda key, val: isinstance(val, int)) |
||
| 268 | r = { |
||
| 269 | 'a': 1, |
||
| 270 | 'b': 2, |
||
| 271 | 'f': 6, |
||
| 272 | 'g': 7, |
||
| 273 | } |
||
| 274 | self.assertEqual(f, r) |
||
| 275 | self.assertFalse(b is f) |
||
| 276 | |||
| 277 | def test_flatten(self): |
||
| 278 | d = { |
||
| 279 | 'a': 1, |
||
| 280 | 'b': 2, |
||
| 281 | 'c': { |
||
| 282 | 'd': { |
||
| 283 | 'e': 3, |
||
| 284 | 'f': 4, |
||
| 285 | 'g': { |
||
| 286 | 'h': 5, |
||
| 287 | } |
||
| 288 | } |
||
| 289 | }, |
||
| 290 | } |
||
| 291 | b = UtilityDict(d) |
||
| 292 | f = b.flatten() |
||
| 293 | r = { |
||
| 294 | 'a': 1, |
||
| 295 | 'b': 2, |
||
| 296 | 'c_d_e': 3, |
||
| 297 | 'c_d_f': 4, |
||
| 298 | 'c_d_g_h': 5, |
||
| 299 | } |
||
| 300 | self.assertEqual(f, r) |
||
| 301 | self.assertFalse(b is f) |
||
| 302 | |||
| 303 | def test_flatten_with_custom_separator(self): |
||
| 304 | d = { |
||
| 305 | 'a': 1, |
||
| 306 | 'b': 2, |
||
| 307 | 'c': { |
||
| 308 | 'd': { |
||
| 309 | 'e': 3, |
||
| 310 | 'f': 4, |
||
| 311 | 'g': { |
||
| 312 | 'h': 5, |
||
| 313 | } |
||
| 314 | } |
||
| 315 | }, |
||
| 316 | } |
||
| 317 | b = UtilityDict(d) |
||
| 318 | f = b.flatten(separator='|') |
||
| 319 | r = { |
||
| 320 | 'a': 1, |
||
| 321 | 'b': 2, |
||
| 322 | 'c|d|e': 3, |
||
| 323 | 'c|d|f': 4, |
||
| 324 | 'c|d|g|h': 5, |
||
| 325 | } |
||
| 326 | self.assertEqual(f, r) |
||
| 327 | self.assertFalse(b is f) |
||
| 328 | |||
| 329 | def test_flatten_with_key_conflict(self): |
||
| 330 | d = { |
||
| 331 | 'a': 1, |
||
| 332 | 'b': 2, |
||
| 333 | 'c_d': 4, |
||
| 334 | 'c': { |
||
| 335 | 'd': 3, |
||
| 336 | }, |
||
| 337 | } |
||
| 338 | b = UtilityDict(d) |
||
| 339 | f = b.flatten() |
||
| 340 | r = { |
||
| 341 | 'a': 1, |
||
| 342 | 'b': 2, |
||
| 343 | 'c_d': 4, |
||
| 344 | } |
||
| 345 | self.assertEqual(f, r) |
||
| 346 | self.assertFalse(b is f) |
||
| 347 | |||
| 348 | def test_merge_with_single_dict(self): |
||
| 349 | d = { |
||
| 350 | 'a': 1, |
||
| 351 | 'b': 1, |
||
| 352 | } |
||
| 353 | a = { |
||
| 354 | 'b': 2, |
||
| 355 | 'c': 3, |
||
| 356 | } |
||
| 357 | d = UtilityDict(d) |
||
| 358 | d.merge(a) |
||
| 359 | r = { |
||
| 360 | 'a': 1, |
||
| 361 | 'b': 2, |
||
| 362 | 'c': 3, |
||
| 363 | } |
||
| 364 | self.assertEqual(d, r) |
||
| 365 | |||
| 366 | def test_merge_with_multiple_dicts(self): |
||
| 367 | d = { |
||
| 368 | 'a': 1, |
||
| 369 | 'b': 1, |
||
| 370 | } |
||
| 371 | a = { |
||
| 372 | 'b': 2, |
||
| 373 | 'c': 3, |
||
| 374 | 'd': 3, |
||
| 375 | } |
||
| 376 | b = { |
||
| 377 | 'd': 5, |
||
| 378 | 'e': 5, |
||
| 379 | } |
||
| 380 | c = { |
||
| 381 | 'd': 4, |
||
| 382 | 'f': 6, |
||
| 383 | } |
||
| 384 | d = UtilityDict(d) |
||
| 385 | d.merge(a, b, c) |
||
| 386 | r = { |
||
| 387 | 'a': 1, |
||
| 388 | 'b': 2, |
||
| 389 | 'c': 3, |
||
| 390 | 'd': 4, |
||
| 391 | 'e': 5, |
||
| 392 | 'f': 6, |
||
| 393 | } |
||
| 394 | self.assertEqual(d, r) |
||
| 395 | |||
| 396 | def test_merge(self): |
||
| 397 | d = { |
||
| 398 | 'a': 1, |
||
| 399 | 'b': { |
||
| 400 | 'c': { |
||
| 401 | 'x': 2, |
||
| 402 | 'y': 3, |
||
| 403 | }, |
||
| 404 | 'd': { |
||
| 405 | 'x': 4, |
||
| 406 | 'y': 5, |
||
| 407 | }, |
||
| 408 | 'e': { |
||
| 409 | 'x': 6, |
||
| 410 | 'y': 7, |
||
| 411 | }, |
||
| 412 | }, |
||
| 413 | } |
||
| 414 | a = { |
||
| 415 | 'a': 0, |
||
| 416 | 'b': { |
||
| 417 | 'c': 1, |
||
| 418 | 'd': { |
||
| 419 | 'y': 1, |
||
| 420 | 'z': 2, |
||
| 421 | }, |
||
| 422 | 'e': { |
||
| 423 | 'f': { |
||
| 424 | 'x': 2, |
||
| 425 | 'y': 3, |
||
| 426 | }, |
||
| 427 | 'g': { |
||
| 428 | 'x': 4, |
||
| 429 | 'y': 5, |
||
| 430 | }, |
||
| 431 | }, |
||
| 432 | }, |
||
| 433 | } |
||
| 434 | d = UtilityDict(d) |
||
| 435 | d.merge(a) |
||
| 436 | r = { |
||
| 437 | 'a': 0, |
||
| 438 | 'b': { |
||
| 439 | 'c': 1, |
||
| 440 | 'd': { |
||
| 441 | 'x': 4, |
||
| 442 | 'y': 1, |
||
| 443 | 'z': 2, |
||
| 444 | }, |
||
| 445 | 'e': { |
||
| 446 | 'f': { |
||
| 447 | 'x': 2, |
||
| 448 | 'y': 3, |
||
| 449 | }, |
||
| 450 | 'g': { |
||
| 451 | 'x': 4, |
||
| 452 | 'y': 5, |
||
| 453 | }, |
||
| 454 | 'x': 6, |
||
| 455 | 'y': 7, |
||
| 456 | }, |
||
| 457 | }, |
||
| 458 | } |
||
| 459 | self.assertEqual(d, r) |
||
| 460 | |||
| 461 | def test_remove(self): |
||
| 462 | d = { |
||
| 463 | 'a': 1, |
||
| 464 | 'b': 2, |
||
| 465 | 'c': '4', |
||
| 466 | 'e': '5', |
||
| 467 | 'f': 6, |
||
| 468 | 'g': 7, |
||
| 469 | } |
||
| 470 | b = UtilityDict(d) |
||
| 471 | b.remove(['c', 'e', 'f', 'g', 'x', 'y', 'z']) |
||
| 472 | r = { |
||
| 473 | 'a': 1, |
||
| 474 | 'b': 2, |
||
| 475 | } |
||
| 476 | self.assertEqual(b, r) |
||
| 477 | |||
| 478 | def test_subset(self): |
||
| 479 | d = { |
||
| 480 | 'a': 1, |
||
| 481 | 'b': 2, |
||
| 482 | 'c': '4', |
||
| 483 | 'e': '5', |
||
| 484 | 'f': 6, |
||
| 485 | 'g': 7, |
||
| 486 | } |
||
| 487 | b = UtilityDict(d) |
||
| 488 | f = b.subset(['c', 'f', 'x']) |
||
| 489 | r = { |
||
| 490 | 'c': '4', |
||
| 491 | 'f': 6, |
||
| 492 | 'x': None, |
||
| 493 | } |
||
| 494 | self.assertEqual(f, r) |
||
| 495 | self.assertFalse(f is b) |
||
| 496 |
