Fix the rendering of __str__ on wrapped referencing exceptions.

Be a bit less heavy handed, using __getattr__ rather than taking
over attribute lookups entirely.

Author: Julian

jsonschema/exceptions.py

@@ -213,11 +213,23 @@ def __str__(self):
 
 class _WrappedReferencingError(_RefResolutionError, _Unresolvable):
     def __init__(self, cause: _Unresolvable):
-        object.__setattr__(self, "_cause", cause)
+        object.__setattr__(self, "_wrapped", cause)
 
-    def __getattribute__(self, attr):
-        cause = object.__getattribute__(self, "_cause")
-        return getattr(cause, attr)
+    def __eq__(self, other):
+        if other.__class__ is self.__class__:
+            return self._wrapped == other._wrapped
+        elif other.__class__ is self._wrapped.__class__:
+            return self._wrapped == other
+        return NotImplemented
+
+    def __getattr__(self, attr):
+        return getattr(self._wrapped, attr)
+
+    def __repr__(self):
+        return f"<WrappedReferencingError {self._wrapped!r}>"
+
+    def __str__(self):
+        return f"{self._wrapped.__class__.__name__}: {self._wrapped}"
 
 
 class UndefinedTypeCheck(Exception):

jsonschema/tests/test_deprecations.py

@@ -184,7 +184,10 @@ def test_catching_Unresolvable_directly(self):
             validator.validate(12)
 
         expected = referencing.exceptions.Unresolvable(ref="urn:nothing")
-        self.assertEqual(e.exception, expected)
+        self.assertEqual(
+            (e.exception, str(e.exception)),
+            (expected, "Unresolvable: urn:nothing")
+        )
 
     def test_catching_Unresolvable_via_RefResolutionError(self):
         """
@@ -197,12 +200,17 @@ def test_catching_Unresolvable_via_RefResolutionError(self):
 
         validator = validators.Draft202012Validator({"$ref": "urn:nothing"})
 
-        with self.assertRaises(referencing.exceptions.Unresolvable):
+        with self.assertRaises(referencing.exceptions.Unresolvable) as u:
             validator.validate(12)
 
-        with self.assertRaises(RefResolutionError):
+        with self.assertRaises(RefResolutionError) as e:
             validator.validate(12)
 
+        self.assertEqual(
+            (e.exception, str(e.exception)),
+            (u.exception, "Unresolvable: urn:nothing")
+        )
+
     def test_Validator_subclassing(self):
         """
         As of v4.12.0, subclassing a validator class produces an explicit