頭號玩家 模擬世界

單元測試庫介紹

mock

Mock是Python中一個用於支援單元測試的庫，它的主要功能是使用mock物件替代掉指定的Python物件，以達到模擬物件的行為。

python3.3 以前，mock是第三方庫，需要安裝之後才能使用。python3.3之後，mock作為標準庫內建到 unittest。

unittest：

unittest是Python標準庫中自帶的單元測試框架，unittest有時候也被稱為PyUnit，就像JUnit是Java語言的標準單元測試框架一樣，unittest則是Python語言的標準單元測試框架。

unittest是一個單元測試的框架,能夠提供很多測試相關的功能，如：編寫測試用例，準備測試環境，生成測試報告等。unittest 中集成了mock，可以用來模擬一些函式返回，未實現的介面等。

unittest匯入mock物件：

from Unittest import mock

pytest：

pytest是基於unittest衍生出來的新的測試框架，使用起來相對於unittest來說更簡單、效率來說更高，pytest相容unittest測試用例，但是反過來unittest不相容pytest。

pytest也是一個測試框架，公認的比Unittest更加簡單和高效。pytest中也有mock方法就是pytest-mock，pytest-mock是一個pytest外掛，和 Unittest 中的mock使用接近，大多數方法的定義都是一致的。

對比

-	mock	unittest	pytest
型別	模組	框架	框架
功能	模擬物件行為	測試相關功能，功能包含mock	效率更高的框架，功能包含mock
效能	單一模擬功能	測試相關多種功能	測試相關多種功能，效率更高，更簡單

unitest 中 Mock

因為unittest集成了mock，而且python3.0使用更加廣泛，所以以unittest中的mock為例介紹mock功能。

mock模組主要的函式如下：

mock.Mock

Mock物件是模擬的基石，提供了豐富多彩的功能。從測試的階段來分類包括：

1. 構造器：建立mock物件
2. 斷言方法：判斷程式碼執行的狀態
3. 管理方法：管理mock物件
4. 統計方法：統計mock物件的呼叫

定義：

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

Mock是一個類，類中有很多屬性和方法，這些屬性和方法可以通過引數傳遞進入，也可以通過例項設定。

重要的引數：

return_value ：呼叫mock的返回值，模擬某一個方法的返回值。

side_effect ：呼叫mock時的返回值，可以是函式，異常類，可迭代物件。使用side_effect可以將模擬物件的返回值變成函式，異常類，可迭代物件等。

當設定了該方法時，如果該方法返回值是DEFAULT，那麼返回return_value的值，如果不是，則返回該方法的值。 return_value 和 side_effect 同時存在，side_effect會返回。

如果 side_effect 是異常類或例項時，呼叫模擬程式時將引發異常。

如果 side_effect 是可迭代物件，則每次呼叫 mock 都將返回可迭代物件的下一個值。

name ：mock 的名稱。 這個是用來命名一個mock物件，只是起到標識作用，當你print一個mock物件的時候，可以看到它的name。

wraps: 裝飾器：模擬物件要裝飾的專案。

如果wrapps不是None，那麼呼叫Mock將把呼叫傳遞給wrapped物件（返回實際結果）。

對mock的屬性訪問將返回一個mock物件，該物件裝飾了包裝物件的相應屬性。

spec_set：更加嚴格的要求，spec_set=True時，如果訪問mock不存在屬性或方法會報錯

spec: 引數可以把一個物件設定為 Mock 物件的屬性。訪問mock物件上不存在的屬性或方法時，將會丟擲屬性錯誤。

基礎使用

使用mock.Mock()可以建立一個mock物件，物件中的方法有兩種設定途徑：

1. 作為Mock類的引數傳入。
   
   mock.Mock(return_value=20,side_effect=mock_fun, name='mock_sum')

2. 例項化mock物件之後設定屬性。

   mock_sum = mock.Mock()
   
   mock_sum.return_value = 20
   
   mock_sum.side_effect = mock_fun
   
   

return_value

return_value 用於設定mock物件的返回值，可以是數值，字串等。

