tests.test_benedict.BenedictTestCase.test_flatten() - Code Metrics - Inspection of "Improved tests coverage." - fabiocaccamo/python-benedict - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( df1182...461010 )

by Fabio

created 2019-09-12 15:14 UTC

BenedictTestCase.test_flatten() A

↳ Parent: tests.test_benedict

Complexity

Conditions

Size

Total Lines	25
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	20
dl	0
loc	25
rs	9.4
c	0
b	0
f	0
cc	1
nop	1

# -*- coding: utf-8 -*-

from benedict import benedict
from datetime import datetime
from decimal import Decimal

import unittest


class BenedictTestCase(unittest.TestCase):

    def test_cast(self):
        d = {
            'a': 1,
        }
        b = benedict.cast(d)
        self.assertEqual(d, b)
        self.assertFalse(b is d)
        self.assertTrue(isinstance(b, benedict))
        v = [0, 1, 2, 3]
        b = benedict.cast(v)
        self.assertEqual(v, b)
        self.assertTrue(b is v)
        self.assertFalse(isinstance(b, benedict))

    def test_copy(self):
        d = {
            'a': {
                'b': {
                    'c': 1
                }
            }
        }
        b = benedict(d)
        c = b.copy()
        self.assertEqual(type(b), type(c))
        self.assertEqual(b, c)
        self.assertFalse(c is b)
        c['a.b.c'] = 2
        self.assertEqual(b.get('a.b.c'), 2)
        self.assertEqual(c.get('a.b.c'), 2)

    def test_deepcopy(self):
        d = {
            'a': {
                'b': {
                    'c': 1
                }
            }
        }
        b = benedict(d)
        c = b.deepcopy()
        self.assertEqual(type(b), type(c))
        self.assertEqual(b, c)
        self.assertFalse(c is b)
        c['a.b.c'] = 2
        self.assertEqual(b.get('a.b.c'), 1)
        self.assertEqual(c.get('a.b.c'), 2)

    def test_dump(self):
        d = {
            'a': {
                'b': {
                    'c': 1
                }
            }
        }
        b = benedict(d)
        expected_output = """{
    "a": {
        "b": {
            "c": 1
        }
    }
}"""
        output = benedict.dump(b)
        self.assertEqual(output, expected_output)
        output = b.dump()
        self.assertEqual(output, expected_output)

    def test_dump_with_datetime(self):
        d = {
            'datetime': datetime(2019, 6, 11),
        }
        b = benedict(d)
        expected_output = """{
    "datetime": "2019-06-11 00:00:00"
}"""
        output = b.dump()
        self.assertEqual(output, expected_output)

    def test_dump_with_decimal(self):
        d = {
            'decimal': Decimal('1.75'),
        }
        b = benedict(d)
        expected_output = """{
    "decimal": "1.75"
}"""
        output = b.dump()
        self.assertEqual(output, expected_output)

    def test_filter(self):
        d = {
            'a': {
                'ok': 'yes',
            },
            'b': {
                'ok': 'no',
            },
            'c': {
                'ok': 'yes',
            },
            'e': {
                'ok': 'no',
            },
            'f': {
                'ok': 'yes',
            },
            'g': {
                'ok': 'no',
            },
        }
        b = benedict(d)
        f = b.filter(lambda key, val: val.get_bool('ok'))
        r = {
            'a': {
                'ok': 'yes',
            },
            'c': {
                'ok': 'yes',
            },
            'f': {
                'ok': 'yes',
            },
        }
        self.assertEqual(f, r)
        self.assertTrue(isinstance(f, benedict))

    def test_flatten(self):
        d = {
            'a': 1,
            'b': 2,
            'c': {
                'd': {
                    'e': 3,
                    'f': 4,
                    'g': {
                        'h': 5,
                    }
                }
            },
        }
        b = benedict(d)
        f = b.flatten()
        r = {
            'a': 1,
            'b': 2,
            'c_d_e': 3,
            'c_d_f': 4,
            'c_d_g_h': 5,
        }
        self.assertEqual(f, r)
        self.assertTrue(isinstance(f, benedict))

    def test_fromkeys(self):
        k = [
            'a',
            'a.b',
            'a.b.c',
            'a.b.d',
            'a.b.e',
            'x',
            'x.y',
            'x.z',
        ]
        b = benedict.fromkeys(k)
        r = {
            'x': {
                'y': None,
                'z': None,
            },
            'a': {
                'b': {
                    'c': None,
                    'd': None,
                    'e': None,
                },
            },
        }
        self.assertEqual(b, r)
        self.assertEqual(type(b), benedict)

    def test_fromkeys_with_value(self):
        k = [
            'a',
            'a.b',
            'a.b.c',
            'a.b.d',
            'a.b.e',
            'x',
            'x.y',
            'x.z',
        ]
        b = benedict.fromkeys(k, True)
        r = {
            'x': {
                'y': True,
                'z': True,
            },
            'a': {
                'b': {
                    'c': True,
                    'd': True,
                    'e': True,
                },
            },
        }
        self.assertEqual(b, r)
        self.assertEqual(type(b), benedict)

    def test_from_json(self):
        j = '{"a": 1, "b": 2, "c": 3}'
        # static method
        d = benedict.from_json(j)
        self.assertTrue(isinstance(d, benedict))
        self.assertEqual(d, { 'a': 1, 'b': 2, 'c': 3, })
        # constructor
        d = benedict(j)
        self.assertTrue(isinstance(d, benedict))
        self.assertEqual(d, { 'a': 1, 'b': 2, 'c': 3, })

    def test_get(self):
        d = {
            'a': 1,
            'b': {
                'c': 2,
                'd': {
                    'e': 3,
                }
            }
        }
        b = benedict(d)
        self.assertEqual(b.get('a'), 1)
        self.assertEqual(b.get('b.c'), 2)
        self.assertTrue(isinstance(b.get('b'), benedict))
        self.assertTrue(isinstance(b.get('b.d'), benedict))
        bb = b.get('b')
        self.assertTrue(isinstance(bb.get('d'), benedict))

    def test_get_item(self):
        d = {
            'a': 1,
            'b': {
                'c': 2,
                'd': {
                    'e': 3,
                }
            }
        }
        b = benedict(d)
        self.assertEqual(b['a'], 1)
        self.assertEqual(b['b.c'], 2)
        self.assertTrue(isinstance(b['b'], benedict))
        self.assertTrue(isinstance(b['b.d'], benedict))
        bb = b['b']
        self.assertTrue(isinstance(bb['d'], benedict))

    def test_get_dict(self):
        d = {
            'a': {'x': 1, 'y': 2},
            'b': {},
        }
        b = benedict(d)
        self.assertTrue(isinstance(b.get_dict('a'), benedict))
        self.assertEqual(b.get('a.x'), 1)

    def test_get_list(self):
        d = {
            'a': [
                {
                    'b': {
                        'c': 1,
                    }
                },
                {
                    'b': {
                        'c': 2,
                    }
                },
                {
                    'b': {
                        'c': 3,
                    }
                },
            ]
        }
        b = benedict(d)
        l = b.get_list('a')
        self.assertTrue(isinstance(l[0], benedict))
        self.assertTrue(isinstance(l[1], benedict))
        self.assertTrue(isinstance(l[2], benedict))
        self.assertEqual(l[0].get('b.c'), 1)
        self.assertEqual(l[1].get('b.c'), 2)
        self.assertEqual(l[2].get('b.c'), 3)

    def test_get_list_item(self):
        d = {
            'a': [
                {
                    'b': {
                        'c': 1,
                    }
                },
                {
                    'b': {
                        'c': 2,
                    }
                },
                {
                    'b': {
                        'c': 3,
                    }
                },
            ]
        }
        b = benedict(d)
        i = b.get_list_item('a', index=1)
        self.assertTrue(isinstance(i, benedict))
        self.assertEqual(i.get('b.c'), 2)

    def test_get_phonenumber(self):
        d = {
            'a': {
                'b': ' (0039) 3334445566 ',
                'c': '+393334445566  ',
                'd': '+39333444556677889900',
            }
        }
        r = {
            'e164': '+393334445566',
            'international': '+39 333 444 5566',
            'national': '333 444 5566'
        }
        b = benedict(d)

        p = b.get_phonenumber('a.b')
        self.assertEqual(p, r)
        self.assertTrue(isinstance(p, benedict))

        p = b.get_phonenumber('a.c')
        self.assertEqual(p, r)
        self.assertTrue(isinstance(p, benedict))

        p = b.get_phonenumber('a.d')
        self.assertEqual(p, {})
        self.assertTrue(isinstance(p, benedict))

    def test_pop(self):
        d = {
            'a': 1,
            'b': {
                'c': 2,
                'd': {
                    'e': 3,
                }
            }
        }
        b = benedict(d)
        self.assertEqual(b.pop('a'), 1)
        self.assertEqual(b.pop('b.c'), 2)
        self.assertTrue(isinstance(b.pop('b.d'), benedict))

    def test_remove(self):
        d = {
            'a': {
                'x': 1,
                'y': 1,
            },
            'b': {
                'x': 2,
                'y': 2,
            },
            'c': {
                'x': 3,
                'y': 3,
            },
            'd': {
                'x': 4,
                'y': 4,
            },
        }
        b = benedict(d)
        b.remove(['a.x', 'b.y', 'c.x', 'c.y', 'd'])
        r = {
            'a': {
                'y': 1
            },
            'b': {
                'x': 2
            },
            'c': {
            },
        }
        self.assertEqual(b, r)

    def test_setdefault(self):
        d = {
            'a': 1,
            'b': {
                'c': 2,
                'd': {
                    'e': 3,
                }
            }
        }
        b = benedict(d)
        self.assertTrue(isinstance(b.setdefault('b', 1), benedict))
        self.assertTrue(isinstance(b.setdefault('b.d', 1), benedict))

    def test_subset(self):
        d = {
            'x': {
                'a': 1,
                'aa': 1,
            },
            'y': {
                'b': 2,
                'bb': 2,
            },
            'z': {
                'c': 3,
                'cc': 3,
            },
        }
        b = benedict(d)
        f = b.subset(['x', 'y'])
        r = {
            'x': {
                'a': 1,
                'aa': 1,
            },
            'y': {
                'b': 2,
                'bb': 2,
            },
        }
        self.assertEqual(f, r)
        self.assertFalse(f is b)
        self.assertTrue(isinstance(f, benedict))
        self.assertEqual(f.get('x.a'), 1)
        self.assertEqual(f.get('x.aa'), 1)
        self.assertEqual(f.get('y.b'), 2)
        self.assertEqual(f.get('y.bb'), 2)
        # test with keypath
        f = b.subset(['x.a', 'y.b'])
        r = {
            'x': {
                'a': 1,
            },
            'y': {
                'b': 2,
            },
        }
        self.assertEqual(f, r)
        self.assertFalse(f is b)
        self.assertTrue(isinstance(f, benedict))
        self.assertEqual(f.get('x.a'), 1)
        self.assertEqual(f.get('y.b'), 2)


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

fabiocaccamo / python-benedict

Push — master ( df1182...461010 )

BenedictTestCase.test_flatten() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like