快速上手?

當您訪(fǎng)問(wèn)對象時(shí)， Mock 和 MagicMock 將創(chuàng )建所有屬性和方法，并保存他們在使用時(shí)的細節。你可以通過(guò)配置，指定返回值或者限制可訪(fǎng)問(wèn)屬性，然后斷言他們如何被調用：

>>> from unittest.mock import MagicMock
>>> thing = ProductionClass()
>>> thing.method = MagicMock(return_value=3)
>>> thing.method(3, 4, 5, key='value')
3
>>> thing.method.assert_called_with(3, 4, 5, key='value')

通過(guò) side_effect 設置副作用(side effects) ，可以是一個(gè) mock 被調用是拋出的異常：

>>> mock = Mock(side_effect=KeyError('foo'))
>>> mock()
Traceback (most recent call last):
 ...
KeyError: 'foo'

>>> values = {'a': 1, 'b': 2, 'c': 3}
>>> def side_effect(arg):
...     return values[arg]
...
>>> mock.side_effect = side_effect
>>> mock('a'), mock('b'), mock('c')
(1, 2, 3)
>>> mock.side_effect = [5, 4, 3, 2, 1]
>>> mock(), mock(), mock()
(5, 4, 3)

Mock 還可以通過(guò)其他方法配置和控制其行為。例如 mock 可以通過(guò)設置 spec 參數來(lái)從一個(gè)對象中獲取其規格(specification)。如果訪(fǎng)問(wèn) mock 的屬性或方法不在 spec 中，會(huì )報 AttributeError 錯誤。

使用 patch() 裝飾去/上下文管理器，可以更方便地測試一個(gè)模塊下的類(lèi)或對象。你指定的對象會(huì )在測試過(guò)程中替換成 mock （或者其他對象），測試結束后恢復。

>>> from unittest.mock import patch
>>> @patch('module.ClassName2')
... @patch('module.ClassName1')
... def test(MockClass1, MockClass2):
...     module.ClassName1()
...     module.ClassName2()
...     assert MockClass1 is module.ClassName1
...     assert MockClass2 is module.ClassName2
...     assert MockClass1.called
...     assert MockClass2.called
...
>>> test()

patch() 也可以 with 語(yǔ)句中使用上下文管理。

>>> with patch.object(ProductionClass, 'method', return_value=None) as mock_method:
...     thing = ProductionClass()
...     thing.method(1, 2, 3)
...
>>> mock_method.assert_called_once_with(1, 2, 3)

還有一個(gè) patch.dict() 用于在一定范圍內設置字典中的值，并在測試結束時(shí)將字典恢復為其原始狀態(tài)：

>>> foo = {'key': 'value'}
>>> original = foo.copy()
>>> with patch.dict(foo, {'newkey': 'newvalue'}, clear=True):
...     assert foo == {'newkey': 'newvalue'}
...
>>> assert foo == original

Mock支持 Python 魔術(shù)方法 。使用模式方法最簡(jiǎn)單的方式是使用 MagicMock class. 。它可以做如下事情：

>>> mock = MagicMock()
>>> mock.__str__.return_value = 'foobarbaz'
>>> str(mock)
'foobarbaz'
>>> mock.__str__.assert_called_with()

Mock 能指定函數（或其他 Mock 實(shí)例）為魔術(shù)方法，它們將被適當地調用。 MagicMock 是預先創(chuàng )建了所有魔術(shù)方法（所有有用的方法） 的 Mock 。

下面是一個(gè)使用了普通 Mock 類(lèi)的魔術(shù)方法的例子

>>> mock = Mock()
>>> mock.__str__ = Mock(return_value='wheeeeee')
>>> str(mock)
'wheeeeee'

使用 auto-speccing 可以保證測試中的模擬對象與要替換的對象具有相同的api 。在 patch 中可以通過(guò) autospec 參數實(shí)現自動(dòng)推斷，或者使用 create_autospec() 函數。自動(dòng)推斷會(huì )創(chuàng )建一個(gè)與要替換對象相同的屬相和方法的模擬對象，并且任何函數和方法（包括構造函數）都具有與真實(shí)對象相同的調用簽名。

這么做是為了因確保不當地使用 mock 導致與生產(chǎn)代碼相同的失?。?/p>

>>> from unittest.mock import create_autospec
>>> def function(a, b, c):
...     pass
...
>>> mock_function = create_autospec(function, return_value='fishy')
>>> mock_function(1, 2, 3)
'fishy'
>>> mock_function.assert_called_once_with(1, 2, 3)
>>> mock_function('wrong arguments')
Traceback (most recent call last):
 ...
TypeError: <lambda>() takes exactly 3 arguments (1 given)

在類(lèi)中使用 create_autospec() 時(shí)，會(huì )復制 __init__ 方法的簽名，另外在可調用對象上使用時(shí)，會(huì )復制 __call__ 方法的簽名。

Mock 類(lèi)?

Mock 是一個(gè)可以靈活的替換存根 (stubs) 的對象，可以測試所有代碼。 Mock 是可調用的，在訪(fǎng)問(wèn)其屬性時(shí)創(chuàng )建一個(gè)新的 mock 1 。訪(fǎng)問(wèn)相同的屬性只會(huì )返回相同的 mock 。 Mock 會(huì )保存調用記錄，可以通過(guò)斷言獲悉代碼的調用。

MagicMock 是 Mock 的子類(lèi)，它有所有預創(chuàng )建且可使用的魔術(shù)方法。在需要模擬不可調用對象時(shí)，可以使用 NonCallableMock  和 NonCallableMagicMock

patch() 裝飾器使得用 Mock 對象臨時(shí)替換特定模塊中的類(lèi)非常方便。 默認情況下 patch() 將為你創(chuàng )建一個(gè) MagicMock。 你可以使用 patch() 的 new_callable 參數指定替代 Mock 的類(lèi)。

class unittest.mock.Mock(spec=None, side_effect=None, return_value=DEFAULT, wraps=None, name=None, spec_set=None, unsafe=False, **kwargs)?

