Python: patching function defined in same module of tested function

Question

I have been working with Python's unittest.mock library quite a bit, but right now I'm struggling with a use case that may not be approached correctly.

Consider a file mymodule/code.py containing the following snippet:

def sum():
  pass

def mul():
  pass

def div():
  pass

def get_functions():
  return [sum, mul, div]

def foo():
  functions = get_functions()
  for func in functions:
    func()

I want to test the foo function, patching the sum function, and leaving mul and div as they are. This is what I tried initially:

class TestFoo(unittest.TestCase):
  @mock.patch('mymodule.code.foo.sum')
  def test_foo(foo_sum_mock):
    foo()
    foo_sum_mock.assert_called_once()

However, the patching approach illustrated above does not work. I believe that the sum function is patched correctly when loading mymodule.code.py, but redefined due to the def sum() block.

By reading the official documentation, I also tried to use the start and stop functions of the unittest.mock library as follows:

def test_foo():
  patcher = mock.patch('module.code.sum')
  mocked_sum_fun = patcher.start()

  foo()

  mocked_sum_fun.assert_called_once()
  mock_sum_fun.stop()

This approach also did not work. I was hoping it would avoid the sum function override after the modules/code.py file gets loaded.

Is it possible to patch a local function such as sum? Or is moving the sum function to another file the only option for patching?

Many thanks in advance!

Did you ever figure this out? I'm having the same issue.

amnesia
– amnesia

2021-07-17 00:36:06 +00:00
Commented Jul 17, 2021 at 0:36 — amnesia
– amnesia, Commented Jul 17, 2021 at 0:36

Mauro Baraldi · Accepted Answer · 2021-07-02 17:27:54Z

6

You can mock a function of same module using mock.patch and refering this module as __main__

code.py

from unittest.mock import patch

def sum():
    print("called method sum")
    pass

def call_sum():
    sum()

def return_mock():
    print("I'm a mocked method")
    return True

with patch('__main__.sum', return_value=return_mock()) as mock_test:
    call_sum()
    mock_test.assert_called_once() # assure that mocked method was called, not original.

You could also use the path of lib (my_project.code.sum) instead of __main__.sum.

edited Jul 2, 2021 at 17:27

answered Jul 15, 2020 at 19:22

Mauro Baraldi

6,6042 gold badges35 silver badges48 bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

Velkan Over a year ago

Getting ModuleNotFoundError, '__main__' is not a package.

Mauro Baraldi Over a year ago

@Velkan check here the code running

Mauro Baraldi Over a year ago

@Velkan in this example, all the code is in just one file.

Velkan Over a year ago

It depends heavily on how it's called. I've found somewhere that the reliable way is to use something like __name__ + '.sum'.

LoneCodeRanger Over a year ago

@Velkan You are right and the answer is misleading, you might want to edit it.

Javon · Accepted Answer · 2019-01-07 23:04:04Z

Generally speaking, you'd want to separate your test code from your production code:

code.py

def sum():
    pass

def mul():
    pass

def div():
    pass

def get_functions():
    return [sum, mul, div]

def foo():
    functions = get_functions()
    for func in functions:
        func()

code_test.py

import unittest
import mock_test as mock
import code

class TestFoo(unittest.TestCase):
    @mock.patch('code.sum')
    def test_foo(self, sum_mock):
        def new_sum_mock(*args, **kwargs):
            # mock code here
            pass
        sum_mock.side_effect = new_sum_mock
        code.foo()
        sum_mock.assert_called_once()

But yes, you could place it all into one file:

code_test.py:

import unittest
import mock_test as mock
import code

def sum():
    pass


def mul():
    pass


def div():
    pass


def get_functions():
    return [sum, mul, div]


def foo():
    functions = get_functions()
    for func in functions:
        func()


class TestFoo(unittest.TestCase):

    @mock.patch('code_test.sum')
    def test_foo(self, sum_mock):
        def new_sum_mock(*args, **kwargs):
            # mock code here
            pass

        sum_mock.side_effect = new_sum_mock
        code.foo()
        sum_mock.assert_called_once()

Collectives™ on Stack Overflow

Python: patching function defined in same module of tested function

2 Answers 2

5 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

5 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related