test_jsons.TestJsons.test_case_transformers() - Code Metrics - Inspection of "Added the feature that allows the case transformat..." - ramonhagenaars/jsons - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 9b1fb7...3baa10 )

by Ramon

created 2018-07-18 19:17 UTC

test_jsons.TestJsons.test_case_transformers() A

↳ Parent: test_jsons

Complexity

Conditions

Size

Total Lines	30
Code Lines	26

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	26
nop	1
dl	0
loc	30
rs	9.256
c	0
b	0
f	0

from enum import Enum
from typing import List
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):
        self.assertEqual({'a': 123}, jsons.dump({'a': 123}))

    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))

    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_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):
        self.assertEqual({'a': 123}, jsons.load({'a': 123}))

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

    def test_load_datetime(self):
        d = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
        self.assertEqual(d, 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))

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

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

ramonhagenaars / jsons

Push — master ( 9b1fb7...3baa10 )

test_jsons.TestJsons.test_case_transformers() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like