from unittest import mock

def get_sum(x, y):

    pass

if __name__ == '__main__':

    get_sum = mock.Mock(return_value=20)

    result = get_sum(100, 200)

    print(result)

>>>>>

20

from unittest import mock

def get_sum(x, y):

    pass

if __name__ == '__main__':

    get_sum = mock.Mock()

    get_sum.return_value = 20

    result = get_sum()

    print(result)

>>>

20

side_effect

side_effect 用於返回一個函式，可迭代物件，異常類等。

該函式的返回值就是呼叫 Mock 物件的返回值：

from unittest import mock

def get_sum(x, y):

    pass

def mock_fun():

    return 30

if __name__ == '__main__':

    a = 100

    b = 200

    get_sum = mock.Mock(side_effect=mock_fun)

    result = get_sum()

    print(result)

>>>

30

from unittest import mock

def get_sum(x, y):

    pass

def mock_fun():

    return 30

if __name__ == '__main__':

    get_sum = mock.Mock()

    get_sum.side_effect = mock_fun

    result = get_sum()

    print(result)

>>>>

30

return_value 和 side_effect 同時存在

當 return_value 和 side_effect 同時設定時，會返回side_effect的結果。

from unittest import mock

def get_sum(x, y):

    pass

def mock_fun():

    return 30

if __name__ == '__main__':

    a = 100

    b = 200

    get_sum = mock.Mock(return_value=20, side_effect=mock_fun)

    result = get_sum()

    print(result)

>>>

30

from unittest import mock

def get_sum(x, y):

    pass

def mock_fun():

    return 30

if __name__ == '__main__':

    a = 100

    b = 200

    get_sum = mock.Mock()

    get_sum.return_value = 20

    get_sum.side_effect = mock_fun

    result = get_sum()

    print(result)

side_effect除了上述的常規使用方法外，還可以用在一些複雜的測試場景下：

可迭代物件

可以將 side_effect 設定為可迭代物件。對於 Mock 物件將要被呼叫多次，並且每次呼叫需要返回不同的值的情形，可以將 side_effect 指定為一個可迭代物件。每次呼叫 Mock 物件將返回可迭代物件的下一個值。

動態返回值

對於更復雜的使用場景，比如根據呼叫 Mock 物件時傳遞的引數動態地更改返回值，可以將 side_effect 設定為函式。該函式將被使用與 Mock 物件相同的引數呼叫。

name

列印mock物件時，如果沒有設定名字會顯示mock的id，如果設定了name屬性會顯示name。

from unittest import mock

def get_sum(x, y):

    pass

if __name__ == '__main__':

    a = 100

    b = 200

    get_sum = mock.Mock()

    print(get_sum)

    get_sum = mock.Mock(name='get_sum')

    print(get_sum)

>>>>

<Mock id='139999033794288'>

<Mock name='get_sum' id='139999033794344'>

wraps

物件是裝飾器時的mock方法。

from unittest import mock

def get_sum(x, y):

    pass

def mock_fun():

    return 30

def wrap_fun():

    return mock_fun()

get_sum = mock.Mock(wraps=wrap_fun)

print(get_sum())

>>>

30

spec

引數可以把一個物件設定為 Mock 物件的屬性。訪問mock物件上不存在的屬性或方法時，將會丟擲屬性錯誤。

from unittest import mock

class SomeClass:

    def new_method(self):

        return 20

mock = mock.Mock(spec=SomeClass)

print(mock.new_method())

print(mock.old_method())

>>>>

<Mock name='mock.new_method()' id='4401569552'>

Traceback (most recent call last):

  File "mock_demo.py", line 57, in <module>

    print(mock.old_method())

  File "/Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/unittest/mock.py", line 637, in __getattr__

    raise AttributeError("Mock object has no attribute %r" % name)

AttributeError: Mock object has no attribute 'old_method'

spec_set

spec_set 嚴格限制mock物件的屬性訪問。如果訪問不存在的物件會報錯。

沒有設定spec_set，當訪問未定義屬性時不會報錯

