bpo-32092: consumes self/cls arguments when patching methods

Currently, when patching methods with autospec, their self / cls
arguments are not consumed, causing call asserts to fail (they
expect an instance / class reference as the first argument).

Example:

from unittest import mock

class Something(object):
    def foo(self, a, b, c, d):
        pass

patcher = mock.patch.object(Something, 'foo', autospec=True)
patcher.start()

s = Something()
s.foo()

Author: claudiubelu

Lib/unittest/mock.py

@@ -155,6 +155,10 @@ def _set_signature(mock, original, instance=False):
     if not _callable(original):
         return
 
+    if '_spec_signature' in mock.__dict__:
+        # mock already has a spec signature. Nothing to do.
+        return mock
+
     skipfirst = isinstance(original, type)
     result = _get_signature_object(original, instance, skipfirst)
     if result is None:
@@ -1354,11 +1358,21 @@ def __enter__(self):
             if original is DEFAULT:
                 raise TypeError("Can't use 'autospec' with create=True")
             spec_set = bool(spec_set)
+            is_class = isinstance(self.target, type)
             if autospec is True:
-                autospec = original
+                if is_class:
+                    # if it's a class, "original" could represent a class
+                    # or static method object (non-callable), instead of the
+                    # method itself, causing a NonCallableMagicMock to be
+                    # created.
+                    autospec = getattr(self.target, self.attribute, original)
+                else:
+                    autospec = original
 
+            eat_self = _must_skip(self.target, self.attribute, is_class)
             new = create_autospec(autospec, spec_set=spec_set,
-                                  _name=self.attribute, **kwargs)
+                                  _name=self.attribute, _eat_self=eat_self,
+                                  **kwargs)
         elif kwargs:
             # can't set keyword args when we aren't creating the mock
             # XXXX If new is a Mock we could call new.configure_mock(**kwargs)
@@ -2252,9 +2266,9 @@ def create_autospec(spec, spec_set=False, instance=False, _parent=None,
             new = _SpecState(original, spec_set, mock, entry, instance)
             mock._mock_children[entry] = new
         else:
+            # we are looping over a spec's attributes, so mock is the parent
+            # of mocked spec attributes.
             parent = mock
-            if isinstance(spec, FunctionTypes):
-                parent = mock.mock
 
             skipfirst = _must_skip(spec, entry, is_type)
             kwargs['_eat_self'] = skipfirst

Lib/unittest/test/testmock/testmock.py

@@ -790,6 +790,21 @@ def test_filter_dir(self):
             patcher.stop()
 
 
+    def test_patch_autospec_obj(self):
+        something = Something()
+        with patch.multiple(something, meth=DEFAULT, cmeth=DEFAULT,
+                            smeth=DEFAULT, autospec=True):
+            self._check_autospeced_something(something)
+
+
+    @patch.object(Something, 'smeth', autospec=True)
+    @patch.object(Something, 'cmeth', autospec=True)
+    @patch.object(Something, 'meth', autospec=True)
+    def test_patch_autospec_class(self, mock_meth, mock_cmeth, mock_smeth):
+        something = Something()
+        self._check_autospeced_something(something)
+
+
     def test_configure_mock(self):
         mock = Mock(foo='bar')
         self.assertEqual(mock.foo, 'bar')

Misc/NEWS.d/next/Library/2017-11-20-08-06-32.bpo-32092.fjNh4q.rst

@@ -0,0 +1 @@
+mock: Fixes mock.patch self / cls argument consumption when autospec=True.