How can I inject an object into another namespace in python?

Question

I'm writing some unittests for code written by someone else here at the office. Python is not my strongest language. While I've been successful with basic unit tests, mocking in python is throwing me for a loop.

What I need to do is override a call to ConfigObj and inject my own mock config/fixture into any ConfigObj call.

settings.py

from configobj import ConfigObj
config = ConfigObj('/etc/myapp/config')

utils.py

from settings import config
"""lots of stuff methods using various config values."""

What I would like to do is, in my unittests for utils.py, inject myself either for ANY call to ConfigObj or settings.py itself.

Many of the mocking libraries expect me to Mock my own classes but in the case of this app, it doesn't have any explicit classes.

Can it be done or are the python namespace restrictions too strict that I can't intervene in what a module that I'm importing imports itself?

Side note: running 2.7 so I can't do any of the tricks I've read about from 2.5.

Answer 1

Couldn't you just overwrite the original function with another one?

There are no constants in Python, you can change everything, you could even do True = False.

Answer 2

If the tests are in a separate file from from settings.py and utils.py you can create a file mock.py

import configobj

class MockConfigObj(object):
     #mock whatever you wan

configobj.ConfigObj = MockConfigObj

and then import mock before importing (from) any module that itself imports settings. This will ensure that settings.config is created with MockConfigObj. If you want a uniform global mocking, import it before any file that imports configobj.

This works because python will store configobj in sys.modules and check that before actually reading from a file on subsequent imports. in mock.py, the identifier ConfigObj is just a reference to the entry in sys.modules so that any changes that you make will be globally visible.

This strikes me as a little hacky though but it's the best that I can think of.

Answer 3

Python namespaces are not strict at all within the same scope. Just override the variable name containing your object (or the class itself and provided it) within the same scope you'd be expecting the original and that is good enough.

Now, whether or not what you're replacing it with behaves the same is up to you...

Answer 4

I faced a similar situation before. Here is how I would go about addressing your problem.

Consider a test case for a function from utils.py.

import utils, unittest

class FooFunctionTests(unittest.TestCase):
    def setUp(self):
        utils._old_config = utils.config
        utils.config = MockClass()

    def tearDown(self):
        utils.config = utils._old_config
        del utils._old_config

    def test_foo_function_returns_correct_value(self):        
        self.assertEqual("success!", utils.foo())