from unittest import mock

def get_sum(x, y):

    pass

get_sum = mock.Mock()

get_sum.return_value = 100

print(get_sum())

print(get_sum.name)

>>>

ljk@work:~/Desktop$ python3 mock_fun1.py

100

<Mock name='mock.name' id='140556594167200'>

設定了spec_set，訪問未定義屬性會報錯

from unittest import mock

def get_sum(x, y):

    pass

get_sum = mock.Mock(spec_set=True)

get_sum.return_value = 100

print(get_sum())

print(get_sum.name)

>>>>

ljk@work:~/Desktop$ python3 mock_fun1.py

100

Traceback (most recent call last):

  File "mock_fun1.py", line 37, in <module>

    print(mock_demo.get_sum.name)

  File "/usr/lib/python3.7/unittest/mock.py", line 590, in __getattr__

    raise AttributeError("Mock object has no attribute %r" % name)

AttributeError: Mock object has no attribute 'name'

mock.Mock的不足之處

Mock方法是最基礎的方法，在使用的使用需要例項化一個物件，設定方法，然後完成模擬。這裡有一個問題：沒有控制mock範圍，控制不精細。

完成模擬之後之後，必須把它們復原。如果模擬物件在其它測試中持續存在，那麼會導致難以診斷的問題。

為此，mock中還提供了 mock.patch和mock.patch.object 等多個物件。mock.patch 是一種進階的使用方法，主要是方便函式和類的測試，有三種使用方法：

1. 函式修飾器
2. 類修飾器
3. 上下文管理器

使用patch或者patch.object的目的是為了控制mock的範圍。

patch：用於mock一個函式

patch.object：用於mock一個類

mock.patch

mock.patch 的定義：

unittest.mock.patch(target, new=DEFAULT, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)

說明：

Patch()充當函式修飾器、類修飾器或上下文管理器。在函式體或with語句中，使用patch中的new替換目標函式或方法。當function/with語句退出時，模擬程式被撤消。

引數：

target: 模擬物件的路徑，引數必須是一個str,格式為'package.module.ClassName'，

注意這裡的格式一定要寫對。如果物件和mock函式在同一個檔案中，路徑要加檔名

new: 模擬返回的結果，是一個具體的值，也可是函式。new屬性替換target，返回模擬的結果。

new_callable 模擬返回的結果，是一個可呼叫的物件，可以是函式。

spec: 與Mock物件的引數類似，用於設定mock物件屬性。

spec_set: 與Mock物件的引數類似，嚴格限制mock物件的屬性或方法的訪問。

autospec：替換mock物件中所有的屬性。可以替換物件所有屬性，但不包括動態建立的屬性。

autospec是一個更嚴格的規範。如果你設定了autospec=True，將會使用spec替換物件的屬性來建立一個mock物件。mock物件的所有屬性都會被spec相應的屬性替換。

被mock的方法和函式會檢查他們的屬性，如果呼叫它們沒有屬性會丟擲 TypeError。它們返回的例項也會是相同屬性的類。

create：允許訪問不存在屬性

預設情況下，patch()將無法替換不存在的屬性。如果你通過create=True，當替換的屬性不存在時，patch會建立一個屬性，並且當函式退出時會刪除掉屬性。這對於針對生產程式碼在執行時建立的屬性編寫測試非常有用。它在預設情況下是關閉的，因為它可能是危險的，開啟它後，您可以針對實際不存在的api編寫通過測試的程式碼

同時mock.patch也是mock的一個子類，所以可以用return_value 和 side_effect

直接使用

return_value

demo.py

def get_sum(x, y):

    pass

test_demo.py

import demo

from unittest import mock

def need_mock_fun():

    mock_get_sum = mock.patch('demo.get_sum', return_value=20)

    mock_get_sum.start()

    result = demo.get_sum()

    mock_get_sum.stop()

    print(result)

need_mock_fun()

side_effect

import demo

from unittest import mock

def need_mock_fun():

    mock_get_sum = mock.patch('demo.get_sum', side_effect=mock_fun)

    mock_get_sum.start()

    result = demo.get_sum()

    mock_get_sum.stop()

    print(result)

