test_jsons.TestJsons.test_dump_tuple() - Code Metrics - Inspection of "Improved tuple (de)serialization." - ramonhagenaars/jsons - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( b4eeac...5f33ea )

by Ramon

created 2018-07-20 15:05 UTC

test_jsons.TestJsons.test_dump_tuple() A

↳ Parent: test_jsons

Complexity

Conditions

Size

Total Lines	5
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	5
nop	1
dl	0
loc	5
rs	10
c	0
b	0
f	0

from enum import Enum
from typing import List, Tuple
from unittest.case import TestCase
import datetime
import jsons
import json
from jsons import JsonSerializable
from jsons._common_impl import snakecase, camelcase, pascalcase, lispcase


class TestJsons(TestCase):

    def test_dump_str(self):
        self.assertEqual('some string', jsons.dump('some string'))

    def test_dump_int(self):
        self.assertEqual(123, jsons.dump(123))

    def test_dump_float(self):
        self.assertEqual(123.456, jsons.dump(123.456))

    def test_dump_bool(self):
        self.assertEqual(True, jsons.dump(True))

    def test_dump_dict(self):
        d = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
        dict_ = {'a': {'b': {'c': {'d': d}}}}
        expectation = {'a': {'b': {'c': {'d': '2018-07-08T21:34:00Z'}}}}
        self.assertEqual(expectation, jsons.dump(dict_))

    def test_dump_none(self):
        self.assertEqual(None, jsons.dump(None))

    def test_dump_datetime(self):
        d = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
        self.assertEqual('2018-07-08T21:34:00Z', jsons.dump(d))

    def test_dump_datetime_with_microseconds(self):
        d = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34,
                              microsecond=123456)
        self.assertEqual('2018-07-08T21:34:00.123456Z', jsons.dump(d))

    def test_dump_enum(self):
        class E(Enum):
            x = 1
            y = 2
        self.assertEqual('x', jsons.dump(E.x))
        self.assertEqual(2, jsons.dump(E.y, use_enum_name=False))

    def test_dump_list(self):
        d = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
        l = [1, 2, 3, [4, 5, [d]]]
        self.assertEqual([1, 2, 3, [4, 5, ['2018-07-08T21:34:00Z']]],
                         jsons.dump(l))

    def test_dump_tuple(self):
        dat = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
        tup = (1, 2, 3, [4, 5, (dat,)])
        self.assertEqual([1, 2, 3, [4, 5, ['2018-07-08T21:34:00Z']]],
                         jsons.dump(tup))

    def test_dump_object(self):
        class A:
            def __init__(self):
                self.name = 'A'

        class B:
            def __init__(self, a):
                self.a = a
                self.name = 'B'

        b = B(A())
        self.assertEqual({'name': 'B', 'a': {'name': 'A'}}, jsons.dump(b))

    def test_load_str(self):
        self.assertEqual('some string', jsons.load('some string'))

    def test_load_int(self):
        self.assertEqual(123, jsons.load(123))

    def test_load_float(self):
        self.assertEqual(123.456, jsons.load(123.456))

    def test_load_bool(self):
        self.assertEqual(True, jsons.load(True))

    def test_load_dict(self):
        dumped = {'a': {'b': {'c': {'d': '2018-07-08T21:34:00Z'}}}}
        loaded = jsons.load(dumped)
        self.assertEqual(loaded['a']['b']['c']['d'].year, 2018)
        self.assertEqual(loaded['a']['b']['c']['d'].month, 7)
        self.assertEqual(loaded['a']['b']['c']['d'].day, 8)
        self.assertEqual(loaded['a']['b']['c']['d'].hour, 21)
        self.assertEqual(loaded['a']['b']['c']['d'].minute, 34)
        self.assertEqual(loaded['a']['b']['c']['d'].second, 0)

    def test_load_none(self):
        self.assertEqual(None, jsons.load(None))

    def test_load_datetime(self):
        dat = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
        self.assertEqual(dat, jsons.load('2018-07-08T21:34:00Z'))

    def test_load_enum(self):
        class E(Enum):
            x = 1
            y = 2

        self.assertEqual(E.x, jsons.load('x', E))
        self.assertEqual(E.y, jsons.load(2, E, use_enum_name=False))

    def test_load_list(self):
        dat = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
        list_ = [1, 2, 3, [4, 5, [dat]]]
        expectation = [1, 2, 3, [4, 5, ['2018-07-08T21:34:00Z']]]
        self.assertEqual(list_, jsons.load(expectation))

    def test_load_tuple(self):
        dat = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
        tup = (1, ([dat],))
        expectation = (1, (['2018-07-08T21:34:00Z'],))
        cls = Tuple[int, Tuple[List[datetime.datetime]]]
        self.assertEqual(tup, jsons.load(expectation, cls))

    def test_load_object(self):
        class A:
            def __init__(self):
                self.name = 'A'

        class B:
            def __init__(self, a: A):
                self.a = a
                self.name = 'B'

        b = B(A())
        loaded_b = jsons.load({'name': 'B', 'a': {'name': 'A'}}, B)
        self.assertEqual(b.name, loaded_b.name)
        self.assertEqual(b.a.name, loaded_b.a.name)

    def test_load_object_with_default_value(self):
        class A:
            def __init__(self, x, y = 2):
                self.x = x
                self.y = y

        a = A(1)
        loaded_a = jsons.load({'x': 1}, A)
        self.assertEqual(a.x, loaded_a.x)
        self.assertEqual(a.y, loaded_a.y)

    def test_dump_load_object_deep(self):
        class A:
            def __init__(self):
                self.name = 'A'

        class B:
            def __init__(self, list_a: List[A],
                         list_dates: List[datetime.datetime]):
                self.list_a = list_a
                self.list_dates = list_dates
                self.name = 'B'

        class C:
            def __init__(self, list_b: List[B]):
                self.list_b = list_b

        c = C([B([A(), A()], []),
               B([], [datetime.datetime.now(), datetime.datetime.now()])])
        dumped_c = jsons.dump(c)
        loaded_c = jsons.load(dumped_c, C)
        self.assertEqual(loaded_c.list_b[0].name, 'B')
        self.assertEqual(loaded_c.list_b[0].list_a[0].name, 'A')
        self.assertEqual(loaded_c.list_b[0].list_a[1].name, 'A')
        self.assertEqual(loaded_c.list_b[1].list_dates[0].year,
                         c.list_b[1].list_dates[0].year)
        self.assertEqual(loaded_c.list_b[1].list_dates[0].month,
                         c.list_b[1].list_dates[0].month)
        self.assertEqual(loaded_c.list_b[1].list_dates[0].day,
                         c.list_b[1].list_dates[0].day)
        self.assertEqual(loaded_c.list_b[1].list_dates[0].hour,
                         c.list_b[1].list_dates[0].hour)
        self.assertEqual(loaded_c.list_b[1].list_dates[0].minute,
                         c.list_b[1].list_dates[0].minute)
        self.assertEqual(loaded_c.list_b[1].list_dates[0].second,
                         c.list_b[1].list_dates[0].second)

    def test_dumps(self):
        class A:
            def __init__(self):
                self.name = 'A'

        class B:
            def __init__(self, a: A):
                self.a = a
                self.name = 'B'

        sdumped = jsons.dumps(B(A()))
        s = json.dumps({'a': {'name': 'A'}, 'name': 'B'})
        self.assertEqual(s, sdumped)

    def test_loads(self):
        class A:
            def __init__(self):
                self.name = 'A'

        class B:
            def __init__(self, a: A):
                self.a = a
                self.name = 'B'

        s = json.dumps({'a': {'name': 'A'}, 'name': 'B'})
        loaded_dict = jsons.loads(s)
        self.assertEqual('B', loaded_dict['name'])
        self.assertEqual('A', loaded_dict['a']['name'])

        loaded_obj = jsons.loads(s, B)
        self.assertEqual('B', loaded_obj.name)
        self.assertEqual('A', loaded_obj.a.name)

    def test_jsonserializable(self):
        class Person(JsonSerializable):
            def __init__(self, name, age):
                self.name = name
                self.age = age

        person = Person('John', 65)
        person_json = person.json
        person_loaded = Person.from_json(person_json)

        self.assertEqual(person_json, {'name': 'John', 'age': 65})
        self.assertEqual(person.dump(), {'name': 'John', 'age': 65})
        self.assertEqual(person_loaded.name, 'John')
        self.assertEqual(person_loaded.age, 65)
        self.assertEqual(Person.load(person_json).name, 'John')
        self.assertEqual(Person.load(person_json).age, 65)

    def test_case_transformers(self):
        camelcase_str = 'camelCase'
        snakecase_str = 'snake_case'
        pascalcase_str = 'Pascal_case'
        pascalcase_str2 = 'ABcDe'
        lispcase_str = 'lisp-case'

        self.assertEqual(camelcase(camelcase_str), 'camelCase')
        self.assertEqual(camelcase(snakecase_str), 'snakeCase')
        self.assertEqual(camelcase(pascalcase_str), 'pascalCase')
        self.assertEqual(camelcase(pascalcase_str2), 'aBcDe')
        self.assertEqual(camelcase(lispcase_str), 'lispCase')

        self.assertEqual(snakecase(camelcase_str), 'camel_case')
        self.assertEqual(snakecase(snakecase_str), 'snake_case')
        self.assertEqual(snakecase(pascalcase_str), 'pascal_case')
        self.assertEqual(snakecase(pascalcase_str2), 'a_bc_de')
        self.assertEqual(snakecase(lispcase_str), 'lisp_case')

        self.assertEqual(pascalcase(camelcase_str), 'CamelCase')
        self.assertEqual(pascalcase(snakecase_str), 'SnakeCase')
        self.assertEqual(pascalcase(pascalcase_str), 'PascalCase')
        self.assertEqual(pascalcase(pascalcase_str2), 'ABcDe')
        self.assertEqual(pascalcase(lispcase_str), 'LispCase')

        self.assertEqual(lispcase(camelcase_str), 'camel-case')
        self.assertEqual(lispcase(snakecase_str), 'snake-case')
        self.assertEqual(lispcase(pascalcase_str), 'pascal-case')
        self.assertEqual(lispcase(pascalcase_str2), 'a-bc-de')
        self.assertEqual(lispcase(lispcase_str), 'lisp-case')

    def test_serialize_and_deserialize_with_case_transformer(self):
        class A:
            def __init__(self, snake_case_str):
                self.snake_case_str = snake_case_str

        class B:
            def __init__(self, a_obj: A, camel_case_str):
                self.a_obj = a_obj
                self.camel_case_str = camel_case_str

        b = B(A('one_two'), 'theeFour')
        dumped_pascalcase = \
            jsons.dump(b, key_transformer=jsons.KEY_TRANSFORMER_PASCALCASE)
        loaded_snakecase = \
            jsons.load(dumped_pascalcase, B,
                       key_transformer=jsons.KEY_TRANSFORMER_SNAKECASE)
        expected_dump = {'AObj': {'SnakeCaseStr': 'one_two'},
                    'CamelCaseStr': 'theeFour'}
        self.assertEqual(expected_dump, dumped_pascalcase)
        self.assertEqual(loaded_snakecase.a_obj.snake_case_str, 'one_two')
        self.assertEqual(loaded_snakecase.camel_case_str, 'theeFour')


