fix: enforce effective signature for functools.partial patch targets

`functools.partial` is not a `FunctionType`, so `mock.create_autospec`
fell back to a generic `MagicMock(spec=...)` with no call-signature
checking, even when `autospec=True` was passed explicitly.

Wrap the partial in a thin function whose `__signature__` is set to
`inspect.signature(partial)`, which already computes the post-partial
effective signature. `create_autospec` then treats it as a plain function
and wires up enforcement correctly.

Covers both module-level partials and instance-attribute partials
wrapping bound methods.

Author: claudiubelu

mockey/fixture.py

@@ -18,6 +18,7 @@
 from __future__ import annotations
 
 import functools
+import inspect
 import typing
 from typing import TYPE_CHECKING, Any, TypeVar
 from unittest import mock
@@ -48,6 +49,18 @@ def _lazy_autospec_method(
     if mocked_method._mock_check_sig.__dict__.get("autospeced"):
         return
 
+    # functools.partial is not a FunctionType, so create_autospec falls back to
+    # a generic MagicMock(spec=...) with no call-signature enforcement. Wrap it
+    # in a thin function that carries the effective (post-partial) signature so
+    # create_autospec wires up enforcement correctly.
+    if isinstance(original_method, functools.partial):
+
+        def _sig_wrapper(*args: Any, **kwargs: Any) -> None:
+            pass
+
+        _sig_wrapper.__signature__ = inspect.signature(original_method)  # type: ignore[attr-defined]
+        original_method = _sig_wrapper
+
     _lazy_autospec: Any = mock.create_autospec(original_method)
     if eat_self:
         # consume self argument.

tests/test_issues_exist.py

@@ -198,6 +198,33 @@ def test_patch_partialmethod_autospec_true(self):
             client = utils._ClientWithPartialMethod()
             self.assertRaises(TypeError, client._send_post_request, "https://globex.com")
 
+    def test_patch_partial_instance_not_enforced(self):
+        # Even with explicit autospec=True, upstream does not enforce the
+        # effective signature of an instance-attribute partial; any call succeeds.
+        client = utils._ClientWithPartialMethod()
+        with (
+            self._restored_patch(),
+            mock.patch.object(client, "_send_get_request", autospec=True),
+        ):
+            client._send_get_request()  # missing url
+            # too many args
+            client._send_get_request(
+                "https://dunder-mifflin.com",
+                "worlds_best_boss",
+                "thats_what_she_said",
+            )
+
+    def test_patch_partial_module_level_not_enforced(self):
+        # Even with explicit autospec=True, upstream does not enforce the
+        # effective signature of a module-level partial; any call succeeds.
+        with (
+            self._restored_patch(),
+            mock.patch("tests.utils._send_post_request", autospec=True),
+        ):
+            utils._send_post_request()  # missing url
+            # too many args
+            utils._send_post_request("https://weyland-yutani.corp", "xenomorph_egg", "facehugger")
+
     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

@@ -175,6 +175,27 @@ def test_patch_partialmethod(self):
             # Unknown kwarg raises TypeError.
             self.assertRaises(TypeError, client._send_post_request, "https://initech.com", foo="lish")
 
+    def test_patch_partial_instance(self):
+        # The effective signature of _send_get_request is (url, payload=None);
+        # "GET" is pre-filled by partial.
+        client = utils._ClientWithPartialMethod()
+        with mock.patch.object(client, "_send_get_request"):
+            client._send_get_request("https://prestige-worldwide.com")
+            client._send_get_request("https://prestige-worldwide.com", payload="catalina_wine_mixer")
+
+            self.assertRaises(TypeError, client._send_get_request)
+            self.assertRaises(TypeError, client._send_get_request, "https://prestige-worldwide.com", foo="lish")
+
+    def test_patch_partial_function(self):
+        # The effective signature of _send_post_request is (url, payload=None);
+        # "POST" is pre-filled by partial.
+        with mock.patch("tests.utils._send_post_request"):
+            utils._send_post_request("https://aperture.science")
+            utils._send_post_request("https://aperture.science", payload="the_cake_is_a_lie")
+
+            self.assertRaises(TypeError, utils._send_post_request)
+            self.assertRaises(TypeError, utils._send_post_request, "https://aperture.science", foo="lish")
+
     def test_constructor_autospec(self):
         # Correct usage.
         m = mock.Mock(autospec=utils._ClassWithInit)

tests/utils.py

@@ -64,7 +64,17 @@ def get_none(self) -> None:
 
 
 class _ClientWithPartialMethod:
+    def __init__(self) -> None:
+        self._send_get_request = functools.partial(self._send_request, "GET")
+
     def _send_request(self, method: str, url: str, payload: str | None = None) -> None:
         pass
 
     _send_post_request = functools.partialmethod(_send_request, "POST")
+
+
+def _send_request(method: str, url: str, payload: str | None = None) -> None:
+    pass
+
+
+_send_post_request = functools.partial(_send_request, "POST")