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() takes 2 positional arguments but 3 were given。

Answer 1

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

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

utils.py

def expensive_function():
    return 12345

module1.py

from utils import expensive_function
from module2 import method2

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

module2.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()