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就知足了…
面试官：工作三年，还来面初级测试？恐怕你的软件测试工程师的头衔要加双引号…
什么样的人适合从事软件测试工作？
那个准点下班的人，比我先升职了…
测试岗反复跳槽，跳着跳着就跳没了…
