refactor(matchers): simplify branching logic and add test coverage (#303)

Author: mcous

decoy/matchers.py

@@ -178,14 +178,11 @@ def __init__(self, attributes: Mapping[str, Any]) -> None:
 
     def __eq__(self, target: object) -> bool:
         """Return true if target matches all given attributes."""
-        is_match = True
         for attr_name, value in self._attributes.items():
-            if is_match:
-                is_match = (
-                    hasattr(target, attr_name) and getattr(target, attr_name) == value
-                )
+            if not hasattr(target, attr_name) or getattr(target, attr_name) != value:
+                return False
 
-        return is_match
+        return True
 
     def __repr__(self) -> str:
         """Return a string representation of the matcher."""
@@ -219,16 +216,14 @@ def __init__(self, values: Mapping[Any, Any]) -> None:
 
     def __eq__(self, target: object) -> bool:
         """Return true if target matches all given keys/values."""
-        is_match = True
-
         for key, value in self._values.items():
-            if is_match:
-                try:
-                    is_match = key in target and target[key] == value  # type: ignore[index,operator]
-                except TypeError:
-                    is_match = False
+            try:
+                if key not in target or target[key] != value:  # type: ignore[index,operator]
+                    return False
+            except TypeError:
+                return False
 
-        return is_match
+        return True
 
     def __repr__(self) -> str:
         """Return a string representation of the matcher."""
@@ -319,10 +314,12 @@ def StringMatching(match: str) -> str:
 class _ErrorMatching:
     _error_type: Type[BaseException]
     _string_matcher: Optional[_StringMatching]
+    _match: Optional[str]
 
     def __init__(self, error: Type[BaseException], match: Optional[str] = None) -> None:
         """Initialize with the Exception type and optional message matcher."""
         self._error_type = error
+        self._match = match
         self._string_matcher = _StringMatching(match) if match is not None else None
 
     def __eq__(self, target: object) -> bool:
@@ -338,9 +335,7 @@ def __eq__(self, target: object) -> bool:
 
     def __repr__(self) -> str:
         """Return a string representation of the matcher."""
-        return (
-            f"<ErrorMatching {self._error_type.__name__} match={self._string_matcher}>"
-        )
+        return f"<ErrorMatching {self._error_type.__name__} match={self._match!r}>"
 
 
 ErrorT = TypeVar("ErrorT", bound=BaseException)

tests/test_matchers.py

@@ -31,6 +31,9 @@ def test_anything_or_none_matcher() -> None:
     assert SomeClass() == matchers.AnythingOrNone()
     assert None == matchers.AnythingOrNone()  # noqa: E711
 
+
+def test_anything_or_none_repr() -> None:
+    """`AnythingOrNone()` has a string representation."""
     assert str(matchers.AnythingOrNone()) == "<AnythingOrNone>"
 
 
@@ -45,6 +48,11 @@ def test_any_matcher() -> None:
     assert None != matchers.Anything()  # noqa: E711
 
 
+def test_anything_repr() -> None:
+    """`Anything()` has a string representation."""
+    assert str(matchers.Anything()) == "<Anything>"
+
+
 def test_is_a_matcher() -> None:
     """It should have an "anything that is this type" matcher."""
     assert 1 == matchers.IsA(int)
@@ -65,6 +73,19 @@ def test_is_a_matcher_checks_instance(decoy: Decoy) -> None:
     assert target == matchers.IsA(SomeClass)
 
 
+def test_is_a_repr() -> None:
+    """`IsA()` has a string representation."""
+    assert str(matchers.IsA(SomeClass)) == "<IsA SomeClass>"
+
+
+def test_is_a_with_attrs_repr() -> None:
+    """`IsA()` has a string representation when passed attributes."""
+    assert (
+        str(matchers.IsA(SomeClass, {"hello": "world"}))
+        == "<IsA SomeClass {'hello': 'world'}>"
+    )
+
+
 def test_is_not_matcher() -> None:
     """It should have an "anything that isn't this" matcher."""
     assert 1 == matchers.IsNot(2)
@@ -80,19 +101,35 @@ def test_is_not_matcher() -> None:
     assert ("hello", "world") != matchers.IsNot(("hello", "world"))
 
 
-def test_has_attribute_matcher() -> None:
+def test_is_not_repr() -> None:
+    """`IsNot()` has a string representation."""
+    assert str(matchers.IsNot("hello")) == "<IsNot 'hello'>"
+
+
+def test_has_attributes_matcher() -> None:
     """It should have an "anything with these attributes" matcher."""
     assert _HelloTuple("world") == matchers.HasAttributes({"hello": "world"})
     assert _HelloClass() == matchers.HasAttributes({"hello": "world"})
     assert _HelloClass() == matchers.HasAttributes({"goodbye": "so long"})
 
     assert {"hello": "world"} != matchers.HasAttributes({"hello": "world"})
-    assert _HelloTuple("world") != matchers.HasAttributes({"goodbye": "so long"})
+    assert _HelloTuple("world") != matchers.HasAttributes({"hello": "goodbye"})
+    assert _HelloTuple("world") != matchers.HasAttributes(
+        {"hello": "world", "goodbye": "so long"}
+    )
     assert 1 != matchers.HasAttributes({"hello": "world"})
     assert False != matchers.HasAttributes({"hello": "world"})  # noqa: E712
     assert [] != matchers.HasAttributes({"hello": "world"})
 
 
+def test_has_attributes_repr() -> None:
+    """`HasAttributes()` has a string representation."""
+    assert (
+        str(matchers.HasAttributes({"hello": "world"}))
+        == "<HasAttributes {'hello': 'world'}>"
+    )
+
+
 def test_dict_matching_matcher() -> None:
     """It should have a "dictionary matching" matcher."""
     assert {"hello": "world"} == matchers.DictMatching({"hello": "world"})
@@ -114,6 +151,11 @@ def test_dict_matching_matcher_with_int_key() -> None:
     assert {1: "hello", 2: "world"} == matchers.DictMatching({2: "world"})
 
 
+def test_dict_matching_repr() -> None:
+    """`DictMatching()` has a string representation."""
+    assert str(matchers.DictMatching({1: "hello"})) == "<DictMatching {1: 'hello'}>"
+
+
 def test_list_matching_matcher() -> None:
     """It should have a "contains this sub-list" matcher."""
     assert [1, 2, 3] == matchers.ListMatching([1])
@@ -134,6 +176,9 @@ def test_list_matching_matcher() -> None:
 
     assert 1 != matchers.ListMatching([1])
 
+
+def test_list_matching_repr() -> None:
+    """`ListMatching()` has a string representation."""
     assert str(matchers.ListMatching([1])) == "<ListMatching [1]>"
 
 
@@ -143,6 +188,11 @@ def test_string_matching_matcher() -> None:
     assert "hello" != matchers.StringMatching("^ello$")
 
 
+def test_string_matching_repr() -> None:
+    """`StringMatching()` has a string representation."""
+    assert str(matchers.StringMatching("ello")) == "<StringMatching 'ello'>"
+
+
 def test_error_matching_matcher() -> None:
     """It should have an "any error that matches" matcher."""
     assert RuntimeError("ah!") == matchers.ErrorMatching(RuntimeError)
@@ -151,6 +201,14 @@ def test_error_matching_matcher() -> None:
     assert RuntimeError("ah!") != matchers.ErrorMatching(RuntimeError, "ah$")
 
 
+def test_error_matching_repr() -> None:
+    """`ErrorMatching()` has a string representation."""
+    assert (
+        str(matchers.ErrorMatching(RuntimeError, "ah"))
+        == "<ErrorMatching RuntimeError match='ah'>"
+    )
+
+
 def test_captor_matcher_legacy() -> None:
     """It should have a captor matcher that captures the compared value."""
     captor = matchers.Captor()
@@ -195,3 +253,8 @@ def test_captor_matcher_raises_if_no_value() -> None:
 
     with pytest.raises(AssertionError, match="No value captured"):
         captor.value  # noqa: B018
+
+
+def test_captor_repr() -> None:
+    """`StringMatching()` has a string representation."""
+    assert str(matchers.ValueCaptor()) == "<Captor>"