新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案

創(chuàng)新互聯(lián)Python教程：unittest.mock —- 模擬對象庫

unittest.mock —- 模擬對象庫

3.3 新版功能.

成都創(chuàng)新互聯(lián)主要從事成都網(wǎng)站設(shè)計(jì)、網(wǎng)站制作、網(wǎng)頁設(shè)計(jì)、企業(yè)做網(wǎng)站、公司建網(wǎng)站等業(yè)務(wù)。立足成都服務(wù)葉城,十余年網(wǎng)站建設(shè)經(jīng)驗(yàn),價(jià)格優(yōu)惠、服務(wù)專業(yè),歡迎來電咨詢建站服務(wù):13518219792

源代碼： Lib/unittest/mock.py

unittest.mock 是一個(gè)用于測試的python庫。它允許使用模擬對象來替換受測系統(tǒng)的一些部分，并對這些部分如何被使用進(jìn)行斷言判斷。

unittest.mock 提供的 Mock 類，能在整個(gè)測試套件中模擬大量的方法。創(chuàng)建后，就可以斷言調(diào)用了哪些方法/屬性及其參數(shù)。還可以以常規(guī)方式指定返回值并設(shè)置所需的屬性。

此外，mock 還提供了用于修補(bǔ)測試范圍內(nèi)模塊和類級別屬性的 patch() 裝飾器，和用于創(chuàng)建獨(dú)特對象的 sentinel 。閱讀 quick guide 中的案例了解如何使用 Mock ，MagicMock 和 patch() 。

mock 被設(shè)計(jì)為配合 unittest 使用且它是基于 ‘a(chǎn)ction -> assertion’ 模式而非許多模擬框架所使用的 ‘record -> replay’ 模式。

在 Python 的早期版本要單獨(dú)使用 unittest.mock ，在 PyPI 獲取 mock 。

快速上手

當(dāng)您訪問對象時(shí)， Mock 和 MagicMock 將創(chuàng)建所有屬性和方法，并保存他們在使用時(shí)的細(xì)節(jié)。你可以通過配置，指定返回值或者限制可訪問屬性，然后斷言他們?nèi)绾伪徽{(diào)用：

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

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

 
 
 
   
  
  
  >>> 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 還可以通過其他方法配置和控制其行為。例如 mock 可以通過設(shè)置 spec 參數(shù)來從一個(gè)對象中獲取其規(guī)格(specification)。如果訪問 mock 的屬性或方法不在 spec 中，會(huì)報(bào) AttributeError 錯(cuò)誤。

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

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

備注

當(dāng)你嵌套 patch 裝飾器時(shí)，mock 將以執(zhí)行順序傳遞給裝飾器函數(shù)（Python 裝飾器正常順序）。由于從下至上，因此在上面的示例中，首先 mock 傳入的 module.ClassName1 。

在查找對象的名稱空間中修補(bǔ)對象使用 patch() 。使用起來很簡單，閱讀在哪里打補(bǔ)丁來快速上手。

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

 
 
 
   
  
  
  >>> 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() 用于在一定范圍內(nèi)設(shè)置字典中的值，并在測試結(jié)束時(shí)將字典恢復(fù)為其原始狀態(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ù)方法。使用模式方法最簡單的方式是使用 MagicMock class. 。它可以做如下事情：

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

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

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

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

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

這么做是為了因確保不當(dāng)?shù)厥褂?mock 導(dǎo)致與生產(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: () takes exactly 3 arguments (1 given)

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

Mock 類

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

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

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

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 對象。通過可選參數(shù)指定 Mock 對象的行為：

spec: 可以是要給字符串列表，也可以是充當(dāng)模擬對象規(guī)范的現(xiàn)有對象（類或?qū)嵗Ｈ绻麄魅胍粋€(gè)對象，則通過在該對象上調(diào)用 dir 來生成字符串列表（不支持的魔法屬性和方法除外）。訪問不在此列表中的任何屬性都將觸發(fā) AttributeError 。
如果 spec 是一個(gè)對象（而不是字符串列表），則 __class__ 返回 spec 對象的類。這允許模擬程序通過 isinstance() 測試。
spec_set ：spec 的更嚴(yán)格的變體。如果使用了該屬性，嘗試模擬 set 或 get 的屬性不在 spec_set 所包含的對象中時(shí)，會(huì)拋出 AttributeError 。
side_effect ：每當(dāng)調(diào)用 Mock 時(shí)都會(huì)調(diào)用的函數(shù)。參見 side_effect 屬性。對于引發(fā)異常或動(dòng)態(tài)更改返回值很有用。該函數(shù)使用與 mock 函數(shù)相同的參數(shù)調(diào)用，并且除非返回 DEFAULT ，否則該函數(shù)的返回值將用作返回值。
另外， side_effect 可以是異常類或?qū)嵗?此時(shí)，調(diào)用模擬程序時(shí)將引發(fā)異常。
如果 side_effect 是可迭代對象，則每次調(diào)用 mock 都將返回可迭代對象的下一個(gè)值。
設(shè)置 side_effect 為 None 即可清空。
return_value ：調(diào)用 mock 的返回值。默認(rèn)情況下，是一個(gè)新的Mock（在首次訪問時(shí)創(chuàng)建）。參見 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 ，那么調(diào)用 Mock 會(huì)將調(diào)用傳遞給 wraps 的對象（返回實(shí)際結(jié)果）。對模擬的屬性訪問將返回一個(gè) Mock 對象，該對象包裝了 wraps 對象的相應(yīng)屬性（因此，嘗試訪問不存在的屬性將引發(fā) AttributeError ）。
如果明確指定 return_value ，則調(diào)用時(shí)不會(huì)返回包裝對象，而是返回 return_value 。
name ：mock 的名稱。在調(diào)試時(shí)很有用。名稱會(huì)傳遞到子 mock 。

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

