utittest和pytest中mock的使用詳細介紹
頭號玩家 模擬世界
單元測試庫介紹
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對象是模擬的基石，提供了豐富多彩的功能。從測試的階段來分類包括：
- 構造器：創建mock對象
- 斷言方法：判斷程式碼運行的狀態
- 管理方法：管理mock對象
- 統計方法：統計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對象，對象中的方法有兩種設置途徑：
-
作為Mock類的參數傳入。
mock.Mock(return_value=20,side_effect=mock_fun, name='mock_sum') -
實例化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 是一種進階的使用方法，主要是方便函數和類的測試，有三種使用方法：
- 函數修飾器
- 類修飾器
- 上下文管理器
使用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)
特有屬性：
- Type Annotations 類型註解
- Spy 間諜
- 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來完成模擬。