need_mock_fun()

import demo

from unittest import mock

def need_mock_fun():

    mock_get_sum = mock.patch('demo.get_sum', return_value=20, side_effect=mock_fun)

    mock_get_sum.start()

    result = demo.get_sum()

    mock_get_sum.stop()

    print(result)

need_mock_fun()

new

new 用來模擬返回結果

import demo

from unittest import mock

def need_mock_fun():

    mock_get_sum = mock.patch('demo.get_sum')

    mock_get_sum.new = 40

    mock_get_sum.start()

    result = demo.get_sum

    print(result)

    mock_get_sum.stop()

new 是用來返回結果，return_value 也是用來返回結果。但是兩者有不同之處。設定return_value時，呼叫模擬物件時使用函式的方法。如result = demo.get_sum()，而new是將整個函式模擬成一個返回值，需要使用result = demo.get_sum。如下使用函式呼叫的方式就會報錯。

def need_mock_fun():

    with mock.patch('demo.get_sum', new=40):

        result = demo.get_sum()

        print(result)

>>>>>

Traceback (most recent call last):

  File "mock_demo.py", line 37, in <module>

    need_mock_fun()

  File "/Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/unittest/mock.py", line 1348, in patched

    return func(*newargs, **newkeywargs)

  File "mock_demo.py", line 12, in need_mock_fun

    result = demo.get_sum()

TypeError: 'int' object is not callable

def need_mock_fun():

    mock_get_sum = mock.patch('demo.get_sum', new=40)

    mock_get_sum.start()

    result = demo.get_sum

    print(result)

    mock_get_sum.stop()

上面的使用方法常用於模擬一個變數的情況，對於模擬函式並不是合適。如果模擬函式，可以給new賦值一個函式。如下：

import demo

from unittest import mock

def mock_fun():

    return 30

def need_mock_fun():

    mock_get_sum = mock.patch('demo.get_sum', new=mock_fun)

    mock_get_sum.start()

    result = demo.get_sum()

    mock_get_sum.stop()

    print(result)

need_mock_fun()

>>>

30

new_callable

模擬返回的結果，必須是一個可呼叫的物件，可以是函式。

import demo

from unittest import mock

def mock_fun():

    return 30

def need_mock_fun():

    mock_get_sum = mock.patch('demo.get_sum')

    mock_get_sum.new_callable = mock_fun

    mock_get_sum.start()

    result = demo.get_sum

    print(result)

    mock_get_sum.stop()

>>>>

30

def need_mock_fun():

    mock_get_sum = mock.patch('demo.get_sum', new_callable=mock_fun)

    mock_get_sum.start()

    result = demo.get_sum

    print(result)

    mock_get_sum.stop()

>>>

30

new和new_callable不可共存

new 與 new_callable 不可以共同設定。

new是實際物件；new_callable是用於建立物件的可呼叫物件。兩者不能一起使用（您可以指定替換或函式來建立替換；同時使用兩者是錯誤的。）

def need_mock_fun():

    mock_get_sum = mock.patch('demo.get_sum', new=40, new_callable=mock_fun)

    # mock_get_sum.new_callable = mock_fun

    # mock_get_sum.new = 40

    mock_get_sum.start()

    # mock_get_sum.return_value = 20

    # mock_get_sum.side_effect = mock_fun

    result = demo.get_sum

    print(result)

    mock_get_sum.stop()

>>>>>>