assert_called()

斷言 mock 已被調(diào)用至少一次。

   
   
   
       
    
    
    >>> mock = Mock()    
    
    
    >>> mock.method()    
    
    
        
    
    
    >>> mock.method.assert_called()

3.6 新版功能.

assert_called_once()

斷言 mock 已被調(diào)用恰好一次。

   
   
   
       
    
    
    >>> mock = Mock()    
    
    
    >>> mock.method()    
    
    
        
    
    
    >>> mock.method.assert_called_once()    
    
    
    >>> mock.method()    
    
    
        
    
    
    >>> 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*)

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

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

assert_called_once_with(\args,**kwargs*)

斷言 mock 已被調(diào)用恰好一次，并且向該調(diào)用傳入了指定的參數(shù)。

   
   
   
       
    
    
    >>> 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 已被調(diào)用并附帶了指定的參數(shù)。
如果 mock 曾經(jīng) 被調(diào)用過則斷言通過，不同于 assert_called_with() 和 assert_called_once_with() 那樣只有在調(diào)用是最近的一次時(shí)才會(huì)通過，而對于 assert_called_once_with() 則它還必須是唯一的一次調(diào)用。
```
   
   
   
       
    
    
    >>> 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 已附帶指定的參數(shù)被調(diào)用。將針對這些調(diào)用檢查 mock_calls 列表。

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

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

   
   
   
       
    
    
    >>> 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 從未被調(diào)用過。

   
   
   
       
    
    
    >>> 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 對象上重圍所有的調(diào)用屬性:
```
   
   
   
       
    
    
    >>> mock = Mock(return_value=None)    
    
    
    >>> mock('hello')    
    
    
    >>> mock.called    
    
    
    True    
    
    
    >>> mock.reset_mock()    
    
    
    >>> mock.called    
    
    
    False   
   
   
 
