Python Mock.Patch 在多个地方使用的函数

Question

这有效:

我得到了我的程序:

# module/core_functions.py

def new_input(question):
    print(question)
    value = input(">").strip()
    return value


def main_function():
    #do things
    new_input("question1")
    #do other things
    new_input("question2")
    ...

我写了一个单元测试:

import unittest
from unittest.mock import patch, Mock
from module.core_functions import main_function

class MytestClass(unittest.TestCase):

    @patch('module.core_functions.new_input')
    def test_multiple_answer(self, mock_input):
        mock_input.return_value = Mock()
        mock_input.side_effect = ['Answer1', 'Answer2']
        result = main_function()
        self.assertIn('ExpectedResult', result)

这工作得很好(我使用nose2来运行我的所有测试)。

现在这不起作用:

随着我的代码变得越来越大，我想让其他人参与我的项目，并且我需要模块化我的功能以使修改更容易和更干净。

因此，我将 new_input 函数放入新文件 module/io.py 中，并获得了一个新的子函数:

# module/subfunctions.py
from module.io import new_input

def subfunction():
    # do things
    new_input("question")
    # do things
    return things

我的核心程序演变为:

# module/core_functions.py
from module.io import new_input
from module.subfunctions import subfunction

def main_function():
    #do things
    new_input("question1")
    #do other things
    subfuntion()
    ...

所以问题是要模拟的函数位于多个地方:在主函数和一些子函数中。我找不到一种方法让我的单元测试工作(我无法预测主函数或一个子函数是否需要 AnswerX)。

您知道如何修复我的测试以使其正常工作吗？谢谢(我希望我已经说得相当清楚了)。

编辑:

我尝试过类似的方法:

@patch('module.core_functions.new_input')
@patch('module.subfunctions.new_input')
def test_multiple_answer(self, mock_input):
    mock_input.return_value = Mock()
    mock_input.side_effect = ['Answer1', 'Answer2']
    result = main_function()
    self.assertIn('ExpectedResult', result)

但我收到错误:TypeError: test_multiple_answer() 采用 2 个位置参数，但给出了 3 个。

Answer 1

我刚刚问了自己同样的问题，虽然我很确定答案，但我写了一个愚蠢的小但可以理解的概念证明。

就像@whats-done-is 指出的那样，有两种方法可以解决这个问题；使用 mock.patch() 的 new 参数指定要内联的模拟对象，或者为每个 @patch 注释添加一个参数。

utils.py

def expensive_function():
    return 12345

模块1.py

from utils import expensive_function
from module2 import method2

def method1():
    return {'method1': expensive_function(), 'method2': method2()}

模块2.py

from utils import expensive_function

def method2():
    return expensive_function()

main.py

import unittest
from unittest.mock import patch
from module1 import method1

def mock_expensive_function():
    return 123

class TestCases(unittest.TestCase):
    def test_unpatched(self):
        self.assertEqual({'method1': 12345, 'method2': 12345}, method1())

    @patch('module1.expensive_function', new=mock_expensive_function)
    def test_method1_patched(self):
        self.assertEqual({'method1': 123, 'method2': 12345}, method1())

    @patch('module2.expensive_function', new=mock_expensive_function)
    def test_method2_patched(self):
        self.assertEqual({'method1': 12345, 'method2': 123}, method1())

    @patch('module1.expensive_function', new=mock_expensive_function)
    @patch('module2.expensive_function', new=mock_expensive_function)
    def test_both_patched_inline(self):
        self.assertEqual({'method1': 123, 'method2': 123}, method1())

    @patch('module1.expensive_function')
    @patch('module2.expensive_function')
    def test_both_patched_magicmock(self, mock_in_module2, mock_in_module1):
        mock_in_module1.return_value = mock_expensive_function()
        mock_in_module2.return_value = mock_expensive_function()
        self.assertEqual({'method1': 123, 'method2': 123}, method1())

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