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

Passed

Push — master ( 929d80...68a360 )

by Fabio

created 2019-07-19 09:02 UTC

UtilityDictTestCase.test_clean() B

↳ Parent: tests.test_utility_dict

Complexity

Conditions

Size

Total Lines	54
Code Lines	45

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	45
dl	0
loc	54
rs	8.8
c	0
b	0
f	0
cc	1
nop	1

How to fix Long Method

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

from benedict.dicts import UtilityDict
from datetime import datetime
from decimal import Decimal

import unittest


class UtilityDictTestCase(unittest.TestCase):

    def test_clean(self):
        d = {
            'a': {},
            'b': { 'x': 1 },
            'c': [],
            'd': [0, 1],
            'e': 0.0,
            'f': '',
            'g': None,
            'h': '0'
        }

        b = UtilityDict(d)
        b.clean()
        r = {
            'b': { 'x': 1 },
            'd': [0, 1],
            'e': 0.0,
            'h': '0',
        }
        self.assertEqual(b, r)

        b = UtilityDict(d)
        b.clean(dicts=False)
        r = {
            'a': {},
            'b': { 'x': 1 },
            'd': [0, 1],
            'e': 0.0,
            'h': '0'
        }
        self.assertEqual(b, r)

        b = UtilityDict(d)
        b.clean(lists=False)
        r = {
            'b': { 'x': 1 },
            'c': [],
            'd': [0, 1],
            'e': 0.0,
            'h': '0'
        }
        self.assertEqual(b, r)

        b = UtilityDict(d)
        b.clean(strings=False)
        r = {
            'b': { 'x': 1 },
            'd': [0, 1],
            'e': 0.0,
            'f': '',
            'h': '0',
        }
        self.assertEqual(b, r)

    def test_deepcopy(self):
        d = {
            'a': {
                'b': {
                    'c': 1
                }
            }
        }
        b = UtilityDict(d)
        c = b.deepcopy()
        self.assertEqual(b, c)
        self.assertFalse(c is b)
        c['a']['b']['c'] = 2
        self.assertEqual(b['a']['b']['c'], 1)
        self.assertEqual(c['a']['b']['c'], 2)

    def test_dump(self):
        d = {
            'a': {
                'b': {
                    'c': 1
                }
            }
        }
        b = UtilityDict(d)
        expected_output = """{
    "a": {
        "b": {
            "c": 1
        }
    }
}"""
        output = UtilityDict.dump(b)
        self.assertEqual(output, expected_output)

    def test_dump_items(self):
        d = {
            'a': {
                'b': {
                    'c': 1
                }
            }
        }
        b = UtilityDict(d)
        print(b.dump_items())
        expected_output = """{
    "a": {
        "b": {
            "c": 1
        }
    }
}"""
        output = b.dump_items()
        self.assertEqual(output, expected_output)

    def test_dump_items_with_key(self):
        d = {
            'a': {
                'b': 1
            }
        }
        b = UtilityDict(d)
        expected_output = """{
    "b": 1
}"""
        output = b.dump_items('a')
        self.assertEqual(output, expected_output)

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

    def test_dump_items_with_decimal(self):
        d = {
            'decimal': Decimal('1.75'),
        }
        b = UtilityDict(d)
        expected_output = """{
    "decimal": "1.75"
}"""
        output = b.dump_items()
        self.assertEqual(output, expected_output)

    def test_filter(self):
        d = {
            'a': 1,
            'b': 2,
            'c': '4',
            'e': '5',
            'f': 6,
            'g': 7,
        }
        b = UtilityDict(d)
        with self.assertRaises(ValueError):
            f = b.filter(True)
        f = b.filter(lambda key, val: isinstance(val, int))
        r = {
            'a': 1,
            'b': 2,
            'f': 6,
            'g': 7,
        }
        self.assertEqual(f, r)
        self.assertFalse(b is f)

    def test_remove(self):
        d = {
            'a': 1,
            'b': 2,
            'c': '4',
            'e': '5',
            'f': 6,
            'g': 7,
        }
        b = UtilityDict(d)
        b.remove(['c', 'e', 'f', 'g'])
        r = {
            'a': 1,
            'b': 2,
        }
        self.assertEqual(b, r)

    def test_subset(self):
        d = {
            'a': 1,
            'b': 2,
            'c': '4',
            'e': '5',
            'f': 6,
            'g': 7,
        }
        b = UtilityDict(d)
        f = b.subset(['c', 'f', 'x'])
        r = {
            'c': '4',
            'f': 6,
            'x': None,
        }
        self.assertEqual(f, r)
        self.assertFalse(f is b)