創(chuàng )建一個(gè)新的 Mock 對象。通過(guò)可選參數指定 Mock 對象的行為：

• spec: 可以是要給字符串列表，也可以是充當模擬對象規范的現有對象（類(lèi)或實(shí)例）。如果傳入一個(gè)對象，則通過(guò)在該對象上調用 dir 來(lái)生成字符串列表（不支持的魔法屬性和方法除外）。訪(fǎng)問(wèn)不在此列表中的任何屬性都將觸發(fā) AttributeError 。

  如果 spec 是一個(gè)對象（而不是字符串列表），則 __class__ 返回 spec 對象的類(lèi)。 這允許模擬程序通過(guò) isinstance() 測試。

• spec_set ：spec 的更嚴格的變體。如果使用了該屬性，嘗試模擬 set 或 get 的屬性不在 spec_set 所包含的對象中時(shí)，會(huì )拋出 AttributeError 。

• side_effect ：每當調用 Mock 時(shí)都會(huì )調用的函數。 參見(jiàn) side_effect 屬性。 對于引發(fā)異?；騽?dòng)態(tài)更改返回值很有用。 該函數使用與 mock 函數相同的參數調用，并且除非返回 DEFAULT ，否則該函數的返回值將用作返回值。

  另外， side_effect 可以是異常類(lèi)或實(shí)例。 此時(shí)，調用模擬程序時(shí)將引發(fā)異常。

  如果 side_effect 是可迭代對象，則每次調用 mock 都將返回可迭代對象的下一個(gè)值。

  設置 side_effect 為 None 即可清空。

• return_value ：調用 mock 的返回值。 默認情況下，是一個(gè)新的Mock（在首次訪(fǎng)問(wèn)時(shí)創(chuàng )建）。 參見(jiàn) return_value 屬性 。

• unsafe: By default, accessing any attribute whose name starts with assert, assret, asert, aseert or assrt will raise an AttributeError. Passing unsafe=True will allow access to these attributes.

  3.5 新版功能.

• wraps ：要包裝的 mock 對象。 如果 wraps 不是 None ，那么調用 Mock 會(huì )將調用傳遞給 wraps 的對象（返回實(shí)際結果）。 對模擬的屬性訪(fǎng)問(wèn)將返回一個(gè) Mock 對象，該對象包裝了 wraps 對象的相應屬性（因此，嘗試訪(fǎng)問(wèn)不存在的屬性將引發(fā) AttributeError ）。

  如果明確指定 return_value ，則調用時(shí)不會(huì )返回包裝對象，而是返回 return_value 。

• name ：mock 的名稱(chēng)。 在調試時(shí)很有用。 名稱(chēng)會(huì )傳遞到子 mock 。

還可以使用任意關(guān)鍵字參數來(lái)調用 mock 。 創(chuàng )建模擬后，將使用這些屬性來(lái)設置 mock 的屬性。 有關(guān)詳細信息，請參見(jiàn) configure_mock() 方法。

assert_called()?

斷言 mock 已被調用至少一次。

>>>

>>> mock = Mock()
>>> mock.method()
<Mock name='mock.method()' id='...'>
>>> mock.method.assert_called()

3.6 新版功能.

assert_called_once()?

斷言 mock 已被調用恰好一次。

>>>

>>> mock = Mock()
>>> mock.method()
<Mock name='mock.method()' id='...'>
>>> mock.method.assert_called_once()
>>> mock.method()
<Mock name='mock.method()' id='...'>
>>> mock.method.assert_called_once()
Traceback (most recent call last):
...
AssertionError: Expected 'method' to have been called once. Called 2 times.

3.6 新版功能.

assert_called_with(*args, **kwargs)?

此方法是斷言上次調用已以特定方式進(jìn)行的一種便捷方法：

>>>

>>> mock = Mock()
>>> mock.method(1, 2, 3, test='wow')
<Mock name='mock.method()' id='...'>
>>> mock.method.assert_called_with(1, 2, 3, test='wow')

assert_called_once_with(*args, **kwargs)?

斷言 mock 已被調用恰好一次，并且向該調用傳入了指定的參數。

>>>

>>> mock = Mock(return_value=None)
>>> mock('foo', bar='baz')
>>> mock.assert_called_once_with('foo', bar='baz')
>>> mock('other', bar='values')
>>> mock.assert_called_once_with('other', bar='values')
Traceback (most recent call last):
  ...
AssertionError: Expected 'mock' to be called once. Called 2 times.

assert_any_call(*args, **kwargs)?

斷言 mock 已被調用并附帶了指定的參數。

如果 mock 曾經(jīng) 被調用過(guò)則斷言通過(guò)，不同于 assert_called_with() 和 assert_called_once_with() 那樣只有在調用是最近的一次時(shí)才會(huì )通過(guò)，而對于 assert_called_once_with() 則它還必須是唯一的一次調用。

>>>

>>> mock = Mock(return_value=None)
>>> mock(1, 2, arg='thing')
>>> mock('some', 'thing', 'else')
>>> mock.assert_any_call(1, 2, arg='thing')

assert_has_calls(calls, any_order=False)?

斷言 mock 已附帶指定的參數被調用。 將針對這些調用檢查 mock_calls 列表。

如果 any_order 為假值則調用必須是順序進(jìn)行的。 在指定的調用之前或之后還可以有額外的調用。

如果 any_order 為真值則調用可以是任意順序的，但它們都必須在 mock_calls 中出現。

>>>

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

assert_not_called()?

斷言 mock 從未被調用過(guò)。

>>>

>>> m = Mock()
>>> m.hello.assert_not_called()
>>> obj = m.hello()
>>> m.hello.assert_not_called()
Traceback (most recent call last):
  ...
AssertionError: Expected 'hello' to not have been called. Called 1 times.

3.5 新版功能.

reset_mock(*, return_value=False, side_effect=False)?

reset_mock 方法將在 mock 對象上重圍所有的調用屬性:

>>>

>>> mock = Mock(return_value=None)
>>> mock('hello')
>>> mock.called
True
>>> mock.reset_mock()
>>> mock.called
False

