MonkeyPatch staticmethod

In Python setattr(Class, name, func) automatically converts a function
into an instancemethod. To keep type(Class.func) as function,
staticmethod(func) must be applied explicitly.

This was previously fixed for Python 2 when cleaning up the patched
function but Python 3 needs the same handling.

When patching a function it was being converted to an instancemethod for
both Python 2 and 3 and this has now been fixed. This is a breaking
change as it was previously acceptable to patch a staticmethod with an
instancemethod.

The test for this case was updated to correctly check both cases. The
patched function is called as both Class.function() and
Class().function(), and then called again after the cleanup has occurred
resetting the function to its original state.  The Class().function()
check is important because the method does not become bound until the
class it is defined on is instantiated.

Sem-Ver: api-break

fixtures/_fixtures/monkeypatch.py

@@ -23,6 +23,23 @@
 from fixtures import Fixture
 
 
+def _setattr(obj, name, value):
+    """Handle some corner cases when calling setattr.
+
+    setattr transforms a function into instancemethod, so where appropriate
+    value needs to be wrapped with staticmethod().
+    """
+    if sys.version_info[0] == 2:
+        class_types = (type, types.ClassType)
+    else:
+        # All classes are <class 'type'> in Python 3
+        class_types = type
+    if (isinstance(obj, class_types) and
+            isinstance(value, types.FunctionType)):
+        value = staticmethod(value)
+    setattr(obj, name, value)
+
+
 class MonkeyPatch(Fixture):
     """Replace or delete an attribute."""
 
@@ -60,16 +77,11 @@ def _setUp(self):
             if old_value is not sentinel:
                 delattr(current, attribute)
         else:
-            setattr(current, attribute, self.new_value)
+            _setattr(current, attribute, self.new_value)
         if old_value is sentinel:
             self.addCleanup(self._safe_delete, current, attribute)
         else:
-            # Python 2's setattr transforms function into instancemethod
-            if (sys.version_info[0] == 2 and
-                isinstance(current, (type, types.ClassType)) and
-                isinstance(old_value, types.FunctionType)):
-                    old_value = staticmethod(old_value)
-            self.addCleanup(setattr, current, attribute, old_value)
+            self.addCleanup(_setattr, current, attribute, old_value)
 
     def _safe_delete(self, obj, attribute):
         """Delete obj.attribute handling the case where its missing."""

fixtures/tests/_fixtures/test_monkeypatch.py

@@ -78,6 +78,8 @@ def test_patch_staticmethod(self):
             'fixtures.tests._fixtures.test_monkeypatch.C.foo',
             bar)
         with fixture:
-            pass
+            C.foo()
+            C().foo()
         self.assertEqual(oldfoo, C.foo)
+        self.assertEqual(oldfoo, C().foo)