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