new_callable arg to unittest.mock.patch seems not to support partial

[filip-komarzyniec]

Bug report

Bug description:

As in the title. The following code seems to disregard the partial and proceed to call the wrapped function right away (instead of calling the wrapping partial object).

from functools import partial
from unittest.mock import patch

def wrapped():
  """an exemplary response from `some.directory.module.my_function` function"""
    return [
        {
            "some_key": "some_value",
        }]

def test_some_func():
    with patch(
        "some.directory.module.my_function", new_callable=partial(wrapped)
    ):

    # calls `my_function` internally
    some.directory.module.another_function()

Running the above will produce: TypeError: 'list' object is not callable.
Acc. to the docs an object passed as new_callable argument should be called by patch to create a new dummy object replacing the target (some.directory.module.my_function). However it seems that instead of partial being called and returning a wrapped function, a wrapped function itself is called returning the list.

CPython versions tested on:

3.11

Operating systems tested on:

macOS

[terryjreedy]

The code posted has 2 SyntaxErrors. 1. wrapped docstring indented 2 spaces and return 4. 2. with body beginning with some is not indented relative to with. Running the file as is with 2 valid func defs produces no error. Something is missing. You did not post the traceback. Even if you did, 3.11 only gets security fixes; we need correct complete code to test on current python.

[filip-komarzyniec]

Right -- my buggy example was meant to be as short and brief as possible, only giving an idea of what the problem is about. The indentation errors were my mistake, though. (I typed everything directly on GitHub).

The example was never meant to be run directly as is. Obviously, the whole thing requires proper setup (probably different based on the testing framework of choice). So let me give you a, minimalistic once again, but reproducible example.

The directory structure is as follows:

📦gh_137145
 ┣ 📂src
 ┃ ┣ 📜__init__.py
 ┃ ┗ 📜my_module.py
 ┗ 📂tests
 ┃ ┗ 📜test_my_module.py

src/my_module.py content

def my_function() -> list[dict[str, str]]:
    # some really costly calls to external resources
    response = {"some_key": "some response from external resources"}
    return [response]


def another_function() -> str:
    # some logic
    response = my_function()

    modified_response = response[0]["some_key"].upper()

    # some more advanced logic
    return modified_response

tests/test_my_module.py content

from functools import partial
from unittest.mock import patch

from src.my_module import another_function


def wrapped():
    """
    An exemplary response from `src.my_module.my_function` function.
    """

    return [
        {
            "some_key": "some mocked ideal value from external resources",
        }
    ]


def test_some_func():
    with patch("src.my_module.my_function", new_callable=partial(wrapped)):
        # calls `my_function` internally
        another_function()

Test run using the following pytest command: pytest --capture=no --tb=long . give the below failure.

test run results (traceback)

============================================================ test session starts =============================================================
platform darwin -- Python 3.11.12, pytest-8.4.1, pluggy-1.6.0
rootdir: /Users/filip.komarzyniec/gh_137145
plugins: anyio-4.9.0, cov-6.2.1, mock-3.14.1, langsmith-0.4.8
collected 1 item                                                                                                                             

tests/test_my_module.py F

================================================================== FAILURES ==================================================================
_______________________________________________________________ test_some_func _______________________________________________________________

    def test_some_func():
        with patch("src.my_module.my_function", new_callable=partial(wrapped)):
            # calls `my_function` internally
>           another_function()

tests/test_my_module.py:22: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

    def another_function() -> str:
        # some logic
>       response = my_function()
                   ^^^^^^^^^^^^^
E       TypeError: 'list' object is not callable

src/my_module.py:9: TypeError
========================================================== short test summary info ===========================================================
FAILED tests/test_my_module.py::test_some_func - TypeError: 'list' object is not callable
============================================================= 1 failed in 0.04s ==============================================================

[infohash]

This is how it is supposed to work. new_callable is meant to be used when the patched value for the test can only be generated dynamically at runtime. Something which can't be known at definition time. E.g. Retrieving the test value from the database when the test will run. When you provide a callable to new_callable, mock.patch calls the callable to obtain the value and patch the function with that value.

If you want partial(wrapped)) to substitute another_function, just use new.

with patch("src.my_module.my_function", new=partial(wrapped)):
    # calls `my_function` internally
    another_function()

Both new and new_callable substitute the target object. The only difference is, new_callable substitutes the target after retrieving the value to substitute with from the callable.