def test_from_dict_with_strict(): @dataclass class X: s: str with pytest.raises(UnexpectedDataError) as exception_info: from_dict(X, {"s": "test", "i": 1}, Config(strict=True)) assert str(exception_info.value) == 'can not match "i" to any data class field'
def test_from_dict_with_literal_and_wrong_value(): from typing import Literal @dataclass class X: l: Literal["A", "B"] with pytest.raises(WrongTypeError) as exception_info: from_dict(X, {"l": "C"})
def test_from_dict_with_wrong_type_for_type_parameter(): @dataclass class X: l: Type[int] with pytest.raises(WrongTypeError) as exception_info: from_dict(X, {"l": float}) assert exception_info.value.field_path == "l" assert exception_info.value.field_type == Type[int]
def test_from_dict_with_value_instead_of_type(): @dataclass class X: l: Type[int] with pytest.raises(WrongTypeError) as exception_info: from_dict(X, {"l": 1}) assert exception_info.value.field_path == "l" assert exception_info.value.field_type == Type[int]
def test_from_dict_with_wrong_type_of_collection_item(): @dataclass class X: l: List[int] with pytest.raises(WrongTypeError) as exception_info: from_dict(X, {"l": ["1"]}) assert exception_info.value.field_path == "l" assert exception_info.value.field_type == List[int]
def test_from_dict_with_wrong_type_of_dict_value(): @dataclass class X: d: Dict[str, int] with pytest.raises(WrongTypeError) as exception_info: from_dict(X, {"d": {"a": "test"}}) assert exception_info.value.field_path == "d" assert exception_info.value.field_type == Dict[str, int]
def test_from_dict_with_union_and_optional_and_wrong_value(): @dataclass class X: i: Union[int, Optional[str]] with pytest.raises(UnionMatchError) as exception_info: from_dict(X, {"i": 1.0}) assert exception_info.value.field_path == "i" assert exception_info.value.field_type == Union[int, str, None] assert exception_info.value.value == 1.0
def test_from_dict_with_missing_value(): @dataclass class X: s: str i: int with pytest.raises(MissingValueError) as exception_info: from_dict(X, {"s": "test"}) assert str(exception_info.value) == 'missing value for field "i"' assert exception_info.value.field_path == "i"
def test_from_dict_with_none_for_non_optional_field(): @dataclass class X: s: str with pytest.raises(WrongTypeError) as exception_info: from_dict(X, {"s": None}) assert exception_info.value.field_path == "s" assert exception_info.value.field_type == str assert exception_info.value.value is None
def test_from_dict_with_wrong_type_of_optional_value(): @dataclass class X: s: Optional[str] i: int with pytest.raises(WrongTypeError) as exception_info: from_dict(X, {"s": 1, "i": 1}) assert exception_info.value.field_path == "s" assert exception_info.value.field_type == Optional[str]
def test_from_dict_with_missing_forward_reference(): @dataclass class X: y: "Y" @dataclass class Y: s: str with pytest.raises(ForwardReferenceError) as exception_info: from_dict(X, {"y": {"s": "text"}}) assert str(exception_info.value) == "can not resolve forward reference: name 'Y' is not defined"
def test_from_dict_with_missing_value_of_nested_data_class(): @dataclass class X: i: int @dataclass class Y: x: X with pytest.raises(MissingValueError) as exception_info: from_dict(Y, {"x": {}}) assert exception_info.value.field_path == "x.i"
def test_from_dict_with_optional_nested_data_class_and_missing_value(): @dataclass class X: i: int j: int @dataclass class Y: x: Optional[X] with pytest.raises(MissingValueError) as exception_info: from_dict(Y, {"x": {"i": 1}}) assert exception_info.value.field_path == "x.j"
def test_from_dict_with_union_and_wrong_data(): @dataclass class X: i: Union[int, str] with pytest.raises(UnionMatchError) as exception_info: from_dict(X, {"i": 1.0}) assert ( str(exception_info.value) == 'can not match type "float" to any type of "i" union: typing.Union[int, str]' ) assert exception_info.value.field_path == "i" assert exception_info.value.field_type == Union[int, str] assert exception_info.value.value == 1.0
def test_from_dict_with_union_and_optional_and_none_value(): @dataclass class X: i: Union[int, Optional[str]] result = from_dict(X, {"i": None}) assert result == X(i=None)
def test_from_dict_with_wrong_type(): @dataclass class X: s: str i: int with pytest.raises(WrongTypeError) as exception_info: from_dict(X, {"s": "test", "i": "wrong"}) assert ( str(exception_info.value) == 'wrong value type for field "i" - should be "int" instead of value "wrong" of type "str"' ) assert exception_info.value.field_path == "i" assert exception_info.value.field_type == int assert exception_info.value.value == "wrong"
def test_from_dict_with_cast(): @dataclass class X: s: str result = from_dict(X, {"s": 1}, Config(cast=[str])) assert result == X(s="1")
def test_from_dict_with_cast_and_generic_collection(): @dataclass class X: s: List[int] result = from_dict(X, {"s": (1,)}, Config(cast=[List])) assert result == X(s=[1])
def test_from_dict_with_type_hooks_and_generic_sequence(): @dataclass class X: c: List[str] result = from_dict(X, {"c": ["TEST"]}, config=Config(type_hooks={str: str.lower})) assert result == X(c=["test"])
def test_from_dict_with_none_optional_value_for_union(): @dataclass class X: i: Optional[Union[int, str]] result = from_dict(X, {"i": None}) assert result == X(i=None)
def test_from_dict_with_optional_field_and_default_value(): @dataclass class X: i: Optional[int] = 1 result = from_dict(X, {}) assert result == X(i=1)
def test_from_dict_with_union_and_optional(): @dataclass class X: i: Union[int, Optional[str]] result = from_dict(X, {"i": "s"}) assert result == X(i="s")
def test_from_dict_with_generic_collection(): @dataclass class X: l: List[int] result = from_dict(X, {"l": [1]}) assert result == X(l=[1])
def test_from_dict_with_any(): @dataclass class X: i: Any result = from_dict(X, {"i": 1}) assert result == X(i=1)
def test_from_dict_with_additional_values(): @dataclass class X: i: int result = from_dict(X, {"i": 1, "s": "extra"}) assert result == X(i=1)
def test_from_dict_with_set(): @dataclass class X: i_set: Set[int] result = from_dict(X, {"i_set": {1, 2}}) assert result == X(i_set={1, 2})
def test_from_dict_with_dict(): @dataclass class X: d: Dict[str, int] result = from_dict(X, {"d": {"a": 1, "b": 2}}) assert result == X(d={"a": 1, "b": 2})
def test_from_dict_with_type_parameter(): @dataclass class X: l: Type[int] result = from_dict(X, {"l": bool}) # bool is a subclass of int in Python assert result == X(l=bool)
def test_from_dict_with_post_init_missing_value(): @dataclass class X: s: str = field(init=False) result = from_dict(X, {}) assert not hasattr(result, "s")
def test_from_dict_with_union_of_builtin_types(): @dataclass class X: i: Union[int, str] result = from_dict(X, {"i": "s"}) assert result == X(i="s")