Improve coverage (#505)

* Improve coverage

* Fix type hint

* Fix lint

Author: Tinche

src/cattrs/_compat.py

@@ -128,10 +128,7 @@ def fields(type):
     try:
         return type.__attrs_attrs__
     except AttributeError:
-        try:
-            return dataclass_fields(type)
-        except AttributeError:
-            raise Exception("Not an attrs or dataclass class.") from None
+        return dataclass_fields(type)
 
 
 def fields_dict(type) -> Dict[str, Union[Attribute, Field]]:

src/cattrs/strategies/_unions.py

@@ -1,5 +1,5 @@
 from collections import defaultdict
-from typing import Any, Callable, Dict, Optional, Type, Union
+from typing import Any, Callable, Dict, Literal, Type, Union
 
 from attrs import NOTHING
 
@@ -23,7 +23,7 @@ def configure_tagged_union(
     converter: BaseConverter,
     tag_generator: Callable[[Type], str] = default_tag_generator,
     tag_name: str = "_type",
-    default: Optional[Type] = NOTHING,
+    default: Union[Type, Literal[NOTHING]] = NOTHING,
 ) -> None:
     """
     Configure the converter so that `union` (which should be a union) is

tests/strategies/test_include_subclasses.py

@@ -328,3 +328,18 @@ def test_overrides(with_union_strategy: bool, struct_unstruct: str):
     assert c.unstructure(structured) == unstructured
     assert c.structure(unstructured, Parent) == structured
     assert c.structure(unstructured, structured.__class__) == structured
+
+
+def test_no_parent_classes(genconverter: Converter):
+    """Test an edge condition when a union strategy is used.
+
+    The class being registered has no subclasses.
+    """
+
+    @define
+    class A:
+        a: int
+
+    include_subclasses(A, genconverter, union_strategy=configure_tagged_union)
+
+    assert genconverter.structure({"a": 1}, A) == A(1)

tests/strategies/test_tagged_unions.py

@@ -90,6 +90,8 @@ def test_default_member(converter: BaseConverter) -> None:
 
     # No tag, so should structure as A.
     assert converter.structure({"a": 1}, union) == A(1)
+    # Wrong tag, so should again structure as A.
+    assert converter.structure({"_type": "C", "a": 1}, union) == A(1)
 
     assert converter.structure({"_type": "A", "a": 1}, union) == A(1)
     assert converter.structure({"_type": "B", "a": 1}, union) == B("1")

tests/test_generics.py

@@ -81,7 +81,7 @@ def test_structure_generics_with_cols(t, result, detailed_validation):
 @pytest.mark.parametrize(
     ("t", "result"), ((int, (1, [2], {"3": 3})), (str, ("1", ["2"], {"3": "3"})))
 )
-def test_39_structure_generics_with_cols(t, result):
+def test_39_structure_generics_with_cols(t, result, genconverter: Converter):
     @define
     class GenericCols(Generic[T]):
         a: T
@@ -90,21 +90,21 @@ class GenericCols(Generic[T]):
 
     expected = GenericCols(*result)
 
-    res = Converter().structure(asdict(expected), GenericCols[t])
+    res = genconverter.structure(asdict(expected), GenericCols[t])
 
     assert res == expected
 
 
 @pytest.mark.parametrize(("t", "result"), ((int, (1, [1, 2, 3])), (int, (1, None))))
-def test_structure_nested_generics_with_cols(t, result):
+def test_structure_nested_generics_with_cols(t, result, genconverter: Converter):
     @define
     class GenericCols(Generic[T]):
         a: T
         b: Optional[List[T]]
 
     expected = GenericCols(*result)
 
-    res = Converter().structure(asdict(expected), GenericCols[t])
+    res = genconverter.structure(asdict(expected), GenericCols[t])
 
     assert res == expected
 
@@ -296,6 +296,7 @@ def test_generate_typeddict_mapping() -> None:
     from typing import Generic, TypedDict, TypeVar
 
     T = TypeVar("T")
+    U = TypeVar("U")
 
     class A(TypedDict):
         pass
@@ -312,6 +313,12 @@ class B(A[int]):
 
     assert generate_mapping(B, {}) == {T.__name__: int}
 
+    class C(Generic[T, U]):
+        a: T
+        c: U
+
+    assert generate_mapping(C[int, U], {}) == {T.__name__: int}
+
 
 def test_nongeneric_protocols(converter):
     """Non-generic protocols work."""

tests/test_v.py

@@ -9,7 +9,7 @@
     Tuple,
 )
 
-from attrs import Factory, define
+from attrs import Factory, define, field
 from pytest import fixture, raises
 
 from cattrs import Converter, transform_error
@@ -103,6 +103,31 @@ class C:
         ]
 
 
+def test_untyped_class_errors(c: Converter) -> None:
+    """Errors on untyped attrs classes transform correctly."""
+
+    @define
+    class C:
+        a = field()
+
+    def struct_hook(v, __):
+        if v == 0:
+            raise ValueError()
+        raise TypeError("wrong type")
+
+    c.register_structure_hook_func(lambda t: t is None, struct_hook)
+
+    with raises(Exception) as exc_info:
+        c.structure({"a": 0}, C)
+
+    assert transform_error(exc_info.value) == ["invalid value @ $.a"]
+
+    with raises(Exception) as exc_info:
+        c.structure({"a": 1}, C)
+
+    assert transform_error(exc_info.value) == ["invalid type (wrong type) @ $.a"]
+
+
 def test_sequence_errors(c: Converter) -> None:
     try:
         c.structure(["str", 1, "str"], List[int])
@@ -315,3 +340,8 @@ class E(TypedDict):
     assert transform_error(exc.value) == [
         f"invalid value for type, expected {tn} @ $.a"
     ]
+
+
+def test_other_errors():
+    """Errors without explicit support transform predictably."""
+    assert format_exception(IndexError("Test"), List[int]) == "unknown error (Test)"