在 3.6 版更改: 向 reset_mock 函數添加了兩個(gè)僅限關(guān)鍵字參數。

這在你想要創(chuàng )建一系列重用相同對象的斷言時(shí)會(huì )很有用處。 請注意 reset_mock() 不會(huì ) 清除返回值、side_effect 或任何你使用普通賦值所默認設置的子屬性。 如果你想要重置 return_value 或 side_effect，則要為相應的形參傳入 True。 子 mock 和返回值 mock (如果有的話(huà)) 也會(huì )被重置。

備注

return_value 和 side_effect 均為僅限關(guān)鍵字參數。

mock_add_spec(spec, spec_set=False)?

為 mock 添加描述。 spec 可以是一個(gè)對象或字符串列表。 只有 spec 上的屬性可以作為來(lái)自 mock 的屬性被獲取。

如果 spec_set 為真值則只有 spec 上的屬性可以被設置。

attach_mock(mock, attribute)?

附加一個(gè) mock 作為這一個(gè)的屬性，替換它的名稱(chēng)和上級。 對附加 mock 的調用將記錄在這一個(gè)的 method_calls 和 mock_calls 屬性中。

configure_mock(**kwargs)?

通過(guò)關(guān)鍵字參數在 mock 上設置屬性。

屬性加返回值和附帶影響可以使用標準點(diǎn)號標記在子 mock 上設置并在方法調用中解包一個(gè)字典:

>>>

>>> mock = Mock()
>>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError}
>>> mock.configure_mock(**attrs)
>>> mock.method()
3
>>> mock.other()
Traceback (most recent call last):
  ...
KeyError

同樣的操作可在對 mock 的構造器調用中達成:

>>>

>>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError}
>>> mock = Mock(some_attribute='eggs', **attrs)
>>> mock.some_attribute
'eggs'
>>> mock.method()
3
>>> mock.other()
Traceback (most recent call last):
  ...
KeyError

configure_mock() 的存在是使得 mock 被創(chuàng )建之后的配置更為容易。

__dir__()?

Mock 對象會(huì )將 dir(some_mock) 的結果限制為有用結果。 對于帶有 spec 的 mock 這還包括 mock 的所有被允許的屬性。

請查看 FILTER_DIR 了解此過(guò)濾做了什么，以及如何停用它。

_get_child_mock(**kw)?

創(chuàng )建針對屬性和返回值的子 mock。 默認情況下子 mock 將為與其上級相同的類(lèi)型。 Mock 的子類(lèi)可能需要重載它來(lái)定制子 mock 的創(chuàng )建方式。

對于非可調用的 mock 將會(huì )使用可調用的變化形式（而非不是任意的自定義子類(lèi)）。

called?

一個(gè)表示 mock 對象是否已被調用的布爾值:

>>>

>>> mock = Mock(return_value=None)
>>> mock.called
False
>>> mock()
>>> mock.called
True

call_count?

一個(gè)告訴你 mock 對象已被調用多少次的整數值:

>>>

>>> mock = Mock(return_value=None)
>>> mock.call_count
0
>>> mock()
>>> mock()
>>> mock.call_count
2

return_value?

設置這個(gè)來(lái)配置通過(guò)調用該 mock 所返回的值:

>>>

>>> mock = Mock()
>>> mock.return_value = 'fish'
>>> mock()
'fish'

默認的返回值是一個(gè) mock 對象并且你可以通過(guò)正常方式來(lái)配置它:

>>>

>>> mock = Mock()
>>> mock.return_value.attribute = sentinel.Attribute
>>> mock.return_value()
<Mock name='mock()()' id='...'>
>>> mock.return_value.assert_called_with()

return_value 也可以在構造器中設置:

>>>

>>> mock = Mock(return_value=3)
>>> mock.return_value
3
>>> mock()
3

side_effect?

這可以是當該This can either be a function to be called when the mock 被調用時(shí)將被調用的一個(gè)函數，可調用對象或者要被引發(fā)的異常（類(lèi)或實(shí)例）。

如果你傳入一個(gè)函數則它將附帶與該 mock 相同的參數被調用并且除了該函數返回 DEFAULT 單例的情況以外對該 mock 的調用都將隨后返回該函數所返回的任何東西。 如果該函數返回 DEFAULT 則該 mock 將返回其正常值 (來(lái)自 return_value)。

如果你傳入一個(gè)可迭代對象，它會(huì )被用來(lái)獲取一個(gè)在每次調用時(shí)必須產(chǎn)生一個(gè)值的迭代器。 這個(gè)值可以是一個(gè)要被引發(fā)的異常實(shí)例，或是一個(gè)要從該調用返回給 mock 的值 (DEFAULT 處理與函數的情況一致)。

一個(gè)引發(fā)異常（來(lái)測試 API 的異常處理）的 mock 的示例:

>>>

>>> mock = Mock()
>>> mock.side_effect = Exception('Boom!')
>>> mock()
Traceback (most recent call last):
  ...
Exception: Boom!

使用 side_effect 來(lái)返回包含多個(gè)值的序列:

>>>

>>> mock = Mock()
>>> mock.side_effect = [3, 2, 1]
>>> mock(), mock(), mock()
(3, 2, 1)

使用一個(gè)可調用對象:

>>>

>>> mock = Mock(return_value=3)
>>> def side_effect(*args, **kwargs):
...     return DEFAULT
...
>>> mock.side_effect = side_effect
>>> mock()
3

side_effect 可以在構造器中設置。 下面是在 mock 被調用時(shí)增加一個(gè)該屬性值并返回它的例子:

>>>

>>> side_effect = lambda value: value + 1
>>> mock = Mock(side_effect=side_effect)
>>> mock(3)
4
>>> mock(-8)
-7

將 side_effect 設為 None 可以清除它:

>>>

>>> m = Mock(side_effect=KeyError, return_value=3)
>>> m()
Traceback (most recent call last):
 ...
KeyError
>>> m.side_effect = None
>>> m()
3

call_args?

