title: How to mock bound method for introspection
body: <p>I would like to test the following code</p>
  
  <pre><code>import weakref
  
  class WeakBoundMethod:
      """
      Wrapper around a method bound to a class instance. As opposed to bare
      bound methods, it holds only a weak reference to the `self` object,
      allowing it to be deleted.
  
      This can be useful when implementing certain kinds of systems that
      manage callback functions, such as an event manager.
  
      """
      def __init__(self, meth):
          """
          Initializes the class instance. It should be ensured that methods
          passed through the `meth` parameter are always bound methods. Static
          methods and free functions will produce an `AssertionError`.
  
          """
          assert (hasattr(meth, '__func__') and hasattr(meth, '__self__')),\
                 'Object is not a bound method.'
  
          self._self = weakref.ref(meth.__self__)
          self._func = meth.__func__
  
      def __call__(self, *args, **kw):
          """
          Calls the bound method and returns whatever object the method returns.
          Any arguments passed to this will also be forwarded to the method.
  
          In case an exception is raised by the bound method, it will be
          caught and thrown again to the caller of this `WeakBoundMethod` object.
  
          Calling this on objects that have been collected will result in
          an `AssertionError` being raised.
  
          """        
          assert self.alive(), 'Bound method called on deleted object.'
  
          try:
              return self._func(self._self(), *args, **kw)
          except Exception as e:
              raise e
  
      def alive(self):
          """
          Checks whether the `self` object the method is bound to has
          been collected.
  
          """
          return self._self() is not None
  </code></pre>
  
  <p>I thought about using mock from the standard library to check if the __call__ method calls the required arguments. The problem I face is that if I create a Mock object for a bound method, it does not have a __self__ or __func__ attribute. So I tried the following code:</p>
  
  <pre><code>class TestWeakBoundMEthod(unittest.TestCase):
      def setUp(self):
          self.bm = Mock(name='bound method')
          self.bm.__self__ = Mock(name='self')
          self.bm.__func__ = Mock(name='func')
  
      def test_call(self):
          wbm = events.WeakBoundMethod(self.bm)
          wbm()
          self.bm.__func__.assert_called_with(self.bm.__self__)
          wbm(1, 2, 3)
          self.bm.__func__.assert_called_with(self.bm.__self__, 1, 2, 3)
  </code></pre>
  
  <p>It works, but I feel like I'm not testing properly. I'm using too much knowledge on how the class WeakBoundMethod is working, instead of testing the actual result.</p>
  
  <p>Is there a better way to mock a bound method? Should I make a Dummy class with a dummy method instead?</p>