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对象是模拟的基石，提供了丰富多彩的功能。从测试的阶段来分类包括：

构造器：创建mock对象
断言方法：判断代码运行的状态
管理方法：管理mock对象
统计方法：统计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对象，对象中的方法有两种设置途径：

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

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

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

特有属性：

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

小结：

mocker兼容mock的功能，但是对于mock.patch的装饰器用法和上下文用法是不支持的。

如果是使用pytest的框架，如pytest-django，或者pytest-flask等，推荐使用mocker来完成模拟。

秒客网

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

单元测试库介绍

mock

unittest：

pytest：

unitest 中 Mock

mock.Mock

基础使用

return_value

side_effect

return_value 和 side_effect 同时存在

name

wraps

spec

spec_set

mock.Mock的不足之处

mock.patch

直接使用

new

new_callable

new和new_callable不可共存

装饰器@mock.patch

with 上下文管理器

三种使用方法对比

patch的最佳实践

mock.patch.object

mock.multiple

patch.dict

start和stop

Magic Mock

magic 方法：

pytest

mock使用

spy

stub

小结：

相关文章