def test_schemas_can_be_nested():
# Given that I have an Account schema and another schema with an Account field
# When I validate some data against it
# Then it should validate the account field as expected
with pytest.raises(ValidationError) as e_data:
load_schema(CreateAccountRequest, {})
assert e_data.value.reasons == {"account": "this field is required"}
with pytest.raises(ValidationError) as e_data:
load_schema(CreateAccountRequest, {"account": {}})
assert e_data.value.reasons == {
"account": {
"username": "******",
"password": "******",
}
}
request_data = load_schema(
CreateAccountRequest,
{"account": {
"username": "******",
"password": "******",
}})
assert request_data.account.username == "*****@*****.**"
assert request_data.account.password == "Joker90210"
def test_schemas_can_validate_data(data, expected):
if isinstance(expected, ValidationError):
with pytest.raises(ValidationError) as e_data:
load_schema(Account, data)
assert e_data.value.reasons == expected.reasons
else:
assert load_schema(Account, data) == expected
def test_schemas_can_have_fields_of_type_Any():
# Given that I have a schema with a field of type Any
@schema
class A:
x: Any
# Then that field should accept values of any type
assert load_schema(A, {"x": 1}) == A(x=1)
assert load_schema(A, {"x": "1"}) == A(x="1")
assert load_schema(A, {"x": []}) == A(x=[])
def test_schemas_can_be_nested_within_lists():
# Given that I have an Account schema and another schema with a field that's a list of Accounts
# When I validate some data against it
# Then it should validate the accounts field as expected
with pytest.raises(ValidationError) as e_data:
load_schema(CreateAccountsRequest, {})
assert e_data.value.reasons == {"accounts": "this field is required"}
with pytest.raises(ValidationError) as e_data:
load_schema(CreateAccountsRequest, {"accounts": {}})
assert e_data.value.reasons == {"accounts": "value must be a list"}
with pytest.raises(ValidationError) as e_data:
load_schema(CreateAccountsRequest, {"accounts": [None]})
assert e_data.value.reasons == {
"accounts": {
0: "this field cannot be null"
}
}
with pytest.raises(ValidationError) as e_data:
load_schema(CreateAccountsRequest, {"accounts": [{}]})
assert e_data.value.reasons == {
"accounts": {
0: {
"username": "******",
"password": "******",
}
}
}
request_data = load_schema(
CreateAccountsRequest, {
"accounts": [{
"username": "******",
"password": "******",
"is_admin": True,
}, {
"username": "******",
"password": "******",
}],
})
assert request_data == CreateAccountsRequest(accounts=[
Account(None, "*****@*****.**", "password123", is_admin=True),
Account(None, "*****@*****.**", "password234"),
], )
def test_schema_fields_can_have_custom_validators():
# Given that I have a custom validator
class TagsValidator:
def validate(self, field, value):
return value.split(",")
# When I create a schema whose fields use that validator
@schema
class Post:
tags: List[str] = field(validator=TagsValidator())
# Then load some data
# Then my validator should be used
assert load_schema(Post, {"tags": "a,b,c"}) == Post(tags=["a", "b", "c"])
def test_schemas_can_have_forward_references():
# Given that I have a schema that references a schema that isn't defined yet
# Then that schema should validate as normal
assert load_schema(A, {"b": {"x": 42}}) == A(b=B(x=42))
assert load_schema(A, {
"b": {
"x": 42
},
"b_opt": {
"x": 43
}
}) == A(b=B(x=42), b_opt=B(x=43))
assert load_schema(A, {
"b": {
"x": 42
},
"b_list": [{
"x": 43
}, {
"x": 44
}]
}) == A(b=B(x=42), b_list=[B(x=43), B(x=44)])
with pytest.raises(ValidationError) as e:
load_schema(A, {"b": {"x": 42}, "b_opt": {"x": "43"}})
assert e.value.reasons == {"b_opt": {"x": "unexpected type str"}}
with pytest.raises(ValidationError) as e:
load_schema(A, {"b": {"x": 42}, "b_list": [{}]})
assert e.value.reasons == {"b_list": {0: {"x": "this field is required"}}}
# When I dump instances of those schemas
# Then that operation should succeed
assert dump_schema(load_schema(A, {"b": {"x": 42}})) == \
{"b": {"x": 42}, "b_list": None, "b_opt": None}
def test_load_schema_fails_if_not_given_a_schema():
# When I call load_schema with an object that isn't a schema
# Then a TypeError should be raised
with pytest.raises(TypeError):
load_schema(object, {})
