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)