def test_amount(): Amount(a=10, b=20) with pytest.raises(ValidationError): to_dict(Amount(a=9, b=20)) with pytest.raises(ValidationError): to_dict(Amount(a=10, b=21))
def test_amount(self): Amount(a=10, b=20) with self.assertRaises(ValidationError): to_dict(Amount(a=9, b=20)) with self.assertRaises(ValidationError): to_dict(Amount(a=10, b=21))
def test_dataclass_with_options(): try: from dataclasses import dataclass except ImportError: return _data = { "name": "John", "items": None, "skills": None } PlayerB() PlayerB( name="John" ) PlayerB( name="John" ) _data = { "name": "John", "items": [ {"title": "Rose"} ], "skills": { "fire": { "level": 1, "multiplier": 2.0, }, "ice": { "level": 2, "multiplier": 3.0, } } } p = PlayerB( name="John", items=[ ItemB(title="Rose"), ], skills={ "fire": SkillB(level=1, multiplier=2.0), "ice": SkillB(level=2, multiplier=3.0), } ) assert to_dict(p) == _data assert p.name == "John" assert p.items[0].title == "Rose" assert p.skills["ice"].level == 2 assert to_dict(p) == _data
def test_optional_dict_with_default(): c = OptionalDictWithDefaultC( s="s", nested_with_elements={ 1: OptionalDictWithDefaultB(nested=OptionalDictWithDefaultA(i=2)) } ) assert c.s == "s" assert to_dict(c) == {"s": "s", "nested_with_elements": {1: {"nested": {"i": 2}}}} c.nested_with_elements[1].nested = OptionalDictWithDefaultA(i=10) to_dict(c)
def test_not_required(self): _data = {"_required": 1} self.assertEqual(to_dict(NotRequired(**_data)), _data) _data = {"_required": 1, "_optional": 1} self.assertEqual(to_dict(NotRequired(**_data)), _data) _data = {} with self.assertRaises(ValidationError): to_dict(NotRequired(**_data))
def test_optional_dict(): b = OptionalDictB( s="s", nested_with_elements={1: OptionalDictA(i=2)} ) assert to_dict(b) == {"s": "s", "nested_with_elements": {1: {"i": 2}}}
def test_nested_validation_and_members_access(self): _data = { "name": "John", "items": [{ "title": "Rose" }], "skills": { "fire": { "level": 1, "multiplier": 2.0, }, "ice": { "level": 2, "multiplier": 3.0, } } } p = Player(name="John", items=[ Item(title="Rose"), ], skills={ "fire": Skill(level=1, multiplier=2.0), "ice": Skill(level=2, multiplier=3.0), }) self.assertEqual(to_dict(p), _data) self.assertEqual(p.name, "John") self.assertEqual(p.items[0].title, "Rose") self.assertEqual(p.skills["ice"].level, 2)
def test_unexpected(self): a = Unexpected(a="1.1", b="1.1") assert a.a == 1.1 assert to_dict(a) == {"a": 1} with self.assertRaises(ValidationError): UnexpectedNotStrip(a="1.1", b="1.1")
def test_not_required_default_callable(): _data = { "_required": 0, "_optional": 0, "_optional_with_options": 1 } assert to_dict(NotRequiredDefaultCallable(**_data)) == _data
def test_clone(self): data = {"a": 1, "b": 2} first = First(**data) self.assertEquals(data, to_dict(first)) second = Second(**data) self.assertEquals({"a": 1}, to_dict(second)) third = Third(**data) self.assertEquals({"b": 2}, to_dict(third)) fourth = Fourth(**data) self.assertEquals({"a": "1", "b": 2}, to_dict(fourth)) fifth = Fifth(**data) self.assertEquals({"a": 1, "b": 2, "_id": 1}, to_dict(fifth))
def test_clone(): data = {"a": 1, "b": 2} first = First(**data) assert data == to_dict(first) second = Second(**data) assert {"a": 1} == to_dict(second) third = Third(**data) assert {"b": 2} == to_dict(third) fourth = Fourth(**data) assert {"a": "1", "b": 2} == to_dict(fourth) fifth = Fifth(**data) assert {"a": 1, "b": 2, "_id": 1} == to_dict(fifth)
def test_not_required(): _data = { "_required": 1 } assert to_dict(NotRequired(**_data)) == _data _data = { "_required": 1, "_optional": 1 } assert to_dict(NotRequired(**_data)) == _data _data = {} with pytest.raises(ValidationError): to_dict(NotRequired(**_data))
def empty(): _data = { "_required": 0, "_optional": None } _expected = { "_required": 0 } assert to_dict(Empty(**_data)) == _expected
def test_descriptor(self): a = DescriptorType(a=[], b=[1], c={"a": "b"}, d={1: 2}) assert to_dict(a) == {"a": [], "b": [1], "c": {"a": "b"}, "d": {1: 2}} with self.assertRaises(ValidationError): a.a = {} a.a = [100] assert a.a == [100]
def test_required_default_callable(): _data = { "_int": 1, "_float": 1.0, "_bool": True, "_str": "x", "_dict": {"x": 1}, "_list": [1, 2] } assert to_dict(RequiredDefaultCallable()) == _data
def test_optional_dict(self): b = OptionalDictB(s="s", nested_with_elements={1: OptionalDictA(i=2)}) self.assertEqual(to_dict(b), { "s": "s", "nested_with_elements": { 1: { "i": 2 } } })
def test_not_specified(): with pytest.raises(ValidationError): NotSpecified(a={1: 1}, b={1: 1}) with pytest.raises(ValidationError): NotSpecified(a=[1, 1], b=[1, 1]) assert to_dict(NotSpecified(a=[1, 1], b={1: 1})) == { "a": [1, 1], "b": {1: 1} }
def test_required_default_callable(self): _data = { "_int": 1, "_float": 1.0, "_bool": True, "_str": "x", "_dict": { "x": 1 }, "_list": [1, 2] } self.assertEqual(to_dict(RequiredDefaultCallable()), _data)
def test_not_specified(self): with self.assertRaises(ValidationError): NotSpecified(a={1: 1}, b={1: 1}) with self.assertRaises(ValidationError): NotSpecified(a=[1, 1], b=[1, 1]) self.assertEqual(to_dict(NotSpecified(a=[1, 1], b={1: 1})), { "a": [1, 1], "b": { 1: 1 } })
def test_dataclass(self): try: from dataclasses import dataclass except ImportError: return _data = { "name": "John", "items": [{ "title": "Rose" }], "skills": { "fire": { "level": 1, "multiplier": 2.0, }, "ice": { "level": 2, "multiplier": 3.0, } } } p = PlayerA(name="John", items=[ ItemA(title="Rose"), ], skills={ "fire": SkillA(level=1, multiplier=2.0), "ice": SkillA(level=2, multiplier=3.0), }) self.assertEqual(to_dict(p), _data) self.assertEqual(p.name, "John") self.assertEqual(p.items[0].title, "Rose") self.assertEqual(p.skills["ice"].level, 2) self.assertEqual(to_dict(p), _data)
def test_required(self): with self.assertRaises(ValidationError): Required() _data = { "_int": 1, "_float": 1.0, "_bool": True, "_str": "str", "_dict": dict(), "_list": list() } assert to_dict(Required(**_data)) == _data
def test_optional_dict_with_default(self): c = OptionalDictWithDefaultC( s="s", nested_with_elements={ 1: OptionalDictWithDefaultB(nested=OptionalDictWithDefaultA(i=2)) }) self.assertEqual(c.s, "s") self.assertEqual(to_dict(c), { "s": "s", "nested_with_elements": { 1: { "nested": { "i": 2 } } } }) c.nested_with_elements[1].nested = OptionalDictWithDefaultA(i=10) to_dict(c)
def test_inheritance(self): @schema class A: a: int @schema class B: b: int = Options(default=1) @schema class C(A, B): c: str @schema class D(C): d: str example = D(a=1, c="c", d="1") assert to_dict(example) == {"a": 1, "b": 1, "c": "c", "d": "1"}
def test_unpack(): assert {'a': {'a': 1}} == to_dict(OptionalAutoPackDisabled(a=A(a=1))) assert {'a': {'a': 1}} == to_dict(OptionalAutoPackEnabled(a={'a': 1})) assert {} == to_dict(OptionalAutoPackEnabled(a=None)) assert {} == to_dict(OptionalAutoPackEnabled())
def test_not_required_default_callable(self): _data = {"_required": 0, "_optional": 0, "_optional_with_options": 1} self.assertEqual(to_dict(NotRequiredDefaultCallable(**_data)), _data)
def test_convert(): assert to_dict(Convert(a=1)) == {"a": "1"}
def test_serializer(self): a = SerializerType(a="1.1") assert a.a == 1.1 assert to_dict(a) == {"a": 1}
def test_convert(self): self.assertEqual(to_dict(Convert(a=1)), {"a": "1"})
def empty(self): _data = {"_required": 0, "_optional": None} _expected = {"_required": 0} self.assertEqual(to_dict(Empty(**_data)), _expected)
def test_typevar(self): data = {"a": [], "b": [1], "c": {"a": "b"}, "d": {1: 2}} assert to_dict(TypeVarType(**data)) == data