tests.test_benedict.benedict_test_case.test_deepupdate() - Code Metrics - Inspection of "Create pythonpackage.yml" - fabiocaccamo/python-benedict - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (6e6000)

by Fabio

created 2019-11-15 10:56 UTC

tests.test_benedict.benedict_test_case.test_deepupdate() B

↳ Parent: Project

Complexity

Conditions

Size

Total Lines	64
Code Lines	47

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	47
dl	0
loc	64
rs	8.7345
c	0
b	0
f	0
cc	1
nop	1

How to fix Long Method

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 benedict_test_case(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			bd = benedict(d)
24			bd.clean()
25			r = {
26			'b': { 'x': 1 },
27			'd': [0, 1],
28			'e': 0.0,
29			'h': '0',
30			}
31			self.assertEqual(bd, r)
32
33			bd = benedict(d)
34			bd.clean(dicts=False)
35			r = {
36			'a': {},
37			'b': { 'x': 1 },
38			'd': [0, 1],
39			'e': 0.0,
40			'h': '0'
41			}
42			self.assertEqual(bd, r)
43
44			bd = benedict(d)
45			bd.clean(lists=False)
46			r = {
47			'b': { 'x': 1 },
48			'c': [],
49			'd': [0, 1],
50			'e': 0.0,
51			'h': '0'
52			}
53			self.assertEqual(bd, r)
54
55			bd = benedict(d)
56			bd.clean(strings=False)
57			r = {
58			'b': { 'x': 1 },
59			'd': [0, 1],
60			'e': 0.0,
61			'f': '',
62			'h': '0',
63			}
64			self.assertEqual(bd, r)
65
66			def test_clone(self):
67			d = {
68			'a': {
69			'b': {
70			'c': 1
71			}
72			}
73			}
74			b = benedict(d)
75			c = b.clone()
76			self.assertEqual(type(b), type(c))
77			self.assertTrue(isinstance(c, benedict))
78			self.assertEqual(b, c)
79			self.assertFalse(c is b)
80			c['a']['b']['c'] = 2
81			self.assertEqual(b['a']['b']['c'], 1)
82			self.assertEqual(c['a']['b']['c'], 2)
83
84			def test_copy(self):
85			d = {
86			'a': {
87			'b': {
88			'c': 1
89			}
90			}
91			}
92			b = benedict(d)
93			c = b.copy()
94			self.assertEqual(type(b), type(c))
95			self.assertTrue(isinstance(c, benedict))
96			self.assertEqual(b, c)
97			self.assertFalse(c is b)
98			c['a.b.c'] = 2
99			self.assertEqual(b.get('a.b.c'), 2)
100			self.assertEqual(c.get('a.b.c'), 2)
101
102			def test_deepcopy(self):
103			d = {
104			'a': {
105			'b': {
106			'c': 1
107			}
108			}
109			}
110			b = benedict(d)
111			c = b.deepcopy()
112			self.assertEqual(type(b), type(c))
113			self.assertEqual(b, c)
114			self.assertFalse(c is b)
115			c['a.b.c'] = 2
116			self.assertEqual(b.get('a.b.c'), 1)
117			self.assertEqual(c.get('a.b.c'), 2)
118
119			def test_deepupdate_with_single_dict(self):
120			d = {
121			'a': 1,
122			'b': 1,
123			}
124			a = {
125			'b': 2,
126			'c': 3,
127			}
128			bd = benedict(d)
129			bd.deepupdate(a)
130			r = {
131			'a': 1,
132			'b': 2,
133			'c': 3,
134			}
135			self.assertEqual(bd, r)
136
137			def test_deepupdate_with_multiple_dicts(self):
138			d = {
139			'a': 1,
140			'b': 1,
141			}
142			a = {
143			'b': 2,
144			'c': 3,
145			'd': 3,
146			}
147			b = {
148			'd': 5,
149			'e': 5,
150			}
151			c = {
152			'd': 4,
153			'f': 6,
154			}
155			bd = benedict(d)
156			bd.deepupdate(a, b, c)
157			r = {
158			'a': 1,
159			'b': 2,
160			'c': 3,
161			'd': 4,
162			'e': 5,
163			'f': 6,
164			}
165			self.assertEqual(bd, r)
166
167			def test_deepupdate(self):
168			d = {
169			'a': 1,
170			'b': {
171			'c': {
172			'x': 2,
173			'y': 3,
174			},
175			'd': {
176			'x': 4,
177			'y': 5,
178			},
179			'e': {
180			'x': 6,
181			'y': 7,
182			},
183			},
184			}
185			a = {
186			'a': 0,
187			'b': {
188			'c': 1,
189			'd': {
190			'y': 1,
191			'z': 2,
192			},
193			'e': {
194			'f': {
195			'x': 2,
196			'y': 3,
197			},
198			'g': {
199			'x': 4,
200			'y': 5,
201			},
202			},
203			},
204			}
205			bd = benedict(d)
206			bd.deepupdate(a)
207			r = {
208			'a': 0,
209			'b': {
210			'c': 1,
211			'd': {
212			'x': 4,
213			'y': 1,
214			'z': 2,
215			},
216			'e': {
217			'f': {
218			'x': 2,
219			'y': 3,
220			},
221			'g': {
222			'x': 4,
223			'y': 5,
224			},
225			'x': 6,
226			'y': 7,
227			},
228			},
229			}
230			self.assertEqual(bd, r)
231
232			def test_dump(self):
233			d = {
234			'a': {
235			'b': {
236			'c': 1
237			}
238			}
239			}
240			b = benedict(d)
241			expected_output = """{
242			"a": {
243			"b": {
244			"c": 1
245			}
246			}
247			}"""
248			output = benedict.dump(b)
249			self.assertEqual(output, expected_output)
250			output = b.dump()
251			self.assertEqual(output, expected_output)
252
253			def test_dump_with_datetime(self):
254			d = {
255			'datetime': datetime(2019, 6, 11),
256			}
257			b = benedict(d)
258			expected_output = """{
259			"datetime": "2019-06-11 00:00:00"
260			}"""
261			output = b.dump()
262			self.assertEqual(output, expected_output)
263
264			def test_dump_with_decimal(self):
265			d = {
266			'decimal': Decimal('1.75'),
267			}
268			b = benedict(d)
269			expected_output = """{
270			"decimal": "1.75"
271			}"""
272			output = b.dump()
273			self.assertEqual(output, expected_output)
274
275			def test_filter(self):
276			d = {
277			'a': 1,
278			'b': 2,
279			'c': '4',
280			'e': '5',
281			'f': 6,
282			'g': 7,
283			}
284			b = benedict(d)
285			with self.assertRaises(ValueError):
286			f = b.filter(True)
287			f = b.filter(lambda key, val: isinstance(val, int))
288			r = {
289			'a': 1,
290			'b': 2,
291			'f': 6,
292			'g': 7,
293			}
294			self.assertEqual(type(b), type(f))
295			self.assertTrue(isinstance(f, benedict))
296			self.assertEqual(f, r)
297			self.assertFalse(b is f)
298
299			def test_filter_with_parse(self):
300			d = {
301			'a': {
302			'ok': 'yes',
303			},
304			'b': {
305			'ok': 'no',
306			},
307			'c': {
308			'ok': 'yes',
309			},
310			'e': {
311			'ok': 'no',
312			},
313			'f': {
314			'ok': 'yes',
315			},
316			'g': {
317			'ok': 'no',
318			},
319			}
320			b = benedict(d)
321			f = b.filter(lambda key, val: benedict(val).get_bool('ok'))
322			r = {
323			'a': {
324			'ok': 'yes',
325			},
326			'c': {
327			'ok': 'yes',
328			},
329			'f': {
330			'ok': 'yes',
331			},
332			}
333			self.assertEqual(f, r)
334			self.assertTrue(isinstance(f, benedict))
335
336			def test_flatten(self):
337			d = {
338			'a': 1,
339			'b': 2,
340			'c': {
341			'd': {
342			'e': 3,
343			'f': 4,
344			'g': {
345			'h': 5,
346			}
347			}
348			},
349			}
350			b = benedict(d)
351			f = b.flatten()
352			r = {
353			'a': 1,
354			'b': 2,
355			'c_d_e': 3,
356			'c_d_f': 4,
357			'c_d_g_h': 5,
358			}
359			self.assertEqual(f, r)
360			self.assertEqual(type(b), type(f))
361			self.assertTrue(isinstance(f, benedict))
362
363			def test_flatten_with_custom_separator(self):
364			d = {
365			'a': 1,
366			'b': 2,
367			'c': {
368			'd': {
369			'e': 3,
370			'f': 4,
371			'g': {
372			'h': 5,
373			}
374			}
375			},
376			}
377			b = benedict(d)
378			f = b.flatten(separator='\|')
379			r = {
380			'a': 1,
381			'b': 2,
382			'c\|d\|e': 3,
383			'c\|d\|f': 4,
384			'c\|d\|g\|h': 5,
385			}
386			self.assertEqual(f, r)
387			self.assertFalse(b is f)
388
389			def test_flatten_with_key_conflict(self):
390			d = {
391			'a': 1,
392			'b': 2,
393			'c_d': 4,
394			'c': {
395			'd': 3,
396			},
397			}
398			b = benedict(d)
399			f = b.flatten()
400			r = {
401			'a': 1,
402			'b': 2,
403			'c_d': 4,
404			}
405			self.assertEqual(f, r)
406			self.assertFalse(b is f)
407
408			def test_fromkeys(self):
409			k = [
410			'a',
411			'a.b',
412			'a.b.c',
413			'a.b.d',
414			'a.b.e',
415			'x',
416			'x.y',
417			'x.z',
418			]
419			b = benedict.fromkeys(k)
420			r = {
421			'x': {
422			'y': None,
423			'z': None,
424			},
425			'a': {
426			'b': {
427			'c': None,
428			'd': None,
429			'e': None,
430			},
431			},
432			}
433			self.assertEqual(b, r)
434			self.assertEqual(type(b), benedict)
435
436			def test_fromkeys_with_value(self):
437			k = [
438			'a',
439			'a.b',
440			'a.b.c',
441			'a.b.d',
442			'a.b.e',
443			'x',
444			'x.y',
445			'x.z',
446			]
447			b = benedict.fromkeys(k, True)
448			r = {
449			'x': {
450			'y': True,
451			'z': True,
452			},
453			'a': {
454			'b': {
455			'c': True,
456			'd': True,
457			'e': True,
458			},
459			},
460			}
461			self.assertEqual(b, r)
462			self.assertEqual(type(b), benedict)
463
464			def test_from_base64(self):
465			j = 'eyJhIjogMSwgImIiOiAyLCAiYyI6IDN9'
466			# static method
467			d = benedict.from_base64(j)
468			self.assertTrue(isinstance(d, benedict))
469			self.assertEqual(d, { 'a': 1, 'b': 2, 'c': 3, })
470			# static method with subformat
471			d = benedict.from_base64(j, subformat='json')
472			self.assertTrue(isinstance(d, benedict))
473			self.assertEqual(d, { 'a': 1, 'b': 2, 'c': 3, })
474			# constructor
475			d = benedict(j, format='base64')
476			self.assertTrue(isinstance(d, benedict))
477			self.assertEqual(d, { 'a': 1, 'b': 2, 'c': 3, })
478			# constructor with subformat
479			d = benedict(j, format='base64', subformat='json')
480			self.assertTrue(isinstance(d, benedict))
481			self.assertEqual(d, { 'a': 1, 'b': 2, 'c': 3, })
482
483			def test_from_csv_with_valid_data(self):
484			s = """id,name,age,height,weight
485			1,Alice,20,62,120.6
486			2,Freddie,21,74,190.6
487			3,Bob,17,68,120.0
488			4,François,32,75,110.05
489			"""
490			r = {
491			'values': [
492			{ 'id':'1', 'name':'Alice', 'age':'20', 'height':'62', 'weight':'120.6', },
493			{ 'id':'2', 'name':'Freddie', 'age':'21', 'height':'74', 'weight':'190.6', },
494			{ 'id':'3', 'name':'Bob', 'age':'17', 'height':'68', 'weight':'120.0', },
495			{ 'id':'4', 'name':'François', 'age':'32', 'height':'75', 'weight':'110.05', },
496			],
497			}
498			# static method
499			d = benedict.from_csv(s)
500			self.assertTrue(isinstance(d, dict))
501			self.assertEqual(d, r)
502			# constructor
503			d = benedict(s, format='csv')
504			self.assertTrue(isinstance(d, dict))
505			self.assertEqual(d, r)
506
507			def test_from_json(self):
508			j = '{"a": 1, "b": 2, "c": 3}'
509			# static method
510			d = benedict.from_json(j)
511			self.assertTrue(isinstance(d, benedict))
512			self.assertEqual(d, { 'a': 1, 'b': 2, 'c': 3, })
513			# constructor
514			d = benedict(j, format='json')
515			self.assertTrue(isinstance(d, benedict))
516			self.assertEqual(d, { 'a': 1, 'b': 2, 'c': 3, })
517
518			def test_from_query_string_with_valid_data(self):
519			s = 'ok=1&test=2&page=3&lib=python%20benedict&author=Fabio+Caccamo&author=Fabio%20Caccamo'
520			r = { 'ok': '1', 'test': '2', 'page': '3', 'lib':'python benedict', 'author':'Fabio Caccamo' }
521			# static method
522			d = benedict.from_query_string(s)
523			self.assertTrue(isinstance(d, benedict))
524			self.assertEqual(d, r)
525			# constructor
526			d = benedict(s, format='query-string')
527			self.assertTrue(isinstance(d, benedict))
528			self.assertEqual(d, r)
529
530			def test_from_toml(self):
531			j = """
532			a = 1
533
534			[b]
535			c = 3
536			d = 4
537			"""
538			# static method
539			d = benedict.from_toml(j)
540			self.assertTrue(isinstance(d, benedict))
541			self.assertEqual(d, { 'a':1, 'b':{ 'c':3, 'd':4 },})
542			# constructor
543			d = benedict(j, format='toml')
544			self.assertTrue(isinstance(d, benedict))
545			self.assertEqual(d, { 'a':1, 'b':{ 'c':3, 'd':4 },})
546
547			def test_from_xml(self):
548			j = """
549			<?xml version="1.0" ?>
550			<root>
551			<a>1</a>
552			<b>
553			<c>3</c>
554			<d>4</d>
555			</b>
556			</root>
557			"""
558			# static method
559			d = benedict.from_xml(j)
560			self.assertTrue(isinstance(d, benedict))
561			self.assertEqual(d.get('root'), { 'a':'1', 'b':{ 'c':'3', 'd':'4' },})
562			# constructor
563			d = benedict(j, format='xml')
564			self.assertTrue(isinstance(d, benedict))
565			self.assertEqual(d.get('root'), { 'a':'1', 'b':{ 'c':'3', 'd':'4' },})
566
567			def test_from_yaml(self):
568			j = """
569			a: 1
570			b:
571			c: 3
572			d: 4
573			"""
574			# static method
575			d = benedict.from_yaml(j)
576			self.assertTrue(isinstance(d, benedict))
577			self.assertEqual(d, { 'a':1, 'b':{ 'c':3, 'd':4 },})
578			# constructor
579			d = benedict(j, format='yaml')
580			self.assertTrue(isinstance(d, benedict))
581			self.assertEqual(d, { 'a':1, 'b':{ 'c':3, 'd':4 },})
582
583			def test_get(self):
584			d = {
585			'a': 1,
586			'b': {
587			'c': 2,
588			'd': {
589			'e': 3,
590			}
591			}
592			}
593			b = benedict(d)
594			self.assertEqual(b.get('a'), 1)
595			self.assertEqual(b.get('b.c'), 2)
596			# self.assertTrue(isinstance(b.get('b'), benedict))
597			# self.assertTrue(isinstance(b.get('b.d'), benedict))
598			# bb = b.get('b')
599			# self.assertTrue(isinstance(bb.get('d'), benedict))
600
601			def test_get_item(self):
602			d = {
603			'a': 1,
604			'b': {
605			'c': 2,
606			'd': {
607			'e': 3,
608			}
609			}
610			}
611			b = benedict(d)
612			self.assertEqual(b['a'], 1)
613			self.assertEqual(b['b.c'], 2)
614			# self.assertTrue(isinstance(b['b'], benedict))
615			# self.assertTrue(isinstance(b['b.d'], benedict))
616			# bb = b['b']
617			# self.assertTrue(isinstance(bb['d'], benedict))
618
619			def test_get_dict(self):
620			d = {
621			'a': {'x': 1, 'y': 2},
622			'b': {},
623			}
624			b = benedict(d)
625			# self.assertTrue(isinstance(b.get_dict('a'), benedict))
626			self.assertEqual(b.get('a.x'), 1)
627
628			def test_get_list(self):
629			d = {
630			'a': [
631			{
632			'b': {
633			'c': 1,
634			}
635			},
636			{
637			'b': {
638			'c': 2,
639			}
640			},
641			{
642			'b': {
643			'c': 3,
644			}
645			},
646			]
647			}
648			b = benedict(d)
649			l = b.get_list('a')
650			# self.assertTrue(isinstance(l[0], benedict))
651			# self.assertTrue(isinstance(l[1], benedict))
652			# self.assertTrue(isinstance(l[2], benedict))
653			# self.assertEqual(l[0].get('b.c'), 1)
654			# self.assertEqual(l[1].get('b.c'), 2)
655			# self.assertEqual(l[2].get('b.c'), 3)
656			self.assertEqual(benedict(l[0]).get('b.c'), 1)
657			self.assertEqual(benedict(l[1]).get('b.c'), 2)
658			self.assertEqual(benedict(l[2]).get('b.c'), 3)
659
660			def test_get_list_item(self):
661			d = {
662			'a': [
663			{
664			'b': {
665			'c': 1,
666			}
667			},
668			{
669			'b': {
670			'c': 2,
671			}
672			},
673			{
674			'b': {
675			'c': 3,
676			}
677			},
678			]
679			}
680			b = benedict(d)
681			i = benedict(b.get_list_item('a', index=1))
682			# self.assertTrue(isinstance(i, benedict))
683			self.assertEqual(i.get('b.c'), 2)
684
685			def test_get_phonenumber(self):
686			d = {
687			'a': {
688			'b': ' (0039) 3334445566 ',
689			'c': '+393334445566 ',
690			'd': '+39333444556677889900',
691			}
692			}
693			r = {
694			'e164': '+393334445566',
695			'international': '+39 333 444 5566',
696			'national': '333 444 5566'
697			}
698			b = benedict(d)
699
700			p = b.get_phonenumber('a.b')
701			self.assertEqual(p, r)
702			# self.assertTrue(isinstance(p, benedict))
703
704			p = b.get_phonenumber('a.c')
705			self.assertEqual(p, r)
706			# self.assertTrue(isinstance(p, benedict))
707
708			p = b.get_phonenumber('a.d')
709			self.assertEqual(p, {})
710			# self.assertTrue(isinstance(p, benedict))
711
712			def test_invert(self):
713			d = {
714			'a': 1,
715			'b': 2,
716			'c': 3,
717			'd': 4,
718			'e': 5,
719			}
720			bd = benedict(d)
721			i = bd.invert()
722			r = {
723			1: ['a'],
724			2: ['b'],
725			3: ['c'],
726			4: ['d'],
727			5: ['e'],
728			}
729			self.assertEqual(i, r)
730
731			def test_invert_multiple_values(self):
732			d = {
733			'a': 1,
734			'b': 2,
735			'c': 3,
736			'd': 1,
737			'e': 2,
738			'f': 3,
739			}
740			bd = benedict(d)
741			i = bd.invert()
742			self.assertTrue('a' and 'd' in i[1])
743			self.assertTrue('b' and 'e' in i[2])
744			self.assertTrue('c' and 'f' in i[3])
745
746			def test_invert_flat(self):
747			d = {
748			'a': 1,
749			'b': 2,
750			'c': 3,
751			'd': 4,
752			'e': 5,
753			}
754			bd = benedict(d)
755			i = bd.invert(flat=True)
756			r = {
757			1: 'a',
758			2: 'b',
759			3: 'c',
760			4: 'd',
761			5: 'e',
762			}
763			self.assertEqual(i, r)
764
765			def test_items_sorted_by_keys(self):
766			d = {
767			'y': 3,
768			'a': 6,
769			'f': 9,
770			'z': 4,
771			'x': 1,
772			}
773			bd = benedict(d)
774			items = bd.items_sorted_by_keys()
775			self.assertEqual(items, [
776			('a', 6,),
777			('f', 9,),
778			('x', 1,),
779			('y', 3,),
780			('z', 4,),
781			])
782
783			def test_items_sorted_by_keys_reverse(self):
784			d = {
785			'y': 3,
786			'a': 6,
787			'f': 9,
788			'z': 4,
789			'x': 1,
790			}
791			bd = benedict(d)
792			items = bd.items_sorted_by_keys(reverse=True)
793			self.assertEqual(items, [
794			('z', 4,),
795			('y', 3,),
796			('x', 1,),
797			('f', 9,),
798			('a', 6,),
799			])
800
801			def test_items_sorted_by_values(self):
802			d = {
803			'a': 3,
804			'b': 6,
805			'c': 9,
806			'e': 4,
807			'd': 1,
808			}
809			bd = benedict(d)
810			items = bd.items_sorted_by_values()
811			self.assertEqual(items, [
812			('d', 1,),
813			('a', 3,),
814			('e', 4,),
815			('b', 6,),
816			('c', 9,),
817			])
818
819			def test_items_sorted_by_values_reverse(self):
820			d = {
821			'a': 3,
822			'b': 6,
823			'c': 9,
824			'e': 4,
825			'd': 1,
826			}
827			bd = benedict(d)
828			items = bd.items_sorted_by_values(reverse=True)
829			self.assertEqual(items, [
830			('c', 9,),
831			('b', 6,),
832			('e', 4,),
833			('a', 3,),
834			('d', 1,),
835			])
836
837			def test_keypaths(self):
838			d = {
839			'x': {
840			'y': True,
841			'z': False,
842			},
843			'a': {
844			'b': {
845			'c': 0,
846			'd': None,
847			'e': {},
848			},
849			},
850			}
851			b = benedict(d)
852			r = [
853			'a',
854			'a.b',
855			'a.b.c',
856			'a.b.d',
857			'a.b.e',
858			'x',
859			'x.y',
860			'x.z',
861			]
862			self.assertEqual(b.keypaths(), r)
863
864			def test_merge_with_single_dict(self):
865			d = {
866			'a': 1,
867			'b': 1,
868			}
869			a = {
870			'b': 2,
871			'c': 3,
872			}
873			d = benedict(d)
874			d.merge(a)
875			r = {
876			'a': 1,
877			'b': 2,
878			'c': 3,
879			}
880			self.assertEqual(d, r)
881
882			def test_merge_with_multiple_dicts(self):
883			d = {
884			'a': 1,
885			'b': 1,
886			}
887			a = {
888			'b': 2,
889			'c': 3,
890			'd': 3,
891			}
892			b = {
893			'd': 5,
894			'e': 5,
895			}
896			c = {
897			'd': 4,
898			'f': 6,
899			}
900			d = benedict(d)
901			d.merge(a, b, c)
902			r = {
903			'a': 1,
904			'b': 2,
905			'c': 3,
906			'd': 4,
907			'e': 5,
908			'f': 6,
909			}
910			self.assertEqual(d, r)
911
912			def test_merge(self):
913			d = {
914			'a': 1,
915			'b': {
916			'c': {
917			'x': 2,
918			'y': 3,
919			},
920			'd': {
921			'x': 4,
922			'y': 5,
923			},
924			'e': {
925			'x': 6,
926			'y': 7,
927			},
928			},
929			}
930			a = {
931			'a': 0,
932			'b': {
933			'c': 1,
934			'd': {
935			'y': 1,
936			'z': 2,
937			},
938			'e': {
939			'f': {
940			'x': 2,
941			'y': 3,
942			},
943			'g': {
944			'x': 4,
945			'y': 5,
946			},
947			},
948			},
949			}
950			d = benedict(d)
951			d.merge(a)
952			r = {
953			'a': 0,
954			'b': {
955			'c': 1,
956			'd': {
957			'x': 4,
958			'y': 1,
959			'z': 2,
960			},
961			'e': {
962			'f': {
963			'x': 2,
964			'y': 3,
965			},
966			'g': {
967			'x': 4,
968			'y': 5,
969			},
970			'x': 6,
971			'y': 7,
972			},
973			},
974			}
975			self.assertEqual(d, r)
976
977			def test_move(self):
978			d = {
979			'a': {
980			'x': 1,
981			'y': 1,
982			},
983			'b': {
984			'x': 2,
985			'y': 2,
986			},
987			'c': {
988			'x': 3,
989			'y': 3,
990			},
991			}
992			b = benedict(d)
993			b.move('a', 'c.z')
994			r = {
995			'b': {
996			'x': 2,
997			'y': 2,
998			},
999			'c': {
1000			'x': 3,
1001			'y': 3,
1002			'z': {
1003			'x': 1,
1004			'y': 1,
1005			},
1006			},
1007			}
1008			self.assertEqual(b, r)
1009
1010			def test_pop(self):
1011			d = {
1012			'a': 1,
1013			'b': {
1014			'c': 2,
1015			'd': {
1016			'e': 3,
1017			}
1018			}
1019			}
1020			b = benedict(d)
1021			self.assertEqual(b.pop('a'), 1)
1022			self.assertEqual(b.pop('b.c'), 2)
1023			# self.assertTrue(isinstance(b.pop('b.d'), benedict))
1024
1025			def test_remove_with_key(self):
1026			d = {
1027			'a': 1,
1028			'b': 2,
1029			'c': '4',
1030			}
1031			b = benedict(d)
1032			b.remove('c')
1033			r = {
1034			'a': 1,
1035			'b': 2,
1036			}
1037			self.assertEqual(b, r)
1038
1039			def test_remove_with_keys_list(self):
1040			d = {
1041			'a': 1,
1042			'b': 2,
1043			'c': '4',
1044			'e': '5',
1045			'f': 6,
1046			'g': 7,
1047			}
1048			b = benedict(d)
1049			b.remove(['c', 'e', 'f', 'g', 'x', 'y', 'z'])
1050			r = {
1051			'a': 1,
1052			'b': 2,
1053			}
1054			self.assertEqual(b, r)
1055
1056			def test_remove_with_keys_args(self):
1057			d = {
1058			'a': 1,
1059			'b': 2,
1060			'c': '4',
1061			'e': '5',
1062			'f': 6,
1063			'g': 7,
1064			}
1065			b = benedict(d)
1066			b.remove('c', 'e', 'f', 'g', 'x', 'y', 'z')
1067			r = {
1068			'a': 1,
1069			'b': 2,
1070			}
1071			self.assertEqual(b, r)
1072
1073			def test_remove_with_keypath(self):
1074			d = {
1075			'a': {
1076			'x': 1,
1077			'y': 1,
1078			},
1079			'b': {
1080			'x': 2,
1081			'y': 2,
1082			},
1083			'c': {
1084			'x': 3,
1085			'y': 3,
1086			},
1087			'd': {
1088			'x': 4,
1089			'y': 4,
1090			},
1091			}
1092			b = benedict(d)
1093			b.remove(['a.x', 'b.y', 'c.x', 'c.y', 'd'])
1094			r = {
1095			'a': {
1096			'y': 1
1097			},
1098			'b': {
1099			'x': 2
1100			},
1101			'c': {
1102			},
1103			}
1104			self.assertEqual(b, r)
1105
1106			# def test_setdefault(self):
1107			# d = {
1108			# 'a': 1,
1109			# 'b': {
1110			# 'c': 2,
1111			# 'd': {
1112			# 'e': 3,
1113			# }
1114			# }
1115			# }
1116			# b = benedict(d)
1117			# self.assertTrue(isinstance(b.setdefault('b', 1), benedict))
1118			# self.assertTrue(isinstance(b.setdefault('b.d', 1), benedict))
1119
1120			def test_standardize(self):
1121			d = {
1122			'CamelCase': 1,
1123			'CamelCamelCase': 1,
1124			'Camel2Camel2Case': 1,
1125			'getHTTPResponseCode': 1,
1126			'get2HTTPResponseCode': 1,
1127			'HTTPResponseCode': 1,
1128			'HTTPResponseCodeXYZ': 1,
1129			' LocationCoordinates ': {
1130			'Lat. ': 0.0,
1131			'Lng. ': 0.0,
1132			},
1133			}
1134			b = benedict(d, keypath_separator=None)
1135			b.standardize()
1136			b.keypath_separator = '.'
1137			r = {
1138			'camel_case': 1,
1139			'camel_camel_case': 1,
1140			'camel2_camel2_case': 1,
1141			'get_http_response_code': 1,
1142			'get2_http_response_code': 1,
1143			'http_response_code': 1,
1144			'http_response_code_xyz': 1,
1145			'location_coordinates': {
1146			'lat': 0.0,
1147			'lng': 0.0,
1148			},
1149			}
1150			self.assertEqual(b, r)
1151			self.assertEqual(b['location_coordinates.lat'], 0.0)
1152			self.assertEqual(b['location_coordinates.lng'], 0.0)
1153
1154			def test_subset(self):
1155			d = {
1156			'a': 1,
1157			'b': 2,
1158			'c': '4',
1159			'e': '5',
1160			'f': 6,
1161			'g': 7,
1162			}
1163			b = benedict(d)
1164			f = b.subset(['c', 'f', 'x'])
1165			r = {
1166			'c': '4',
1167			'f': 6,
1168			'x': None,
1169			}
1170			self.assertEqual(f, r)
1171			self.assertFalse(f is b)
1172			self.assertEqual(type(b), type(f))
1173			self.assertTrue(isinstance(f, benedict))
1174
1175			def test_subset_with_keys_args(self):
1176			d = {
1177			'a': 1,
1178			'b': 2,
1179			'c': '4',
1180			'e': '5',
1181			'f': 6,
1182			'g': 7,
1183			}
1184			b = benedict(d)
1185			f = b.subset('c', 'f', 'x')
1186			r = {
1187			'c': '4',
1188			'f': 6,
1189			'x': None,
1190			}
1191			self.assertEqual(f, r)
1192			self.assertFalse(f is b)
1193
1194			def test_subset_with_keypath(self):
1195			d = {
1196			'x': {
1197			'a': 1,
1198			'aa': 1,
1199			},
1200			'y': {
1201			'b': 2,
1202			'bb': 2,
1203			},
1204			'z': {
1205			'c': 3,
1206			'cc': 3,
1207			},
1208			}
1209			b = benedict(d)
1210			f = b.subset(['x', 'y'])
1211			r = {
1212			'x': {
1213			'a': 1,
1214			'aa': 1,
1215			},
1216			'y': {
1217			'b': 2,
1218			'bb': 2,
1219			},
1220			}
1221			self.assertEqual(f, r)
1222			self.assertFalse(f is b)
1223			self.assertTrue(isinstance(f, benedict))
1224			self.assertEqual(f.get('x.a'), 1)
1225			self.assertEqual(f.get('x.aa'), 1)
1226			self.assertEqual(f.get('y.b'), 2)
1227			self.assertEqual(f.get('y.bb'), 2)
1228			# test with keypath
1229			f = b.subset(['x.a', 'y.b'])
1230			r = {
1231			'x': {
1232			'a': 1,
1233			},
1234			'y': {
1235			'b': 2,
1236			},
1237			}
1238			self.assertEqual(f, r)
1239			self.assertFalse(f is b)
1240			self.assertTrue(isinstance(f, benedict))
1241			self.assertEqual(f.get('x.a'), 1)
1242			self.assertEqual(f.get('y.b'), 2)
1243
1244			def test_swap(self):
1245			d = {
1246			'a': 1,
1247			'b': 2,
1248			'c': 3,
1249			}
1250			b = benedict(d)
1251			b.swap('a', 'b')
1252			r = {
1253			'a': 2,
1254			'b': 1,
1255			'c': 3,
1256			}
1257			self.assertEqual(b, r)
1258
1259			def test_swap_with_invalid_key(self):
1260			d = {
1261			'a': 1,
1262			'b': 2,
1263			'c': 3,
1264			}
1265			b = benedict(d)
1266			with self.assertRaises(KeyError):
1267			b.swap('a', 'd')
1268
1269			def test_swap_with_keypath(self):
1270			d = {
1271			'a': {
1272			'x': 1,
1273			'y': 1,
1274			},
1275			'b': {
1276			'x': 2,
1277			'y': 2,
1278			},
1279			'c': {
1280			'x': 3,
1281			'y': 3,
1282			},
1283			}
1284			b = benedict(d)
1285			b.swap('a.y', 'b.y')
1286			b.swap('b.x', 'c.x')
1287			b.swap('a', 'c')
1288			r = {
1289			'a': {
1290			'x': 2,
1291			'y': 3,
1292			},
1293			'b': {
1294			'x': 3,
1295			'y': 1,
1296			},
1297			'c': {
1298			'x': 1,
1299			'y': 2,
1300			},
1301			}
1302			self.assertEqual(b, r)
1303
1304			def test_traverse(self):
1305			d = {
1306			'a': {
1307			'x': 2,
1308			'y': 3,
1309			'z': {
1310			'ok': 5,
1311			}
1312			},
1313			'b': {
1314			'x': 7,
1315			'y': 11,
1316			'z': {
1317			'ok': 13,
1318			}
1319			},
1320			'c': {
1321			'x': 17,
1322			'y': 19,
1323			'z': {
1324			'ok': 23,
1325			}
1326			},
1327			}
1328			b = benedict(d)
1329			def f(parent, key, value):
1330			if not isinstance(value, dict):
1331			parent[key] = (value + 1)
1332			b.traverse(f)
1333			r = {
1334			'a': {
1335			'x': 3,
1336			'y': 4,
1337			'z': {
1338			'ok': 6,
1339			}
1340			},
1341			'b': {
1342			'x': 8,
1343			'y': 12,
1344			'z': {
1345			'ok': 14,
1346			}
1347			},
1348			'c': {
1349			'x': 18,
1350			'y': 20,
1351			'z': {
1352			'ok': 24,
1353			}
1354			},
1355			}
1356			self.assertEqual(b, r)
1357
1358			def test_unique(self):
1359			d = {
1360			'a': {
1361			'x': 1,
1362			'y': 1,
1363			},
1364			'b': {
1365			'x': 2,
1366			'y': 2,
1367			},
1368			'c': {
1369			'x': 1,
1370			'y': 1,
1371			},
1372			'd': {
1373			'x': 1,
1374			},
1375			'e': {
1376			'x': 1,
1377			'y': 1,
1378			'z': 1,
1379			},
1380			'f': {
1381			'x': 2,
1382			'y': 2,
1383			},
1384			}
1385			b = benedict(d)
1386			b.unique()
1387			rv = [
1388			{
1389			'x': 1,
1390			'y': 1,
1391			},
1392			{
1393			'x': 2,
1394			'y': 2,
1395			},
1396			{
1397			'x': 1,
1398			},
1399			{
1400			'x': 1,
1401			'y': 1,
1402			'z': 1,
1403			},
1404			]
1405			self.assertEqual(len(b.keys()), len(rv))
1406			self.assertTrue(all([value in rv for value in b.values()]))
1407

fabiocaccamo / python-benedict

Branch — master (6e6000)

tests.test_benedict.benedict_test_case.test_deepupdate() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like