vTraceback (most recent call last):

  File "mock_demo.py", line 38, in <module>

    need_mock_fun()

  File "mock_demo.py", line 26, in need_mock_fun

    mock_get_sum = mock.patch('demo.get_sum', new=40, new_callable=mock_fun)

  File "/Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/unittest/mock.py", line 1727, in patch

    return _patch(

  File "/Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/unittest/mock.py", line 1248, in __init__

    raise ValueError(

ValueError: Cannot use 'new' and 'new_callable' together

生效：

new > side_effect > return_value

new_callable > side_effect > return_value

def mock_fun():

    return 30

def mock_fun_two():

    return 50

def need_mock_fun():

    mock_get_sum = mock.patch('demo.get_sum')

    mock_get_sum.new_callable = mock_fun_two

    mock_get_sum.new = 40

    mock_get_sum.start()

    mock_get_sum.return_value = 20

    mock_get_sum.side_effect = mock_fun

    result = demo.get_sum

    print(result)

    mock_get_sum.stop()

>>>>

40

---

裝飾器@mock.patch

mock.patch可以作為裝飾器來裝飾一個測試函式

demo.py

def get_sum(x, y):

    pass

test_demo.py

from unittest import mock

import demo

@mock.patch('demo.get_sum')

def need_mock_fun(mock_get_sum):

    mock_get_sum.return_value = 20

    result = demo.get_sum()

    print(result)

need_mock_fun()

>>>>

20

from unittest import mock

import demo

def mock_fun():

    return 30

@mock.patch('demo.get_sum')

def need_mock_fun(mock_get_sum):

    mock_get_sum.side_effect = mock_fun

    result = demo.get_sum()

    print(result)

need_mock_fun()

>>>

30

from unittest import mock

import demo

def mock_fun():

    return 30

@mock.patch('demo.get_sum')

def need_mock_fun(mock_get_sum):

    mock_get_sum.return_value = 20

    mock_get_sum.side_effect = mock_fun

    result = demo.get_sum()

    print(result)

need_mock_fun()

>>>

30

with 上下文管理器

使用with將mock物件作用於上下文

demo.py

def get_sum(x, y):

    pass

new

demo.py

def get_sum(x, y):

    pass

import demo

from unittest import mock

def need_mock_fun():

    with mock.patch('demo.get_sum', new=40):

        result = demo.get_sum

        print(result)

>>>

40

new_callable

demo.py

def get_sum(x, y):

    pass

import demo

from unittest import mock

def mock_fun():

    return 30

def need_mock_fun():

    with mock.patch('demo.get_sum', new_callable=mock_fun) as mock_get_sum:

        result = demo.get_sum

        print(result)

need_mock_fun()

>>>

30

三種使用方法對比

-	手動指定	裝飾器	上下文管理器
優點	可以更精細控制mock的範圍	方便mock多個物件
不足之處	需要手動start和stop	裝飾器順序和函式引數相反容易混亂	一個with只能mock一個物件

patch的最佳實踐

patch有三種使用方法，最佳的使用實踐是裝飾器形態。

手動指定方法需要start和stop控制，過於繁瑣，雖然存在一個stopall的方法，但是仍然要逐個start

with寫法的缺點很明顯，一次不可以mock多個目標，多個with層層縮排很明顯不可能。

最佳實踐：裝飾器方法可以方便的mock多個物件，只需要熟悉裝飾的順序和函式引數的對應關係。patch中可以return_value和new都可以改變結果，推薦patch中使用new屬性，Mock中使用return_value.

---

mock.patch.object

mock.patch.object 定義如下：

patch.object(target, attribute, new=DEFAULT, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)

說明：

object()可以用作裝飾器、類裝飾器或上下文管理器。引數new, spec, create, spec set, autospec和new callable的含義與patch()相同。與patch()類似，patch.object()接受任意關鍵字引數，用於配置它建立的模擬物件。

使用場景：

僅僅需要mock一個類或模組中裡的method，而無需mock整個類或模組。 例如，在對當前模組的某個函式進行測試時，可以用patch.object。與patch不同的是在引數的寫法上，需要傳入路徑，mock物件，其他屬性。

import demo

from unittest import mock

def need_mock_fun():

    mock_get_sum = mock.patch.object(demo, 'get_sum', return_value=20)

    mock_get_sum.start()

    result = demo.get_sum()

    mock_get_sum.stop()

    print(result)

need_mock_fun()

import demo

from unittest import mock

def need_mock_fun():

    with mock.patch.object(demo, 'get_sum', return_value=20):

        result = demo.get_sum()

        print(result)

import demo

from unittest import mock

@mock.patch.object(demo, 'get_sum')

def need_mock_fun(mock_get_sum):

    mock_get_sum.return_value = 20

    result = demo.get_sum()

    print(result)

mock.multiple

用於一次mock多個物件

定義：

patch.multiple(target, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)

說明：

multiple（）可以用作裝飾器、類裝飾器或上下文管理器。引數spec、spec_set、create、autospec和new_callable與patch（）的含義相同

demo.py

def funa():

    pass

def funb():

    pass

from unittest import mock

import demo

with mock.patch.multiple(demo, funa = mock.DEFAULT, funb = mock.DEFAULT) as mock_multiple:

    print(mock_multiple.get('funa'))

    mock_multiple['funa'].return_value =100

    print(demo.funa())

    mock_multiple['funb'].return_value =200

    print(demo.funb())

>>>>

<MagicMock name='funa' id='140604333786840'>

100

200

@mock.patch.multiple(mock_demo, funa = mock.DEFAULT, funb = mock.DEFAULT)

def need_mock_fun(funa, funb):

    funa.return_value = 100

    print(demo.funa())

    funb.return_value = 200

    print(demo.funb())

>>>

100

200

該方法並不推薦使用，因為如果需要一次mock兩個物件完全可以用裝飾器@mock.path()的方式，比起該方法更加直觀和簡潔。

patch.dict

patch.dict() 用於在一個作用域中設定字典的值，當測試結束時，字典會被恢復到原始狀態。可以用作裝飾器、類裝飾器或上下文管理

定義：

patch.dict(in_dict, values=(), clear=False, **kwargs)

from unittest.mock import patch

foo = {'key': 'value'}

with patch.dict(foo, {'newkey': 'newvalue'}, clear=True):

    assert foo == {'newkey': 'newvalue'}

    print(foo)

print(foo)

>>>>

{'newkey': 'newvalue'}

{'key': 'value'}

start和stop

所有修補程式都有start（）和stop（）方法。這使得在安裝方法中進行修補變得更簡單，或者在不使用巢狀裝飾器或語句的情況下進行多個修補。然後可以呼叫start()將修補程式放置到位，呼叫stop()將其撤消。

如果您正在使用patch()為您建立模擬，則呼叫patche.start將返回該模擬。

如果是用使用mock.patch的方法，需要用start開始模擬，stop停止模擬。

Magic Mock

MagicMock是Mock的一個子類，具有大多數魔法方法的預設實現。在mock.patch中new引數如果沒寫，預設建立的是MagicMock。

>>> from unittest import mock

>>>

>>> a = mock.MagicMock()

>>>

>>> int(a)

1

>>> len(a)

0

>>> str(a)

"<MagicMock id='139819504851824'>"

magic 方法：

魔法方法：Python 中的類有一些特殊的方法。在python的類中，以兩個下畫線__開頭和結尾的方法如__new__，__init__ 。這些方法統稱“魔術方法”（Magic Method）。任意自定義類都會擁有魔法方法。

使用魔術方法可以實現運算子過載，如物件之間使用 == 做比較時，其實是物件中 __eq__ 實現的。魔法方法類似於物件預設提供的各種方法。

__new__	   建立類並返回這個類的例項

__init__   可理解為“建構函式”，在物件初始化的時候呼叫，使用傳入的引數初始化該例項

__del__	   可理解為“解構函式”，當一個物件進行垃圾回收時呼叫

__class__

__delattr__

__dict__

__dir__

__doc__

__eq__

__format__

__ge__

__getattribute__

__gt__

__hash__

__init_subclass__

__le__

__lt__

__module__

__ne__

__reduce__

__reduce_ex__

__repr__

__setattr__

__sizeof__

__str__

__subclasshook__

__weakref__

Magic Mock 的預設值：

Magic Mock 例項化之後就會有一些初始值，是一些屬性的實現。具體的預設值如下：

__lt__: NotImplemented

__gt__: NotImplemented

__le__: NotImplemented

__ge__: NotImplemented

__int__: 1

__contains__: False

__len__: 0

__iter__: iter([])

__exit__: False

__aexit__: False

__complex__: 1j

__float__: 1.0

__bool__: True

__index__: 1

__hash__: default hash for the mock

__str__: default str for the mock

__sizeof__: default sizeof for the mock

使用MagicMock和Mock的場景：

使用MagicMock：需要魔法方法的場景，如迭代

使用Mock：不需要魔法方法的場景可以用Mock

pytest

pytest是一個測試的框架，能夠提供測試場景中的多種功能。這裡不討論別的功能，只說mock。

pytest-mock是一個pytest的外掛，安裝即可使用。pytest-mock提供了一個mocker物件，在匯入pytest時預設匯入。

mocker 是對mock的一個相容，mock有的屬性和方法，mocker都有，而且還有自己特有的方法。

mocker對mock的相容：

mocker.patch

mocker.patch.object

mocker.patch.multiple

mocker.patch.dict

mocker.stopall

mocker.resetall

Mock

MagicMock

PropertyMock

ANY

DEFAULT (Version 1.4)

call (Version 1.1)

sentinel (Version 1.2)

mock_open

seal (Version 3.4)

特有屬性：

1. Type Annotations 型別註解
2. Spy 間諜
3. Stub 存根

mock使用

在pytest框架中使用的mock 是pytest-mock，這個模組需要獨立安裝。

pip install pytest-mock

pytest_demo.py

def test_mock_fun(mocker):

    mock_get_sum = mocker.patch('mock_demo.get_sum')

    mock_get_sum.return_value = 20

    print(mock_demo.get_sum())

執行：

pytest pytest_demo.py

>>>

============================================================== test session starts ==============================================================

platform linux -- Python 3.7.3, pytest-6.2.4, py-1.10.0, pluggy-0.13.1

rootdir: /home/ljk/Desktop

plugins: mock-3.6.1

collected 1 item                                                                                                                                

mock_fun1.py .                                                                                                                            [100%]

=============================================================== 1 passed in 0.02s ===============================================================

(work) ljk@work:~/Desktop$

spy

spy簡介:

在所有情況下，mocker.spy物件的行為都與原始方法完全相同，只是spy還跟蹤函式/方法呼叫、返回值和引發的異常。

import os

def test_spy_listdir(mocker):

    mock_listdir = mocker.spy(os, 'getcwd')

    os.getcwd()

    assert mock_listdir.called

pytest pytest_demo.py

>>>

============================================================== test session starts ==============================================================

platform linux -- Python 3.7.3, pytest-6.2.4, py-1.10.0, pluggy-0.13.1

rootdir: /home/ljk/Desktop

plugins: mock-3.6.1

collected 1 item                                                                                                                                

mock_fun1.py .                                                                                                                            [100%]

=============================================================== 1 passed in 0.02s ==============================================================

stub

存根是一個模擬物件，它接受任何引數，對測試呼叫非常有用。

stub可以模擬測試物件中的屬性，如可以模擬成測試物件中的變數，函式等。將stub例項傳入測試物件中，可以獲得測試物件內部執行的過程。所以：

Stub 可以跟蹤和測試物件的互動，使用在回撥函式中十分有效。

def foo(param):

    param('foo', 'bar')

def test_stub(mocker):

    # 模擬成foo中的一個函式

    stub = mocker.stub(name='on_something_stub')

    foo(stub)

    # 測試foo中這個函式的呼叫引數是否正確

    stub.assert_called_once_with('foo', 'bar')

在pytest框架中可以直接使用mock物件。

demo.py

def get_sum(x, y):

    pass

mock_demo.py

from unittest import mock

import demo

import pytest

def test_mock_fun():

    mock_get_sum = mock.patch('demo.get_sum', return_value = 20)

    print(demo.get_sum(1,2))

小結：

mocker相容mock的功能，但是對於mock.patch的裝飾器用法和上下文用法是不支援的。

如果是使用pytest的框架，如pytest-django，或者pytest-flask等，推薦使用mocker來完成模擬。