這可以是 None (如果 mock 沒(méi)有被調用)，或是 mock 最近一次被調用時(shí)附帶的參數。 這將采用元組的形式：第一個(gè)成員也可以通過(guò) args 特征屬性來(lái)訪(fǎng)問(wèn)，它是 mock 被調用時(shí)所附帶的任何位置參數 (或為空元組)，而第二個(gè)成員也可以通過(guò) kwargs 特征屬性來(lái)訪(fǎng)問(wèn)，它則是任何關(guān)鍵字參數 (或為空字典)。

>>>

>>> mock = Mock(return_value=None)
>>> print(mock.call_args)
None
>>> mock()
>>> mock.call_args
call()
>>> mock.call_args == ()
True
>>> mock(3, 4)
>>> mock.call_args
call(3, 4)
>>> mock.call_args == ((3, 4),)
True
>>> mock.call_args.args
(3, 4)
>>> mock.call_args.kwargs
{}
>>> mock(3, 4, 5, key='fish', next='w00t!')
>>> mock.call_args
call(3, 4, 5, key='fish', next='w00t!')
>>> mock.call_args.args
(3, 4, 5)
>>> mock.call_args.kwargs
{'key': 'fish', 'next': 'w00t!'}

call_args，以及列表 call_args_list, method_calls 和 mock_calls 的成員都是 call 對象。 這些對象屬性元組，因此它們可被解包以獲得單獨的參數并創(chuàng )建更復雜的斷言。 參見(jiàn) 作為元組的 call。

在 3.8 版更改: 增加了 args 和 kwargs 特征屬性。properties.

call_args_list?

這是一個(gè)已排序的對 mock 對象的所有調用的列表（因此該列表的長(cháng)度就是它已被調用的次數）。 在執行任何調用之前它將是一個(gè)空列表。 call 對象可以被用來(lái)方便地構造調用列表以與 call_args_list 相比較。

>>>

>>> mock = Mock(return_value=None)
>>> mock()
>>> mock(3, 4)
>>> mock(key='fish', next='w00t!')
>>> mock.call_args_list
[call(), call(3, 4), call(key='fish', next='w00t!')]
>>> expected = [(), ((3, 4),), ({'key': 'fish', 'next': 'w00t!'},)]
>>> mock.call_args_list == expected
True

call_args_list 的成員均為 call 對象。 它們可作為元組被解包以獲得單個(gè)參數。 參見(jiàn) 作為元組的 call。

method_calls?

除了會(huì )追蹤對其自身的調用，mock 還會(huì )追蹤對方法和屬性，以及 它們的 方法和屬性的訪(fǎng)問(wèn):

>>>

>>> mock = Mock()
>>> mock.method()
<Mock name='mock.method()' id='...'>
>>> mock.property.method.attribute()
<Mock name='mock.property.method.attribute()' id='...'>
>>> mock.method_calls
[call.method(), call.property.method.attribute()]

method_calls 的成員均為 call 對象。 它們可以作為元組被解包以獲得單個(gè)參數。 參見(jiàn) 作為元組的 call。

mock_calls?

mock_calls 會(huì )記錄 所有 對 mock 對象、它的方法、魔術(shù)方法的調用 以及 返回值的 mock。

>>>

>>> mock = MagicMock()
>>> result = mock(1, 2, 3)
>>> mock.first(a=3)
<MagicMock name='mock.first()' id='...'>
>>> mock.second()
<MagicMock name='mock.second()' id='...'>
>>> int(mock)
1
>>> result(1)
<MagicMock name='mock()()' id='...'>
>>> expected = [call(1, 2, 3), call.first(a=3), call.second(),
... call.__int__(), call()(1)]
>>> mock.mock_calls == expected
True

mock_calls 的成員均為 call 對象。 它們可以作為元組被解包以獲得單個(gè)參數。 參見(jiàn) 作為元組的 call。

備注

mock_calls 的記錄方式意味著(zhù)在進(jìn)行嵌套調用時(shí)，之前調用的形參不會(huì )被記錄因而這樣的比較將總是相等:

>>>

>>> mock = MagicMock()
>>> mock.top(a=3).bottom()
<MagicMock name='mock.top().bottom()' id='...'>
>>> mock.mock_calls
[call.top(a=3), call.top().bottom()]
>>> mock.mock_calls[-1] == call.top(a=-1).bottom()
True

__class__?

通常一個(gè)對象的 __class__ 屬性將返回其類(lèi)型。 對于具有 spec 的 mock 對象來(lái)說(shuō)，__class__ 將改為返回 spec 類(lèi)。 這將允許 mock 對象為它們所替換 / 屏蔽的對象跳過(guò) isinstance() 測試:

>>>

>>> mock = Mock(spec=3)
>>> isinstance(mock, int)
True

__class__ 是可以被賦值的，這將允許 mock 跳過(guò) isinstance() 檢測而不強制要求你使用 spec:

>>>

>>> mock = Mock()
>>> mock.__class__ = dict
>>> isinstance(mock, dict)
True

class unittest.mock.NonCallableMock(spec=None, wraps=None, name=None, spec_set=None, **kwargs)?

不可調用的 Mock 版本。 其構造器的形參具有與 Mock 相同的含義，區別在于 return_value 和 side_effect 在不可調用的 mock 上沒(méi)有意義。

使用類(lèi)或實(shí)例作為 spec 或 spec_set 的 mock 對象能夠跳過(guò) isinstance() 測試:

>>> mock = Mock(spec=SomeClass)
>>> isinstance(mock, SomeClass)
True
>>> mock = Mock(spec_set=SomeClass())
>>> isinstance(mock, SomeClass)
True

Mock 類(lèi)具有對 mock 操作魔術(shù)方法的支持。 請參閱 魔術(shù)方法 了解完整細節。

mock 操作類(lèi)和 patch() 裝飾器都接受任意關(guān)鍵字參數用于配置。 對于 patch() 裝飾器來(lái)說(shuō)關(guān)鍵字參數會(huì )被傳給所創(chuàng )建 mock 的構造器。 這些關(guān)鍵字被用于配置 mock 的屬性:

>>> m = MagicMock(attribute=3, other='fish')
>>> m.attribute
3
>>> m.other
'fish'

