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