utittest和pytest中mock的使用详细介绍

2021年09月15日 阅读数:5
这篇文章主要向大家介绍utittest和pytest中mock的使用详细介绍,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。


头号玩家 模拟世界python

单元测试库介绍

mock

Mock是Python中一个用于支持单元测试的库,它的主要功能是使用mock对象替代掉指定的Python对象,以达到模拟对象的行为。
python3.3 之前,mock是第三方库,须要安装以后才能使用。python3.3以后,mock做为标准库内置到 unittest。linux

unittest:

unittest是Python标准库中自带的单元测试框架,unittest有时候也被称为PyUnit,就像JUnit是Java语言的标准单元测试框架同样,unittest则是Python语言的标准单元测试框架。
unittest是一个单元测试的框架,可以提供不少测试相关的功能,如:编写测试用例,准备测试环境,生成测试报告等。unittest 中集成了mock,能够用来模拟一些函数返回,未实现的接口等。django

unittest导入mock对象:
from Unittest import mockflask

pytest:

pytest是基于unittest衍生出来的新的测试框架,使用起来相对于unittest来讲更简单、效率来讲更高,pytest兼容unittest测试用例,可是反过来unittest不兼容pytest。
pytest也是一个测试框架,公认的比Unittest更加简单和高效。pytest中也有mock方法就是pytest-mock,pytest-mock是一个pytest插件,和 Unittest 中的mock使用接近,大多数方法的定义都是一致的。api

对比session

- mock unittest pytest
类型 模块 框架 框架
功能 模拟对象行为 测试相关功能,功能包含mock 效率更高的框架,功能包含mock
性能 单一模拟功能 测试相关多种功能 测试相关多种功能,效率更高,更简单

unitest 中 Mock

由于unittest集成了mock,并且python3.0使用更加普遍,因此以unittest中的mock为例介绍mock功能。
mock模块主要的函数以下:
app

mock.Mock

Mock对象是模拟的基石,提供了丰富多彩的功能。从测试的阶段来分类包括:框架

  1. 构造器:建立mock对象
  2. 断言方法:判断代码运行的状态
  3. 管理方法:管理mock对象
  4. 统计方法:统计mock对象的调用

定义:ssh

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

Mock是一个类,类中有不少属性和方法,这些属性和方法能够经过参数传递进入,也能够经过实例设置。ide

重要的参数:

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_valueside_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来完成模拟。