Harden matcher repr rendering

Use safe repr handling in ValueMatcher and Contains so diagnostic
rendering cannot fail when user objects implement a broken __repr__.

Also preserve explicit flags in Matches.__repr__ when a compiled pattern
is passed, while still omitting default regex engine flags.

Author: kaste

mockito/matchers.py

@@ -174,7 +174,10 @@ def __init__(self, value):
         self.value = value
 
     def __repr__(self):
-        return "<%s: %r>" % (self.__class__.__name__, self.value)
+        return "<%s: %s>" % (
+            self.__class__.__name__,
+            _safe_repr(self.value),
+        )
 
 
 class Eq(ValueMatcher):
@@ -351,13 +354,13 @@ def matches(self, arg):
         return self.sub and len(self.sub) > 0 and arg.find(self.sub) > -1
 
     def __repr__(self):
-        return "<Contains: %r>" % self.sub
+        return "<Contains: %s>" % _safe_repr(self.sub)
 
 
 class Matches(Matcher):
     def __init__(self, regex, flags=0):
         self.regex = re.compile(regex, flags)
-        self.flags = flags
+        self.flags = _explicit_regex_flags(regex, flags)
 
     def matches(self, arg):
         if not isinstance(arg, str):
@@ -371,6 +374,23 @@ def __repr__(self):
             return "<Matches: %r>" % self.regex.pattern
 
 
+def _explicit_regex_flags(regex, flags):
+    if flags:
+        return flags
+
+    compiled_flags = _safe_getattr(regex, 'flags')
+    pattern = _safe_getattr(regex, 'pattern')
+    if compiled_flags is None or pattern is None:
+        return 0
+
+    try:
+        baseline_flags = re.compile(pattern).flags
+    except Exception:
+        return compiled_flags
+
+    return compiled_flags & ~baseline_flags
+
+
 class ArgumentCaptor(Matcher, Capturing):
     def __init__(self, matcher=None):
         self.matcher = matcher or Any()

tests/matcher_repr_test.py

@@ -50,6 +50,26 @@ def __repr__(self):
     assert 'BrokenRepr object' in matcher_repr
 
 
+def test_value_matcher_repr_handles_values_with_broken_repr():
+    class BrokenRepr:
+        def __repr__(self):
+            raise RuntimeError('boom')
+
+    matcher_repr = repr(eq(BrokenRepr()))
+    assert matcher_repr.startswith('<Eq: <')
+    assert 'BrokenRepr object' in matcher_repr
+
+
+def test_contains_repr_handles_values_with_broken_repr():
+    class BrokenRepr:
+        def __repr__(self):
+            raise RuntimeError('boom')
+
+    matcher_repr = repr(contains(BrokenRepr()))
+    assert matcher_repr.startswith('<Contains: <')
+    assert 'BrokenRepr object' in matcher_repr
+
+
 def test_contains_repr_uses_safe_quoted_substring():
     assert repr(contains("a'b")) == "<Contains: \"a'b\">"
 
@@ -61,6 +81,14 @@ def test_matches_repr_shows_only_explicit_flags():
     )
 
 
+def test_matches_repr_shows_flags_for_compiled_patterns():
+    compiled = re.compile('f..', re.IGNORECASE)
+
+    assert repr(matches(compiled)) == (
+        f"<Matches: 'f..' flags={int(re.IGNORECASE)}>"
+    )
+
+
 def test_arg_that_repr_includes_named_function_name():
     # Predicate display name: "def is_positive"
     def is_positive(value):