test_jsons.TestJsons.test_dump_object_strip_nulls() - Code Metrics - Inspection of "Added a note." - ramonhagenaars/jsons - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 5f33ea...c0ff9a )

by Ramon

created 2018-07-23 05:57 UTC

TestJsons.test_dump_object_strip_nulls() A

↳ Parent: test_jsons

Complexity

Conditions

Size

Total Lines	13
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	11
nop	1
dl	0
loc	13
rs	9.85
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, KEY_TRANSFORMER_CAMELCASE
from jsons._common_impl import snakecase, camelcase, pascalcase, lispcase
from jsons.deserializers import KEY_TRANSFORMER_SNAKECASE


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_dump_object_strip_nulls(self):
        class A:
            def __init__(self):
                self.name = None  # This will be stripped.

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

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

    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_jsonserializable_with_kwargs(self):
        custom_serializable = JsonSerializable\
            .with_dump(key_transformer=KEY_TRANSFORMER_CAMELCASE)\
            .with_load(key_transformer=KEY_TRANSFORMER_SNAKECASE)

        class Person(custom_serializable):
            def __init__(self, my_name):
                self.my_name = my_name

        person = Person('John')
        person_json = person.json  # should have camelCase
        person_loaded = Person.from_json(person_json)  # should have snake_case

        self.assertEqual(person_json, {'myName': 'John'})
        self.assertEqual(person_loaded.my_name, 'John')

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

ramonhagenaars / jsons

Push — master ( 5f33ea...c0ff9a )

TestJsons.test_dump_object_strip_nulls() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like