Harden Any repr formatting and add edge-case coverage

Improve Any repr readability for type constraints while preserving
robustness for unusual objects. Type constraints now render as concise
names (e.g. "<Any: int>", "<Any: (int, str)>") and still fall back
safely for non-type values.

Author: kaste

mockito/matchers.py

@@ -138,7 +138,35 @@ def matches(self, arg):
             return True
 
     def __repr__(self):
-        return "<Any: %r>" % self.wanted_type
+        return "<Any: %s>" % _any_wanted_type_label(self.wanted_type)
+
+
+def _any_wanted_type_label(wanted_type):
+    if isinstance(wanted_type, type):
+        return _type_label(wanted_type)
+
+    if (
+        isinstance(wanted_type, tuple)
+        and all(isinstance(t, type) for t in wanted_type)
+    ):
+        items = [_type_label(t) for t in wanted_type]
+        if len(items) == 1:
+            return '(%s,)' % items[0]
+        return '(%s)' % ', '.join(items)
+
+    return _safe_repr(wanted_type)
+
+
+def _type_label(type_):
+    module = _safe_getattr(type_, '__module__')
+    qualname = _safe_getattr(type_, '__qualname__') or _safe_getattr(type_, '__name__')
+    if qualname is None:
+        return _safe_repr(type_)
+
+    if module is None or module == 'builtins':
+        return qualname
+
+    return '%s.%s' % (module, qualname)
 
 
 class ValueMatcher(Matcher):
@@ -300,6 +328,16 @@ def _safe_getattr(value, name, default=None):
         return default
 
 
+def _safe_repr(value):
+    try:
+        return repr(value)
+    except Exception:
+        try:
+            return object.__repr__(value)
+        except Exception:
+            return '<unrepresentable>'
+
+
 def _label_with_line(label, line_number):
     if line_number is None:
         return label

tests/matcher_repr_test.py

@@ -16,10 +16,40 @@ def test_composed_matchers_include_quoted_nested_values():
     assert repr(or_(eq("foo"), gt(1))) == "<Or: [<Eq: 'foo'>, <Gt: 1>]>"
 
 
+def test_any_repr_uses_pretty_names_for_types():
+    assert repr(any_(int)) == "<Any: int>"
+    assert repr(any_((int, str))) == "<Any: (int, str)>"
+
+
 def test_any_repr_quotes_non_type_values():
     assert repr(any_("foo")) == "<Any: 'foo'>"
 
 
+def test_any_repr_handles_types_with_broken_introspection():
+    class EvilMeta(type):
+        def __getattribute__(cls, name):
+            if name in {'__module__', '__qualname__', '__name__'}:
+                raise RuntimeError('boom')
+            return super().__getattribute__(name)
+
+    class Evil(metaclass=EvilMeta):
+        pass
+
+    matcher_repr = repr(any_(Evil))
+    assert matcher_repr.startswith("<Any: <class '")
+    assert "Evil" in matcher_repr
+
+
+def test_any_repr_handles_values_with_broken_repr():
+    class BrokenRepr:
+        def __repr__(self):
+            raise RuntimeError('boom')
+
+    matcher_repr = repr(any_(BrokenRepr()))
+    assert matcher_repr.startswith('<Any: <')
+    assert 'BrokenRepr object' in matcher_repr
+
+
 def test_contains_repr_uses_safe_quoted_substring():
     assert repr(contains("a'b")) == "<Contains: \"a'b\">"