Error handling coverage

Author: Tinche

HISTORY.md

@@ -31,6 +31,8 @@ can now be used as decorators and have gained new features.
   ([#472](https://github.com/python-attrs/cattrs/pull/472))
 - The default union handler now also handles dataclasses.
   ([#426](https://github.com/python-attrs/cattrs/issues/426) [#477](https://github.com/python-attrs/cattrs/pull/477))
+- **Potentially breaking**: `IterableValidationError`s now require their subexceptions to have appropriate notes attached.
+  This was always the case internally in _cattrs_, but is now required of errors produced outside too.
 - Add support for [PEP 695](https://peps.python.org/pep-0695/) type aliases.
   ([#452](https://github.com/python-attrs/cattrs/pull/452))
 - Add support for named tuples with type metadata ([`typing.NamedTuple`](https://docs.python.org/3/library/typing.html#typing.NamedTuple)).

src/cattrs/errors.py

@@ -45,26 +45,24 @@ def __getnewargs__(self) -> Tuple[str, Union[int, str], Any]:
 
 
 class IterableValidationError(BaseValidationError):
-    """Raised when structuring an iterable."""
+    """Raised when structuring an iterable.
 
-    def group_exceptions(
-        self,
-    ) -> Tuple[List[Tuple[Exception, IterableValidationNote]], List[Exception]]:
-        """Split the exceptions into two groups: with and without validation notes."""
+    If instantiating this error manually (outside of cattrs), ensure every
+    subexception has an appropriate IterableValidationNote note in its notes.
+    """
+
+    def group_exceptions(self) -> List[Tuple[Exception, IterableValidationNote]]:
+        """Group up the subexceptions alongside their IV notes."""
         excs_with_notes = []
-        other_excs = []
         for subexc in self.exceptions:
-            if hasattr(subexc, "__notes__"):
-                for note in subexc.__notes__:
-                    if note.__class__ is IterableValidationNote:
-                        excs_with_notes.append((subexc, note))
-                        break
-                else:
-                    other_excs.append(subexc)
+            for note in subexc.__notes__:
+                if note.__class__ is IterableValidationNote:
+                    excs_with_notes.append((subexc, note))
+                    break
             else:
-                other_excs.append(subexc)
+                raise AttributeError("Subexceptions require notes")
 
-        return excs_with_notes, other_excs
+        return excs_with_notes
 
 
 class AttributeValidationNote(str):

src/cattrs/v/__init__.py

@@ -98,15 +98,12 @@ def transform_error(
     """
     errors: List[str] = []
     if isinstance(exc, IterableValidationError):
-        with_notes, without = exc.group_exceptions()
-        for exc, note in with_notes:
+        for e, note in exc.group_exceptions():
             p = f"{path}[{note.index!r}]"
-            if isinstance(exc, (ClassValidationError, IterableValidationError)):
-                errors.extend(transform_error(exc, p, format_exception))
+            if isinstance(e, (ClassValidationError, IterableValidationError)):
+                errors.extend(transform_error(e, p, format_exception))
             else:
-                errors.append(f"{format_exception(exc, note.type)} @ {p}")
-        for exc in without:
-            errors.append(f"{format_exception(exc, None)} @ {path}")
+                errors.append(f"{format_exception(e, note.type)} @ {p}")
     elif isinstance(exc, ClassValidationError):
         with_notes, without = exc.group_exceptions()
         for exc, note in with_notes:

tests/v/test_v.py

@@ -12,7 +12,7 @@
 from attrs import Factory, define, field
 from pytest import raises
 
-from cattrs import Converter, transform_error
+from cattrs import Converter, IterableValidationError, transform_error
 from cattrs._compat import Mapping, TypedDict
 from cattrs.gen import make_dict_structure_fn
 from cattrs.v import format_exception
@@ -351,3 +351,20 @@ class E(TypedDict):
 def test_other_errors():
     """Errors without explicit support transform predictably."""
     assert format_exception(IndexError("Test"), List[int]) == "unknown error (Test)"
+
+
+def test_iterable_val_no_note():
+    """`IterableValidationErrors` require subexceptions with notes."""
+    with raises(AttributeError):
+        IterableValidationError("Test", [RuntimeError()], List[str]).group_exceptions()
+
+    r = RuntimeError()
+    r.__notes__ = ["test"]
+    with raises(AttributeError):
+        IterableValidationError("Test", [r], List[str]).group_exceptions()
+
+
+def test_typeerror_formatting():
+    """`format_exception` works with non-iteration TypeErrors."""
+    exc = TypeError("exception")
+    assert format_exception(exc, None) == "invalid type (exception)"