```
在 3.6 版更改: 向 reset_mock 函數(shù)添加了兩個(gè)僅限關(guān)鍵字參數(shù)。
這在你想要?jiǎng)?chuàng)建一系列重用相同對象的斷言時(shí)會(huì)很有用處。請注意 reset_mock() 不會(huì) 清除返回值、side_effect 或任何你使用普通賦值所默認(rèn)設(shè)置的子屬性。如果你想要重置 return_value 或 side_effect，則要為相應(yīng)的形參傳入 True。子 mock 和返回值 mock (如果有的話) 也會(huì)被重置。
備注
return_value 和 side_effect 均為僅限關(guān)鍵字參數(shù)。
mock_add_spec(spec, spec_set=False)
為 mock 添加描述。 spec 可以是一個(gè)對象或字符串列表。只有 spec 上的屬性可以作為來自 mock 的屬性被獲取。
如果 spec_set 為真值則只有 spec 上的屬性可以被設(shè)置。
attach_mock(mock, attribute)
附加一個(gè) mock 作為這一個(gè)的屬性，替換它的名稱和上級。對附加 mock 的調(diào)用將記錄在這一個(gè)的 method_calls 和 mock_calls 屬性中。

configure_mock(\*kwargs*)

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

屬性加返回值和附帶影響可以使用標(biāo)準(zhǔn)點(diǎn)號標(biāo)記在子 mock 上設(shè)置并在方法調(diào)用中解包一個(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 的構(gòu)造器調(diào)用中達(dá)成:

   
   
   
       
    
    
    >>> 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) 的結(jié)果限制為有用結(jié)果。對于帶有 spec 的 mock 這還包括 mock 的所有被允許的屬性。
請查看 FILTER_DIR 了解此過濾做了什么，以及如何停用它。
_get_child_mock(\*kw*)
創(chuàng)建針對屬性和返回值的子 mock。默認(rèn)情況下子 mock 將為與其上級相同的類型。 Mock 的子類可能需要重載它來定制子 mock 的創(chuàng)建方式。
對于非可調(diào)用的 mock 將會(huì)使用可調(diào)用的變化形式（而非不是任意的自定義子類）。

called

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

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

call_count

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

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

return_value

設(shè)置這個(gè)來配置通過調(diào)用該 mock 所返回的值:

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

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

   
   
   
       
    
    
    >>> mock = Mock()    
    
    
    >>> mock.return_value.attribute = sentinel.Attribute    
    
    
    >>> mock.return_value()    
    
    
        
    
    
    >>> mock.return_value.assert_called_with()

return_value 也可以在構(gòu)造器中設(shè)置:

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

side_effect

這可以是當(dāng)該This can either be a function to be called when the mock 被調(diào)用時(shí)將被調(diào)用的一個(gè)函數(shù)，可調(diào)用對象或者要被引發(fā)的異常（類或?qū)嵗?/p>

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

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

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

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

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

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

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

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

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

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

將 side_effect 設(shè)為 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 沒有被調(diào)用)，或是 mock 最近一次被調(diào)用時(shí)附帶的參數(shù)。這將采用元組的形式：第一個(gè)成員也可以通過 args 特征屬性來訪問，它是 mock 被調(diào)用時(shí)所附帶的任何位置參數(shù) (或?yàn)榭赵M)，而第二個(gè)成員也可以通過 kwargs 特征屬性來訪問，它則是任何關(guān)鍵字參數(shù) (或?yà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 對象。這些對象屬性元組，因此它們可被解包以獲得單獨(dú)的參數(shù)并創(chuàng)建更復(fù)雜的斷言。參見作為元組的 call。

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

call_args_list

這是一個(gè)已排序的對 mock 對象的所有調(diào)用的列表（因此該列表的長度就是它已被調(diào)用的次數(shù)）。在執(zhí)行任何調(diào)用之前它將是一個(gè)空列表。 call 對象可以被用來方便地構(gòu)造調(diào)用列表以與 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è)參數(shù)。參見作為元組的 call。

method_calls

除了會(huì)追蹤對其自身的調(diào)用，mock 還會(huì)追蹤對方法和屬性，以及 它們的 方法和屬性的訪問:

   
   
   
       
    
    
    >>> mock = Mock()    
    
    
    >>> mock.method()    
    
    
        
    
    
    >>> mock.property.method.attribute()    
    
    
        
    
    
    >>> mock.method_calls    
    
    
    [call.method(), call.property.method.attribute()]

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

mock_calls

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

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

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

備注

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

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

__class__

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

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

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

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

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

不可調(diào)用的 Mock 版本。其構(gòu)造器的形參具有與 Mock 相同的含義，區(qū)別在于 return_value 和 side_effect 在不可調(diào)用的 mock 上沒有意義。

使用類或?qū)嵗鳛?spec 或 spec_set 的 mock 對象能夠跳過 isinstance() 測試:

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

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

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

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

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

 
 
 
   
  
  
  >>> 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)建的可調(diào)用 mock 將在匹配調(diào)用與 mock 時(shí)內(nèi)省規(guī)格說明對象的簽名。因此，它可以匹配實(shí)際調(diào)用的參數(shù)而不必關(guān)心它們是按位置還是按名稱傳入的:

 
 
 
   
  
  
  >>> def f(a, b, c): pass  
  
  
  ...  
  
  
  >>> mock = Mock(spec=f)  
  
  
  >>> mock(1, 2, c=3)  
  
  
    
  
  
  >>> mock.assert_called_with(1, 2, 3)  
  
  
  >>> mock.assert_called_with(a=1, b=2, c=3
                                                網(wǎng)頁標(biāo)題：創(chuàng)新互聯(lián)Python教程：unittest.mock —- 模擬對象庫                                                

                                                分享地址：http://www.5511xx.com/article/dpcgsjo.html


                                            
                                                
                                                    其他資訊
                                                
                                                
                                                    
                                                        
                                                                程序包怎么上傳
                                                            

                                                                C#工作流引擎的理解解析
                                                            

                                                                優(yōu)化Redis性能精妙的配置之道（redis配置性能優(yōu)化）
                                                            

                                                                你有一張HUAWEI CONNECT門票尚未領(lǐng)??！
                                                            

                                                                cdn緩存清理是什么（cdn的緩存怎么穿透）