def test_inh(self):
factory = Factory(debug_path=True)
with self.assertRaises(ValueError):
factory.load({"f1": 1, "b1": 2, "b2": 3}, Baz[str])
with self.assertRaises(ValueError):
factory.load({"f1": "1", "b1": "qwe", "b2": "3"}, Baz[str])
res = factory.load({"f1": "1", "b1": 2, "b2": "3"}, Baz[str])
self.assertEqual(res, Baz(f1="1", b1=2, b2="3"))
def test_forbid(self):
factory = Factory(
default_schema=Schema(
unknown=Unknown.FORBID,
),
)
serialized = {"a": "AA", "b": "b"}
with self.assertRaises(ValueError):
factory.load(serialized, Data)
def test_parse_missed(self):
factory = Factory(schemas={
A: schema,
}, )
expected = A(y="test")
data = {"y": "test"}
self.assertEqual(expected, factory.load(data, A))
data = {"y": "test", "a": {}}
self.assertEqual(expected, factory.load(data, A))
data = {"y": "test", "a": {"b": []}}
self.assertEqual(expected, factory.load(data, 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_plain_list(self):
factory = Factory(schemas={
A: schema_tuple,
}, )
data = ["hello", "world"]
expected = A("hello", "world")
self.assertEqual(expected, factory.load(data, A))
def test_load_list(self):
factory = Factory(schemas={
A: schema_list,
}, )
data = [["hello", "world"]]
expected = A("hello", "world")
self.assertEqual(expected, factory.load(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_load(self):
factory = Factory(schemas={
FakeFoo[str]: Schema(name_mapping={"value": "s"}),
FakeFoo: Schema(name_mapping={"value": "v"}),
})
data = {"v": "hello", "i": 42, "s": "SSS"}
self.assertEqual(factory.load(data, FakeFoo[str]), FakeFoo("SSS"))
self.assertEqual(factory.load(data, FakeFoo[int]), FakeFoo("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)
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_skip(self):
factory = Factory(
default_schema=Schema(
unknown=Unknown.SKIP,
),
)
data = Data("AA")
serialized = {"a": "AA", "b": "b"}
self.assertEqual(data, factory.load(serialized, Data))
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_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_load(self, typed_dict):
class Book(typed_dict):
name: str
year: int
factory = Factory()
data = {"name": "hello", "year": 1}
expected = dict(name="hello", year=1)
self.assertEqual(expected, factory.load(data, Book))
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_not_total(self, typed_dict):
class Book(typed_dict, total=False):
name: str
year: int
factory = Factory()
data = {"name": "hello"}
expected = dict(name="hello")
self.assertEqual(expected, factory.load(data, Book))
def test_include(self):
factory = Factory(
default_schema=Schema(
unknown=Unknown.STORE,
),
)
serialized = {"a": "AA", "b": "b"}
data = factory.load(serialized, DataWithExtras)
self.assertEqual(data.a, "AA")
self.assertEqual(data.extras, {"b": "b"})
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_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_load(self):
factory = Factory(
schemas={
A: schema
}
)
data = {
"a": {"b": ["hello"]},
"y": "world"
}
expected = A("hello", "world")
self.assertEqual(expected, factory.load(data, A))
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_choice(self):
factory = Factory(
schemas={
A: Schema(pre_parse=type_checker("A", field="x")),
B: Schema(pre_parse=type_checker("B", field="x")),
C: Schema(pre_parse=type_checker("C", field="x")),
})
self.assertEqual(
factory.load({"some": {
"a": "hello",
"x": "A"
}}, Container), Container(A("hello")))
self.assertEqual(
factory.load({"some": {
"a": "hello",
"x": "B"
}}, Container), Container(B("hello")))
self.assertEqual(
factory.load({"some": {
"a": "hello",
"x": "C"
}}, Container), Container(C("hello")))
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_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)
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_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_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)
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_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_parse(self):
factory = Factory()
serialized = {
'id': 0,
'ducklings': [
{'id': 1, 'ducklings': []},
{'id': 2, 'ducklings': []},
]
}
expected = Duck(
Id(0),
[Duck(Id(1), []), Duck(Id(2), [])]
)
parsed = factory.load(serialized, Duck)
self.assertEqual(expected, parsed)
