def test_union_optional_type_raises(self):
@dataclass
class X:
key: Union[None, str, bool]
with pytest.raises(TypeError):
dataclass_schema(X)
def test_any_list_raises(self):
@dataclass
class X:
key: List[Any]
with pytest.raises(TypeError):
dataclass_schema(X)
def test_base_list_raises(self):
@dataclass
class X:
key: list
with pytest.raises(TypeError):
dataclass_schema(X)
def test_any_raises(self):
@dataclass
class X:
key: Any
with pytest.raises(TypeError):
dataclass_schema(X)
def test_base_unknown_type_raises(self):
@dataclass
class X:
key: Fraction
with pytest.raises(TypeError):
dataclass_schema(X)
def test_any_dict_raises(self):
@dataclass
class X:
key: Dict[Any, Any]
with pytest.raises(TypeError):
dataclass_schema(X)
def test_true_union_raises(self):
@dataclass
class X:
key: Union[str, int]
with pytest.raises(TypeError):
dataclass_schema(X)
def test_exclude_field(self):
@dataclass
class X:
field1: str
field2: str
schema_type = dataclass_schema(X)
schema = schema_type(exclude=["field1"])
data = {"field2": "value2"}
loaded: X = schema.load(data)
print(f"loaded: {loaded}")
assert loaded.field1 is MISSING
assert loaded.field2 == "value2"
dumped = schema.dump(loaded)
print(f"dumped: {dumped}")
assert dumped == data
loaded.field1 = "value1"
dumped = schema.dump(loaded)
print(f"dumped: {dumped}")
assert dumped == data
def test_wacky(self):
@dataclass
class XWacky:
"""Dpcstring here"""
key_a: str
"""key_a description"""
key_b: int = 10
def a_method(self):
"""it's own docstring"""
pass
key_c: float = 1.0
"""key_c description"""
@property
def a_prop(self) -> None:
"""a prop description"""
return
key_d: dict = field(default_factory=dict)
"""key_d description"""
schema = dataclass_schema(XWacky)
mfields = schema._declared_fields
assert mfields["key_a"].metadata["description"] == "Key_a description."
assert mfields["key_c"].metadata["description"] == "Key_c description."
assert mfields["key_d"].metadata["description"] == "Key_d description."
assert "description" not in mfields["key_b"].metadata
def test_load_partial_default_factory(self):
@dataclass
class X:
value1: int
value2: int = field(default_factory=int)
schema = dataclass_schema(X)
assert schema(partial=True).load({"value1": 1}) == X(1, MISSING)
def test_load_partial_default(self):
@dataclass
class X:
value1: int
value2: int = 2
schema = dataclass_schema(X)
assert schema(partial=True).load({"value1": 1}) == X(1, MISSING)
def test_nested_handler_custom(self):
@dataclass
class X:
key: str
@dataclass
class Y:
x: X
type_handlers = {}
XSchema = dataclass_schema(X, type_handlers=type_handlers)
assert type_handlers[X] is XSchema
YSchema = dataclass_schema(Y, type_handlers=type_handlers)
assert type_handlers[X] is XSchema
assert type_handlers[Y] is YSchema
def test_partial_raises(self):
@dataclass
class PartialData:
field1: str
field2: str
schema = dataclass_schema(PartialData)
with pytest.raises(ValidationError):
loaded: PartialData = schema().load({"field2": "two"})
def test_validator_fails(self):
schema = dataclass_schema(HasValidator)
data = {"num": 11}
data_dict = schema().dump(data)
result = schema().validate(data_dict)
assert len(result) == 1
assert "num" in result
def test_dataclass_no_default_load_raises(self):
@dataclass
class X:
text: str
schema = dataclass_schema(X)
with pytest.raises(ValidationError):
loaded = schema().load(dict())
print(f"loaded: {loaded}")
def test_dataclass_non_optional_raises(self):
@dataclass
class X:
text: str
schema = dataclass_schema(X)
with pytest.raises(ValidationError):
obj = schema().load({"text": None})
def test_simple_schema(self):
@dataclass
class X:
pass
schema = dataclass_schema(X)
assert issubclass(schema, DataSchemaConcrete)
assert isinstance(schema, type)
assert schema.__name__ == "XSchema"
def test_single(self):
@dataclass
class XTestSingle:
key: str
"""key description"""
schema = dataclass_schema(XTestSingle)
mfields = schema._declared_fields
assert mfields["key"].metadata["description"] == "Key description."
def test_type_handler_add_func(self):
@dataclass
class X:
key: str
type_handlers = {}
XSchema = dataclass_schema(X, type_handlers=type_handlers)
assert type_handlers[X] is XSchema
def test_type_handler_add_func_false(self):
@dataclass
class X:
key: str
type_handlers = {}
_ = dataclass_schema(X, type_handlers=type_handlers, add_handler=False)
assert X not in type_handlers
def test_field_required_garams(self):
@dataclass
class X:
text: str = gfield(default="value", garams=Garams(required=True))
schema = dataclass_schema(X)
result = schema().validate({})
assert len(result) == 1
assert "text" in result
def test_load_partial_missing(self):
@dataclass
class X:
key1: str
key2: uuid.UUID
schema_type = dataclass_schema(X)
schema = schema_type(partial=True)
dumped = schema.dump(X(key1="value", key2=MISSING))
assert dumped == {"key1": "value"}
def test_no_default_still_missing(self):
@dataclass
class X:
value1: int
value2: int
schema = dataclass_schema(X)
loaded: X = schema(partial=True, use_defaults=True).load({"value1": 1})
assert loaded.value1 == 1
assert loaded.value2 is MISSING
def test_factory_default(self):
@dataclass
class X:
value1: int
value2: int = field(default_factory=int)
schema = dataclass_schema(X)
loaded: X = schema(partial=True, use_defaults=True).load({"value1": 1})
assert loaded.value1 == 1
assert loaded.value2 == 0
def test_regular_default(self):
@dataclass
class X:
value1: int
value2: int = 2
schema = dataclass_schema(X)
loaded: X = schema(partial=True, use_defaults=True).load({"value1": 1})
assert loaded.value1 == 1
assert loaded.value2 == 2
def test_field_required(self):
@dataclass
class X:
text: str = field(default="value",
metadata={"garams": Garams(required=True)})
schema = dataclass_schema(X)
result = schema().validate({})
assert len(result) == 1
assert "text" in result
def test_dump_with_type_field(self):
data_dict = {"frac": "3/4"}
data = HasFractions(Fraction("3/4"))
schema = dataclass_schema(HasFractions,
type_handlers={Fraction: FractionField})
dumped = schema().dump(data)
print(f"dumped: {dumped}")
assert dumped == data_dict
def test_codegen(self):
@dataclass
class XDeclared:
key21: str
"""key21 description"""
genned = type("XCodeGen", (XDeclared,), dict())
schema = dataclass_schema(genned)
mfields = schema._declared_fields
assert mfields["key21"].metadata["description"] == "Key21 description."
def test_missing_description(self):
@dataclass
class XMissingDescription:
key5: str
key6: int
"""a number"""
schema = dataclass_schema(XMissingDescription)
mfields = schema._declared_fields
assert "description" not in mfields["key5"].metadata
assert mfields["key6"].metadata["description"] == "A number."
def test_load_with_type_field(self):
data_dict = {"frac": "3/4"}
data = HasFractions(Fraction("3/4"))
schema = dataclass_schema(HasFractions,
type_handlers={Fraction: FractionField})
loaded = schema().load(data_dict)
print(f"loaded: {loaded}")
assert loaded == data