子 mock 的返回值和附帶效果也可使用帶點(diǎn)號的標記通過(guò)相同的方式來(lái)設置。 由于你無(wú)法直接在調用中使用帶點(diǎn)號的名稱(chēng)因此你需要創(chuàng )建一個(gè)字典并使用 ** 來(lái)解包它:

>>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError}
>>> mock = Mock(some_attribute='eggs', **attrs)
>>> mock.some_attribute
'eggs'
>>> mock.method()
3
>>> mock.other()
Traceback (most recent call last):
  ...
KeyError

使用 spec (或 spec_set) 創(chuàng )建的可調用 mock 將在匹配調用與 mock 時(shí)內省規格說(shuō)明對象的簽名。 因此，它可以匹配實(shí)際調用的參數而不必關(guān)心它們是按位置還是按名稱(chēng)傳入的:

>>> def f(a, b, c): pass
...
>>> mock = Mock(spec=f)
>>> mock(1, 2, c=3)
<Mock name='mock()' id='140161580456576'>
>>> mock.assert_called_with(1, 2, 3)
>>> mock.assert_called_with(a=1, b=2, c=3)

這適用于 assert_called_with(), assert_called_once_with(), assert_has_calls() 和 assert_any_call()。 當執行 Autospeccing 時(shí)，它還將應用于 mock 對象的方法調用。

在 3.4 版更改: 添加了在附帶規格說(shuō)明和自動(dòng)規格說(shuō)明的 mock 對象上的簽名內省

class unittest.mock.PropertyMock(*args, **kwargs)?

旨在作為類(lèi)的特征屬性或其他描述器使用的 mock。 PropertyMock 提供了 __get__() 和 __set__() 方法以便你可以在它被提取時(shí)指定一個(gè)返回值。

當從一個(gè)對象提取 PropertyMock 實(shí)例時(shí)將不附帶任何參數地調用該 mock。 如果設置它則調用該 mock 時(shí)將附帶被設置的值。

>>>

>>> class Foo:
...     @property
...     def foo(self):
...         return 'something'
...     @foo.setter
...     def foo(self, value):
...         pass
...
>>> with patch('__main__.Foo.foo', new_callable=PropertyMock) as mock_foo:
...     mock_foo.return_value = 'mockity-mock'
...     this_foo = Foo()
...     print(this_foo.foo)
...     this_foo.foo = 6
...
mockity-mock
>>> mock_foo.mock_calls
[call(), call(6)]

由于 mock 屬性的存儲方式你無(wú)法直接將 PropertyMock 附加到一個(gè) mock 對象。 但是你可以將它附加到 mock 類(lèi)型對象:

>>> m = MagicMock()
>>> p = PropertyMock(return_value=3)
>>> type(m).foo = p
>>> m.foo
3
>>> p.assert_called_once_with()

class unittest.mock.AsyncMock(spec=None, side_effect=None, return_value=DEFAULT, wraps=None, name=None, spec_set=None, unsafe=False, **kwargs)?

MagicMock 的異步版本。 AsyncMock 對象的行為方式將使該對象被識別為異步函數，其調用的結果將為可等待對象。

>>>

>>> mock = AsyncMock()
>>> asyncio.iscoroutinefunction(mock)
True
>>> inspect.isawaitable(mock())  
True

調用 mock() 的結果是一個(gè)異步函數，它在被等待之后將具有 side_effect 或 return_value 的結果:

• 如果 side_effect 是一個(gè)函數，則異步函數將返回該函數的結果,

• 如果 side_effect 是一個(gè)異常，則異步函數將引發(fā)該異常,

• 如果 side_effect 是一個(gè)可迭代對象，則異步函數將返回該可迭代對象的下一個(gè)值，但是，如果結果序列被耗盡，則會(huì )立即引發(fā) StopAsyncIteration,

• 如果 side_effect 未被定義，則異步函數將返回is not defined, the async function will return the value defined by return_value 所定義的值，因而，在默認情況下，異步函數會(huì )返回一個(gè)新的 AsyncMock 對象。

將 Mock 或 MagicMock 的 spec 設為異步函數將導致在調用后返回一個(gè)協(xié)程對象。

>>>

>>> async def async_func(): pass
...
>>> mock = MagicMock(async_func)
>>> mock
<MagicMock spec='function' id='...'>
>>> mock()  
<coroutine object AsyncMockMixin._mock_call at ...>

將 Mock, MagicMock 或 AsyncMock 的 spec 設為帶有異步和同步函數的類(lèi)將自動(dòng)刪除其中的同步函數并將它們設為 MagicMock (如果上級 mock 是 AsyncMock 或 MagicMock) 或者 Mock (如果上級 mock 是 Mock)。 所有異步函數都將為 AsyncMock。

>>>

>>> class ExampleClass:
...     def sync_foo():
...         pass
...     async def async_foo():
...         pass
...
>>> a_mock = AsyncMock(ExampleClass)
>>> a_mock.sync_foo
<MagicMock name='mock.sync_foo' id='...'>
>>> a_mock.async_foo
<AsyncMock name='mock.async_foo' id='...'>
>>> mock = Mock(ExampleClass)
>>> mock.sync_foo
<Mock name='mock.sync_foo' id='...'>
>>> mock.async_foo
<AsyncMock name='mock.async_foo' id='...'>

3.8 新版功能.

assert_awaited()?

斷言 mock 已被等待至少一次。 請注意這是從被調用的對象中分離出來(lái)的，必須要使用 await 關(guān)鍵字:

>>>

>>> mock = AsyncMock()
>>> async def main(coroutine_mock):
...     await coroutine_mock
...
>>> coroutine_mock = mock()
>>> mock.called
True
>>> mock.assert_awaited()
Traceback (most recent call last):
...
AssertionError: Expected mock to have been awaited.
>>> asyncio.run(main(coroutine_mock))
>>> mock.assert_awaited()

assert_awaited_once()?

斷言 mock 已被等待恰好一次。

>>>

