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
