python - 模拟一个类方法并将 self 参数传递给 Mock 的副作用

Question

我正在尝试在单元测试中修补现有类中的单个方法。要修补的类是：

class Example:
    def __init__(self: "Example", id: int) -> None:
        self.id : int = id
        self._loaded : bool = False
        self._data : typing.Union[str,None] = None

    def data(self: "Example") -> str:
        if not self._loaded:
            self.load()
        return self._data

    def load(self: "Example") -> None:
        self._loaded = True
        # some expensive computations
        self._data = f"real_data{self.id}"

因此，不是调用self.load()a而是unittest.mock.Mock使用mocked_load函数（如下）作为副作用调用：

def mocked_load(self: "Example") -> None:
    # mock the side effects of load without the expensive computation.
    self._loaded = True
    self._data = f"test_data{self.id}"

第一次尝试是：

@unittest.mock.patch.object(Example, "load", new = mocked_load)
def test_data__patch_new(
    self: "TestExample",
) -> None:
    example1 = Example(id=1)
    example2 = Example(id=2)

    data1_1 = example1.data()
    self.assertEqual(data1_1, "test_data1")

    data2_1 = example2.data()
    self.assertEqual(data2_1, "test_data2")

    data1_2 = example1.data()
    self.assertEqual(data1_2, "test_data1")

    data2_2 = example2.data()
    self.assertEqual(data2_2, "test_data2")

这可行，但只是用Example.load函数替换函数，mocked_load而不是将其包装在Mock; 所以，虽然它确实通过了，但你不能扩展测试来断言修补Example.load方法被调用了多少次。这不是我正在寻找的解决方案。

第二次尝试是：

@unittest.mock.patch.object(Example, "load")
def test_data__patch_side_effect(
    self: "TestExample",
    patched_load: unittest.mock.Mock
) -> None:
    patched_load.side_effect = mocked_load

    example1 = Example(id=1)
    example2 = Example(id=2)

    self.assertEqual(patched_load.call_count, 0)

    data1_1 = example1.data()
    self.assertEqual(data1_1, "test_data1")
    self.assertEqual(patched_load.call_count, 1)

    data2_1 = example2.data()
    self.assertEqual(data2_1, "test_data2")
    self.assertEqual(patched_load.call_count, 2)

    data1_2 = example1.data()
    self.assertEqual(data1_2, "test_data1")
    self.assertEqual(patched_load.call_count, 2)

    data2_2 = example2.data()
    self.assertEqual(data2_2, "test_data2")
    self.assertEqual(patched_load.call_count, 2)

这失败了，但有以下例外：

Traceback (most recent call last):
  File "/usr/lib/python3.8/unittest/mock.py", line 1325, in patched
    return func(*newargs, **newkeywargs)
  File "my_file.py", line 65, in test_data__patch_side_effect
    data1_1 = example1.data()
  File "my_file.py", line 13, in data
    self.load()
  File "/usr/lib/python3.8/unittest/mock.py", line 1081, in __call__
    return self._mock_call(*args, **kwargs)
  File "/usr/lib/python3.8/unittest/mock.py", line 1085, in _mock_call
    return self._execute_mock_call(*args, **kwargs)
  File "/usr/lib/python3.8/unittest/mock.py", line 1146, in _execute_mock_call
    result = effect(*args, **kwargs)
TypeError: mocked_load() missing 1 required positional argument: 'self'

最后的尝试是：

@unittest.mock.patch.object(Example, "load")
def test_data__patch_multiple_side_effect(
    self: "TestExample",
    patched_load: unittest.mock.Mock
) -> None:
    example1 = Example(id=1)
    example2 = Example(id=2)

    side_effect1 = lambda: mocked_load( example1 )
    side_effect2 = lambda: mocked_load( example2 )

    patched_load.side_effect = side_effect1

    self.assertEqual(patched_load.call_count, 0)

    data1_1 = example1.data()
    self.assertEqual(data1_1, "test_data1")
    self.assertEqual(patched_load.call_count, 1)

    patched_load.side_effect = side_effect2

    data2_1 = example2.data()
    self.assertEqual(data2_1, "test_data2")
    self.assertEqual(patched_load.call_count, 2)

    patched_load.side_effect = side_effect1

    data1_2 = example1.data()
    self.assertEqual(data1_2, "test_data1")
    self.assertEqual(patched_load.call_count, 2)

    patched_load.side_effect = side_effect2

    data2_2 = example2.data()
    self.assertEqual(data2_2, "test_data2")
    self.assertEqual(patched_load.call_count, 2)

这“有效”但它非常脆弱，因为self参数被硬编码到函数中，并且需要交换lambda模拟以匹配每个调用。side_effect

完整的最小代表性示例是：

import typing
import unittest
import unittest.mock

class Example:
    def __init__(self: "Example", id: int) -> None:
        self.id : int = id
        self._loaded : bool = False
        self._data : typing.Union[str,None] = None

    def data(self: "Example") -> str:
        if not self._loaded:
            self.load()
        return self._data

    def load(self: "Example") -> None:
        self._loaded = True
        # some expensive computations
        self._data = f"real_data{self.id}"