>>> mock = AsyncMock()
>>> async def main():
...     await mock()
...
>>> asyncio.run(main())
>>> mock.assert_awaited_once()
>>> asyncio.run(main())
>>> mock.method.assert_awaited_once()
Traceback (most recent call last):
...
AssertionError: Expected mock to have been awaited once. Awaited 2 times.

assert_awaited_with(*args, **kwargs)?

斷言上一次等待傳入了指定的參數。

>>>

>>> mock = AsyncMock()
>>> async def main(*args, **kwargs):
...     await mock(*args, **kwargs)
...
>>> asyncio.run(main('foo', bar='bar'))
>>> mock.assert_awaited_with('foo', bar='bar')
>>> mock.assert_awaited_with('other')
Traceback (most recent call last):
...
AssertionError: expected call not found.
Expected: mock('other')
Actual: mock('foo', bar='bar')

assert_awaited_once_with(*args, **kwargs)?

斷言 mock 已被等待恰好一次并且附帶了指定的參數。

>>>

>>> mock = AsyncMock()
>>> async def main(*args, **kwargs):
...     await mock(*args, **kwargs)
...
>>> asyncio.run(main('foo', bar='bar'))
>>> mock.assert_awaited_once_with('foo', bar='bar')
>>> asyncio.run(main('foo', bar='bar'))
>>> mock.assert_awaited_once_with('foo', bar='bar')
Traceback (most recent call last):
...
AssertionError: Expected mock to have been awaited once. Awaited 2 times.

assert_any_await(*args, **kwargs)?

斷言 mock 已附帶了指定的參數被等待。

>>>

>>> mock = AsyncMock()
>>> async def main(*args, **kwargs):
...     await mock(*args, **kwargs)
...
>>> asyncio.run(main('foo', bar='bar'))
>>> asyncio.run(main('hello'))
>>> mock.assert_any_await('foo', bar='bar')
>>> mock.assert_any_await('other')
Traceback (most recent call last):
...
AssertionError: mock('other') await not found

assert_has_awaits(calls, any_order=False)?

斷言 mock 已附帶了指定的調用被等待。 將針對這些等待檢查 await_args_list 列表。

如果 any_order 為假值則等待必須是順序進(jìn)行的。 在指定的等待之前或之后還可以有額外的調用。

如果 any_order 為真值則等待可以是任意順序的，但它們都必須在 await_args_list 中出現。

>>>

>>> mock = AsyncMock()
>>> async def main(*args, **kwargs):
...     await mock(*args, **kwargs)
...
>>> calls = [call("foo"), call("bar")]
>>> mock.assert_has_awaits(calls)
Traceback (most recent call last):
...
AssertionError: Awaits not found.
Expected: [call('foo'), call('bar')]
Actual: []
>>> asyncio.run(main('foo'))
>>> asyncio.run(main('bar'))
>>> mock.assert_has_awaits(calls)

assert_not_awaited()?

斷言 mock 從未被等待過(guò)。

>>>

>>> mock = AsyncMock()
>>> mock.assert_not_awaited()

reset_mock(*args, **kwargs)?

參見(jiàn) Mock.reset_mock()。 還會(huì )將 await_count 設為 0，將 await_args 設為 None，并清空 await_args_list。

await_count?

一個(gè)追蹤 mock 對象已被等待多少次的整數值。

>>>

>>> mock = AsyncMock()
>>> async def main():
...     await mock()
...
>>> asyncio.run(main())
>>> mock.await_count
1
>>> asyncio.run(main())
>>> mock.await_count
2

await_args?

這可能為 None (如果 mock 從未被等待)，或為該 mock 上一次被等待所附帶的參數。 其功能與 Mock.call_args 相同。

>>>

>>> mock = AsyncMock()
>>> async def main(*args):
...     await mock(*args)
...
>>> mock.await_args
>>> asyncio.run(main('foo'))
>>> mock.await_args
call('foo')
>>> asyncio.run(main('bar'))
>>> mock.await_args
call('bar')

await_args_list?

這是由對 mock 對象按順序執行的所有等待組成的列表（因此該列表的長(cháng)度即它被等待的次數）。 在有任何等待被執行之前它將為一個(gè)空列表。

>>>

>>> mock = AsyncMock()
>>> async def main(*args):
...     await mock(*args)
...
>>> mock.await_args_list
[]
>>> asyncio.run(main('foo'))
>>> mock.await_args_list
[call('foo')]
>>> asyncio.run(main('bar'))
>>> mock.await_args_list
[call('foo'), call('bar')]

>>> m = MagicMock(side_effect=IndexError)
>>> m(1, 2, 3)
Traceback (most recent call last):
  ...
IndexError
>>> m.mock_calls
[call(1, 2, 3)]
>>> m.side_effect = KeyError('Bang!')
>>> m('two', 'three', 'four')
Traceback (most recent call last):
  ...
KeyError: 'Bang!'
>>> m.mock_calls
[call(1, 2, 3), call('two', 'three', 'four')]

>>> def side_effect(value):
...     return value + 1
...
>>> m = MagicMock(side_effect=side_effect)
>>> m(1)
2
>>> m(2)
3
>>> m.mock_calls
[call(1), call(2)]

>>> m = MagicMock()
>>> def side_effect(*args, **kwargs):
...     return m.return_value
...
>>> m.side_effect = side_effect
>>> m.return_value = 3
>>> m()
3
>>> def side_effect(*args, **kwargs):
...     return DEFAULT
...
>>> m.side_effect = side_effect
>>> m()
3

>>> m = MagicMock(return_value=6)
>>> def side_effect(*args, **kwargs):
...     return 3
...
>>> m.side_effect = side_effect
>>> m()
3
>>> m.side_effect = None
>>> m()
6

>>> m = MagicMock(side_effect=[1, 2, 3])
>>> m()
1
>>> m()
2
>>> m()
3
>>> m()
Traceback (most recent call last):
  ...
StopIteration

>>> iterable = (33, ValueError, 66)
>>> m = MagicMock(side_effect=iterable)
>>> m()
33
>>> m()
Traceback (most recent call last):
 ...
ValueError
>>> m()
66