1			# -- coding: utf-8 --
2
3			from benedict.dicts import UtilityDict
4			from datetime import datetime
5			from decimal import Decimal
6
7			import unittest
8
9
10			class UtilityDictTestCase(unittest.TestCase):
11
12			def test_clean(self):
13			d = {
14			'a': {},
15			'b': { 'x': 1 },
16			'c': [],
17			'd': [0, 1],
18			'e': 0.0,
19			'f': '',
20			'g': None,
21			'h': '0'
22			}
23
24			b = UtilityDict(d)
25			b.clean()
26			r = {
27			'b': { 'x': 1 },
28			'd': [0, 1],
29			'e': 0.0,
30			'h': '0',
31			}
32			self.assertEqual(b, r)
33
34			b = UtilityDict(d)
35			b.clean(dicts=False)
36			r = {
37			'a': {},
38			'b': { 'x': 1 },
39			'd': [0, 1],
40			'e': 0.0,
41			'h': '0'
42			}
43			self.assertEqual(b, r)
44
45			b = UtilityDict(d)
46			b.clean(lists=False)
47			r = {
48			'b': { 'x': 1 },
49			'c': [],
50			'd': [0, 1],
51			'e': 0.0,
52			'h': '0'
53			}
54			self.assertEqual(b, r)
55
56			b = UtilityDict(d)
57			b.clean(strings=False)
58			r = {
59			'b': { 'x': 1 },
60			'd': [0, 1],
61			'e': 0.0,
62			'f': '',
63			'h': '0',
64			}
65			self.assertEqual(b, r)
66
67			def test_deepcopy(self):
68			d = {
69			'a': {
70			'b': {
71			'c': 1
72			}
73			}
74			}
75			b = UtilityDict(d)
76			c = b.deepcopy()
77			self.assertEqual(b, c)
78			self.assertFalse(c is b)
79			c['a']['b']['c'] = 2
80			self.assertEqual(b['a']['b']['c'], 1)
81			self.assertEqual(c['a']['b']['c'], 2)
82
83			def test_dump(self):
84			d = {
85			'a': {
86			'b': {
87			'c': 1
88			}
89			}
90			}
91			b = UtilityDict(d)
92			expected_output = """{
93			"a": {
94			"b": {
95			"c": 1
96			}
97			}
98			}"""
99			output = UtilityDict.dump(b)
100			self.assertEqual(output, expected_output)
101
102			def test_dump_items(self):
103			d = {
104			'a': {
105			'b': {
106			'c': 1
107			}
108			}
109			}
110			b = UtilityDict(d)
111			print(b.dump_items())
112			expected_output = """{
113			"a": {
114			"b": {
115			"c": 1
116			}
117			}
118			}"""
119			output = b.dump_items()
120			self.assertEqual(output, expected_output)
121
122			def test_dump_items_with_key(self):
123			d = {
124			'a': {
125			'b': 1
126			}
127			}
128			b = UtilityDict(d)
129			expected_output = """{
130			"b": 1
131			}"""
132			output = b.dump_items('a')
133			self.assertEqual(output, expected_output)
134
135			def test_dump_items_with_datetime(self):
136			d = {
137			'datetime': datetime(2019, 6, 11),
138			}
139			b = UtilityDict(d)
140			expected_output = """{
141			"datetime": "2019-06-11 00:00:00"
142			}"""
143			output = b.dump_items()
144			self.assertEqual(output, expected_output)
145
146			def test_dump_items_with_decimal(self):
147			d = {
148			'decimal': Decimal('1.75'),
149			}
150			b = UtilityDict(d)
151			expected_output = """{
152			"decimal": "1.75"
153			}"""
154			output = b.dump_items()
155			self.assertEqual(output, expected_output)
156
157			def test_filter(self):
158			d = {
159			'a': 1,
160			'b': 2,
161			'c': '4',
162			'e': '5',
163			'f': 6,
164			'g': 7,
165			}
166			b = UtilityDict(d)
167			with self.assertRaises(ValueError):
168			f = b.filter(True)
169			f = b.filter(lambda key, val: isinstance(val, int))
170			r = {
171			'a': 1,
172			'b': 2,
173			'f': 6,
174			'g': 7,
175			}
176			self.assertEqual(f, r)
177			self.assertFalse(b is f)
178
179			def test_remove(self):
180			d = {
181			'a': 1,
182			'b': 2,
183			'c': '4',
184			'e': '5',
185			'f': 6,
186			'g': 7,
187			}
188			b = UtilityDict(d)
189			b.remove(['c', 'e', 'f', 'g'])
190			r = {
191			'a': 1,
192			'b': 2,
193			}
194			self.assertEqual(b, r)
195
196			def test_subset(self):
197			d = {
198			'a': 1,
199			'b': 2,
200			'c': '4',
201			'e': '5',
202			'f': 6,
203			'g': 7,
204			}
205			b = UtilityDict(d)
206			f = b.subset(['c', 'f', 'x'])
207			r = {
208			'c': '4',
209			'f': 6,
210			'x': None,
211			}
212			self.assertEqual(f, r)
213			self.assertFalse(f is b)
214

fabiocaccamo / python-benedict

Push — master ( 929d80...68a360 )

UtilityDictTestCase.test_clean() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like