Mock有一个helpful assert_called_with() method。但是，据我所知，这只会检查 last 对方法的调用
如果我有连续3次调用模拟方法的代码，每次使用不同的参数，我如何用它们的特定参数断言这3个调用？
答案 0 :(得分：129)
assert_has_calls是解决此问题的另一种方法。
来自文档：
assert_has_calls （来电，any_order = False）
断言模拟已经存在 用指定的调用调用。检查mock_calls列表 电话。
如果any_order为False（默认值），则调用必须是顺序的。 在指定的呼叫之前或之后可以有额外的呼叫。
如果any_order为True，那么调用可以是任何顺序，但它们必须 所有都出现在mock_calls中。
示例：
>>> from mock import call, Mock
>>> mock = Mock(return_value=None)
>>> mock(1)
>>> mock(2)
>>> mock(3)
>>> mock(4)
>>> calls = [call(2), call(3)]
>>> mock.assert_has_calls(calls)
>>> calls = [call(4), call(2), call(3)]
>>> mock.assert_has_calls(calls, any_order=True)
来源：https://docs.python.org/3/library/unittest.mock.html#unittest.mock.Mock.assert_has_calls
答案 1 :(得分：82)
通常，我不关心电话的顺序，只是他们发生了。在这种情况下，我将assert_any_call与关于call_count的断言结合起来。
>>> import mock
>>> m = mock.Mock()
>>> m(1)
<Mock name='mock()' id='37578160'>
>>> m(2)
<Mock name='mock()' id='37578160'>
>>> m(3)
<Mock name='mock()' id='37578160'>
>>> m.assert_any_call(1)
>>> m.assert_any_call(2)
>>> m.assert_any_call(3)
>>> assert 3 == m.call_count
>>> m.assert_any_call(4)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "[python path]\lib\site-packages\mock.py", line 891, in assert_any_call
'%s call not found' % expected_string
AssertionError: mock(4) call not found
我发现这样做比传递给单个方法的大量调用更容易阅读和理解。
如果您确实关心订单，或者您希望进行多次相同的来电，assert_has_calls可能更合适。
自从我发布这个答案以来，我一直在考虑我的测试方法。我认为值得一提的是，如果您的测试变得复杂，您可能会进行不适当的测试或出现设计问题。模拟被设计用于在面向对象的设计中测试对象间通信。如果您的设计没有面向对象（如更多程序或功能），那么模拟可能完全不合适。您可能也在方法内部进行了太多操作，或者您可能正在测试最好不要进行模拟的内部详细信息。当我的代码不是面向对象的时候，我开发了这个方法中提到的策略，我相信我也在测试内部细节，这些细节最好不要被嘲笑。
答案 2 :(得分：36)
您可以使用Mock.call_args_list attribute将参数与之前的方法调用进行比较。与Mock.call_count attribute一起使用可以让您完全控制。
答案 3 :(得分：16)
我总是要一次又一次地看这个，所以这是我的答案。
假设我们有一个重型职业（我们想要模拟）：
In [1]: class HeavyDuty(object):
...: def __init__(self):
...: import time
...: time.sleep(2) # <- Spends a lot of time here
...:
...: def do_work(self, arg1, arg2):
...: print("Called with %r and %r" % (arg1, arg2))
...:
这里有一些使用HeavyDuty类的两个实例的代码：
In [2]: def heavy_work():
...: hd1 = HeavyDuty()
...: hd1.do_work(13, 17)
...: hd2 = HeavyDuty()
...: hd2.do_work(23, 29)
...:
现在，这是heavy_work函数的测试用例：
In [3]: from unittest.mock import patch, call
...: def test_heavy_work():
...: expected_calls = [call.do_work(13, 17),call.do_work(23, 29)]
...:
...: with patch('__main__.HeavyDuty') as MockHeavyDuty:
...: heavy_work()
...: MockHeavyDuty.return_value.assert_has_calls(expected_calls)
...:
我们正在使用HeavyDuty模仿MockHeavyDuty班级。要断言来自每个HeavyDuty实例的方法调用，我们必须引用MockHeavyDuty.return_value.assert_has_calls，而不是MockHeavyDuty.assert_has_calls。此外，在expected_calls列表中，我们必须指定我们感兴趣的断言调用的方法名称。因此，我们的列表是对call.do_work的调用，而不是call。
练习测试用例告诉我们它是成功的：
In [4]: print(test_heavy_work())
None
如果我们修改heavy_work函数，测试将失败并产生一条有用的错误消息：
In [5]: def heavy_work():
...: hd1 = HeavyDuty()
...: hd1.do_work(113, 117) # <- call args are different
...: hd2 = HeavyDuty()
...: hd2.do_work(123, 129) # <- call args are different
...:
In [6]: print(test_heavy_work())
---------------------------------------------------------------------------
(traceback omitted for clarity)
AssertionError: Calls not found.
Expected: [call.do_work(13, 17), call.do_work(23, 29)]
Actual: [call.do_work(113, 117), call.do_work(123, 129)]
与上述相反，这里有一个示例，说明如何模拟对函数的多个调用：
In [7]: def work_function(arg1, arg2):
...: print("Called with args %r and %r" % (arg1, arg2))
In [8]: from unittest.mock import patch, call
...: def test_work_function():
...: expected_calls = [call(13, 17), call(23, 29)]
...: with patch('__main__.work_function') as mock_work_function:
...: work_function(13, 17)
...: work_function(23, 29)
...: mock_work_function.assert_has_calls(expected_calls)
...:
In [9]: print(test_work_function())
None
主要有两个不同之处。第一个是在模拟函数时，我们使用call设置我们预期的调用，而不是使用call.some_method。第二个是我们在assert_has_calls上拨打mock_work_function，而不是mock_work_function.return_value。