fix(warnings): don't raise MiscalledStubWarning on verified calls (#42)

Closes #41

Author: mcous

.github/workflows/ci.yml

@@ -26,7 +26,9 @@ jobs:
 
             - name: "Set up dependency cache"
               uses: actions/cache@v2
-              if: ${{ matrix.os != 'Windows' || matrix.python-version != 3.6 }}
+              # poetry venv restore is buggy on windows
+              # https://github.com/python-poetry/poetry/issues/2629
+              if: ${{ matrix.os != 'Windows' }}
               with:
                   key: deps-${{ secrets.GH_CACHE }}-${{ runner.os }}-python${{ matrix.python-version }}-${{ hashFiles('**/*.lock') }}
                   path: |

decoy/warning_checker.py

@@ -26,37 +26,33 @@ def _check_no_miscalled_stubs(all_calls: Sequence[BaseSpyCall]) -> None:
         all_calls_by_id[spy_id] = spy_calls + [call]
 
     for spy_id, spy_calls in all_calls_by_id.items():
-        rehearsals: List[WhenRehearsal] = []
         unmatched: List[SpyCall] = []
 
-        for call in spy_calls:
-            next_rehearsals = rehearsals
-            next_unmatched = unmatched
+        for index, call in enumerate(spy_calls):
+            past_stubs = [
+                wr for wr in spy_calls[0:index] if isinstance(wr, WhenRehearsal)
+            ]
 
-            if isinstance(call, WhenRehearsal):
-                next_rehearsals = rehearsals + [call]
+            matched_past_stubs = [wr for wr in past_stubs if wr == call]
 
-                if len(unmatched) > 0:
-                    next_unmatched = []
+            matched_future_verifies = [
+                vr
+                for vr in spy_calls[index + 1 :]
+                if isinstance(vr, VerifyRehearsal) and vr == call
+            ]
 
-                    warn(
-                        MiscalledStubWarning(
-                            calls=unmatched,
-                            rehearsals=rehearsals,
-                        )
-                    )
-            elif (
+            if (
                 isinstance(call, SpyCall)
-                and len(rehearsals) > 0
-                and not any(rh == call for rh in rehearsals)
+                and len(past_stubs) > 0
+                and len(matched_past_stubs) == 0
+                and len(matched_future_verifies) == 0
             ):
-                next_unmatched = unmatched + [call]
-
-            rehearsals = next_rehearsals
-            unmatched = next_unmatched
-
-        if len(unmatched) > 0:
-            warn(MiscalledStubWarning(calls=unmatched, rehearsals=rehearsals))
+                unmatched = unmatched + [call]
+                if index == len(spy_calls) - 1:
+                    warn(MiscalledStubWarning(calls=unmatched, rehearsals=past_stubs))
+            elif isinstance(call, WhenRehearsal) and len(unmatched) > 0:
+                warn(MiscalledStubWarning(calls=unmatched, rehearsals=past_stubs))
+                unmatched = []
 
 
 def _check_no_redundant_verify(all_calls: Sequence[BaseSpyCall]) -> None:

tests/test_warning_checker.py

@@ -1,6 +1,6 @@
-"""Tests for spy call verification."""
+"""Tests for the WarningChecker API."""
 import pytest
-from typing import Any, List, NamedTuple, Sequence
+from typing import List, NamedTuple, Sequence
 
 from decoy import matchers
 from decoy.spy_calls import BaseSpyCall, SpyCall, WhenRehearsal, VerifyRehearsal
@@ -172,6 +172,34 @@ class WarningCheckerSpec(NamedTuple):
             ),
         ],
     ),
+    # it should not warn if a call misses a stubbing but is later verified
+    WarningCheckerSpec(
+        all_calls=[
+            WhenRehearsal(spy_id=1, spy_name="spy", args=(1,), kwargs={}),
+            SpyCall(spy_id=1, spy_name="spy", args=(2,), kwargs={}),
+            VerifyRehearsal(spy_id=1, spy_name="spy", args=(2,), kwargs={}),
+        ],
+        expected_warnings=[],
+    ),
+    # it should warn if a call misses a stubbing after it is verified
+    WarningCheckerSpec(
+        all_calls=[
+            SpyCall(spy_id=1, spy_name="spy", args=(2,), kwargs={}),
+            VerifyRehearsal(spy_id=1, spy_name="spy", args=(2,), kwargs={}),
+            WhenRehearsal(spy_id=1, spy_name="spy", args=(1,), kwargs={}),
+            SpyCall(spy_id=1, spy_name="spy", args=(2,), kwargs={}),
+        ],
+        expected_warnings=[
+            MiscalledStubWarning(
+                rehearsals=[
+                    WhenRehearsal(spy_id=1, spy_name="spy", args=(1,), kwargs={}),
+                ],
+                calls=[
+                    SpyCall(spy_id=1, spy_name="spy", args=(2,), kwargs={}),
+                ],
+            ),
+        ],
+    ),
     # it should issue a redundant verify warning if a call has a when and a verify
     WarningCheckerSpec(
         all_calls=[
@@ -210,14 +238,16 @@ def test_verify_no_misscalled_stubs(
     subject = WarningChecker()
     subject.check(all_calls)
 
-    assert len(recwarn) == len(expected_warnings)
-    for expected in expected_warnings:
-        result: Any = recwarn.pop(DecoyWarning).message
-        expected_attr = {}
+    warning_matchers = []
+
+    for warning in expected_warnings:
+        if isinstance(warning, MiscalledStubWarning):
+            warning_attr = {"rehearsals": warning.rehearsals, "calls": warning.calls}
+        elif isinstance(warning, RedundantVerifyWarning):
+            warning_attr = {"rehearsal": warning.rehearsal}
+
+        warning_matchers.append(matchers.IsA(type(warning), warning_attr))
 
-        if isinstance(expected, MiscalledStubWarning):
-            expected_attr = {"rehearsals": expected.rehearsals, "calls": expected.calls}
-        elif isinstance(expected, RedundantVerifyWarning):
-            expected_attr = {"rehearsal": expected.rehearsal}
+    actual_warnings = [record.message for record in recwarn]
 
-        assert result == matchers.IsA(type(expected), expected_attr)
+    assert actual_warnings == warning_matchers