>>> mock = MagicMock()
>>> hasattr(mock, 'm')
True
>>> del mock.m
>>> hasattr(mock, 'm')
False
>>> del mock.f
>>> mock.f
Traceback (most recent call last):
    ...
AttributeError: f

>>> mock = MagicMock()
>>> mock.configure_mock(name='my_name')
>>> mock.name
'my_name'

>>> mock = MagicMock()
>>> mock.name = "foo"

>>> parent = MagicMock()
>>> child1 = MagicMock(return_value=None)
>>> child2 = MagicMock(return_value=None)
>>> parent.child1 = child1
>>> parent.child2 = child2
>>> child1(1)
>>> child2(2)
>>> parent.mock_calls
[call.child1(1), call.child2(2)]

>>> mock = MagicMock()
>>> not_a_child = MagicMock(name='not-a-child')
>>> mock.attribute = not_a_child
>>> mock.attribute()
<MagicMock name='not-a-child()' id='...'>
>>> mock.mock_calls
[]

>>> thing1 = object()
>>> thing2 = object()
>>> parent = MagicMock()
>>> with patch('__main__.thing1', return_value=None) as child1:
...     with patch('__main__.thing2', return_value=None) as child2:
...         parent.attach_mock(child1, 'child1')
...         parent.attach_mock(child2, 'child2')
...         child1('one')
...         child2('two')
...
>>> parent.mock_calls
[call.child1('one'), call.child2('two')]

patch 裝飾器?

patch 裝飾器僅被用于在它們所裝飾的函數作用域內部為對象添加補丁。 它們會(huì )自動(dòng)為你執行去除補丁的處理，即使是在引發(fā)了異常的情況下。 所有這些函數都還可在 with 語(yǔ)句中使用或是作為類(lèi)裝飾器。

>>> @patch('__main__.SomeClass')
... def function(normal_argument, mock_class):
...     print(mock_class is SomeClass)
...
>>> function(None)
True

>>> class Class:
...     def method(self):
...         pass
...
>>> with patch('__main__.Class') as MockClass:
...     instance = MockClass.return_value
...     instance.method.return_value = 'foo'
...     assert Class() is instance
...     assert Class().method() == 'foo'
...

>>> Original = Class
>>> patcher = patch('__main__.Class', spec=True)
>>> MockClass = patcher.start()
>>> instance = MockClass()
>>> assert isinstance(instance, Original)
>>> patcher.stop()

>>> thing = object()
>>> with patch('__main__.thing', new_callable=NonCallableMock) as mock_thing:
...     assert thing is mock_thing
...     thing()
...
Traceback (most recent call last):
  ...
TypeError: 'NonCallableMock' object is not callable

>>> from io import StringIO
>>> def foo():
...     print('Something')
...
>>> @patch('sys.stdout', new_callable=StringIO)
... def test(mock_stdout):
...     foo()
...     assert mock_stdout.getvalue() == 'Something\n'
...
>>> test()

>>> patcher = patch('__main__.thing', first='one', second='two')
>>> mock_thing = patcher.start()
>>> mock_thing.first
'one'
>>> mock_thing.second
'two'

>>> config = {'method.return_value': 3, 'other.side_effect': KeyError}
>>> patcher = patch('__main__.thing', **config)
>>> mock_thing = patcher.start()
>>> mock_thing.method()
3
>>> mock_thing.other()
Traceback (most recent call last):
  ...
KeyError

>>> @patch('sys.non_existing_attribute', 42)
... def test():
...     assert sys.non_existing_attribute == 42
...
>>> test()
Traceback (most recent call last):
  ...
AttributeError: <module 'sys' (built-in)> does not have the attribute 'non_existing_attribute'

>>> @patch('sys.non_existing_attribute', 42, create=True)
... def test(mock_stdout):
...     assert sys.non_existing_attribute == 42
...
>>> test()

>>> @patch.object(SomeClass, 'class_method')
... def test(mock_method):
...     SomeClass.class_method(3)
...     mock_method.assert_called_with(3)
...
>>> test()

>>> foo = {}
>>> @patch.dict(foo, {'newkey': 'newvalue'})
... def test():
...     assert foo == {'newkey': 'newvalue'}
>>> test()
>>> assert foo == {}

>>> import os
>>> import unittest
>>> from unittest.mock import patch
>>> @patch.dict('os.environ', {'newkey': 'newvalue'})
... class TestSample(unittest.TestCase):
...     def test_sample(self):
...         self.assertEqual(os.environ['newkey'], 'newvalue')

>>> foo = {}
>>> with patch.dict(foo, {'newkey': 'newvalue'}) as patched_foo:
...     assert foo == {'newkey': 'newvalue'}
...     assert patched_foo == {'newkey': 'newvalue'}
...     # You can add, update or delete keys of foo (or patched_foo, it's the same dict)
...     patched_foo['spam'] = 'eggs'
...
>>> assert foo == {}
>>> assert patched_foo == {}

>>> import os
>>> with patch.dict('os.environ', {'newkey': 'newvalue'}):
...     print(os.environ['newkey'])
...
newvalue
>>> assert 'newkey' not in os.environ

>>> mymodule = MagicMock()
>>> mymodule.function.return_value = 'fish'
>>> with patch.dict('sys.modules', mymodule=mymodule):
...     import mymodule
...     mymodule.function('some', 'args')
...
'fish'

>>> class Container:
...     def __init__(self):
...         self.values = {}
...     def __getitem__(self, name):
...         return self.values[name]
...     def __setitem__(self, name, value):
...         self.values[name] = value
...     def __delitem__(self, name):
...         del self.values[name]
...     def __iter__(self):
...         return iter(self.values)
...
>>> thing = Container()
>>> thing['one'] = 1
>>> with patch.dict(thing, one=2, two=3):
...     assert thing['one'] == 2
...     assert thing['two'] == 3
...
>>> assert thing['one'] == 1
>>> assert list(thing) == ['one']

>>> thing = object()
>>> other = object()

>>> @patch.multiple('__main__', thing=DEFAULT, other=DEFAULT)
... def test_function(thing, other):
...     assert isinstance(thing, MagicMock)
...     assert isinstance(other, MagicMock)
...
>>> test_function()

