How to patch a constant in python

Question

I have two different modules in my project. One is a config file which contains

LOGGING_ACTIVATED = False

This constant is used in the second module (lets call it main) like the following:

if LOGGING_ACTIVATED:
    amqp_connector = Connector()

In my test class for the main module i would like to patch this constant with the value

True

Unfortunately the following doesn't work

@patch("config.LOGGING_ACTIVATED", True)

nor does this work:

@patch.object("config.LOGGING_ACTIVATED", True)

Does anybody know how to patch a constant from different modules?

Solution 1

If the if LOGGING_ACTIVATED: test happens at the module level, you need to make sure that that module is not yet imported first. Module-level code runs just once (the first time the module is imported anywhere), you cannot test code that won't run again.

If the test is in a function, note that the global name used is LOGGING_ACTIVATED, not config.LOGGING_ACTIVATED. As such you need to patch out main.LOGGING_ACTIVATED here:

@patch("main.LOGGING_ACTIVATED", True)

as that's the actual reference you wanted to replace.

Also see the Where to patch section of the mock documentation.

You should consider refactoring module-level code to something more testable. Although you can force a reload of module code by deleting the module object from the sys.modules mapping, it is plain cleaner to move code you want to be testable into a function.

So if your code now looks something like this:

if LOGGING_ACTIVATED:
    amqp_connector = Connector()

consider using a function instead:

def main():
    global amqp_connector
    if LOGGING_ACTIVATED:
        amqp_connector = Connector()

main()

or produce an object with attributes even.

Solution 2

The problem you are facing is that you are mocking where it is defined, and you should patch where is it used.

Mock an item where it is used, not where it came from.

I leave you some example code, so you can catch the idea.

project1/constants.py

INPUT_DIRECTORY="/input_folder"

project1/module1.py

from project1.constants import INPUT_DIRECTORY
import os

def clean_directories():
    for filename in os.listdir(INPUT_DIRECTORY):
        filepath = os.path.join(directory, filename)
        os.remove(filepath)

project1/tests/test_module1.py

import mock, pytest

def test_clean_directories(tmpdir_factory):
    """Test that folders supposed to be emptied, are effectively emptied"""

    # Mock folder and one file in it
    in_folder = tmpdir_factory.mktemp("in")
    in_file = in_folder.join("name2.json")
    in_file.write("{'asd': 3}")

    # Check there is one file in the folder
    assert len([name for name in os.listdir(in_folder.strpath) if os.path.isfile(os.path.join(path, name))]) == 1

    # As this folder is not a parameter of the function, mock it.
    with mock.patch('project1.module1.INPUT_DIRECTORY', in_folder.strpath):
        clean_directories()

    # Check there is no file in the folder
    assert len([name for name in os.listdir(in_folder.strpath) if os.path.isfile(os.path.join(path, name))]) == 0

So the importan line would be this one:

with mock.patch('project1.module1.INPUT_DIRECTORY', in_folder.strpath):

See, value is mocked where it is used, and not in constants.py (where it is defined)

Solution 3

Found this thread while having a similar issue, what worked for me:

from unittest import mock

@mock.patch('<name_of_module>.<name_of_file>.<CONSTANT_NAME>', <value_to_replace_with>)
class Test_<name_of_test_suit>(unittest.TestCase):

  def test_<name_of_test>(self):
    <test_body>

Keep in mind that you would need and __init__.py to treat directories containing files as packages. https://docs.python.org/3/tutorial/modules.html#:~:text=The%20__init__.py,on%20the%20module%20search%20path.

P.S. Have a look at https://chase-seibert.github.io/blog/2015/06/25/python-mocking-cookbook.html

Comments

[Steve Jessop]

Beat me to it, I was busy trying to figure out whether patch() is capable of patching the __main__ module, just in case that is what was meant by "call it main".

[Martijn Pieters]

@SteveJessop: for the record: yes it is. __main__ is just another module as far as Python is concerned so patch('__main__.somename', somevalue) works.

[d.a.d.a]

thanks for the fast answer. The if statement is indeed on module level. And in my test class I import the module. So there is no chance to rewrite it for single test methods?

[Martijn Pieters]

@d.a.d.a: You can force a reload of the module by deleting it from sys.modules. if 'main' in sys.modules: del sys.modules['main'].

[Martijn Pieters]

@d.a.d.a: however, I'd refactor the module to use a function instead, ran from the top-level with a single call. That way you can test the function instead.

[d.a.d.a]

thanks for your help it got me to the right thought. Hence I just needed the variable initialized within the if statement to be patched I did that in the end. Could have seen that from the beginning

[Dr_Zaszuś]

My god, the remark about "where it is used" has saved me so much time. Thanks!

[Gonzalo]

And that is true for everything you mock @Dr_Zaszuś =) .. when I learned that testing mantra, it was the moment I knew how to test

[Ahmed]

This will return the mock instead.

[Konstantin Grigorov]

It sounds like you are correct, but if I want to test the value of the constant purely, not that much work is needed? I am more interested in how the rest of the code behaves under the condition that the constant is set to something different. Thank you for chipping in :)