class TestEncoder:
def setup_class(self):
self.dcwdc = JsonModel(DataclassWithDataclass)
self.dcxs = JsonModel(DataclassXs)
def test_nested_dataclass(self):
actual = self.dcwdc.dump(DataclassWithDataclass(DataclassWithList([1
])))
expected = json.dumps({"dcWithList": {"xs": [1]}})
assert actual == expected
def test_nested_list_of_dataclasses(self):
actual = self.dcxs.dump(DataclassXs([DataclassX(0), DataclassX(1)]))
expected = json.dumps({"xs": [{"x": 0}, {"x": 1}]})
assert actual == expected
class TestTime:
def setup_class(self):
self.model = JsonModel(Alarm)
self.json = f'{{"at": "07:00:00", "enabled": true}}'
self.dataclass = Alarm(time(7, 0, 0), enabled=True)
def test_load(self):
assert self.model.load(self.json) == self.dataclass
def test_dump(self):
assert self.model.dump(self.dataclass) == self.json
class TestDate:
def setup_class(self):
self.model = JsonModel(Event)
self.json = f'{{"what": "Nobel Prize", "when": "1922-09-09"}}'
self.dataclass = Event("Nobel Prize", date(1922, 9, 9))
def test_load(self):
assert self.model.load(self.json) == self.dataclass
def test_dump(self):
assert self.model.dump(self.dataclass) == self.json
class TestTimestamp:
def setup_class(self):
self.model = JsonModel(TimestampDatetime)
dt = datetime(2018, 11, 17, 16, 55, 28, 456753, tzinfo=timezone.utc)
ts = dt.timestamp()
self.json = f'{{"value": {ts}}}'
self.dataclass = TimestampDatetime(Timestamp(dt))
def test_load(self):
assert self.model.load(self.json) == self.dataclass
def test_dump(self):
assert self.model.dump(self.dataclass) == self.json
class TestTypes:
def setup_class(self):
self.uuid_s = 'd1d61dd7-c036-47d3-a6ed-91cc2e885fc8'
self.dc_uuid_json = f'{{"id": "{self.uuid_s}"}}'
self.uuid_model = JsonModel(DataclassWithUuid)
def test_uuid_decode(self):
actual = self.uuid_model.load(self.dc_uuid_json)
assert actual == DataclassWithUuid(UUID(self.uuid_s))
def test_uuid_encode(self):
actual = self.uuid_model.dump(DataclassWithUuid(UUID(self.uuid_s)))
assert actual == self.dc_uuid_json
class TestDefaultDatetime:
def setup_class(self):
self.model = JsonModel(Post)
dt = datetime(2018, 11, 17, 16, 55, 28, 456753, tzinfo=timezone.utc)
iso = dt.isoformat()
self.json = f'{{"createdAt": "{iso}"}}'
self.dataclass = Post(datetime.fromisoformat(iso))
def test_load(self):
assert self.model.load(self.json) == self.dataclass
def test_dump(self):
assert self.model.dump(self.dataclass) == self.json
class TestSerializer:
def setup_class(self):
serializers = field_serializers([UserIdSerializer])
self.model = JsonModel(User, serializers=serializers)
def test_dump(self):
actual = self.model.dump(
User(id=UserId(0), username='******', password='******', age=None))
expected = '{"id": 0, "username": "******", "password": "******", "age": null}'
assert actual == expected
def test_load(self):
actual = self.model.load(
'{"id": 0, "username": "******", "password": "******", "age": null}')
expected = User(id=UserId(0),
username='******',
password='******',
age=None)
assert actual == expected
class TestDefaults:
def setup_class(self):
self.model = JsonModel(User)
def test_invalid_class(self):
with pytest.raises(AssertionError):
JsonModel(dict, serializers=[])
def test_load(self):
user = self.model.load(
'{"id": {"value": 0}, "username": "******", "password": "******", "age": null}'
)
assert user == User(id=UserId(0),
username='******',
password='******',
age=None)
def test_load_many(self):
expected = [
User(id=UserId(0), username='******', password='******', age=None),
User(id=UserId(1), username='******', password='******', age=23)
]
data = '[{"id": {"value": 0}, "username": "******", "password": "******", "age": null},' \
'{"id": {"value": 1}, "username": "******", "password": "******", "age": 23}]'
actual = self.model.load_many(data)
assert actual == expected
def test_dump(self):
user = User(id=UserId(0), username='******', password='******', age=None)
d = self.model.dump(user)
assert d == '{"id": {"value": 0}, "username": "******", "password": "******", "age": null}'
def test_dump_many(self):
user1 = User(id=UserId(0),
username='******',
password='******',
age=None)
user2 = User(id=UserId(1), username='******', password='******', age=23)
expected = '[{"id": {"value": 0}, "username": "******", "password": "******", "age": null}, ' \
'{"id": {"value": 1}, "username": "******", "password": "******", "age": 23}]'
actual = self.model.dump_many([user1, user2])
assert actual == expected
def test_json_skips_transformation():
model = JsonModel(Snack, camel_case=False)
actual = model.dump(Snack(1, 2, 3, 4))
expected = '{"butterbeer": 1, "dragon_tartare": 2, "hogwarts_steak_and_kidney_pie_": 3, "_pumpkin__fizz": 4}'
assert actual == expected
def test_json_transforms_case():
model = JsonModel(Snack, camel_case=True)
actual = model.dump(Snack(1, 2, 3, 4))
expected = '{"butterbeer": 1, "dragonTartare": 2, "hogwartsSteakAndKidneyPie": 3, "pumpkinFizz": 4}'
assert actual == expected
def test_course(self):
model = JsonModel(Course)
assert model.dump(self.c) == '{"id": 1, ' \
'"name": "course", ' \
'"professor": {"id": 1, "name": "professor"}, ' \
'"students": [{"id": 1, "name": "student"}]}'
def test_professor(self):
model = JsonModel(Professor)
assert model.dump(self.p) == '{"id": 1, "name": "professor"}'
def test_student(self):
model = JsonModel(Student)
assert model.dump(self.s1) == '{"id": 1, "name": "student"}'
def test_union_int_none(self):
s = JsonModel(DataclassWithUnionIntNone)
assert s.dump(DataclassWithUnionIntNone(1)) == '{"x": 1}'
assert s.dump(DataclassWithUnionIntNone(None)) == '{"x": null}'
def test_optional_str(self):
s = JsonModel(DataclassWithOptionalStr)
assert s.dump(DataclassWithOptionalStr('1')) == '{"x": "1"}'
assert s.dump(DataclassWithOptionalStr(None)) == '{"x": null}'
assert s.dump(DataclassWithOptionalStr()) == '{"x": null}'
def test_optional(self):
s = JsonModel(DataclassWithOptional)
assert s.dump(DataclassWithOptional(1)) == '{"x": 1}'
assert s.dump(DataclassWithOptional(None)) == '{"x": null}'
