The other day I spent far too much time trying to figure out how to mock a module-level function that was being used inside of my class's method in Python. My googling didn't lead to obvious answers, so I figured it'd be good to document here for future reference.
Imagine we have some module-level function like the following:
# file: project/some_module/functions.py def fetch_thing(): # query some database return data
And that we use it inside of a class within a different module:
# file: project/other_module/thing.py from some_module.functions import fetch_thing class Thing: def run(self): try: data = fetch_thing() except: self.fail_gracefully()
In this example, I want to test that a failure fetching from the db will fail gracefully, so I need to mock
fetch_thing and have it raise an exception.
I kept trying to mock the function at its module path, like so:
from other_module.thing import Thing thing = Thing() with patch.object('some_module.functions.fetch_thing') as mocked: mocked.side_effect = Exception('mocked error') data = thing.run()
But this isn't right. It turns out that you need to mock/patch the function within the module it's being imported into.
from other_module.thing import Thing thing = Thing() with patch.object('other_module.fetch_thing') as mocked: mocked.side_effect = Exception('mocked error') data = thing.run()
Note the very subtle difference in the string path we are passing to
patch.object. Because we are importing the function into
other_module where our class uses it, that is what we need to mock.