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

Passed

Push — master ( ec62c9...d2da6a )

by Fabio

created 2019-11-07 16:53 UTC

benedict_test_case.test_traverse() B

↳ Parent: tests.test_benedict

Complexity

Conditions

Size

Total Lines	53
Code Lines	39

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	39
dl	0
loc	53
rs	8.9439
c	0
b	0
f	0
cc	2
nop	1

How to fix Long Method

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

fabiocaccamo / python-benedict

Push — master ( ec62c9...d2da6a )

benedict_test_case.test_traverse() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like