def test_union(self):
data = {"value": "hello"}
self.assertEqual(parse(data, DUnion), DUnion("hello"))
data = {"value": 1}
self.assertEqual(parse(data, DUnion), DUnion(1))
data = {"value": [1]}
self.assertEqual(parse(data, DUnion), DUnion([E.one]))
def test_typing(self):
data = {
"id": 1,
"none": "hello"
}
self.assertEqual(
parse(data, D3),
D3(id_=1, none="hello")
)
data = {
"id": 1,
"lst": None
}
self.assertEqual(
parse(data, D3),
D3(id_=1, lst=None)
)
data = {
"id": 1,
"lst": [1, "hello"]
}
self.assertEqual(
parse(data, D3),
D3(id_=1, lst=[E.one, E.hello])
)
def test_dict(self):
self.assertEqual(parse({1: 2}, dict), {1: 2})
self.assertEqual(parse({1: 2}, Dict[int, int]), {1: 2})
x = frozenset({1, 2})
self.assertEqual(
parse({x: {"q", "w"}}, Dict[FrozenSet[int], Set[str]]),
{x: {"q", "w"}})
def test_tuple(self):
self.assertEqual(parse((True, "True"), tuple), (True, "True"))
self.assertEqual(parse((True, "True"), Tuple[bool, str]),
(True, "True"))
self.assertEqual(parse((True, "True", 1), Tuple[bool, str, int]),
(True, "True", 1))
self.assertEqual(parse((True, False, True), Tuple[bool, ...]),
(True, False, True))
def test_simple_dataclass(self):
data = {"a": 1}
self.assertEqual(parse(data, D), D(a=1))
data = {
"a": 1,
"c": "value",
}
self.assertEqual(parse(data, D), D(a=1, c="value"))
def test_myclass(self):
data = {
"x": 1,
"y": "hello",
"z": "z"
}
expected = MyClass(1, E.hello, "z")
self.assertEqual(parse(data, MyClass), expected)
def test_configs(self):
data = {
"id": 1,
"none": None
}
self.assertEqual(
parse(data, D3, trim_trailing_underscore=True),
D3(id_=1, none=None)
)
def test_complex_dataclass(self):
data = {
"d": {
"a": 1,
"c": "value",
},
"e": "hello"
}
self.assertEqual(parse(data, D2), D2(d=D(a=1, c="value"), e=E.hello))
def test_should_not_convert_to_bool_when_boolean_field_parsing(self):
self.assertEqual(parse({}, Foo), Foo(c=False))
self.assertEqual(parse({"c": "True"}, Foo), Foo(c=True))
self.assertEqual(parse({"c": "False"}, Foo), Foo(c=True))
self.assertEqual(parse({"c": "true"}, Foo), Foo(c=True))
self.assertEqual(parse({"c": "1"}, Foo), Foo(c=True))
self.assertEqual(parse({"c": "0"}, Foo), Foo(c=True))
self.assertEqual(parse({"c": ""}, Foo), Foo(c=False))
def test_parse(self):
data = {
"a": [1, 2, 3],
"b": 4
}
expected = Foo(a=3, b=Bar(43))
self.assertEqual(
parse(data, Foo, type_factories={int: int_factory, Bar: bar_factory}),
expected
)
def test_numbers(self):
self.assertEqual(parse(1, int), 1)
self.assertEqual(type(parse(1, int)), int)
self.assertEqual(parse(1, float), 1)
self.assertEqual(type(parse(1, float)), float)
self.assertEqual(parse(1 + 1j, complex), 1 + 1j)
self.assertEqual(type(parse(1, complex)), complex)
def test_should_convert_to_decimal_when_valid_parsing_valid_decimal(self):
self.assertEqual(parse({"e": "10"}, Foo), Foo(e=Decimal("10")))
self.assertEqual(parse({"e": "-120"}, Foo), Foo(e=Decimal("-120")))
self.assertEqual(parse({"e": "13.6"}, Foo), Foo(e=Decimal("13.6")))
self.assertEqual(parse({"e": "13e6"}, Foo), Foo(e=Decimal("13e6")))
self.assertEqual(parse({"e": "0"}, Foo), Foo(e=Decimal("0")))
def test_enum(self):
self.assertEqual(parse("hello", E), E.hello)
self.assertEqual(parse(1, E), E.one)
self.assertEqual(parse(E.one, E), E.one)
def test_noargs(self):
self.assertEqual(parse([1, "q"], List), [1, "q"])
self.assertEqual(parse({1: "q", "w": 2}, Dict), {1: "q", "w": 2})
def test_any(self):
self.assertEqual(parse(1, Any), 1)
self.assertEqual(parse({1, 2}, Any), {1, 2})
def test_list(self):
self.assertEqual(parse(["q"], list), ["q"])
self.assertEqual(parse(["q"], List[str]), ["q"])
self.assertEqual(parse(["q"], Tuple[str]), ("q",))
self.assertNotEqual(parse(["q"], List[str]), ("q",))
def test_should_convert_to_float_when_valid_parsing_valid_float(self):
self.assertEqual(parse({"b": "10"}, Foo), Foo(b=10.))
self.assertEqual(parse({"b": "-120"}, Foo), Foo(b=-120.))
self.assertEqual(parse({"b": "13.6"}, Foo), Foo(b=13.6))
self.assertEqual(parse({"b": "13e6"}, Foo), Foo(b=13e6))
self.assertEqual(parse({"b": "0"}, Foo), Foo(b=0))
def test_should_convert_to_int_when_valid_parsing_valid_int(self):
self.assertEqual(parse({"a": "10"}, Foo), Foo(a=10))
self.assertEqual(parse({"a": "-120"}, Foo), Foo(a=-120))
