tests.test_benedict.BenedictTestCase.test_get_list() - Code Metrics - Inspection of "Added IODict with json support." - fabiocaccamo/python-benedict - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 68a360...546f3a )

by Fabio

created 2019-09-10 14:58 UTC

BenedictTestCase.test_get_list() A

↳ Parent: tests.test_benedict

Complexity

Conditions

Size

Total Lines	28
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	17
dl	0
loc	28
rs	9.55
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_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_fromkeys(self):
141			k = [
142			'a',
143			'a.b',
144			'a.b.c',
145			'a.b.d',
146			'a.b.e',
147			'x',
148			'x.y',
149			'x.z',
150			]
151			b = benedict.fromkeys(k)
152			r = {
153			'x': {
154			'y': None,
155			'z': None,
156			},
157			'a': {
158			'b': {
159			'c': None,
160			'd': None,
161			'e': None,
162			},
163			},
164			}
165			self.assertEqual(b, r)
166			self.assertEqual(type(b), benedict)
167
168			def test_fromkeys_with_value(self):
169			k = [
170			'a',
171			'a.b',
172			'a.b.c',
173			'a.b.d',
174			'a.b.e',
175			'x',
176			'x.y',
177			'x.z',
178			]
179			b = benedict.fromkeys(k, True)
180			r = {
181			'x': {
182			'y': True,
183			'z': True,
184			},
185			'a': {
186			'b': {
187			'c': True,
188			'd': True,
189			'e': True,
190			},
191			},
192			}
193			self.assertEqual(b, r)
194			self.assertEqual(type(b), benedict)
195
196			def test_from_json(self):
197			j = '{"a": 1, "b": 2, "c": 3}'
198			# static method
199			d = benedict.from_json(j)
200			self.assertTrue(isinstance(d, benedict))
201			self.assertEqual(d, { 'a': 1, 'b': 2, 'c': 3, })
202			# constructor
203			d = benedict(j)
204			self.assertTrue(isinstance(d, benedict))
205			self.assertEqual(d, { 'a': 1, 'b': 2, 'c': 3, })
206
207			def test_get(self):
208			d = {
209			'a': 1,
210			'b': {
211			'c': 2,
212			'd': {
213			'e': 3,
214			}
215			}
216			}
217			b = benedict(d)
218			self.assertEqual(b.get('a'), 1)
219			self.assertEqual(b.get('b.c'), 2)
220			self.assertTrue(isinstance(b.get('b'), benedict))
221			self.assertTrue(isinstance(b.get('b.d'), benedict))
222			bb = b.get('b')
223			self.assertTrue(isinstance(bb.get('d'), benedict))
224
225			def test_get_item(self):
226			d = {
227			'a': 1,
228			'b': {
229			'c': 2,
230			'd': {
231			'e': 3,
232			}
233			}
234			}
235			b = benedict(d)
236			self.assertEqual(b['a'], 1)
237			self.assertEqual(b['b.c'], 2)
238			self.assertTrue(isinstance(b['b'], benedict))
239			self.assertTrue(isinstance(b['b.d'], benedict))
240			bb = b['b']
241			self.assertTrue(isinstance(bb['d'], benedict))
242
243			def test_get_dict(self):
244			d = {
245			'a': {'x': 1, 'y': 2},
246			'b': {},
247			}
248			b = benedict(d)
249			self.assertTrue(isinstance(b.get_dict('a'), benedict))
250			self.assertEqual(b.get('a.x'), 1)
251
252			def test_get_list(self):
253			d = {
254			'a': [
255			{
256			'b': {
257			'c': 1,
258			}
259			},
260			{
261			'b': {
262			'c': 2,
263			}
264			},
265			{
266			'b': {
267			'c': 3,
268			}
269			},
270			]
271			}
272			b = benedict(d)
273			l = b.get_list('a')
274			self.assertTrue(isinstance(l[0], benedict))
275			self.assertTrue(isinstance(l[1], benedict))
276			self.assertTrue(isinstance(l[2], benedict))
277			self.assertEqual(l[0].get('b.c'), 1)
278			self.assertEqual(l[1].get('b.c'), 2)
279			self.assertEqual(l[2].get('b.c'), 3)
280
281			def test_get_list_item(self):
282			d = {
283			'a': [
284			{
285			'b': {
286			'c': 1,
287			}
288			},
289			{
290			'b': {
291			'c': 2,
292			}
293			},
294			{
295			'b': {
296			'c': 3,
297			}
298			},
299			]
300			}
301			b = benedict(d)
302			i = b.get_list_item('a', index=1)
303			self.assertTrue(isinstance(i, benedict))
304			self.assertEqual(i.get('b.c'), 2)
305
306			def test_get_phonenumber(self):
307			d = {
308			'a': {
309			'b': ' (0039) 3334445566 ',
310			'c': '+393334445566 ',
311			'd': '+39333444556677889900',
312			}
313			}
314			r = {
315			'e164': '+393334445566',
316			'international': '+39 333 444 5566',
317			'national': '333 444 5566'
318			}
319			b = benedict(d)
320
321			p = b.get_phonenumber('a.b')
322			self.assertEqual(p, r)
323			self.assertTrue(isinstance(p, benedict))
324
325			p = b.get_phonenumber('a.c')
326			self.assertEqual(p, r)
327			self.assertTrue(isinstance(p, benedict))
328
329			p = b.get_phonenumber('a.d')
330			self.assertEqual(p, {})
331			self.assertTrue(isinstance(p, benedict))
332
333			def test_pop(self):
334			d = {
335			'a': 1,
336			'b': {
337			'c': 2,
338			'd': {
339			'e': 3,
340			}
341			}
342			}
343			b = benedict(d)
344			self.assertEqual(b.pop('a'), 1)
345			self.assertEqual(b.pop('b.c'), 2)
346			self.assertTrue(isinstance(b.pop('b.d'), benedict))
347
348			def test_remove(self):
349			d = {
350			'a': {
351			'x': 1,
352			'y': 1,
353			},
354			'b': {
355			'x': 2,
356			'y': 2,
357			},
358			'c': {
359			'x': 3,
360			'y': 3,
361			},
362			'd': {
363			'x': 4,
364			'y': 4,
365			},
366			}
367			b = benedict(d)
368			b.remove(['a.x', 'b.y', 'c.x', 'c.y', 'd'])
369			r = {
370			'a': {
371			'y': 1
372			},
373			'b': {
374			'x': 2
375			},
376			'c': {
377			},
378			}
379			self.assertEqual(b, r)
380
381			def test_setdefault(self):
382			d = {
383			'a': 1,
384			'b': {
385			'c': 2,
386			'd': {
387			'e': 3,
388			}
389			}
390			}
391			b = benedict(d)
392			self.assertTrue(isinstance(b.setdefault('b', 1), benedict))
393			self.assertTrue(isinstance(b.setdefault('b.d', 1), benedict))
394
395			def test_subset(self):
396			d = {
397			'x': {
398			'a': 1,
399			'aa': 1,
400			},
401			'y': {
402			'b': 2,
403			'bb': 2,
404			},
405			'z': {
406			'c': 3,
407			'cc': 3,
408			},
409			}
410			b = benedict(d)
411			f = b.subset(['x', 'y'])
412			r = {
413			'x': {
414			'a': 1,
415			'aa': 1,
416			},
417			'y': {
418			'b': 2,
419			'bb': 2,
420			},
421			}
422			self.assertEqual(f, r)
423			self.assertFalse(f is b)
424			self.assertTrue(isinstance(f, benedict))
425			self.assertEqual(f.get('x.a'), 1)
426			self.assertEqual(f.get('x.aa'), 1)
427			self.assertEqual(f.get('y.b'), 2)
428			self.assertEqual(f.get('y.bb'), 2)
429			# test with keypath
430			f = b.subset(['x.a', 'y.b'])
431			r = {
432			'x': {
433			'a': 1,
434			},
435			'y': {
436			'b': 2,
437			},
438			}
439			self.assertEqual(f, r)
440			self.assertFalse(f is b)
441			self.assertTrue(isinstance(f, benedict))
442			self.assertEqual(f.get('x.a'), 1)
443			self.assertEqual(f.get('y.b'), 2)
444

fabiocaccamo / python-benedict

Push — master ( 68a360...546f3a )

BenedictTestCase.test_get_list() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like