tests.test_utility_dict.UtilityDictTestCase.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

UtilityDictTestCase.test_flatten() A

↳ Parent: tests.test_utility_dict

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

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

fabiocaccamo / python-benedict

Push — master ( df1182...461010 )

UtilityDictTestCase.test_flatten() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like