How to mock in python and still allow the actual code of mocked function to execute

Question

I have recently started using the mock framework in python. It seems that if I patch a function, the actual code is not called - which means that the database changes etc that this actual function does is not implemented. I have been trying to go around it by calling the function before hand and storing the return value and passing it as arg in patch(), but is there a better way to do it? Ideally, I would want a code that works as a silent observer and i can simply ask it if a certain observed function was called or not, how many times, and with what arguments

My current code

return_val = funct()

# C: Now call me again and assert that these intensive computation functions are not called but taken from cache
with patch('funct', return_value=return_val) as mock_task:

    me_response = self.client.get(me_url, format='json')    #should fetch from cache
    assert not mock_task.called

Answer 1

To mock a method called, you should use the wraps keyword. Consider the following:

class Foo(object):

    def do_thing(self, a):
        print("A: %s" % a)
        self._do_private_thing(a)

    def _do_private_thing(self, a):
        print("PRIVATE STUFF HAPPENING.")
        print("A: %s" % a)

Then In your test you would have something like:

import mock
a = Foo()
with mock.patch.object(a, '_do_private_thing', wraps=a._do_private_thing) as private_mock:
    a.do_thing("lol")
    private_mock.assert_called_with("lol")

Hope this helps.