1			from enum import Enum
2			from typing import List, Tuple
3			from unittest.case import TestCase
4			import datetime
5			import jsons
6			import json
7			from jsons import JsonSerializable
8			from jsons._common_impl import snakecase, camelcase, pascalcase, lispcase
9
10
11			class TestJsons(TestCase):
12
13			def test_dump_str(self):
14			self.assertEqual('some string', jsons.dump('some string'))
15
16			def test_dump_int(self):
17			self.assertEqual(123, jsons.dump(123))
18
19			def test_dump_float(self):
20			self.assertEqual(123.456, jsons.dump(123.456))
21
22			def test_dump_bool(self):
23			self.assertEqual(True, jsons.dump(True))
24
25			def test_dump_dict(self):
26			d = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
27			dict_ = {'a': {'b': {'c': {'d': d}}}}
28			expectation = {'a': {'b': {'c': {'d': '2018-07-08T21:34:00Z'}}}}
29			self.assertEqual(expectation, jsons.dump(dict_))
30
31			def test_dump_none(self):
32			self.assertEqual(None, jsons.dump(None))
33
34			def test_dump_datetime(self):
35			d = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
36			self.assertEqual('2018-07-08T21:34:00Z', jsons.dump(d))
37
38			def test_dump_datetime_with_microseconds(self):
39			d = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34,
40			microsecond=123456)
41			self.assertEqual('2018-07-08T21:34:00.123456Z', jsons.dump(d))
42
43			def test_dump_enum(self):
44			class E(Enum):
45			x = 1
46			y = 2
47			self.assertEqual('x', jsons.dump(E.x))
48			self.assertEqual(2, jsons.dump(E.y, use_enum_name=False))
49
50			def test_dump_list(self):
51			d = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
52			l = [1, 2, 3, [4, 5, [d]]]
53			self.assertEqual([1, 2, 3, [4, 5, ['2018-07-08T21:34:00Z']]],
54			jsons.dump(l))
55
56			def test_dump_tuple(self):
57			dat = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
58			tup = (1, 2, 3, [4, 5, (dat,)])
59			self.assertEqual([1, 2, 3, [4, 5, ['2018-07-08T21:34:00Z']]],
60			jsons.dump(tup))
61
62			def test_dump_object(self):
63			class A:
64			def __init__(self):
65			self.name = 'A'
66
67			class B:
68			def __init__(self, a):
69			self.a = a
70			self.name = 'B'
71
72			b = B(A())
73			self.assertEqual({'name': 'B', 'a': {'name': 'A'}}, jsons.dump(b))
74
75			def test_load_str(self):
76			self.assertEqual('some string', jsons.load('some string'))
77
78			def test_load_int(self):
79			self.assertEqual(123, jsons.load(123))
80
81			def test_load_float(self):
82			self.assertEqual(123.456, jsons.load(123.456))
83
84			def test_load_bool(self):
85			self.assertEqual(True, jsons.load(True))
86
87			def test_load_dict(self):
88			dumped = {'a': {'b': {'c': {'d': '2018-07-08T21:34:00Z'}}}}
89			loaded = jsons.load(dumped)
90			self.assertEqual(loaded['a']['b']['c']['d'].year, 2018)
91			self.assertEqual(loaded['a']['b']['c']['d'].month, 7)
92			self.assertEqual(loaded['a']['b']['c']['d'].day, 8)
93			self.assertEqual(loaded['a']['b']['c']['d'].hour, 21)
94			self.assertEqual(loaded['a']['b']['c']['d'].minute, 34)
95			self.assertEqual(loaded['a']['b']['c']['d'].second, 0)
96
97			def test_load_none(self):
98			self.assertEqual(None, jsons.load(None))
99
100			def test_load_datetime(self):
101			dat = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
102			self.assertEqual(dat, jsons.load('2018-07-08T21:34:00Z'))
103
104			def test_load_enum(self):
105			class E(Enum):
106			x = 1
107			y = 2
108
109			self.assertEqual(E.x, jsons.load('x', E))
110			self.assertEqual(E.y, jsons.load(2, E, use_enum_name=False))
111
112			def test_load_list(self):
113			dat = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
114			list_ = [1, 2, 3, [4, 5, [dat]]]
115			expectation = [1, 2, 3, [4, 5, ['2018-07-08T21:34:00Z']]]
116			self.assertEqual(list_, jsons.load(expectation))
117
118			def test_load_tuple(self):
119			dat = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
120			tup = (1, ([dat],))
121			expectation = (1, (['2018-07-08T21:34:00Z'],))
122			cls = Tuple[int, Tuple[List[datetime.datetime]]]
123			self.assertEqual(tup, jsons.load(expectation, cls))
124
125			def test_load_object(self):
126			class A:
127			def __init__(self):
128			self.name = 'A'
129
130			class B:
131			def __init__(self, a: A):
132			self.a = a
133			self.name = 'B'
134
135			b = B(A())
136			loaded_b = jsons.load({'name': 'B', 'a': {'name': 'A'}}, B)
137			self.assertEqual(b.name, loaded_b.name)
138			self.assertEqual(b.a.name, loaded_b.a.name)
139
140			def test_load_object_with_default_value(self):
141			class A:
142			def __init__(self, x, y = 2):
143			self.x = x
144			self.y = y
145
146			a = A(1)
147			loaded_a = jsons.load({'x': 1}, A)
148			self.assertEqual(a.x, loaded_a.x)
149			self.assertEqual(a.y, loaded_a.y)
150
151			def test_dump_load_object_deep(self):
152			class A:
153			def __init__(self):
154			self.name = 'A'
155
156			class B:
157			def __init__(self, list_a: List[A],
158			list_dates: List[datetime.datetime]):
159			self.list_a = list_a
160			self.list_dates = list_dates
161			self.name = 'B'
162
163			class C:
164			def __init__(self, list_b: List[B]):
165			self.list_b = list_b
166
167			c = C([B([A(), A()], []),
168			B([], [datetime.datetime.now(), datetime.datetime.now()])])
169			dumped_c = jsons.dump(c)
170			loaded_c = jsons.load(dumped_c, C)
171			self.assertEqual(loaded_c.list_b[0].name, 'B')
172			self.assertEqual(loaded_c.list_b[0].list_a[0].name, 'A')
173			self.assertEqual(loaded_c.list_b[0].list_a[1].name, 'A')
174			self.assertEqual(loaded_c.list_b[1].list_dates[0].year,
175			c.list_b[1].list_dates[0].year)
176			self.assertEqual(loaded_c.list_b[1].list_dates[0].month,
177			c.list_b[1].list_dates[0].month)
178			self.assertEqual(loaded_c.list_b[1].list_dates[0].day,
179			c.list_b[1].list_dates[0].day)
180			self.assertEqual(loaded_c.list_b[1].list_dates[0].hour,
181			c.list_b[1].list_dates[0].hour)
182			self.assertEqual(loaded_c.list_b[1].list_dates[0].minute,
183			c.list_b[1].list_dates[0].minute)
184			self.assertEqual(loaded_c.list_b[1].list_dates[0].second,
185			c.list_b[1].list_dates[0].second)
186
187			def test_dumps(self):
188			class A:
189			def __init__(self):
190			self.name = 'A'
191
192			class B:
193			def __init__(self, a: A):
194			self.a = a
195			self.name = 'B'
196
197			sdumped = jsons.dumps(B(A()))
198			s = json.dumps({'a': {'name': 'A'}, 'name': 'B'})
199			self.assertEqual(s, sdumped)
200
201			def test_loads(self):
202			class A:
203			def __init__(self):
204			self.name = 'A'
205
206			class B:
207			def __init__(self, a: A):
208			self.a = a
209			self.name = 'B'
210
211			s = json.dumps({'a': {'name': 'A'}, 'name': 'B'})
212			loaded_dict = jsons.loads(s)
213			self.assertEqual('B', loaded_dict['name'])
214			self.assertEqual('A', loaded_dict['a']['name'])
215
216			loaded_obj = jsons.loads(s, B)
217			self.assertEqual('B', loaded_obj.name)
218			self.assertEqual('A', loaded_obj.a.name)
219
220			def test_jsonserializable(self):
221			class Person(JsonSerializable):
222			def __init__(self, name, age):
223			self.name = name
224			self.age = age
225
226			person = Person('John', 65)
227			person_json = person.json
228			person_loaded = Person.from_json(person_json)
229
230			self.assertEqual(person_json, {'name': 'John', 'age': 65})
231			self.assertEqual(person.dump(), {'name': 'John', 'age': 65})
232			self.assertEqual(person_loaded.name, 'John')
233			self.assertEqual(person_loaded.age, 65)
234			self.assertEqual(Person.load(person_json).name, 'John')
235			self.assertEqual(Person.load(person_json).age, 65)
236
237			def test_case_transformers(self):
238			camelcase_str = 'camelCase'
239			snakecase_str = 'snake_case'
240			pascalcase_str = 'Pascal_case'
241			pascalcase_str2 = 'ABcDe'
242			lispcase_str = 'lisp-case'
243
244			self.assertEqual(camelcase(camelcase_str), 'camelCase')
245			self.assertEqual(camelcase(snakecase_str), 'snakeCase')
246			self.assertEqual(camelcase(pascalcase_str), 'pascalCase')
247			self.assertEqual(camelcase(pascalcase_str2), 'aBcDe')
248			self.assertEqual(camelcase(lispcase_str), 'lispCase')
249
250			self.assertEqual(snakecase(camelcase_str), 'camel_case')
251			self.assertEqual(snakecase(snakecase_str), 'snake_case')
252			self.assertEqual(snakecase(pascalcase_str), 'pascal_case')
253			self.assertEqual(snakecase(pascalcase_str2), 'a_bc_de')
254			self.assertEqual(snakecase(lispcase_str), 'lisp_case')
255
256			self.assertEqual(pascalcase(camelcase_str), 'CamelCase')
257			self.assertEqual(pascalcase(snakecase_str), 'SnakeCase')
258			self.assertEqual(pascalcase(pascalcase_str), 'PascalCase')
259			self.assertEqual(pascalcase(pascalcase_str2), 'ABcDe')
260			self.assertEqual(pascalcase(lispcase_str), 'LispCase')
261
262			self.assertEqual(lispcase(camelcase_str), 'camel-case')
263			self.assertEqual(lispcase(snakecase_str), 'snake-case')
264			self.assertEqual(lispcase(pascalcase_str), 'pascal-case')
265			self.assertEqual(lispcase(pascalcase_str2), 'a-bc-de')
266			self.assertEqual(lispcase(lispcase_str), 'lisp-case')
267
268			def test_serialize_and_deserialize_with_case_transformer(self):
269			class A:
270			def __init__(self, snake_case_str):
271			self.snake_case_str = snake_case_str
272
273			class B:
274			def __init__(self, a_obj: A, camel_case_str):
275			self.a_obj = a_obj
276			self.camel_case_str = camel_case_str
277
278			b = B(A('one_two'), 'theeFour')
279			dumped_pascalcase = \
280			jsons.dump(b, key_transformer=jsons.KEY_TRANSFORMER_PASCALCASE)
281			loaded_snakecase = \
282			jsons.load(dumped_pascalcase, B,
283			key_transformer=jsons.KEY_TRANSFORMER_SNAKECASE)
284			expected_dump = {'AObj': {'SnakeCaseStr': 'one_two'},
285			'CamelCaseStr': 'theeFour'}
286			self.assertEqual(expected_dump, dumped_pascalcase)
287			self.assertEqual(loaded_snakecase.a_obj.snake_case_str, 'one_two')
288			self.assertEqual(loaded_snakecase.camel_case_str, 'theeFour')
289

ramonhagenaars / jsons

Push — master ( b4eeac...5f33ea )

test_jsons.TestJsons.test_dump_tuple() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like