tests.test_benedict - Code Metrics - Inspection of "Added .deepsource.toml" - fabiocaccamo/python-benedict - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ad01fe...01a50b )

by Fabio

created 2019-09-30 12:46 UTC

tests.test_benedict A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	522
Duplicated Lines	0 %

Importance

Changes

Metric	Value
wmc	25
eloc	357
dl	0
loc	522
rs	10
c	0
b	0
f	0

24 Methods

Rating	Name	Size	Complexity
A	BenedictTestCase.test_dump()	20	1
A	BenedictTestCase.test_dump_with_datetime()	10	1
A	BenedictTestCase.test_dump_with_decimal()	10	1
A	BenedictTestCase.test_copy()	16	1
A	BenedictTestCase.test_cast()	13	1
A	BenedictTestCase.test_deepcopy()	16	1
A	BenedictTestCase.test_filter()	36	2
A	BenedictTestCase.test_fromkeys()	27	1
A	BenedictTestCase.test_fromkeys_with_value()	27	1
A	BenedictTestCase.test_from_json()	10	1
A	BenedictTestCase.test_flatten()	25	1
A	BenedictTestCase.test_get_list()	28	1
A	BenedictTestCase.test_get_phonenumber()	26	1
A	BenedictTestCase.test_from_yaml()	15	1
A	BenedictTestCase.test_pop()	14	1
A	BenedictTestCase.test_get_dict()	8	1
A	BenedictTestCase.test_get_list_item()	24	1
A	BenedictTestCase.test_get_item()	17	1
A	BenedictTestCase.test_get()	17	1
B	BenedictTestCase.test_subset()	49	1
A	BenedictTestCase.test_from_toml()	16	1
A	BenedictTestCase.test_setdefault()	13	1
A	BenedictTestCase.test_from_xml()	18	1
A	BenedictTestCase.test_remove()	32	1

# -*- coding: utf-8 -*-

from benedict import benedict
from datetime import datetime
from decimal import Decimal

import unittest


class BenedictTestCase(unittest.TestCase):

    def test_cast(self):
        d = {
            'a': 1,
        }
        b = benedict.cast(d)
        self.assertEqual(d, b)
        self.assertFalse(b is d)
        self.assertTrue(isinstance(b, benedict))
        v = [0, 1, 2, 3]
        b = benedict.cast(v)
        self.assertEqual(v, b)
        self.assertTrue(b is v)
        self.assertFalse(isinstance(b, benedict))

    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)
        output = b.dump()
        self.assertEqual(output, expected_output)

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

    def test_dump_with_decimal(self):
        d = {
            'decimal': Decimal('1.75'),
        }
        b = benedict(d)
        expected_output = """{
    "decimal": "1.75"
}"""
        output = b.dump()
        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_flatten(self):
        d = {
            'a': 1,
            'b': 2,
            'c': {
                'd': {
                    'e': 3,
                    'f': 4,
                    'g': {
                        'h': 5,
                    }
                }
            },
        }
        b = benedict(d)
        f = b.flatten()
        r = {
            'a': 1,
            'b': 2,
            'c_d_e': 3,
            'c_d_f': 4,
            'c_d_g_h': 5,
        }
        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_from_json(self):
        j = '{"a": 1, "b": 2, "c": 3}'
        # static method
        d = benedict.from_json(j)
        self.assertTrue(isinstance(d, benedict))
        self.assertEqual(d, { 'a': 1, 'b': 2, 'c': 3, })
        # constructor
        d = benedict(j)
        self.assertTrue(isinstance(d, benedict))
        self.assertEqual(d, { 'a': 1, 'b': 2, 'c': 3, })

    def test_from_toml(self):
        j = """
            a = 1

            [b]
            c = 3
            d = 4
        """
        # static method
        d = benedict.from_toml(j)
        self.assertTrue(isinstance(d, benedict))
        self.assertEqual(d, { 'a':1, 'b':{ 'c':3, 'd':4 },})
        # constructor
        d = benedict(j)
        self.assertTrue(isinstance(d, benedict))
        self.assertEqual(d, { 'a':1, 'b':{ 'c':3, 'd':4 },})

    def test_from_xml(self):
        j = """<?xml version="1.0" ?>
            <root>
                <a>1</a>
                <b>
                    <c>3</c>
                    <d>4</d>
                </b>
            </root>
        """
        # static method
        d = benedict.from_xml(j)
        self.assertTrue(isinstance(d, benedict))
        self.assertEqual(d.get('root'), { 'a':'1', 'b':{ 'c':'3', 'd':'4' },})
        # constructor
        d = benedict(j)
        self.assertTrue(isinstance(d, benedict))
        self.assertEqual(d.get('root'), { 'a':'1', 'b':{ 'c':'3', 'd':'4' },})

    def test_from_yaml(self):
        j = """
            a: 1
            b:
              c: 3
              d: 4
        """
        # static method
        d = benedict.from_yaml(j)
        self.assertTrue(isinstance(d, benedict))
        self.assertEqual(d, { 'a':1, 'b':{ 'c':3, 'd':4 },})
        # constructor
        d = benedict(j)
        self.assertTrue(isinstance(d, benedict))
        self.assertEqual(d, { 'a':1, 'b':{ 'c':3, 'd':4 },})

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

fabiocaccamo / python-benedict

Push — master ( ad01fe...01a50b )

tests.test_benedict A

Complexity

Size/Duplication

Importance

24 Methods

Duplication Side-by-Side

Filter issues like