fix: handle functools.partialmethod in autospec eat_self logic

mock._must_skip returns False for partialmethod attributes (not plain
functions), causing eat_self=False and incorrect signature enforcement.

Introduce a _must_skip wrapper that corrects this, and document the two
upstream issues:
- no enforcement without autospec
- NonCallableMagicMock with explicit autospec=True.

Author: claudiubelu

mockey/fixture.py

@@ -27,6 +27,19 @@
 _T = TypeVar("_T")
 
 
+def _must_skip(spec: Any, entry: str, is_type: bool) -> bool:
+    """Return whether the first argument must be consumed when autospeccing entry on spec.
+
+    Extends mock._must_skip to handle functools.partialmethod, which the
+    upstream function misidentifies as a non-function and returns False for it.
+    """
+    eat_self: bool = mock._must_skip(spec, entry, is_type)  # type: ignore[attr-defined]
+    if not eat_self and is_type and isinstance(spec.__dict__.get(entry), functools.partialmethod):
+        eat_self = True
+
+    return eat_self
+
+
 def _lazy_autospec_method(
     mocked_method: Any,
     original_method: Any,
@@ -104,10 +117,7 @@ def __getattr__(self, name: str) -> Any:
         # lazily autospec callable attributes.
         original_attr = getattr(original_spec, name)
         if callable(original_attr):
-            # NOTE: _must_skip is a private function in the mock module
-            eat_self = mock._must_skip(  # type: ignore[attr-defined]
-                original_spec, name, isinstance(original_spec, type)
-            )
+            eat_self = _must_skip(original_spec, name, isinstance(original_spec, type))
 
             _lazy_autospec_method(attr, original_attr, eat_self)
 
@@ -203,10 +213,7 @@ def __enter__(self) -> _T:
             if autospec:
                 target = self.getter()
                 original_attr = getattr(target, self.attribute)
-                # NOTE: _must_skip is a private function in the mock module
-                eat_self = mock._must_skip(  # type: ignore[attr-defined]
-                    target, self.attribute, isinstance(target, type)
-                )
+                eat_self = _must_skip(target, self.attribute, isinstance(target, type))
 
                 new = super().__enter__()
 

tests/test_issues_exist.py

@@ -173,6 +173,31 @@ def test_patch_already_mocked_target(self):
             patcher.start()
             patcher.stop()
 
+    def test_patch_partialmethod_not_enforced(self):
+        # Without the fixture, patching a partialmethod attribute does not
+        # enforce the effective signature, any call succeeds.
+        with (
+            self._restored_patch(),
+            mock.patch.object(utils._ClientWithPartialMethod, "_send_post_request"),
+        ):
+            client = utils._ClientWithPartialMethod()
+            client._send_post_request()  # missing url
+            # too many args
+            client._send_post_request("https://speedwagon.foundation", "ripple_energy", "za_warudo")
+
+    def test_patch_partialmethod_autospec_true(self):
+        # Upstream, with explicit autospec=True, create_autospec resolves the
+        # partialmethod descriptor to a NonCallableMagicMock, rendering the
+        # mock completely uncallable. Any call, even with the correct effective
+        # signature, raises TypeError.
+        with (
+            self._restored_patch(),
+            mock.patch.object(utils._ClientWithPartialMethod, "_send_post_request", autospec=True) as mocked,
+        ):
+            self.assertIsInstance(mocked, mock.NonCallableMagicMock)
+            client = utils._ClientWithPartialMethod()
+            self.assertRaises(TypeError, client._send_post_request, "https://globex.com")
+
     def test_constructor_autospec_not_enforced(self):
         # Without the fixture, constructor signature is NOT enforced.
         # mock.Mock / mock.MagicMock do not have an autospec argument

tests/test_issues_fixed.py

@@ -158,6 +158,23 @@ def test_patch_already_mocked_target(self):
                 patcher.start,
             )
 
+    def test_patch_partialmethod(self):
+        # The effective signature of _send_post_request is (url, payload=None)
+        # "POST" is pre-filled by partialmethod.
+        with mock.patch.object(utils._ClientWithPartialMethod, "_send_post_request") as mocked:
+            client = utils._ClientWithPartialMethod()
+
+            # Correct effective args work.
+            client._send_post_request("https://speedwagon.foundation")
+            client._send_post_request("https://umbrella.corp", payload="t_virus")
+            mocked.assert_called_with("https://umbrella.corp", payload="t_virus")
+
+            # Missing required arg raises TypeError.
+            self.assertRaises(TypeError, client._send_post_request)
+
+            # Unknown kwarg raises TypeError.
+            self.assertRaises(TypeError, client._send_post_request, "https://initech.com", foo="lish")
+
     def test_constructor_autospec(self):
         # Correct usage.
         m = mock.Mock(autospec=utils._ClassWithInit)

tests/utils.py

@@ -13,6 +13,8 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import functools
+
 
 class Foo:
     def bar(self, a, b, c, d=None):
@@ -59,3 +61,10 @@ def get_the_thing(self) -> Foo:
 
     def get_none(self) -> None:
         pass
+
+
+class _ClientWithPartialMethod:
+    def _send_request(self, method: str, url: str, payload: str | None = None) -> None:
+        pass
+
+    _send_post_request = functools.partialmethod(_send_request, "POST")