Python——单元测试中mock原理和使用
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python——单元测试中mock原理和使用相关的知识，希望对你有一定的参考价值。
摘要
mock主要是的为了提供开发程序员的做一个的单元测试而使用的。假设你开发一个项目，里面包含了一个登录模块，登录模块需要调用身份证验证模块中的认证函数，该认证函数会进行值的返回，然后系统根据这个返回值来做判断是否能进行登录。但是身份证验证模块中的认证函数只有在正式上线的系统上才提供。公司内部的测试环境或者开发环境上不提供。如果此时需要进行登录模块的业务测试或接口测试。
测试方案一：搭建真实测试环境
搭建一个真实的测试环境器，在测试的时候，让认证函数和这个测试服务器交互，返回值给登录模块；
缺点：
1、测试服务器可能不好搭建，或者搭建效率很低；
2、搭建的测试服务器可能无法返回所有可能的值，或者需要大量的工作才能达到这个目的。
3、有可能真实的测试环境构建不了，又或者是测试的代价太大。
测试方案二：使用mock模拟
Mock是Python中一个用于支持单元测试的库，它的主要功能是使用mock对象替代掉指定的Python对象，以达到模拟对象的行为。python3.3 以前，mock是第三方库，需要安装之后才能使用。python3.3之后，mock作为标准库内置到 unittest。
因为unittest集成了mock，而且python3.0使用更加广泛，所以以unittest中的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)
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.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
mock基础测试
https://github.com/2462612540/Machine-Learning/tree/2021/python_mock
mock高级测试
完成模拟之后之后，必须把它们复原。如果模拟对象在其它测试中持续存在，那么会导致难以诊断的问题。为此，mock中还提供了 mock.patch和mock.patch.object 等多个对象。mock.patch 是一种进阶的使用方法，主要是方便函数和类的测试，有三种使用方法：
- 函数修饰器
- 类修饰器
- 上下文管理器
使用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
mock.patch的使用
def get_sum(x, y):
pass
--------------------------------------------------------------------
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()
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()
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 用来模拟返回结果，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()
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()
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
装饰器@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()
------------------------------------------------------------
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()
------------------------------------------------------------
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()
with 上下文管理器
使用with将mock对象作用于上下文.
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)
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()
三种使用方法对比
手动指定 | 装饰器 | 上下文管理器 | |
优点 | 可以更精细控制mock的范围 | 方便mock多个对象 | |
不足之处 | 需要手动start和stop | 装饰器顺序和函数参数相反容易混乱 | 一个with只能mock一个对象 |
MagicMock
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测试框架
pytest是一个测试的框架，能够提供测试场景中的多种功能。这里不讨论别的功能，只说mock。pytest-mock是一个pytest的插件，安装即可使用。pytest-mock提供了一个mocker对象，在导入pytest时默认导入。mocker 是对mock的一个兼容，mock有的属性和方法，mocker都有，而且还有自己特有的方法。
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，这个模块需要独立安装
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实例传入测试对象中，可以获得测试对象内部执行的过程。所以：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)
mock总结
mocker兼容mock的功能，但是对于mock.patch的装饰器用法和上下文用法是不支持的。
如果是使用pytest的框架，如pytest-django，或者pytest-flask等，推荐使用mocker来完成模拟。
mock基本使用
什么是mock?
mock在翻译过来有模拟的意思。这里要介绍的mock是辅助单元测试的一个模块。它允许您用模拟对象替换您的系统的部分，并对它们已使用的方式进行断言。
在Python2.x 中 mock是一个单独模块，需要单独安装。
> pip install -U mock
在Python3.x中，mock已经被集成到了unittest单元测试框架中，所以，可以直接使用。
可能你和我初次接触这个概念的时候会有这样的疑问：把要测的东西都模拟掉了还测试什么呢？
但在，实际生产中的项目是非常复杂的，对其进行单元测试的时候，会遇到以下问题：
- 接口的依赖
- 外部接口调用
- 测试环境非常复杂
单元测试应该只针对当前单元进行测试, 所有的内部或外部的依赖应该是稳定的, 已经在别处进行测试过的.使用mock 就可以对外部依赖组件实现进行模拟并且替换掉, 从而使得单元测试将焦点只放在当前的单元功能。
简单的例子
我们先从最简单例子开始。
modular.py
#modular.py
class Count():
def add(self):
pass
这里要实现一个Count计算类，add() 方法要实现两数相加。但，这个功能我还没有完成。这时就可以借助mock对其进行测试。
mock_demo01.py
from unittest import mock
import unittest
from modular import Count
# test Count class
class TestCount(unittest.TestCase):
def test_add(self):
count = Count()
count.add = mock.Mock(return_value=13)
result = count.add(8,5)
self.assertEqual(result,13)
if __name__ == ‘__main__‘:
unittest.main()
count = Count()
首先，调用被测试类Count() 。
count.add = mock.Mock(return_value=7)
通过Mock类模拟被调用的方法add()方法，return_value 定义add()方法的返回值。
result = count.add(2,5)
接下来，相当于在正常的调用add()方法，传两个参数2和5，然后会得到相加的结果7。然后，7的结果是我们在上一步就预先设定好的。
self.assertEqual(result,7)
最后，通过assertEqual()方法断言，返回的结果是否是预期的结果7。
运行测试结果：
> python3 mock_demo01.py . ---------------------------------------------------------------------- Ran 1 test in 0.000s OK
这样一个用例就在mock的帮助下编写完成，并且测试通过了。
完成功能测试
再接下来完成module.py文件中add()方法。
#module.py
class Count():
def add(self, a, b):
return a + b
然后，修改测试用例：
from unittest import mock
import unittest
from module import Count
class MockDemo(unittest.TestCase):
def test_add(self):
count = Count()
count.add = mock.Mock(return_value=13, side_effect=count.add)
result = count.add(8, 8)
print(result)
count.add.assert_called_with(8, 8)
self.assertEqual(result, 16)
if __name__ == ‘__main__‘:
unittest.main()
count.add = mock.Mock(return_value=13, side_effect=count.add)
side_effect参数和return_value是相反的。它给mock分配了可替换的结果，覆盖了return_value。简单的说，一个模拟工厂调用将返回side_effect值，而不是return_value。
所以，设置side_effect参数为Count类add()方法，那么return_value的作用失效。
result = count.add(8, 8)
print(result)
这次将会真正的调用add()方法，得到的返回值为16（8+8）。通过print打印结果。
assert_called_with(8,8)
检查mock方法是否获得了正确的参数。
解决测试依赖
前面的例子，只为了让大家对mock有个初步的印象。再接来，我们看看如何mock方法的依赖。
例如，我们要测试A模块，然后A模块依赖于B模块的调用。但是，由于B模块的改变，导致了A模块返回结果的改变，从而使A模块的测试用例失败。其实，对于A模块，以及A模块的用例来说，并没有变化，不应该失败才对。
这个时候就是mock发挥作用的时候了。通过mock模拟掉影响A模块的部分（B模块）。至于mock掉的部分（B模块）应该由其它用例来测试。
# function.py
def add_and_multiply(x, y):
addition = x + y
multiple = multiply(x, y)
return (addition, multiple)
def multiply(x, y):
return x * y
然后，针对 add_and_multiply()函数编写测试用例。func_test.py
import unittest
import function
class MyTestCase(unittest.TestCase):
def test_add_and_multiply(self):
x = 3
y = 5
addition, multiple = function.add_and_multiply(x, y)
self.assertEqual(8, addition)
self.assertEqual(15, multiple)
if __name__ == "__main__":
unittest.main()
运行结果：
> python3 func_test.py . ---------------------------------------------------------------------- Ran 1 test in 0.000s OK
目前运行一切正确常，然而，add_and_multiply()函数依赖了multiply()函数的返回值。如果这个时候修改multiply()函数的代码。
……
def multiply(x, y):
return x * y + 3
这个时候，multiply()函数返回的结果变成了x*y加3。
再次运行测试：
> python3 func_test.py
F
======================================================================
FAIL: test_add_and_multiply (__main__.MyTestCase)
----------------------------------------------------------------------
Traceback (most recent call last):
File "fun_test.py", line 19, in test_add_and_multiply
self.assertEqual(15, multiple)
AssertionError: 15 != 18
----------------------------------------------------------------------
Ran 1 test in 0.000s
FAILED (failures=1)
测试用例运行失败了，然而，add_and_multiply()函数以及它的测试用例并没有做任何修改，罪魁祸首是multiply()函数引起的，我们应该把 multiply()函数mock掉。
import unittest
from unittest.mock import patch
import function
class MyTestCase(unittest.TestCase):
@patch("function.multiply")
def test_add_and_multiply2(self, mock_multiply):
x = 3
y = 5
mock_multiply.return_value = 15
addition, multiple = function.add_and_multiply(x, y)
mock_multiply.assert_called_once_with(3, 5)
self.assertEqual(8, addition)
self.assertEqual(15, multiple)
if __name__ == "__main__":
unittest.main()
@patch("function.multiply")
patch()装饰/上下文管理器可以很容易地模拟类或对象在模块测试。在测试过程中，您指定的对象将被替换为一个模拟（或其他对象），并在测试结束时还原。
这里模拟function.py文件中multiply()函数。
def test_add_and_multiply2(self, mock_multiply):
在定义测试用例中，将mock的multiply()函数（对象）重命名为 mock_multiply对象。
mock_multiply.return_value = 15
设定mock_multiply对象的返回值为固定的15。
ock_multiply.assert_called_once_with(3, 5)
检查ock_multiply方法的参数是否正确。
再次，运行测试用例，通过！
本文摘自虫师：https://www.cnblogs.com/fnng/p/5648247.html
以上是关于Python——单元测试中mock原理和使用的主要内容，如果未能解决你的问题，请参考以下文章