def mocked_load(self: "Example") -> None:
    # mock the side effects of load without the expensive computation.
    self._loaded = True
    self._data = f"test_data{self.id}"

class TestExample( unittest.TestCase ):
    @unittest.mock.patch.object(Example, "load", new = mocked_load)
    def test_data__patch_new(
        self: "TestExample",
    ) -> None:
        # This works but just replaces the Example.load function with another
        # rather than wrapping it in a Mock; so you cannot assert how many
        # times the patched method was called.

        example1 = Example(id=1)
        example2 = Example(id=2)

        data1_1 = example1.data()
        self.assertEqual(data1_1, "test_data1")

        data2_1 = example2.data()
        self.assertEqual(data2_1, "test_data2")

        data1_2 = example1.data()
        self.assertEqual(data1_2, "test_data1")

        data2_2 = example2.data()
        self.assertEqual(data2_2, "test_data2")

    @unittest.mock.patch.object(Example, "load")
    def test_data__patch_side_effect(
        self: "TestExample",
        patched_load: unittest.mock.Mock
    ) -> None:
        # This fails as the self argument is not passed to the side_effect
        # function.

        patched_load.side_effect = mocked_load

        example1 = Example(id=1)
        example2 = Example(id=2)

        self.assertEqual(patched_load.call_count, 0)

        data1_1 = example1.data()
        self.assertEqual(data1_1, "test_data1")
        self.assertEqual(patched_load.call_count, 1)

        data2_1 = example2.data()
        self.assertEqual(data2_1, "test_data2")
        self.assertEqual(patched_load.call_count, 2)

        data1_2 = example1.data()
        self.assertEqual(data1_2, "test_data1")
        self.assertEqual(patched_load.call_count, 2)

        data2_2 = example2.data()
        self.assertEqual(data2_2, "test_data2")
        self.assertEqual(patched_load.call_count, 2)

    @unittest.mock.patch.object(Example, "load")
    def test_data__patch_multiple_side_effect(
        self: "TestExample",
        patched_load: unittest.mock.Mock
    ) -> None:
        # This passes but feels (very) wrong as you have to have change the
        # side_effect each time you call the function and relies on hardcoding
        # the class instances being passed as "self".

        example1 = Example(id=1)
        example2 = Example(id=2)

        side_effect1 = lambda: mocked_load( example1 )
        side_effect2 = lambda: mocked_load( example2 )

        patched_load.side_effect = side_effect1

        self.assertEqual(patched_load.call_count, 0)

        data1_1 = example1.data()
        self.assertEqual(data1_1, "test_data1")
        self.assertEqual(patched_load.call_count, 1)

        patched_load.side_effect = side_effect2

        data2_1 = example2.data()
        self.assertEqual(data2_1, "test_data2")
        self.assertEqual(patched_load.call_count, 2)

        patched_load.side_effect = side_effect1

        data1_2 = example1.data()
        self.assertEqual(data1_2, "test_data1")
        self.assertEqual(patched_load.call_count, 2)

        patched_load.side_effect = side_effect2

        data2_2 = example2.data()
        self.assertEqual(data2_2, "test_data2")
        self.assertEqual(patched_load.call_count, 2)


if __name__ == '__main__':
    unittest.main()

如何“修复”我的第二次尝试（或提供替代方法）Example.load用 a 修补函数，Mock以便side_effect可以调用对 有副作用的函数self？

标签： pythonpython-unittestpython-unittest.mock

Answer 1

直接从这个问题tbh：使用 autospec=True 模拟我在 python3 上工作时：

# test.py
import unittest
from unittest.mock import patch


class TestStringMethods(unittest.TestCase):
    @patch.object(Example, "load", autospec=True)
    def test_data__patch_side_effect(
        self: "TestExample",
        patched_load: unittest.mock.Mock
    ) -> None:
        patched_load.side_effect = mocked_load

        example1 = Example(id=1)
        example2 = Example(id=2)

        self.assertEqual(patched_load.call_count, 0)

        data1_1 = example1.data()
        self.assertEqual(data1_1, "test_data1")
        self.assertEqual(patched_load.call_count, 1)

        data2_1 = example2.data()
        self.assertEqual(data2_1, "test_data2")
        self.assertEqual(patched_load.call_count, 2)

        data1_2 = example1.data()
        self.assertEqual(data1_2, "test_data1")
        self.assertEqual(patched_load.call_count, 2)

        data2_2 = example2.data()
        self.assertEqual(data2_2, "test_data2")
        self.assertEqual(patched_load.call_count, 2)

输出：

$ python3 -m unittest test
.
----------------------------------------------------------------------
Ran 1 test in 0.001s

OK

从文档：

更强大的规范形式是 autospec。如果您设置 autospec=True ，则将使用被替换对象的规范创建模拟。

基于那里的同一段落，您可以使用对象来定义您想要的规范（作为替代方案）。以下内容也对我有用：

@patch.object(Example, "load", autospec=Example.load)