class TestLiteral(TestCase):
def setUp(self) -> None:
self.factory = Factory()
@params(*LITERALS)
def test_literal_fail(self, literal):
abc = literal["a", "b", "c"]
one = literal[1]
with self.assertRaises(ValueError):
self.factory.load("d", abc)
with self.assertRaises(ValueError):
self.factory.load(1.0, one)
@params(*LITERALS)
def test_literal(self, literal):
abc = literal["a", "b", "c"]
one = literal[1]
self.assertEqual(self.factory.load("a", abc), "a")
self.assertEqual(self.factory.load("b", abc), "b")
self.assertEqual(self.factory.load("c", abc), "c")
self.assertEqual(self.factory.load(1, one), 1)
self.assertEqual(self.factory.dump("a", abc), "a")
self.assertEqual(self.factory.dump("b", abc), "b")
self.assertEqual(self.factory.dump("c", abc), "c")
self.assertEqual(self.factory.dump("Z", abc), "Z")
self.assertEqual(self.factory.dump(1, one), 1)
def test_dump_two(self):
factory = Factory(schemas={A: schema})
expected = {"a": {"b": ["hello"]}, "y": "world"}
expected2 = {"a": {"b": ["hello2"]}, "y": "world2"}
data = A("hello", "world")
data2 = A("hello2", "world2")
self.assertEqual(expected, factory.dump(data, A))
self.assertEqual(expected2, factory.dump(data2, A))
class TestGeneric(TestCase):
def setUp(self) -> None:
self.factory = Factory()
def test_self(self):
linked = LinkedList(1, LinkedList(2))
serial = {"data": 1, "next": {"data": 2, "next": None}}
self.assertEqual(self.factory.dump(linked), serial)
self.assertEqual(self.factory.load(serial, LinkedList), linked)
def test_two_classes(self):
a = A(B(A(None)))
serial = {"b": {"a": {"b": None}}}
self.assertEqual(self.factory.dump(a), serial)
self.assertEqual(self.factory.load(serial, A), a)
def test_dump_list(self):
factory = Factory(schemas={
A: schema_list,
}, )
expected = [["hello", "world"]]
data = A("hello", "world")
self.assertEqual(expected, factory.dump(data, A))
def test_store_separate_parse(self):
factory = Factory(default_schema=Schema(unknown=["unknown",
"sub"], ), )
data = DataAllUnknown(Sub("b"))
serialized = {"a": "AA", "b": "b"}
self.assertEqual(data, factory.load(serialized, DataAllUnknown))
self.assertEqual({"b": "b"}, factory.dump(data))
def test_schema_dump(self):
factory = Factory(schemas={
FakeFoo[str]: Schema(name_mapping={"value": "s"}),
FakeFoo: Schema(name_mapping={"value": "v"}),
})
# self.assertEqual(factory.dump(FakeFoo("hello"), FakeFoo[str]), {"s": "hello"})
self.assertEqual(factory.dump(FakeFoo("hello")), {"v": "hello"})
def test_mapping(self):
factory = Factory(schemas={
Data: Schema(name_mapping={"b": "d"}, ),
}, )
data = Data("AA", "BB", "CC")
serial = {"a": "AA", "d": "BB", "c": "CC"}
self.assertEqual(factory.dump(data), serial)
self.assertEqual(factory.load(serial, Data), data)
def test_only(self):
factory = Factory(schemas={
Data: Schema(only=("b", ), ),
}, )
data = Data("AA", "BB", "CC")
serial = {"b": "BB"}
self.assertEqual(factory.dump(data), serial)
data2 = Data(b="BB")
self.assertEqual(factory.load(serial, Data), data2)
def test_exclude(self):
factory = Factory(schemas={
Data: Schema(exclude=("b", ), ),
}, )
data = Data("AA", "BB", "CC")
serial = {"a": "AA", "c": "CC"}
self.assertEqual(factory.dump(data), serial)
data2 = Data(a="AA", c="CC")
self.assertEqual(factory.load(serial, Data), data2)
def test_skip_internal(self):
factory = Factory(schemas={
Data: Schema(skip_internal=True, ),
}, )
data = Data("AA", "BB", "CC", "DD")
serial = {"a": "AA", "c": "CC", "b": "BB"}
self.assertEqual(factory.dump(data), serial)
data2 = Data("AA", "BB", "CC")
self.assertEqual(factory.load(serial, Data), data2)
def test_schema_dump_inner(self):
factory = Factory(
schemas={
FooBaz[int]: Schema(name_mapping={"foo": "bar"}),
Foo[int]: Schema(name_mapping={"value": "v"})
})
self.assertEqual(factory.dump(FooBaz(Foo(1)), FooBaz[int]),
{"bar": {
"v": 1
}})
def test_store_separate(self):
factory = Factory(
default_schema=Schema(
unknown="unknown",
),
)
data = Data("AA", {"b": "b"})
serialized = {"a": "AA", "b": "b"}
self.assertEqual(data, factory.load(serialized, Data))
self.assertEqual({"a": "AA", "b": "b", "sub": None}, factory.dump(data))
def test_dump(self):
factory = Factory(schemas={
A: schema,
}, )
expected = {
"a": {
"b": ["hello"]
},
"y": "world",
}
data = A("hello", "world")
self.assertEqual(expected, factory.dump(data, A))
def test_trailing_mapping(self):
factory = Factory(schemas={
Data:
Schema(
name_mapping={"c_": "c_"},
trim_trailing_underscore=True,
),
}, )
data = Data("AA", "BB", "CC")
serial = {"a": "AA", "b": "BB", "c_": "CC"}
self.assertEqual(factory.dump(data), serial)
self.assertEqual(factory.load(serial, Data), data)
def test_keep_all(self):
factory = Factory(default_schema=Schema(
trim_trailing_underscore=False,
skip_internal=False,
))
data = Data("1", "2", "3")
serial = {
"last_": "1",
"_first": "2",
"normal": "3",
}
self.assertEqual(factory.dump(data), serial)
self.assertEqual(factory.load(serial, Data), data)
class TestInit(TestCase):
def setUp(self) -> None:
self.factory = Factory()
def test_load(self):
data = {"x": 1, "y": "hello", "z": "z"}
expected = MyClass(1, E.hello, "z")
self.assertEqual(self.factory.load(data, MyClass), expected)
def test_dump(self):
expected = {"x": 1, "y": "hello", "z": "z"}
data = MyClass(1, E.hello, "z")
self.assertEqual(self.factory.dump(data, MyClass), expected)
def test_skip(self):
factory = Factory(default_schema=Schema(
trim_trailing_underscore=True,
skip_internal=True,
), )
data = Data("1", "2", "3")
serial = {
"last": "1",
"normal": "3",
}
self.assertEqual(factory.dump(data), serial)
data = Data("1", normal="3")
self.assertEqual(factory.load(serial, Data), data)
def test_only_exclude(self):
factory = Factory(schemas={
Data: Schema(only=(
"a",
"b",
), exclude=("a", )),
})
data = Data("AA", "BB", "CC")
serial = {"b": "BB"}
self.assertEqual(factory.dump(data), serial)
serial = {"a": "XXX", "b": "BB"}
data2 = Data(b="BB")
self.assertEqual(factory.load(serial, Data), data2)
def test_dump_ellipsis(self):
factory = Factory(schemas={
A: schema_ellipsis,
}, )
expected = {
"sub": {
"x": "hello",
"y": "world",
},
}
data = A("hello", "world")
self.assertEqual(expected, factory.dump(data, A))
self.assertEqual(data, factory.load(expected, A))
def test_internal_only(self):
factory = Factory(schemas={
Data: Schema(
only=("_d", ),
skip_internal=True,
),
})
data = Data("AA", "BB", "CC", "DD")
serial = {"_d": "DD"}
self.assertEqual(factory.dump(data), serial)
serial = {"a": "XXX", "_d": "DD"}
data2 = Data(_d="DD")
self.assertEqual(factory.load(serial, Data), data2)
def test_only_mapped(self):
factory = Factory(schemas={
Data:
Schema(
name_mapping={"b": "d"},
only_mapped=True,
),
}, )
data = Data("AA", "BB", "CC")
serial = {"d": "BB"}
self.assertEqual(factory.dump(data), serial)
data2 = Data(b="BB")
self.assertEqual(factory.load(serial, Data), data2)
def test_internal_mapping(self):
factory = Factory(
schemas={
Data: Schema(
name_mapping={"_d": "_d"},
skip_internal=True,
),
})
data = Data("AA", "BB", "CC", "DD")
serial = {"a": "AA", "b": "BB", "c": "CC", "_d": "DD"}
self.assertEqual(factory.dump(data), serial)
serial = {"a": "XXX", "_d": "DD"}
data2 = Data(a="XXX", _d="DD")
self.assertEqual(factory.load(serial, Data), data2)
def test_dump_auto_style_ellipsis(self):
factory = Factory(
schemas={
A: schema_auto_style_ellipsis
}
)
expected = {
"sub": {
"X": "hello",
"Y": "world",
}
}
data = A("hello", "world")
self.assertEqual(expected, factory.dump(data, A))
self.assertEqual(data, factory.load(expected, A))
def test_serialize(self):
factory = Factory()
duck = Duck(
Id(0),
[Duck(Id(1), []), Duck(Id(2), [])]
)
expected = {
'id': 0,
'ducklings': [
{'id': 1, 'ducklings': []},
{'id': 2, 'ducklings': []},
],
}
serialized = factory.dump(duck)
self.assertEqual(expected, serialized)
def test_only_mapping(self):
factory = Factory(
schemas={
Data:
Schema(
only=("b", ),
name_mapping={"a": "A"},
only_mapped=True,
),
})
data = Data("AA", "BB", "CC")
serial = {"b": "BB"}
self.assertEqual(factory.dump(data), serial)
serial = {"a": "XXX", "b": "BB"}
data2 = Data(b="BB")
self.assertEqual(factory.load(serial, Data), data2)
def test_complex(self, typed_dict):
class MyDict(typed_dict, total=False):
python_name: str
other: str
factory = Factory(
default_schema=Schema(name_style=NameStyle.dot,
name_mapping={"other": ("inner", "field")}))
data = {
"python.name": "hello",
"inner": {
"field": "world"
},
}
mydict: MyDict = dict(python_name="hello", other="world")
self.assertEqual(mydict, factory.load(data, MyDict))
self.assertEqual(data, factory.dump(mydict, MyDict))
def test_create(self):
factory = Factory(schemas={
Book: book_schema,
datetime: unixtime_schema,
})
book = Book(
Author("Petr", datetime(1970, 1, 2, 3, 4, 56,
tzinfo=timezone.utc)),
"Book1",
100,
)
expected = {
'Title': 'Book1',
'AuthorInfo': {
'born_at': 97496,
'name': 'Petr'
}
}
serialized = factory.dump(book)
self.assertEqual(expected, serialized)
def test_pre_serialize(self):
factory = Factory(schemas={Data: schema_inner})
data = Data(["a", "b"])
expected = {"items": ["a!", "b!"]}
self.assertEqual(factory.dump(data), expected)
def test_post_serialize(self):
factory = Factory(schemas={Data: schema_outer})
data = Data(["a", "b"])
expected = {"items": "a,b"}
self.assertEqual(factory.dump(data), expected)
@dataclass
class Author:
name: str
born_at: datetime
def parse_timestamp(data):
print("parsing timestamp")
return datetime.fromtimestamp(data, tz=timezone.utc)
unixtime_schema = Schema(
parser=parse_timestamp,
serializer=datetime.timestamp
)
factory = Factory(
schemas={
datetime: unixtime_schema,
}
)
expected_author = Author("Petr", datetime(1970, 1, 2, 3, 4, 56, tzinfo=timezone.utc))
data = {'born_at': 97496, 'name': 'Petr'}
author = factory.load(data, Author)
print(author, expected_author)
assert author == expected_author
serialized = factory.dump(author)
assert data == serialized
