test_jsons.TestJsons.test_load_dict() - Code Metrics - Inspection of "Added JsonSerializable class." - ramonhagenaars/jsons - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 86f2a1...1d3482 )

by Ramon

created 2018-07-16 11:11 UTC

test_jsons.TestJsons.test_load_dict() A

↳ Parent: test_jsons

Complexity

Conditions

Size

Total Lines	2
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

from enum import Enum
from typing import List
from unittest.case import TestCase
import datetime
import jsons
import json
from jsons import JsonSerializable


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)


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
9
10			class TestJsons(TestCase):
11
12			def test_dump_str(self):
13			self.assertEqual('some string', jsons.dump('some string'))
14
15			def test_dump_int(self):
16			self.assertEqual(123, jsons.dump(123))
17
18			def test_dump_float(self):
19			self.assertEqual(123.456, jsons.dump(123.456))
20
21			def test_dump_bool(self):
22			self.assertEqual(True, jsons.dump(True))
23
24			def test_dump_dict(self):
25			self.assertEqual({'a': 123}, jsons.dump({'a': 123}))
26
27			def test_dump_none(self):
28			self.assertEqual(None, jsons.dump(None))
29
30			def test_dump_datetime(self):
31			d = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
32			self.assertEqual('2018-07-08T21:34:00Z', jsons.dump(d))
33
34			def test_dump_datetime_with_microseconds(self):
35			d = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34,
36			microsecond=123456)
37			self.assertEqual('2018-07-08T21:34:00.123456Z', jsons.dump(d))
38
39			def test_dump_enum(self):
40			class E(Enum):
41			x = 1
42			y = 2
43			self.assertEqual('x', jsons.dump(E.x))
44
45			def test_dump_list(self):
46			d = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
47			l = [1, 2, 3, [4, 5, [d]]]
48			self.assertEqual([1, 2, 3, [4, 5, ['2018-07-08T21:34:00Z']]],
49			jsons.dump(l))
50
51			def test_dump_object(self):
52			class A:
53			def __init__(self):
54			self.name = 'A'
55
56			class B:
57			def __init__(self, a):
58			self.a = a
59			self.name = 'B'
60
61			b = B(A())
62			self.assertEqual({'name': 'B', 'a': {'name': 'A'}}, jsons.dump(b))
63
64			def test_load_str(self):
65			self.assertEqual('some string', jsons.load('some string'))
66
67			def test_load_int(self):
68			self.assertEqual(123, jsons.load(123))
69
70			def test_load_float(self):
71			self.assertEqual(123.456, jsons.load(123.456))
72
73			def test_load_bool(self):
74			self.assertEqual(True, jsons.load(True))
75
76			def test_load_dict(self):
77			self.assertEqual({'a': 123}, jsons.load({'a': 123}))
78
79			def test_load_none(self):
80			self.assertEqual(None, jsons.load(None))
81
82			def test_load_datetime(self):
83			d = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
84			self.assertEqual(d, jsons.load('2018-07-08T21:34:00Z'))
85
86			def test_load_enum(self):
87			class E(Enum):
88			x = 1
89			y = 2
90
91			self.assertEqual(E.x, jsons.load('x', E))
92
93			def test_load_list(self):
94			d = datetime.datetime(year=2018, month=7, day=8, hour=21, minute=34)
95			l = [1, 2, 3, [4, 5, [d]]]
96			expectation = [1, 2, 3, [4, 5, ['2018-07-08T21:34:00Z']]]
97			self.assertEqual(l, jsons.load(expectation))
98
99			def test_load_object(self):
100			class A:
101			def __init__(self):
102			self.name = 'A'
103
104			class B:
105			def __init__(self, a: A):
106			self.a = a
107			self.name = 'B'
108
109			b = B(A())
110			loaded_b = jsons.load({'name': 'B', 'a': {'name': 'A'}}, B)
111			self.assertEqual(b.name, loaded_b.name)
112			self.assertEqual(b.a.name, loaded_b.a.name)
113
114			def test_load_object_with_default_value(self):
115			class A:
116			def __init__(self, x, y = 2):
117			self.x = x
118			self.y = y
119
120			a = A(1)
121			loaded_a = jsons.load({'x': 1}, A)
122			self.assertEqual(a.x, loaded_a.x)
123			self.assertEqual(a.y, loaded_a.y)
124
125			def test_dump_load_object_deep(self):
126			class A:
127			def __init__(self):
128			self.name = 'A'
129
130			class B:
131			def __init__(self, list_a: List[A],
132			list_dates: List[datetime.datetime]):
133			self.list_a = list_a
134			self.list_dates = list_dates
135			self.name = 'B'
136
137			class C:
138			def __init__(self, list_b: List[B]):
139			self.list_b = list_b
140
141			c = C([B([A(), A()], []),
142			B([], [datetime.datetime.now(), datetime.datetime.now()])])
143			dumped_c = jsons.dump(c)
144			loaded_c = jsons.load(dumped_c, C)
145			self.assertEqual(loaded_c.list_b[0].name, 'B')
146			self.assertEqual(loaded_c.list_b[0].list_a[0].name, 'A')
147			self.assertEqual(loaded_c.list_b[0].list_a[1].name, 'A')
148			self.assertEqual(loaded_c.list_b[1].list_dates[0].year,
149			c.list_b[1].list_dates[0].year)
150			self.assertEqual(loaded_c.list_b[1].list_dates[0].month,
151			c.list_b[1].list_dates[0].month)
152			self.assertEqual(loaded_c.list_b[1].list_dates[0].day,
153			c.list_b[1].list_dates[0].day)
154			self.assertEqual(loaded_c.list_b[1].list_dates[0].hour,
155			c.list_b[1].list_dates[0].hour)
156			self.assertEqual(loaded_c.list_b[1].list_dates[0].minute,
157			c.list_b[1].list_dates[0].minute)
158			self.assertEqual(loaded_c.list_b[1].list_dates[0].second,
159			c.list_b[1].list_dates[0].second)
160
161			def test_dumps(self):
162			class A:
163			def __init__(self):
164			self.name = 'A'
165
166			class B:
167			def __init__(self, a: A):
168			self.a = a
169			self.name = 'B'
170
171			sdumped = jsons.dumps(B(A()))
172			s = json.dumps({'a': {'name': 'A'}, 'name': 'B'})
173			self.assertEqual(s, sdumped)
174
175			def test_loads(self):
176			class A:
177			def __init__(self):
178			self.name = 'A'
179
180			class B:
181			def __init__(self, a: A):
182			self.a = a
183			self.name = 'B'
184
185			s = json.dumps({'a': {'name': 'A'}, 'name': 'B'})
186			loaded_dict = jsons.loads(s)
187			self.assertEqual('B', loaded_dict['name'])
188			self.assertEqual('A', loaded_dict['a']['name'])
189
190			loaded_obj = jsons.loads(s, B)
191			self.assertEqual('B', loaded_obj.name)
192			self.assertEqual('A', loaded_obj.a.name)
193
194			def test_jsonserializable(self):
195			class Person(JsonSerializable):
196			def __init__(self, name, age):
197			self.name = name
198			self.age = age
199
200			person = Person('John', 65)
201			person_json = person.json
202			person_loaded = Person.from_json(person_json)
203
204			self.assertEqual(person_json, {'name': 'John', 'age': 65})
205			self.assertEqual(person_loaded.name, 'John')
206			self.assertEqual(person_loaded.age, 65)
207

ramonhagenaars / jsons

Push — master ( 86f2a1...1d3482 )

test_jsons.TestJsons.test_load_dict() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like