>>> @patch('sys.exit')
... @patch.multiple('__main__', thing=DEFAULT, other=DEFAULT)
... def test_function(mock_exit, other, thing):
...     assert 'other' in repr(other)
...     assert 'thing' in repr(thing)
...     assert 'exit' in repr(mock_exit)
...
>>> test_function()

>>> with patch.multiple('__main__', thing=DEFAULT, other=DEFAULT) as values:
...     assert 'other' in repr(values['other'])
...     assert 'thing' in repr(values['thing'])
...     assert values['thing'] is thing
...     assert values['other'] is other
...

>>> patcher = patch('package.module.ClassName')
>>> from package import module
>>> original = module.ClassName
>>> new_mock = patcher.start()
>>> assert module.ClassName is not original
>>> assert module.ClassName is new_mock
>>> patcher.stop()
>>> assert module.ClassName is original
>>> assert module.ClassName is not new_mock

>>> class MyTest(unittest.TestCase):
...     def setUp(self):
...         self.patcher1 = patch('package.module.Class1')
...         self.patcher2 = patch('package.module.Class2')
...         self.MockClass1 = self.patcher1.start()
...         self.MockClass2 = self.patcher2.start()
...
...     def tearDown(self):
...         self.patcher1.stop()
...         self.patcher2.stop()
...
...     def test_something(self):
...         assert package.module.Class1 is self.MockClass1
...         assert package.module.Class2 is self.MockClass2
...
>>> MyTest('test_something').run()

>>> class MyTest(unittest.TestCase):
...     def setUp(self):
...         patcher = patch('package.module.Class')
...         self.MockClass = patcher.start()
...         self.addCleanup(patcher.stop)
...
...     def test_something(self):
...         assert package.module.Class is self.MockClass
...

>>> @patch('__main__.ord')
... def test(mock_ord):
...     mock_ord.return_value = 101
...     print(ord('c'))
...
>>> test()
101

>>> patch.TEST_PREFIX = 'foo'
>>> value = 3
>>>
>>> @patch('__main__.value', 'not three')
... class Thing:
...     def foo_one(self):
...         print(value)
...     def foo_two(self):
...         print(value)
...
>>>
>>> Thing().foo_one()
not three
>>> Thing().foo_two()
not three
>>> value
3

>>> @patch.object(SomeClass, 'class_method')
... @patch.object(SomeClass, 'static_method')
... def test(mock1, mock2):
...     assert SomeClass.static_method is mock1
...     assert SomeClass.class_method is mock2
...     SomeClass.static_method('foo')
...     SomeClass.class_method('bar')
...     return mock1, mock2
...
>>> mock1, mock2 = test()
>>> mock1.assert_called_once_with('foo')
>>> mock2.assert_called_once_with('bar')

a.py
    -> Defines SomeClass

b.py
    -> from a import SomeClass
    -> some_function instantiates SomeClass

@patch('b.SomeClass')

@patch('a.SomeClass')

MagicMock 與魔術(shù)方法支持?

>>> def __str__(self):
...     return 'fooble'
...
>>> mock = Mock()
>>> mock.__str__ = __str__
>>> str(mock)
'fooble'

>>> mock = Mock()
>>> mock.__str__ = Mock()
>>> mock.__str__.return_value = 'fooble'
>>> str(mock)
'fooble'

>>> mock = Mock()
>>> mock.__iter__ = Mock(return_value=iter([]))
>>> list(mock)
[]

>>> mock = Mock()
>>> mock.__enter__ = Mock(return_value='foo')
>>> mock.__exit__ = Mock(return_value=False)
>>> with mock as m:
...     assert m == 'foo'
...
>>> mock.__enter__.assert_called_with()
>>> mock.__exit__.assert_called_with(None, None, None)

>>> mock = MagicMock()
>>> mock[3] = 'fish'
>>> mock.__setitem__.assert_called_with(3, 'fish')
>>> mock.__getitem__.return_value = 'result'
>>> mock[2]
'result'

>>> mock = MagicMock()
>>> int(mock)
1
>>> len(mock)
0
>>> list(mock)
[]
>>> object() in mock
False

>>> MagicMock() == 3
False
>>> MagicMock() != 3
True
>>> mock = MagicMock()
>>> mock.__eq__.return_value = True
>>> mock == 3
True

>>> mock = MagicMock()
>>> mock.__iter__.return_value = ['a', 'b', 'c']
>>> list(mock)
['a', 'b', 'c']
>>> list(mock)
['a', 'b', 'c']

>>> mock.__iter__.return_value = iter(['a', 'b', 'c'])
>>> list(mock)
['a', 'b', 'c']
>>> list(mock)
[]

輔助對象?

>>> real = ProductionClass()
>>> real.method = Mock(name="method")
>>> real.method.return_value = sentinel.some_object
>>> result = real.method()
>>> assert result is sentinel.some_object
>>> result
sentinel.some_object

>>> m = MagicMock()
>>> m(1).method(arg='foo').other('bar')(2.0)
<MagicMock name='mock().method().other()()' id='...'>
>>> kall = call(1).method(arg='foo').other('bar')(2.0)
>>> kall.call_list()
[call(1),
 call().method(arg='foo'),
 call().method().other('bar'),
 call().method().other()(2.0)]
>>> m.mock_calls == kall.call_list()
True

>>> m = MagicMock(return_value=None)
>>> m(1, 2, 3, arg='one', arg2='two')
>>> kall = m.call_args
>>> kall.args
(1, 2, 3)
>>> kall.kwargs
{'arg': 'one', 'arg2': 'two'}
>>> kall.args is kall[0]
True
>>> kall.kwargs is kall[1]
True

>>> m = MagicMock()
>>> m.foo(4, 5, 6, arg='two', arg2='three')
<MagicMock name='mock.foo()' id='...'>
>>> kall = m.mock_calls[0]
>>> name, args, kwargs = kall
>>> name
'foo'
>>> args
(4, 5, 6)
>>> kwargs
{'arg': 'two', 'arg2': 'three'}
>>> name is m.mock_calls[0][0]
True