fix: descriptor protocol methods must not have eat_self applied

_must_skip returned True for __get__, __set__, __delete__, __set_name__
on a class because they are regular methods on a type. But Python's
descriptor machinery invokes them directly as (self, instance, owner),
not through normal method binding, so wrapping with partial(_, None)
consumed one argument slot and caused TypeError on invocation.

Author: claudiubelu

mockey/fixture.py

@@ -27,13 +27,22 @@
 
 _T = TypeVar("_T")
 
+_DESCRIPTOR_DUNDERS = frozenset({"__get__", "__set__", "__delete__", "__set_name__"})
+
 
 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.
+
+    Descriptor protocol methods (__get__, __set__, __delete__, __set_name__)
+    are invoked directly by Python's descriptor machinery with (self, instance, owner),
+    not through normal method binding, so eat_self must never be applied to them.
     """
+    if entry in _DESCRIPTOR_DUNDERS:
+        return False
+
     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

tests/test_fixture.py

@@ -67,6 +67,26 @@ def test_patch_with_explicit_new_skips_autospec(self):
             utils.Foo().bar()  # type: ignore[call-arg]
             replacement.assert_called_once_with()
 
+    def test_patch_descriptor_dunder_does_not_eat_self(self):
+        # Mockey's _must_skip used to return eat_self=True for __get__ on a
+        # class, then wrap the mock with partial(_, None), consuming one slot.
+        # Python's descriptor machinery calls __get__(self, instance, owner)
+        # directly, so that extra partial caused TypeError: too many arguments.
+        received = []
+
+        def my_get(self, instance, owner=None):
+            received.append((self, instance, owner))
+
+        with mock.patch.object(utils._DescriptorClass, "__get__", side_effect=my_get):
+            owner_obj = utils._OwnerClass()
+            _ = owner_obj.attr
+
+        self.assertEqual(1, len(received))
+        _self, instance, owner = received[0]
+        self.assertIsInstance(_self, utils._DescriptorClass)
+        self.assertIs(owner_obj, instance)
+        self.assertIs(utils._OwnerClass, owner)
+
 
 class MockFixtureLifecycleTestCase(testtools.TestCase):
     """Tests that must run without MockAutospecFixture active."""

tests/utils.py

@@ -63,6 +63,20 @@ def get_none(self) -> None:
         pass
 
 
+class _DescriptorClass:
+    """Descriptor whose __get__ / __set__ can be patched for testing."""
+
+    def __get__(self, instance, owner=None):
+        return instance
+
+    def __set__(self, instance, value):
+        pass
+
+
+class _OwnerClass:
+    attr = _DescriptorClass()
+
+
 class _ClientWithPartialMethod:
     def __init__(self) -> None:
         self._send_get_request = functools.partial(self._send_request, "GET")