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

Completed

Push — master ( eb677f...0fa067 )

by Fabio

created 2019-10-29 15:31 UTC

BenedictTestCase.test_keypaths() A

↳ Parent: tests.test_benedict

Complexity

Conditions

Size

Total Lines	26
Code Lines	21

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	21
dl	0
loc	26
rs	9.376
c	0
b	0
f	0
cc	1
nop	1

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 BenedictTestCase(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		# constructor
498		d = benedict(j)
499		self.assertTrue(isinstance(d, benedict))
500		self.assertEqual(d, { 'a': 1, 'b': 2, 'c': 3, })
501
502		def test_from_json(self):
503		j = '{"a": 1, "b": 2, "c": 3}'
504		# static method
505		d = benedict.from_json(j)
506		self.assertTrue(isinstance(d, benedict))
507		self.assertEqual(d, { 'a': 1, 'b': 2, 'c': 3, })
508		# constructor
509		d = benedict(j)
510		self.assertTrue(isinstance(d, benedict))
511		self.assertEqual(d, { 'a': 1, 'b': 2, 'c': 3, })
512
513		def test_from_query_string_with_valid_data(self):
514		s = 'ok=1&test=2&page=3&lib=python%20benedict&author=Fabio+Caccamo&author=Fabio%20Caccamo'
515		r = { 'ok': '1', 'test': '2', 'page': '3', 'lib':'python benedict', 'author':'Fabio Caccamo' }
516		# static method
517		d = benedict.from_query_string(s)
518		self.assertTrue(isinstance(d, benedict))
519		self.assertEqual(d, r)
520		# constructor
521		d = benedict(s)
522		self.assertTrue(isinstance(d, benedict))
523		self.assertEqual(d, r)
524
525		def test_from_toml(self):
526		j = """
527		a = 1
528
529		[b]
530		c = 3
531		d = 4
532		"""
533		# static method
534		d = benedict.from_toml(j)
535		self.assertTrue(isinstance(d, benedict))
536		self.assertEqual(d, { 'a':1, 'b':{ 'c':3, 'd':4 },})
537		# constructor
538		d = benedict(j)
539		self.assertTrue(isinstance(d, benedict))
540		self.assertEqual(d, { 'a':1, 'b':{ 'c':3, 'd':4 },})
541
542		def test_from_xml(self):
543		j = """<?xml version="1.0" ?>
544		<root>
545		<a>1</a>
546		<b>
547		<c>3</c>
548		<d>4</d>
549		</b>
550		</root>
551		"""
552		# static method
553		d = benedict.from_xml(j)
554		self.assertTrue(isinstance(d, benedict))
555		self.assertEqual(d.get('root'), { 'a':'1', 'b':{ 'c':'3', 'd':'4' },})
556		# constructor
557		d = benedict(j)
558		self.assertTrue(isinstance(d, benedict))
559		self.assertEqual(d.get('root'), { 'a':'1', 'b':{ 'c':'3', 'd':'4' },})
560
561		def test_from_yaml(self):
562		j = """
563		a: 1
564		b:
565		c: 3
566		d: 4
567		"""
568		# static method
569		d = benedict.from_yaml(j)
570		self.assertTrue(isinstance(d, benedict))
571		self.assertEqual(d, { 'a':1, 'b':{ 'c':3, 'd':4 },})
572		# constructor
573		d = benedict(j)
574		self.assertTrue(isinstance(d, benedict))
575		self.assertEqual(d, { 'a':1, 'b':{ 'c':3, 'd':4 },})
576
577		def test_get(self):
578		d = {
579		'a': 1,
580		'b': {
581		'c': 2,
582		'd': {
583		'e': 3,
584		}
585		}
586		}
587		b = benedict(d)
588		self.assertEqual(b.get('a'), 1)
589		self.assertEqual(b.get('b.c'), 2)
590		# self.assertTrue(isinstance(b.get('b'), benedict))
591		# self.assertTrue(isinstance(b.get('b.d'), benedict))
592		# bb = b.get('b')
593		# self.assertTrue(isinstance(bb.get('d'), benedict))
594
595		def test_get_item(self):
596		d = {
597		'a': 1,
598		'b': {
599		'c': 2,
600		'd': {
601		'e': 3,
602		}
603		}
604		}
605		b = benedict(d)
606		self.assertEqual(b['a'], 1)
607		self.assertEqual(b['b.c'], 2)
608		# self.assertTrue(isinstance(b['b'], benedict))
609		# self.assertTrue(isinstance(b['b.d'], benedict))
610		# bb = b['b']
611		# self.assertTrue(isinstance(bb['d'], benedict))
612
613		def test_get_dict(self):
614		d = {
615		'a': {'x': 1, 'y': 2},
616		'b': {},
617		}
618		b = benedict(d)
619		# self.assertTrue(isinstance(b.get_dict('a'), benedict))
620		self.assertEqual(b.get('a.x'), 1)
621
622		def test_get_list(self):
623		d = {
624		'a': [
625		{
626		'b': {
627		'c': 1,
628		}
629		},
630		{
631		'b': {
632		'c': 2,
633		}
634		},
635		{
636		'b': {
637		'c': 3,
638		}
639		},
640		]
641		}
642		b = benedict(d)
643		l = b.get_list('a')
644		# self.assertTrue(isinstance(l[0], benedict))
645		# self.assertTrue(isinstance(l[1], benedict))
646		# self.assertTrue(isinstance(l[2], benedict))
647		# self.assertEqual(l[0].get('b.c'), 1)
648		# self.assertEqual(l[1].get('b.c'), 2)
649		# self.assertEqual(l[2].get('b.c'), 3)
650		self.assertEqual(benedict(l[0]).get('b.c'), 1)
651		self.assertEqual(benedict(l[1]).get('b.c'), 2)
652		self.assertEqual(benedict(l[2]).get('b.c'), 3)
653
654		def test_get_list_item(self):
655		d = {
656		'a': [
657		{
658		'b': {
659		'c': 1,
660		}
661		},
662		{
663		'b': {
664		'c': 2,
665		}
666		},
667		{
668		'b': {
669		'c': 3,
670		}
671		},
672		]
673		}
674		b = benedict(d)
675		i = benedict(b.get_list_item('a', index=1))
676		# self.assertTrue(isinstance(i, benedict))
677		self.assertEqual(i.get('b.c'), 2)
678
679		def test_get_phonenumber(self):
680		d = {
681		'a': {
682		'b': ' (0039) 3334445566 ',
683		'c': '+393334445566 ',
684		'd': '+39333444556677889900',
685		}
686		}
687		r = {
688		'e164': '+393334445566',
689		'international': '+39 333 444 5566',
690		'national': '333 444 5566'
691		}
692		b = benedict(d)
693
694		p = b.get_phonenumber('a.b')
695		self.assertEqual(p, r)
696		# self.assertTrue(isinstance(p, benedict))
697
698		p = b.get_phonenumber('a.c')
699		self.assertEqual(p, r)
700		# self.assertTrue(isinstance(p, benedict))
701
702		p = b.get_phonenumber('a.d')
703		self.assertEqual(p, {})
704		# self.assertTrue(isinstance(p, benedict))
705
706		def test_invert(self):
707		d = {
708		'a': 1,
709		'b': 2,
710		'c': 3,
711		'd': 4,
712		'e': 5,
713		}
714		bd = benedict(d)
715		i = bd.invert()
716		r = {
717		1: ['a'],
718		2: ['b'],
719		3: ['c'],
720		4: ['d'],
721		5: ['e'],
722		}
723		self.assertEqual(i, r)
724
725		def test_invert_multiple_values(self):
726		d = {
727		'a': 1,
728		'b': 2,
729		'c': 3,
730		'd': 1,
731		'e': 2,
732		'f': 3,
733		}
734		bd = benedict(d)
735		i = bd.invert()
736		self.assertTrue('a' and 'd' in i[1])
737		self.assertTrue('b' and 'e' in i[2])
738		self.assertTrue('c' and 'f' in i[3])
739
740		def test_invert_flat(self):
741		d = {
742		'a': 1,
743		'b': 2,
744		'c': 3,
745		'd': 4,
746		'e': 5,
747		}
748		bd = benedict(d)
749		i = bd.invert(flat=True)
750		r = {
751		1: 'a',
752		2: 'b',
753		3: 'c',
754		4: 'd',
755		5: 'e',
756		}
757		self.assertEqual(i, r)
758
759		def test_items_sorted_by_keys(self):
760		d = {
761		'y': 3,
762		'a': 6,
763		'f': 9,
764		'z': 4,
765		'x': 1,
766		}
767		bd = benedict(d)
768		items = bd.items_sorted_by_keys()
769		self.assertEqual(items, [
770		('a', 6,),
771		('f', 9,),
772		('x', 1,),
773		('y', 3,),
774		('z', 4,),
775		])
776
777		def test_items_sorted_by_keys_reverse(self):
778		d = {
779		'y': 3,
780		'a': 6,
781		'f': 9,
782		'z': 4,
783		'x': 1,
784		}
785		bd = benedict(d)
786		items = bd.items_sorted_by_keys(reverse=True)
787		self.assertEqual(items, [
788		('z', 4,),
789		('y', 3,),
790		('x', 1,),
791		('f', 9,),
792		('a', 6,),
793		])
794
795		def test_items_sorted_by_values(self):
796		d = {
797		'a': 3,
798		'b': 6,
799		'c': 9,
800		'e': 4,
801		'd': 1,
802		}
803		bd = benedict(d)
804		items = bd.items_sorted_by_values()
805		self.assertEqual(items, [
806		('d', 1,),
807		('a', 3,),
808		('e', 4,),
809		('b', 6,),
810		('c', 9,),
811		])
812
813		def test_items_sorted_by_values_reverse(self):
814		d = {
815		'a': 3,
816		'b': 6,
817		'c': 9,
818		'e': 4,
819		'd': 1,
820		}
821		bd = benedict(d)
822		items = bd.items_sorted_by_values(reverse=True)
823		self.assertEqual(items, [
824		('c', 9,),
825		('b', 6,),
826		('e', 4,),
827		('a', 3,),
828		('d', 1,),
829		])
830
831		def test_keypaths(self):
832		d = {
833		'x': {
834		'y': True,
835		'z': False,
836		},
837		'a': {
838		'b': {
839		'c': 0,
840		'd': None,
841		'e': {},
842		},
843		},
844		}
845		b = benedict(d)
846		r = [
847		'a',
848		'a.b',
849		'a.b.c',
850		'a.b.d',
851		'a.b.e',
852		'x',
853		'x.y',
854		'x.z',
855		]
856		self.assertEqual(b.keypaths(), r)
857
858		def test_merge_with_single_dict(self):
859		d = {
860		'a': 1,
861		'b': 1,
862		}
863		a = {
864		'b': 2,
865		'c': 3,
866		}
867		d = benedict(d)
868		d.merge(a)
869		r = {
870		'a': 1,
871		'b': 2,
872		'c': 3,
873		}
874		self.assertEqual(d, r)
875
876	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...
877		d = {
878		'a': 1,
879		'b': 1,
880		}
881		a = {
882		'b': 2,
883		'c': 3,
884		'd': 3,
885		}
886		b = {
887		'd': 5,
888		'e': 5,
889		}
890		c = {
891		'd': 4,
892		'f': 6,
893		}
894		d = benedict(d)
895		d.merge(a, b, c)
896		r = {
897		'a': 1,
898		'b': 2,
899		'c': 3,
900		'd': 4,
901		'e': 5,
902		'f': 6,
903		}
904		self.assertEqual(d, r)
905
906		def test_merge(self):
907		d = {
908		'a': 1,
909		'b': {
910		'c': {
911		'x': 2,
912		'y': 3,
913		},
914		'd': {
915		'x': 4,
916		'y': 5,
917		},
918		'e': {
919		'x': 6,
920		'y': 7,
921		},
922		},
923		}
924		a = {
925		'a': 0,
926		'b': {
927		'c': 1,
928		'd': {
929		'y': 1,
930		'z': 2,
931		},
932		'e': {
933		'f': {
934		'x': 2,
935		'y': 3,
936		},
937		'g': {
938		'x': 4,
939		'y': 5,
940		},
941		},
942		},
943		}
944		d = benedict(d)
945		d.merge(a)
946		r = {
947		'a': 0,
948		'b': {
949		'c': 1,
950		'd': {
951		'x': 4,
952		'y': 1,
953		'z': 2,
954		},
955		'e': {
956		'f': {
957		'x': 2,
958		'y': 3,
959		},
960		'g': {
961		'x': 4,
962		'y': 5,
963		},
964		'x': 6,
965		'y': 7,
966		},
967		},
968		}
969		self.assertEqual(d, r)
970
971		def test_move(self):
972		d = {
973		'a': {
974		'x': 1,
975		'y': 1,
976		},
977		'b': {
978		'x': 2,
979		'y': 2,
980		},
981		'c': {
982		'x': 3,
983		'y': 3,
984		},
985		}
986		b = benedict(d)
987		b.move('a', 'c.z')
988		r = {
989		'b': {
990		'x': 2,
991		'y': 2,
992		},
993		'c': {
994		'x': 3,
995		'y': 3,
996		'z': {
997		'x': 1,
998		'y': 1,
999		},
1000		},
1001		}
1002		self.assertEqual(b, r)
1003
1004		def test_pop(self):
1005		d = {
1006		'a': 1,
1007		'b': {
1008		'c': 2,
1009		'd': {
1010		'e': 3,
1011		}
1012		}
1013		}
1014		b = benedict(d)
1015		self.assertEqual(b.pop('a'), 1)
1016		self.assertEqual(b.pop('b.c'), 2)
1017		# self.assertTrue(isinstance(b.pop('b.d'), benedict))
1018
1019		def test_remove_with_key(self):
1020		d = {
1021		'a': 1,
1022		'b': 2,
1023		'c': '4',
1024		}
1025		b = benedict(d)
1026		b.remove('c')
1027		r = {
1028		'a': 1,
1029		'b': 2,
1030		}
1031		self.assertEqual(b, r)
1032
1033		def test_remove_with_keys_list(self):
1034		d = {
1035		'a': 1,
1036		'b': 2,
1037		'c': '4',
1038		'e': '5',
1039		'f': 6,
1040		'g': 7,
1041		}
1042		b = benedict(d)
1043		b.remove(['c', 'e', 'f', 'g', 'x', 'y', 'z'])
1044		r = {
1045		'a': 1,
1046		'b': 2,
1047		}
1048		self.assertEqual(b, r)
1049
1050		def test_remove_with_keys_args(self):
1051		d = {
1052		'a': 1,
1053		'b': 2,
1054		'c': '4',
1055		'e': '5',
1056		'f': 6,
1057		'g': 7,
1058		}
1059		b = benedict(d)
1060		b.remove('c', 'e', 'f', 'g', 'x', 'y', 'z')
1061		r = {
1062		'a': 1,
1063		'b': 2,
1064		}
1065		self.assertEqual(b, r)
1066
1067		def test_remove_with_keypath(self):
1068		d = {
1069		'a': {
1070		'x': 1,
1071		'y': 1,
1072		},
1073		'b': {
1074		'x': 2,
1075		'y': 2,
1076		},
1077		'c': {
1078		'x': 3,
1079		'y': 3,
1080		},
1081		'd': {
1082		'x': 4,
1083		'y': 4,
1084		},
1085		}
1086		b = benedict(d)
1087		b.remove(['a.x', 'b.y', 'c.x', 'c.y', 'd'])
1088		r = {
1089		'a': {
1090		'y': 1
1091		},
1092		'b': {
1093		'x': 2
1094		},
1095		'c': {
1096		},
1097		}
1098		self.assertEqual(b, r)
1099
1100		# def test_setdefault(self):
1101		# d = {
1102		# 'a': 1,
1103		# 'b': {
1104		# 'c': 2,
1105		# 'd': {
1106		# 'e': 3,
1107		# }
1108		# }
1109		# }
1110		# b = benedict(d)
1111		# self.assertTrue(isinstance(b.setdefault('b', 1), benedict))
1112		# self.assertTrue(isinstance(b.setdefault('b.d', 1), benedict))
1113
1114		def test_standardize(self):
1115		d = {
1116		'CamelCase': 1,
1117		'CamelCamelCase': 1,
1118		'Camel2Camel2Case': 1,
1119		'getHTTPResponseCode': 1,
1120		'get2HTTPResponseCode': 1,
1121		'HTTPResponseCode': 1,
1122		'HTTPResponseCodeXYZ': 1,
1123		' LocationCoordinates ': {
1124		'Lat. ': 0.0,
1125		'Lng. ': 0.0,
1126		},
1127		}
1128		b = benedict(d, keypath_separator=None)
1129		b.standardize()
1130		b.keypath_separator = '.'
1131		r = {
1132		'camel_case': 1,
1133		'camel_camel_case': 1,
1134		'camel2_camel2_case': 1,
1135		'get_http_response_code': 1,
1136		'get2_http_response_code': 1,
1137		'http_response_code': 1,
1138		'http_response_code_xyz': 1,
1139		'location_coordinates': {
1140		'lat': 0.0,
1141		'lng': 0.0,
1142		},
1143		}
1144		self.assertEqual(b, r)
1145		self.assertEqual(b['location_coordinates.lat'], 0.0)
1146		self.assertEqual(b['location_coordinates.lng'], 0.0)
1147
1148		def test_subset(self):
1149		d = {
1150		'a': 1,
1151		'b': 2,
1152		'c': '4',
1153		'e': '5',
1154		'f': 6,
1155		'g': 7,
1156		}
1157		b = benedict(d)
1158		f = b.subset(['c', 'f', 'x'])
1159		r = {
1160		'c': '4',
1161		'f': 6,
1162		'x': None,
1163		}
1164		self.assertEqual(f, r)
1165		self.assertFalse(f is b)
1166		self.assertEqual(type(b), type(f))
1167		self.assertTrue(isinstance(f, benedict))
1168
1169		def test_subset_with_keys_args(self):
1170		d = {
1171		'a': 1,
1172		'b': 2,
1173		'c': '4',
1174		'e': '5',
1175		'f': 6,
1176		'g': 7,
1177		}
1178		b = benedict(d)
1179		f = b.subset('c', 'f', 'x')
1180		r = {
1181		'c': '4',
1182		'f': 6,
1183		'x': None,
1184		}
1185		self.assertEqual(f, r)
1186		self.assertFalse(f is b)
1187
1188		def test_subset_with_keypath(self):
1189		d = {
1190		'x': {
1191		'a': 1,
1192		'aa': 1,
1193		},
1194		'y': {
1195		'b': 2,
1196		'bb': 2,
1197		},
1198		'z': {
1199		'c': 3,
1200		'cc': 3,
1201		},
1202		}
1203		b = benedict(d)
1204		f = b.subset(['x', 'y'])
1205		r = {
1206		'x': {
1207		'a': 1,
1208		'aa': 1,
1209		},
1210		'y': {
1211		'b': 2,
1212		'bb': 2,
1213		},
1214		}
1215		self.assertEqual(f, r)
1216		self.assertFalse(f is b)
1217		self.assertTrue(isinstance(f, benedict))
1218		self.assertEqual(f.get('x.a'), 1)
1219		self.assertEqual(f.get('x.aa'), 1)
1220		self.assertEqual(f.get('y.b'), 2)
1221		self.assertEqual(f.get('y.bb'), 2)
1222		# test with keypath
1223		f = b.subset(['x.a', 'y.b'])
1224		r = {
1225		'x': {
1226		'a': 1,
1227		},
1228		'y': {
1229		'b': 2,
1230		},
1231		}
1232		self.assertEqual(f, r)
1233		self.assertFalse(f is b)
1234		self.assertTrue(isinstance(f, benedict))
1235		self.assertEqual(f.get('x.a'), 1)
1236		self.assertEqual(f.get('y.b'), 2)
1237
1238		def test_swap(self):
1239		d = {
1240		'a': 1,
1241		'b': 2,
1242		'c': 3,
1243		}
1244		b = benedict(d)
1245		b.swap('a', 'b')
1246		r = {
1247		'a': 2,
1248		'b': 1,
1249		'c': 3,
1250		}
1251		self.assertEqual(b, r)
1252
1253		def test_swap_with_invalid_key(self):
1254		d = {
1255		'a': 1,
1256		'b': 2,
1257		'c': 3,
1258		}
1259		b = benedict(d)
1260		with self.assertRaises(KeyError):
1261		b.swap('a', 'd')
1262
1263		def test_swap_with_keypath(self):
1264		d = {
1265		'a': {
1266		'x': 1,
1267		'y': 1,
1268		},
1269		'b': {
1270		'x': 2,
1271		'y': 2,
1272		},
1273		'c': {
1274		'x': 3,
1275		'y': 3,
1276		},
1277		}
1278		b = benedict(d)
1279		b.swap('a.y', 'b.y')
1280		b.swap('b.x', 'c.x')
1281		b.swap('a', 'c')
1282		r = {
1283		'a': {
1284		'x': 2,
1285		'y': 3,
1286		},
1287		'b': {
1288		'x': 3,
1289		'y': 1,
1290		},
1291		'c': {
1292		'x': 1,
1293		'y': 2,
1294		},
1295		}
1296		self.assertEqual(b, r)
1297
1298		def test_traverse(self):
1299		d = {
1300		'a': {
1301		'x': 2,
1302		'y': 3,
1303		'z': {
1304		'ok': 5,
1305		}
1306		},
1307		'b': {
1308		'x': 7,
1309		'y': 11,
1310		'z': {
1311		'ok': 13,
1312		}
1313		},
1314		'c': {
1315		'x': 17,
1316		'y': 19,
1317		'z': {
1318		'ok': 23,
1319		}
1320		},
1321		}
1322		b = benedict(d)
1323		def f(parent, key, value):
1324		if not isinstance(value, dict):
1325		parent[key] = (value + 1)
1326		b.traverse(f)
1327		r = {
1328		'a': {
1329		'x': 3,
1330		'y': 4,
1331		'z': {
1332		'ok': 6,
1333		}
1334		},
1335		'b': {
1336		'x': 8,
1337		'y': 12,
1338		'z': {
1339		'ok': 14,
1340		}
1341		},
1342		'c': {
1343		'x': 18,
1344		'y': 20,
1345		'z': {
1346		'ok': 24,
1347		}
1348		},
1349		}
1350		self.assertEqual(b, r)
1351
1352	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...
1353		d = {
1354		'a': {
1355		'x': 1,
1356		'y': 1,
1357		},
1358		'b': {
1359		'x': 2,
1360		'y': 2,
1361		},
1362		'c': {
1363		'x': 1,
1364		'y': 1,
1365		},
1366		'd': {
1367		'x': 1,
1368		},
1369		'e': {
1370		'x': 1,
1371		'y': 1,
1372		'z': 1,
1373		},
1374		'f': {
1375		'x': 2,
1376		'y': 2,
1377		},
1378		}
1379		b = benedict(d)
1380		b.unique()
1381		rv = [
1382		{
1383		'x': 1,
1384		'y': 1,
1385		},
1386		{
1387		'x': 2,
1388		'y': 2,
1389		},
1390		{
1391		'x': 1,
1392		},
1393		{
1394		'x': 1,
1395		'y': 1,
1396		'z': 1,
1397		},
1398		]
1399		self.assertEqual(len(b.keys()), len(rv))
1400		self.assertTrue(all([value in rv for value in b.values()]))
1401

fabiocaccamo / python-benedict

Push — master ( eb677f...0fa067 )

BenedictTestCase.test_keypaths() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like