Make captor-based roots sameish for chain continuation deduping

Continuation lookup now treats captor-style wildcard roots as structurally
sameish so equivalent root selectors share the same chain continuation.

Specifically, sameish comparison now handles call_captor(), *captor(), and
**captor() sentinel wrappers without relying on object identity, and compares
sentinel wrappers via their underlying captor matcher semantics.

The tests were updated to reflect this contract in sameish unit coverage, and
chaining coverage now includes call_captor/*captor/**captor branch-sharing
scenarios.

Author: kaste

mockito/sameish.py

@@ -54,6 +54,32 @@ def _values_are_sameish(left: object, right: object) -> bool:
     if left is Ellipsis or right is Ellipsis:
         return left is right
 
+    if matchers.is_call_captor(left) and matchers.is_call_captor(right):
+        return True
+
+    if matchers.is_call_captor(left) or matchers.is_call_captor(right):
+        return False
+
+    if (
+        matchers.is_captor_args_sentinel(left)
+        and matchers.is_captor_args_sentinel(right)
+    ):
+        return _values_are_sameish(left.captor.matcher, right.captor.matcher)
+
+    if (
+        matchers.is_captor_kwargs_sentinel(left)
+        and matchers.is_captor_kwargs_sentinel(right)
+    ):
+        return _values_are_sameish(left.captor.matcher, right.captor.matcher)
+
+    if (
+        matchers.is_captor_args_sentinel(left)
+        or matchers.is_captor_args_sentinel(right)
+        or matchers.is_captor_kwargs_sentinel(left)
+        or matchers.is_captor_kwargs_sentinel(right)
+    ):
+        return False
+
     if isinstance(left, matchers.Matcher) and isinstance(right, matchers.Matcher):
         return _matchers_are_sameish(left, right)
 
@@ -112,12 +138,6 @@ def _matchers_are_sameish(  # noqa: C901
     ):
         return _values_are_sameish(left.matcher, right.matcher)
 
-    if (
-        isinstance(left, matchers.CallCaptor)
-        and isinstance(right, matchers.CallCaptor)
-    ):
-        return False
-
     return _equals_or_identity(left, right)
 
 

tests/chaining_test.py

@@ -1,7 +1,7 @@
 import pytest
 
 from mockito import any as any_
-from mockito import arg_that, expect, mock, verify, unstub, when
+from mockito import arg_that, call_captor, captor, expect, mock, verify, unstub, when
 from mockito.invocation import AnswerError, InvocationError
 
 
@@ -60,6 +60,39 @@ def test_multiple_chain_branches_with_same_arg_that_matcher_share_root():
     assert cat_that_meowed.roll() == "playful"
 
 
+def test_multiple_chain_branches_with_call_captor_roots_share_root():
+    cat = mock()
+
+    when(cat).meow(call_captor()).purr().thenReturn("friendly")
+    when(cat).meow(call_captor()).roll().thenReturn("playful")
+
+    cat_that_meowed = cat.meow(1)
+    assert cat_that_meowed.purr() == "friendly"
+    assert cat_that_meowed.roll() == "playful"
+
+
+def test_multiple_chain_branches_with_args_captor_roots_share_root():
+    cat = mock()
+
+    when(cat).meow(*captor()).purr().thenReturn("friendly")
+    when(cat).meow(*captor()).roll().thenReturn("playful")
+
+    cat_that_meowed = cat.meow(1, 2)
+    assert cat_that_meowed.purr() == "friendly"
+    assert cat_that_meowed.roll() == "playful"
+
+
+def test_multiple_chain_branches_with_kwargs_captor_roots_share_root():
+    cat = mock()
+
+    when(cat).meow(**captor()).purr().thenReturn("friendly")
+    when(cat).meow(**captor()).roll().thenReturn("playful")
+
+    cat_that_meowed = cat.meow(volume=1)
+    assert cat_that_meowed.purr() == "friendly"
+    assert cat_that_meowed.roll() == "playful"
+
+
 def test_unstub_child_chain_then_reconfigure_does_not_leave_stale_root_stub():
     cat = mock()
 

tests/sameish_test.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass, field
 
-from mockito import and_, any as any_, arg_that, call_captor, eq, gt, neq, or_
+from mockito import and_, any as any_, arg_that, call_captor, captor, eq, gt, neq, or_
 from mockito import sameish
 
 
@@ -108,20 +108,69 @@ def predicate(value):
     assert seen == []
 
 
-def test_call_captor_instances_are_not_interchangeable():
+def test_call_captor_instances_are_sameish_for_root_deduping():
     left = call_captor()
     right = call_captor()
 
     assert sameish.invocations_are_sameish(
         bar(left),
         bar(left),
     )
-    assert not sameish.invocations_are_sameish(
+    assert sameish.invocations_are_sameish(
+        bar(left),
+        bar(right),
+    )
+
+
+def test_argument_captor_instances_are_sameish_for_root_deduping():
+    left = captor()
+    right = captor()
+
+    assert sameish.invocations_are_sameish(
+        bar(left),
+        bar(left),
+    )
+    assert sameish.invocations_are_sameish(
         bar(left),
         bar(right),
     )
 
 
+def test_star_argument_captor_instances_are_sameish_for_root_deduping():
+    left = captor()
+    right = captor()
+
+    assert sameish.invocations_are_sameish(
+        bar(1, *left),
+        bar(1, *left),
+    )
+    assert sameish.invocations_are_sameish(
+        bar(1, *left),
+        bar(1, *right),
+    )
+
+
+def test_kwargs_argument_captor_instances_are_sameish_for_root_deduping():
+    left = captor()
+    right = captor()
+
+    assert sameish.invocations_are_sameish(
+        bar(1, **left),
+        bar(1, **left),
+    )
+    assert sameish.invocations_are_sameish(
+        bar(1, **left),
+        bar(1, **right),
+    )
+
+
+def test_argument_captor_instances_with_different_matchers_are_not_sameish():
+    assert not sameish.invocations_are_sameish(
+        bar(captor(any_(int))),
+        bar(captor(any_(str))),
+    )
+
+
 def test_eq_failures_fallback_to_identity():
     class EqBoom:
         def __eq__(self, other):