tests.test_benedict.BenedictTestCase.test_subset() - Code Metrics - Inspection of "Updated version, README and CHANGELOG." - fabiocaccamo/python-benedict - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 929d80...68a360 )

by Fabio

created 2019-07-19 09:02 UTC

tests.test_benedict.BenedictTestCase.test_subset() B

↳ Parent: tests.test_benedict

Complexity

Conditions

Size

Total Lines	49
Code Lines	38

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	38
dl	0
loc	49
rs	8.968
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_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)

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

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

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

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

fabiocaccamo / python-benedict

Push — master ( 929d80...68a360 )

tests.test_benedict.BenedictTestCase.test_subset() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like