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

所以问题是模拟函数在几个地方：在main函数和一些子函数中。我无法找到让我的单元测试工作的方法（我无法预测主要功能或一个子功能中是否需要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()

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