头号玩家模拟世界

单元测试库介绍

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