• 微信公众号:美女很有趣。 工作之余,放松一下,关注即送10G+美女照片!

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

开发技术 开发技术 8分钟前 1次浏览

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模块主要的函数如下:
utittest和pytest中mock的使用详细介绍

mock.Mock

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

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

utittest和pytest中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

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语句退出时,模拟程序被撤消。

utittest和pytest中mock的使用详细介绍
参数:
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)

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

特有属性:

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


程序员灯塔
转载请注明原文链接:utittest和pytest中mock的使用详细介绍
喜欢 (0)