Minor coverage hacking.

Author: Julian

jsonschema/_utils.py

@@ -28,10 +28,10 @@ def __delitem__(self, uri):
     def __iter__(self):
         return iter(self.store)
 
-    def __len__(self):
+    def __len__(self):  # pragma: no cover -- untested, but to be removed
         return len(self.store)
 
-    def __repr__(self):
+    def __repr__(self):  # pragma: no cover -- untested, but to be removed
         return repr(self.store)
 
 

jsonschema/exceptions.py

@@ -209,14 +209,14 @@ class _RefResolutionError(Exception):
 
     def __eq__(self, other):
         if self.__class__ is not other.__class__:
-            return NotImplemented
+            return NotImplemented  # pragma: no cover -- uncovered but deprecated  # noqa: E501
         return self._cause == other._cause
 
     def __str__(self):
         return str(self._cause)
 
 
-class _WrappedReferencingError(_RefResolutionError, _Unresolvable):
+class _WrappedReferencingError(_RefResolutionError, _Unresolvable):  # pragma: no cover -- partially uncovered but to be removed  # noqa: E501
     def __init__(self, cause: _Unresolvable):
         object.__setattr__(self, "_wrapped", cause)
 

jsonschema/tests/test_exceptions.py

@@ -396,6 +396,22 @@ def test_if_its_in_the_tree_anyhow_it_does_not_raise_an_error(self):
         tree = exceptions.ErrorTree([error])
         self.assertIsInstance(tree["foo"], exceptions.ErrorTree)
 
+    def test_iter(self):
+        e1, e2 = (
+            exceptions.ValidationError(
+                "1",
+                validator="foo",
+                path=["bar", "bar2"],
+                instance="i1"),
+            exceptions.ValidationError(
+                "2",
+                validator="quux",
+                path=["foobar", 2],
+                instance="i2"),
+        )
+        tree = exceptions.ErrorTree([e1, e2])
+        self.assertEqual(set(tree), {"bar", "foobar"})
+
     def test_repr_single(self):
         error = exceptions.ValidationError(
             "1",

jsonschema/tests/test_format.py

@@ -54,6 +54,7 @@ def test_it_catches_registered_errors(self):
 
         self.assertIs(cm.exception.cause, BOOM)
         self.assertIs(cm.exception.__cause__, BOOM)
+        self.assertEqual(str(cm.exception), "12 is not a 'boom'")
 
         # Unregistered errors should not be caught
         with self.assertRaises(type(BANG)):