fix: accept message string in error and warning constructors (#272)

Fixes #271

Co-authored-by: Michael Cousins <michael@cousins.io>

Author: zlalvani

decoy/__init__.py

@@ -3,14 +3,14 @@
 from typing import Any, Callable, Coroutine, Generic, Optional, Union, overload
 
 from . import errors, matchers, warnings
-from .core import DecoyCore, StubCore, PropCore
-from .types import ClassT, ContextValueT, FuncT, ReturnT
 from .context_managers import (
-    ContextManager,
     AsyncContextManager,
-    GeneratorContextManager,
     AsyncGeneratorContextManager,
+    ContextManager,
+    GeneratorContextManager,
 )
+from .core import DecoyCore, PropCore, StubCore
+from .types import ClassT, ContextValueT, FuncT, ReturnT
 
 # ensure decoy does not pollute pytest tracebacks
 __tracebackhide__ = True
@@ -82,7 +82,7 @@ def test_get_something(decoy: Decoy):
         spec = cls or func
 
         if spec is None and name is None:
-            raise errors.MockNameRequiredError()
+            raise errors.MockNameRequiredError.create()
 
         return self._core.mock(spec=spec, name=name, is_async=is_async)
 

decoy/errors.py

@@ -19,8 +19,10 @@ class MockNameRequiredError(ValueError):
     [MockNameRequiredError guide]: usage/errors-and-warnings.md#mocknamerequirederror
     """
 
-    def __init__(self) -> None:
-        super().__init__("Mocks without `cls` or `func` require a `name`.")
+    @classmethod
+    def create(cls) -> "MockNameRequiredError":
+        """Create a MockNameRequiredError."""
+        return cls("Mocks without `cls` or `func` require a `name`.")
 
 
 class MissingRehearsalError(ValueError):
@@ -36,8 +38,10 @@ class MissingRehearsalError(ValueError):
     [MissingRehearsalError guide]: usage/errors-and-warnings.md#missingrehearsalerror
     """
 
-    def __init__(self) -> None:
-        super().__init__("Rehearsal not found.")
+    @classmethod
+    def create(cls) -> "MissingRehearsalError":
+        """Create a MissingRehearsalError."""
+        return cls("Rehearsal not found.")
 
 
 class MockNotAsyncError(TypeError):
@@ -68,12 +72,14 @@ class VerifyError(AssertionError):
     calls: Sequence[SpyEvent]
     times: Optional[int]
 
-    def __init__(
-        self,
+    @classmethod
+    def create(
+        cls,
         rehearsals: Sequence[VerifyRehearsal],
         calls: Sequence[SpyEvent],
         times: Optional[int],
-    ) -> None:
+    ) -> "VerifyError":
+        """Create a VerifyError."""
         if times is not None:
             heading = f"Expected exactly {count(times, 'call')}:"
         elif len(rehearsals) == 1:
@@ -88,7 +94,9 @@ def __init__(
             include_calls=times is None or times == len(calls),
         )
 
-        super().__init__(message)
-        self.rehearsals = rehearsals
-        self.calls = calls
-        self.times = times
+        result = cls(message)
+        result.rehearsals = rehearsals
+        result.calls = calls
+        result.times = times
+
+        return result

decoy/spy_log.py

@@ -5,13 +5,13 @@
 from .errors import MissingRehearsalError
 from .spy_events import (
     AnySpyEvent,
+    PropAccessType,
+    PropRehearsal,
     SpyCall,
     SpyEvent,
     SpyPropAccess,
-    WhenRehearsal,
     VerifyRehearsal,
-    PropAccessType,
-    PropRehearsal,
+    WhenRehearsal,
 )
 
 
@@ -33,10 +33,10 @@ def consume_when_rehearsal(self, ignore_extra_args: bool) -> WhenRehearsal:
         try:
             event = self._log[-1]
         except IndexError as e:
-            raise MissingRehearsalError() from e
+            raise MissingRehearsalError.create() from e
 
         if not isinstance(event, SpyEvent):
-            raise MissingRehearsalError()
+            raise MissingRehearsalError.create()
 
         spy, payload = _apply_ignore_extra_args(event, ignore_extra_args)
 
@@ -59,12 +59,12 @@ def consume_verify_rehearsals(
 
         while len(rehearsals) < count:
             if index < 0:
-                raise MissingRehearsalError()
+                raise MissingRehearsalError.create()
 
             event = self._log[index]
 
             if not isinstance(event, (SpyEvent, PropRehearsal)):
-                raise MissingRehearsalError()
+                raise MissingRehearsalError.create()
 
             if _is_verifiable(event):
                 rehearsal = VerifyRehearsal(
@@ -82,7 +82,7 @@ def consume_prop_rehearsal(self) -> PropRehearsal:
         try:
             event = self._log[-1]
         except IndexError as e:
-            raise MissingRehearsalError() from e
+            raise MissingRehearsalError.create() from e
 
         spy, payload = event
 
@@ -91,7 +91,7 @@ def consume_prop_rehearsal(self) -> PropRehearsal:
             or not isinstance(payload, SpyPropAccess)
             or payload.access_type != PropAccessType.GET
         ):
-            raise MissingRehearsalError()
+            raise MissingRehearsalError.create()
 
         rehearsal = PropRehearsal(spy, payload)
         self._log[-1] = rehearsal

decoy/verifier.py

@@ -2,8 +2,8 @@
 
 from typing import Optional, Sequence
 
-from .spy_events import SpyEvent, VerifyRehearsal, match_event
 from .errors import VerifyError
+from .spy_events import SpyEvent, VerifyRehearsal, match_event
 
 # ensure decoy.verifier does not pollute Pytest tracebacks
 __tracebackhide__ = True
@@ -42,7 +42,7 @@ def verify(
         calls_verified = match_count != 0 if times is None else match_count == times
 
         if not calls_verified:
-            raise VerifyError(
+            raise VerifyError.create(
                 rehearsals=rehearsals,
                 calls=calls,
                 times=times,

decoy/warning_checker.py

@@ -9,9 +9,9 @@
     AnySpyEvent,
     SpyCall,
     SpyEvent,
+    SpyRehearsal,
     VerifyRehearsal,
     WhenRehearsal,
-    SpyRehearsal,
     match_event,
 )
 from .warnings import DecoyWarning, MiscalledStubWarning, RedundantVerifyWarning
@@ -78,7 +78,7 @@ def _check_no_miscalled_stubs(all_events: Sequence[AnySpyEvent]) -> None:
 
             if is_stubbed and all(len(c.matching_rehearsals) == 0 for c in calls):
                 _warn(
-                    MiscalledStubWarning(
+                    MiscalledStubWarning.create(
                         calls=[c.event for c in calls],
                         rehearsals=rehearsals,
                     )
@@ -91,7 +91,7 @@ def _check_no_redundant_verify(all_calls: Sequence[AnySpyEvent]) -> None:
 
     for vr in verify_rehearsals:
         if any(wr for wr in when_rehearsals if wr == vr):  # type: ignore[comparison-overlap]
-            _warn(RedundantVerifyWarning(rehearsal=vr))
+            _warn(RedundantVerifyWarning.create(rehearsal=vr))
 
 
 def _warn(warning: DecoyWarning) -> None:

decoy/warnings.py

@@ -9,7 +9,7 @@
 from typing import Sequence
 
 from .spy_events import SpyEvent, SpyRehearsal, VerifyRehearsal
-from .stringify import stringify_call, stringify_error_message, count
+from .stringify import count, stringify_call, stringify_error_message
 
 
 class DecoyWarning(UserWarning):
@@ -31,18 +31,20 @@ class MiscalledStubWarning(DecoyWarning):
     [MiscalledStubWarning guide]: usage/errors-and-warnings.md#miscalledstubwarning
 
     Attributes:
-        rehearsals: The mocks's configured rehearsals.
+        rehearsals: The mock's configured rehearsals.
         calls: Actual calls to the mock.
     """
 
     rehearsals: Sequence[SpyRehearsal]
     calls: Sequence[SpyEvent]
 
-    def __init__(
-        self,
+    @classmethod
+    def create(
+        cls,
         rehearsals: Sequence[SpyRehearsal],
         calls: Sequence[SpyEvent],
-    ) -> None:
+    ) -> "MiscalledStubWarning":
+        """Create a MiscalledStubWarning."""
         heading = os.linesep.join(
             [
                 "Stub was called but no matching rehearsal found.",
@@ -56,9 +58,11 @@ def __init__(
             calls=calls,
         )
 
-        super().__init__(message)
-        self.rehearsals = rehearsals
-        self.calls = calls
+        result = cls(message)
+        result.rehearsals = rehearsals
+        result.calls = calls
+
+        return result
 
 
 class RedundantVerifyWarning(DecoyWarning):
@@ -74,7 +78,11 @@ class RedundantVerifyWarning(DecoyWarning):
     [RedundantVerifyWarning guide]: usage/errors-and-warnings.md#redundantverifywarning
     """
 
-    def __init__(self, rehearsal: VerifyRehearsal) -> None:
+    rehearsal: VerifyRehearsal
+
+    @classmethod
+    def create(cls, rehearsal: VerifyRehearsal) -> "RedundantVerifyWarning":
+        """Create a RedundantVerifyWarning."""
         message = os.linesep.join(
             [
                 "The same rehearsal was used in both a `when` and a `verify`.",
@@ -83,8 +91,11 @@ def __init__(self, rehearsal: VerifyRehearsal) -> None:
                 "See https://michael.cousins.io/decoy/usage/errors-and-warnings/#redundantverifywarning",
             ]
         )
-        super().__init__(message)
-        self.rehearsal = rehearsal
+
+        result = cls(message)
+        result.rehearsal = rehearsal
+
+        return result
 
 
 class IncorrectCallWarning(DecoyWarning):

tests/test_errors.py

@@ -1,11 +1,12 @@
 """Tests for error and warning message generation."""
 
-import pytest
 import os
 from typing import List, NamedTuple, Optional
 
-from decoy.spy_events import SpyCall, SpyEvent, SpyInfo, VerifyRehearsal
+import pytest
+
 from decoy.errors import VerifyError
+from decoy.spy_events import SpyCall, SpyEvent, SpyInfo, VerifyRehearsal
 
 
 class VerifyErrorSpec(NamedTuple):
@@ -166,5 +167,5 @@ def test_verify_error(
     expected_message: str,
 ) -> None:
     """It should stringify VerifyError properly."""
-    error = VerifyError(rehearsals=rehearsals, calls=calls, times=times)
+    error = VerifyError.create(rehearsals=rehearsals, calls=calls, times=times)
     assert str(error) == expected_message