Norman Robins wrote:
I'm somewhat new to mocking for unit tests.
I have some code like this:
In foo/bar/baz.py I have 2 function I want to mock, one calls the other"
def function1_to_mock():
.
.
.
def function2_to_mock():
function1_to_mock()
In foo/bar/main.py I import 1 of these and call it"
from .baz import function2_to_mock
def some_function():
function1_to_mock()
I'm assuming this is supposed to be calling `function2_to_mock`?
(Otherwise the import should be for `function1_to_mock`, but then the
fact `function2_to_mock` also calls `function1_to_mock` would be irrelevant)
.
.
.
I want to mock both function1_to_mock and function2_to_mock
In my test I do this:
def function1_to_mock(kid):
return MOCKED_VALUE
@pytest.fixture(autouse=True)
def mock_dependencies():
with patch(foo.bar.baz.function1_to_mock') as mock_function1_to_mock, \
patch('foo.bar.main.function2_to_mock') as mock_function2_to_mock:
mock_function2_to_mock.return_value = {
'this': 'that
}
yield mock_function1_to_mock, mock_function2_to_mock
def test_main(mock_dependencies):
some_function()
When some_function is called the real function1_to_mock is called instead
of my mock.
Can someone please let me know how to properly mock these 2 functions.
Thanks!
In `foo/bar/main.py`, the line:
```
from .baz import function2_to_mock
```
creates a reference named `function2_to_mock` in `main.py` referring to
the method in `foo/bar/baz.py`.
When you patch `foo.bar.baz.function2_to_mock`, you're patching the
reference in `foo.bar.baz`, but the reference in `foo.bar.main` still
refers to the original function object.
There are at least a couple of ways around this. The way I prefer is to
change `main.py` to import the `baz` module rather than just the function:
```
> from . import baz
>
> def some_function():
> baz.function2_to_mock()
```
Here, `main.py` has a reference to the `baz` module rather than the
individual function object. It looks up `function2_to_mock` in `baz`
just before calling it so, when the `baz` module is patched so that
`baz.function2_to_mock` refers to a mock, the call in main.py` gets the
mock and calls that rather than the original function.
There no memory saving by importing just the functions you need from
`baz` - the whole module is still loaded on import and remains in
memory, it's just that `main` only gets a reference to the one function.
The effect is similar to doing something like:
```
from . import baz
function2_to_mock = baz.function2_to_mock
del baz
```
...including the fact that, after the import, the reference to
`function2_to_mock` in `main` is just a copy of the reference in `baz`,
hence not getting updated by the patch.
The other way around it is to patch `main.function2_to_mock` instead of
patching `foo.bar.baz.function2_to_mock`.
See also the documentation under "where to patch" at
<https://docs.python.org/3/library/unittest.mock.html#where-to-patch>.
Note that, since you're patching `function2_to_mock`, you don't
necessarily need to patch `function1_to_mock` as well. The mock of
`function2_to_mock` won't call `function1_to_mock` (or its mock)
regardless of whether `function1_to_mock` has been patched, unless you
set the mock of `function2_to_mock` to do so. You don't necessarily
need to patch `function1_to_mock`, unless of course there are other
calls to it that you need to mock.
--
Mark.
--
https://mail.python.org/mailman/listinfo/python-list
