Mock是Python中一個用于支持單元測驗的庫，它的主要功能是使用mock物件替代掉指定的Python物件，以達到模擬物件的行為，
python3.3 以前，mock是第三方庫，需要安裝之后才能使用，python3.3之后，mock作為標準庫內置到 unittest，
unittest是Python標準庫中自帶的單元測驗框架，unittest有時候也被稱為PyUnit，就像JUnit是Java語言的標準單元測驗框架一樣，unittest則是Python語言的標準單元測驗框架，
unittest是一個單元測驗的框架,能夠提供很多測驗相關的功能，如：撰寫測驗用例，準備測驗環境，生成測驗報告等，unittest 中集成了mock，可以用來模擬一些函式回傳，未實作的介面等，
unittest匯入mock物件：
from Unittest import mock
pytest是基于unittest衍生出來的新的測驗框架，使用起來相對于unittest來說更簡單、效率來說更高，pytest兼容unittest測驗用例，但是反過來unittest不兼容pytest，
pytest也是一個測驗框架，公認的比Unittest更加簡單和高效，pytest中也有mock方法就是pytest-mock，pytest-mock是一個pytest插件，和 Unittest 中的mock使用接近，大多數方法的定義都是一致的，
對比
因為unittest集成了mock，而且python3.0使用更加廣泛，所以以unittest中的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 的定義：
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
三種使用方法對比
patch的最佳實踐
patch有三種使用方法，最佳的使用實踐是裝飾器形態，
手動指定方法需要start和stop控制，過于繁瑣，雖然存在一個stopall的方法，但是仍然要逐個start
with寫法的缺點很明顯，一次不可以mock多個目標，多個with層層縮進很明顯不可能，
最佳實踐：裝飾器方法可以方便的mock多個物件，只需要熟悉裝飾的順序和函式引數的對應關系，patch中可以return_value和new都可以改變結果，推薦patch中使用new屬性，Mock中使用return_value.
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多個物件
定義：
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(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()將其撤消，
如果您正在使用patch()為您創建模擬，則呼叫patche.start將回傳該模擬，
如果是用使用mock.patch的方法，需要用start開始模擬，stop停止模擬，
MagicMock是Mock的一個子類，具有大多數魔法方法的默認實作，在mock.patch中new引數如果沒寫，默認創建的是MagicMock，
>>> from unittest import mock
>>>
>>> a = mock.MagicMock()
>>>
>>> int(a)
1
>>> len(a)
0
>>> str(a)
"<MagicMock id='139819504851824'>"
魔法方法：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是一個測驗的框架，能夠提供測驗場景中的多種功能，這里不討論別的功能，只說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 存根
在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簡介:
在所有情況下，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 可以跟蹤和測驗物件的互動，使用在回呼函式中十分有效，
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來完成模擬，
最后： 可以關注公眾號：傷心的辣條 ！ 進去有許多資料共享！資料都是面試時面試官必問的知識點，也包括了很多測驗行業常見知識，其中包括了有基礎知識、Linux必備、Shell、互聯網程式原理、Mysql資料庫、抓包工具專題、介面測驗工具、測驗進階-Python編程、Web自動化測驗、APP自動化測驗、介面自動化測驗、測驗高級持續集成、測驗架構開發測驗框架、性能測驗、安全測驗等，
如果我的博客對你有幫助、如果你喜歡我的博客內容，請 “點贊” “評論” “收藏” 一鍵三連哦！推薦軟體測驗交流學習群：914172719 里面會分享一些資深架構師錄制的視頻錄像
好文推薦
轉行面試，跳槽面試，軟體測驗人員都必須知道的這幾種面試技巧！
面試經：一線城市搬磚！又面軟體測驗崗，5000就知足了…
面試官：作業三年，還來面初級測驗？恐怕你的軟體測驗工程師的頭銜要加雙引號…
什么樣的人適合從事軟體測驗作業？
那個準點下班的人，比我先升職了…
測驗崗反復跳槽，跳著跳著就跳沒了…
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/300427.html
標籤：其他