Now possible to spy methods in class, static and class methods

Also improved docs, made more compliant to reStructuredText expectations.

Author: fogo

README.rst

@@ -79,6 +79,9 @@ Spy
 The spy acts exactly like the original method in all cases, except it allows use of `mock`
 features with it, like retrieving call count.
 
+From version 0.7 onward it also works for class and static methods. Originally it was only safe to
+use with instance methods.
+
 .. code-block:: python
 
     def test_spy(mocker):

pytest_mock.py

@@ -1,5 +1,6 @@
 import sys
 
+import inspect
 import pytest
 
 
@@ -36,23 +37,40 @@ def spy(self, obj, method_name):
         Creates a spy of method. It will run method normally, but it is now possible to use `mock`
         call features with it, like call count.
 
-        :param object obj:
-            An object.
+        :param object obj: An object.
+        :param unicode method_name: A method in object.
+        :rtype: mock.MagicMock
+        :return: Spy object.
+        """
+        method = getattr(obj, method_name)
 
-        :param unicode method_name:
-            A method in object.
+        if not inspect.ismethod(method):  # staticmethod
+            can_autospec = False
+        elif method.__self__ is obj:  # classmethod
+            can_autospec = False
+        else:
+            can_autospec = True
 
-        :return: mock.MagicMock
-            Spy object.
-        """
-        return self.patch.object(obj, method_name, side_effect=getattr(obj, method_name))
+        if can_autospec:
+            kwargs = dict(autospec=True)
+        else:
+            # Can't use autospec because of https://bugs.python.org/issue23078
+            kwargs = dict(
+                new_callable=mock_module.MagicMock,
+                spec=True,
+            )
+
+        def func(*args, **kwargs):
+            return method(*args, **kwargs)
+
+        return self.patch.object(obj, method_name, side_effect=func, **kwargs)
 
     def stub(self):
         """
         Creates a stub method. It accepts any arguments. Ideal to register to callbacks in tests.
 
-        :return: mock.MagicMock
-            Stub object.
+        :rtype: mock.MagicMock
+        :return: Stub object.
         """
         return mock_module.MagicMock(spec=lambda *args, **kwargs: None)
 

test_pytest_mock.py

@@ -1,3 +1,4 @@
+from collections import namedtuple
 import os
 
 import pytest
@@ -138,24 +139,97 @@ def test_mocker_has_mock_class_as_attribute_for_instantiation():
     assert isinstance(mocker.Mock(), mock_module.Mock)
 
 
-def test_mocker_spy(mocker):
+def test_mocker_stub(mocker):
+    def foo(on_something):
+        on_something('foo', 'bar')
+
+    stub = mocker.stub()
+
+    foo(stub)
+    stub.assert_called_once_with('foo', 'bar')
+
+
+def test_mocker_spy(mocker_spy_cases):
+    foo, expect_obj = mocker_spy_cases
+
+    assert foo.bar(arg=10) == 20
+    if expect_obj:
+        foo.bar.assert_called_once_with(foo, arg=10)
+    else:
+        foo.bar.assert_called_once_with(arg=10)
+
+
+def create_instance_method_spy(mocker):
     class Foo(object):
 
         def bar(self, arg):
             return arg * 2
 
     foo = Foo()
-    spy = mocker.spy(foo, 'bar')
+    mocker.spy(foo, 'bar')
+    return foo, False
 
-    assert foo.bar(arg=10) == 20
-    spy.assert_called_once_with(arg=10)
 
+def create_instance_method_by_class_spy(mocker):
+    class Foo(object):
 
-def test_mocker_stub(mocker):
-    def foo(on_something):
-        on_something('foo', 'bar')
+        def bar(self, arg):
+            return arg * 2
 
-    stub = mocker.stub()
+    mocker.spy(Foo, 'bar')
+    return Foo(), True
 
-    foo(stub)
-    stub.assert_called_once_with('foo', 'bar')
+
+def create_class_method_spy(mocker):
+    class Foo(object):
+
+        @classmethod
+        def bar(cls, arg):
+            return arg * 2
+
+    mocker.spy(Foo, 'bar')
+    return Foo, False
+
+
+def create_class_method_with_metaclass_spy(mocker):
+    class MetaFoo(type): pass
+
+    class Foo(object):
+
+        __metaclass__ = MetaFoo
+
+        @classmethod
+        def bar(cls, arg):
+            return arg * 2
+
+    mocker.spy(Foo, 'bar')
+    return Foo, False
+
+
+def create_static_method_spy(mocker):
+    class Foo(object):
+
+        @staticmethod
+        def bar(arg):
+            return arg * 2
+
+    mocker.spy(Foo, 'bar')
+    return Foo, False
+
+
+mock_spy_case = namedtuple('mock_spy_case', ['do', 'name'])
+
+@pytest.fixture(
+    params=[
+        mock_spy_case(do=create_instance_method_spy, name='instance_method'),
+        mock_spy_case(do=create_instance_method_by_class_spy, name='instance_method_by_class'),
+        mock_spy_case(do=create_class_method_spy, name='classmethod'),
+        mock_spy_case(do=create_class_method_with_metaclass_spy, name='classmethod_with_metaclass'),
+        mock_spy_case(do=create_static_method_spy, name='staticmethod'),
+    ],
+    ids=lambda i: i.name,
+)
+def mocker_spy_cases(mocker, request):
+    case = request.param
+
+    return case.do(mocker)