Feature: Fake Callables

testdoubles/__init__.py

@@ -109,3 +109,7 @@ def default_implementation(*args, **kwargs):
     obj = type(obj.__name__, obj.__bases__, attrs)
 
     return substitute(obj, qualified_name, spec)
+
+from testdoubles import utils
+
+__all__ = ('fake', 'utils')

testdoubles/fakes/callables.py

@@ -2,9 +2,55 @@
 # -*- coding: utf-8 -*-
 import inspect
 import sys
+from testdoubles.utils import are_argspecs_identical
 
 python3 = sys.version_info[0] == 3
 
+
+class CallableInternalAttributesBaseMixin(object):
+    @property
+    def __name__(self):
+        if not self.is_instance_method and not inspect.isfunction(self.live):
+            return self.live.__class__.__name__
+
+        return self.live.__name__
+
+    @property
+    def __self__(self):
+        try:
+            return self.live.__self__
+        except AttributeError:
+            raise AttributeError("'function' object has no attribute '__self__'")
+
+    @property
+    def __func__(self):
+        if not self.is_instance_method:
+            raise AttributeError("'function' object has no attribute '__func__'")
+
+        if self.is_unbound_instance_method:
+            return None
+
+        return self.fake.__func__
+
+    @property
+    def __code__(self):
+        return self.fake.__code__
+
+    @property
+    def __defaults__(self):
+        return self.fake.__defaults__
+
+    @property
+    def __globals__(self):
+        return self.fake.__globals__
+
+    def __getattribute__(self, item):
+        if item == '__doc__':
+            return self.live.__doc__
+
+        return super(CallableInternalAttributesBaseMixin, self).__getattribute__(item)
+
+
 if python3:
     class CallableIntrospectionMixin(object):
         @property
@@ -14,10 +60,15 @@ def is_unbound_instance_method(self):
                 return args[0] == 'self' and not inspect.ismethod(self.live)
             except IndexError:
                 return False
+            except TypeError:
+                return False
 
         @property
         def is_instance_method(self):
             return inspect.ismethod(self.live) or self.is_unbound_instance_method
+
+    class CallableInternalAttributesMixin(CallableInternalAttributesBaseMixin):
+        pass
 else:
     class CallableIntrospectionMixin(object):
         @property
@@ -28,8 +79,38 @@ def is_unbound_instance_method(self):
         def is_instance_method(self):
             return inspect.ismethod(self.live) or self.is_unbound_instance_method
 
-class FakeCallable(CallableIntrospectionMixin):
-    def __init__(self, live):
+    class CallableInternalAttributesMixin(CallableInternalAttributesBaseMixin):
+        @property
+        def im_self(self):
+            return self.__self__
+
+        @property
+        def im_class(self):
+            return self.__self__.__class__
+
+        @property
+        def func_code(self):
+            return self.__code__
+
+        @property
+        def func_doc(self):
+            return self.__doc__
+
+        @property
+        def func_name(self):
+            return self.live.__name__
+
+        @property
+        def func_defaults(self):
+            return self.__defaults__
+
+        @property
+        def func_globals(self):
+            return self.__globals__
+
+
+class FakeCallable(CallableIntrospectionMixin, CallableInternalAttributesMixin):
+    def __init__(self, live, inspect_args=False):
         if not callable(live):
             try:
                 raise TypeError('%s is not callable.' % live.__name__)
@@ -38,6 +119,15 @@ def __init__(self, live):
 
         self._live = live
 
+        if inspect_args:
+            if inspect.isbuiltin(self.live):
+                raise ValueError('Cannot inspect arguments of a builtin live object.')
+
+            if not are_argspecs_identical(self.live, self.fake):
+                raise ValueError("The provided live object's arguments %s does not match %s" % (
+                    inspect.getargspec(self.live), inspect.getargspec(self.fake)))
+
+
     @property
     def live(self):
         return self._live

testdoubles/utils.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import inspect
+
+
+def get_keyword_arguments(argspec):
+    return argspec.args[-len(argspec.defaults):] if argspec.defaults else []
+
+
+def are_arguments_identical(argspec1, argspec2):
+    kwargs1 = get_keyword_arguments(argspec1)
+    kwargs2 = get_keyword_arguments(argspec2)
+
+    arguments1 = set(argspec1.args) - set(kwargs1)
+    arguments2 = set(argspec2.args) - set(kwargs2)
+
+    if len(arguments1) == len(arguments2) and not (argspec1.varargs or argspec2.varargs):
+        return True
+    elif any(_ for _ in arguments1) and argspec2.varargs or any(_ for _ in arguments2) and argspec1.varargs:
+        return True
+
+    return False
+
+
+def are_keyword_arguments_identical(argspec1, argspec2):
+    kwargs1 = get_keyword_arguments(argspec1)
+    kwargs2 = get_keyword_arguments(argspec2)
+
+    if kwargs1 == kwargs2 and not (argspec1.keywords or argspec2.keywords):
+        return True
+    if any(_ for _ in kwargs1) and argspec2.keywords or any(_ for _ in kwargs2) and argspec1.keywords:
+        return True
+
+    return False
+
+
+def are_argspecs_identical(callable1, callable2):
+    argspec1 = inspect.getargspec(callable1)
+    argspec2 = inspect.getargspec(callable2)
+
+    if argspec1 == argspec2:
+        return True
+    else:
+        return are_arguments_identical(argspec1, argspec2) and are_keyword_arguments_identical(argspec1, argspec2)
+
+__all__ = ('are_argspecs_identical', )

tests/common/compat.py

@@ -1,13 +1,19 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
+import six
+import sys
+
 try:
     from unittest import mock
 except ImportError:
     import mock
 
-try:
-    import unittest
-except ImportError:
-    import unittest2 as unittest
+if not six.PY3 and sys.version_info[1] == 6:
+        import unittest2 as unittest
+else:
+    try:
+        import unittest
+    except ImportError:
+        import unittest2 as unittest
 
-__all__ = ['mock']
+__all__ = ['mock', 'unittest']