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

Mock

开发技术 开发技术 4小时前 3次浏览

Mock

"""
用例集
case_set.py
pip install requests
"""
import requests

def v2ex_info():
    """
    获取v2ex的网站信息
    https://www.v2ex.com/api/site/info.json

    """
    response = requests.get(url='https://www.v2ex.com/api/site/info.json')
    return response.json().get('title')  # V2EX

def v2ex_stats():
    """
    获取v2ex的网站信息
    https://www.v2ex.com/api/site/stats.json
    """
    response = requests.get(url='https://www.v2ex.com/api/site/stats.json')
    return response.json().get('member_max')  # int类型

def cnodejs():
    """ 获取 cnodejs,推荐博客总数 """
    response = requests.get('https://cnodejs.org/api/v1/topics')
    return response.json().get('success')  # True

if __name__ == '__main__':
    print(v2ex_info() == 'V2EX')
    print(type(v2ex_stats()) is int)
    print(cnodejs() is True)

关于requests模块, see also:https://www.cnblogs.com/Neeo/articles/11511087.html

规则是:

  • v2ex_info接口返回值中的title是V2EX才算通过。
  • v2ex_stats接口返回值中的member_max是int类型才算通过。
  • cnodejs接口只值中的success是True算通过。

你根据规则很快的写出了测试用例:

"""
用例类
myMain.py
"""

import unittest
from case_set import v2ex_stats, v2ex_info, cnodejs

class InterfaceCase(unittest.TestCase):

    def test_v2ex_stats(self):
        """ 测试 v2ex_stats 接口,返回: int类型"""
        self.assertIs(type(v2ex_stats()), int)

    def test_v2ex_info(self):
        """ 测试 v2ex_info 接口, 返回: V2EX """
        self.assertEqual(v2ex_info(), 'V2EX')

    def test_cnodejs(self):
        """ 测试 cnodejs 接口,返回: True """
        self.assertIs(cnodejs(), True)

if __name__ == '__main__':
    unittest.main()

结果也OK:

M:tests>python36 myMain.py -v
test_cnblogs_info (__main__.InterfaceCase)
测试博客园接口,返回: 200 ... ok
test_v2ex_info (__main__.InterfaceCase)
测试 v2ex_info 接口, 返回: V2EX ... ok
test_v2ex_stats (__main__.InterfaceCase)
测试 v2ex_stats 接口,返回: int类型 ... ok

----------------------------------------------------------------------
Ran 3 tests in 3.075s

OK

完美,你就准备去泡妞了……
为什么需要mock

桥逗麻袋!你在反复的执行测试用例时,发现test_cnodejs用例执行有些问题。有时候执行失败有时候成功,并且就算成功也响应时间较长,一番分析后,发现不是自己的问题,是接口暂时开发的不是很完善,导致现在测试不稳定。
但是你根据接口文档知道,这个接口这么测试,只要返回True就算通过。
那么能不能我们自己模拟出来这么一个接口,然后模拟一些方法和数据,在测试环境下使用。

什么是mock
在协同开发、测试中,总会出现各种问题,比如:

  • 开发人员某些接口还没有开发完毕。
  • 与第三方联调时,第三方拖了后腿,没准备好环境、数据都有可能。比如说我们测试的某个接口本身没有问题,但它依赖的某个接口有些问题,这就影响我们的正常测试任务进度。
  • 测试环境恶劣。
  • 开发只提供接口,数据自己搞!

这些问题总能影响我们的测试进度,那么我们怎么正常的展开呢?
这就需要mock来解决了。

什么是mock
mock是在测试过程中,对于一些不容易构造/获取的对象,创建一个mock对象来模拟对象的行为。
mock测试一般也称为mock数据。
简单来说,mock就是向测试对象提供一套和测试资源完全相同的接口和方法,不关系具体的实现过程,只关心具体结果。
mock测试的优点

  • 团队并行工作:有了mock,前后端人员只需要定义好接口文档就可以开始并行的工作,互不影响,只需要在最后联调的时候多多交流即可。后端与后端之间如果有接口耦合,也同样能被Mock解决;测试过程中如果遇到依赖接口没有准备好,同样可以借助Mock;不会出现一个团队等待另一个团队的情况。这样的话,开发自测阶段就可以及早开展,从而发现缺陷的时机也提前了,有利于整个产品质量以及进度的保证。
  • 开启TDD模式,即测试驱动开发:单元测试是TDD实现的基石,而TDD经常会碰到协同模块尚未开发完成的情况,但是有了mock,这些一切都不是问题。当接口定义好后,测试人员就可以创建一个Mock,把接口添加到自动化测试环境,提前创建测试。
  • 模拟出无法访问的资源:比如说,你需要调用一个“墙”外的资源来方便自己调试,就可以自己Mock一个。
  • 系统隔离:假如我们需要调用一个post请求,为了获得某个响应,来看当前系统是否能正确处理返回的“响应”,但是这个post请求会造成数据库中数据的污染,那么就可以充分利用Mock,构造一个虚拟的post请求,我们给他指定返回就好了。
  • 产品展示:假如我们需要创建一个演示程序,并且做了简单的UI,那么在完全没有开发后端服务的情况下,也可以进行演示。说到演示了,假如你已经做好了一个系统,并且需要给客户进行演示,但是里面有些真实数据并不想让用户看到,那么同样,你可以用Mock接口把这些敏感信息接口全部替换。
  • 测试覆盖:假如有一个接口,有100个不同类型的返回,我们需要测试它在不同返回下,系统是否能够正常响应,但是有些返回在正常情况下基本不会发生,难道你要千方百计地给系统做各种手脚让他返回以便测试吗?比如,我们需要测试在当接口发生500错误的时候,app是否崩溃,别告诉我你一定要给服务端代码做些手脚让他返回500 。。。而使用mock,这一切就都好办了,想要什么返回就模拟什么返回,妈妈再也不用担心你的测试覆盖度了。

关于TDD,see also:https://www.cnblogs.com/Neeo/articles/11504982.html
关于测试覆盖,see also:https://www.cnblogs.com/Neeo/articles/11795996.html

如何mock数据#

下载安装

这里需要用到mock模块了,在Python3.x中,mock被集成到了unittest中,无需下载,直接导入即可,但在Python2.x中,就需要:

pip install mock

mock类的构成

Mock

这里以Python3.x为例。

快速上手#

构造器:_init_#

from unittest import mock

mock_obj = mock.Mock()
print(mock_obj)  # <Mock id='10069264'>
print(dir(mock_obj))
'''
[
    'assert_any_call', 'assert_called', 'assert_called_once', 
    'assert_called_once_with', 'assert_called_with', 'assert_has_calls', 
    'assert_not_called', 'attach_mock', 'call_args', 
    'call_args_list', 'call_count', 'called', 
    'configure_mock', 'method_calls', 'mock_add_spec', 
    'mock_calls', 'reset_mock', 'return_value', 
    'side_effect'
]
'''

虽然__init__是实例化方法,但在这里通常被称为构造器。
由打印结果可以看到,通过mock.Mock()实例化出一个mock对象mock_obj。这个对象是继承了Mock类的属性和方法。这样的一个mock对象对我们来说用处不大。
我们来试着添加一些自定义属性和方法,使之更灵活。
在Mock实例化时,我们可以传入这些参数

  • name:mock对象的名字。它只是起到标识作用,当你print一个有name的mock对象时,可以看到它的name。
  • spec:mock对象的属性值。
  • side_effect:该参数指向一个可调用对象(一般是函数),当mock对象被调用时,如果该参数的返回值是默认的DEFAULT,则mock对象返回return_value指定的值,否则返回side_effect指定的对象的返回值。
  • return_value:该参数指定一个值或者对象,当mock对象被调用时,如果side_effect函数的返回值是DEFAULT,那么mock对象返回return_value指定的值或者对象。

注意,如果side_effect和return_value同时存在的时候,side_effect将会覆盖return_value。

name

from unittest import mock

mock_obj1 = mock.Mock()
mock_obj2 = mock.Mock(name='mock_obj2')
print(mock_obj1)  # <Mock id='50111760'>
print(mock_obj2)  # <Mock name='mock_obj' id='53781776'>

name参数没啥好说的,就是跟mock对象起了个名字。

为return_value指定某个值
现在让我们使用mock来模拟出文章开头的那几个接口测试中的cnodejs接口。

import unittest
from unittest import mock
from case_set import cnodejs  # 导入真实的cnodejs接口函数

class CnodejsTestCase(unittest.TestCase):

    def test_mock_cnodejs(self):
        """ 使用 mock 模拟的 cnodejs 接口 返回: True"""
        # 构造mock对象
        cnodejs = mock.Mock(return_value=True)
        # 使用mock对象进行断言
        self.assertIs(cnodejs(), True)

    def test_cnodejs(self):
        """ 测试 cnodejs 接口,返回: True """
        self.assertIs(cnodejs(), True)


if __name__ == '__main__':
    unittest.main()

用例test_mock_cnodejs方法中:
在Mock类实例化时传入return_value参数,然后构造出的mock对象赋值给cnodejs变量。然后cnodejs()相当于调用mock对象,得到返回值True,完事拿着这个返回值使用unittest进行断言。
用例test_cnodejs方法中,正常写测试用例断言,以判断两个用例方法有什么不同之处:

test_cnodejs (__main__.CnodejsTestCase)
测试 cnodejs 接口,返回: True ... ok
test_mock_cnodejs (__main__.CnodejsTestCase)
使用 mock 模拟的 cnodejs 接口 返回: True ... ok

----------------------------------------------------------------------
Ran 2 tests in 1.097s

OK

可以看到,两个用例方法都通过了,并没有什么区别。
在测试环境下,我们使用mock模拟的方法进行测试,这样能尽早的介入测试,带来的优势不一而足。
为return_value指定类的对象
return_value除了上述用法,还可以指定类的对象:

from unittest import mock


class Foo(object):
    """ 自定义类 """

    def f1(self):
        return 'this is Foo.f1'

    def f2(self, name):
        return name
# 正常的类的实例化与调用
foo_obj = Foo()
print(foo_obj.f1())  # this is Foo.f1
print(foo_obj.f2('this is Foo.f2'))  # this is Foo.f2

# 构造mock对象并传入 Foo实例化对象
foo_Class = mock.Mock(return_value=Foo())
# 想要得到mock对象的返回值,必须调用,也就是加括号
foo_obj = foo_Class()  # mock对象调用得到return_value值也就是Foo的实例化对象
# 接下里就是正常的调用了
print(foo_obj.f1())  # this is Foo.f1
# 同样可以正常传参
print(foo_obj.f2('this is Foo.f2'))  # this is Foo.f2

使用mock对象模拟类的实例化对象同样方便。

side_effect
先来看第一个示例,我们可以为mock对象的side_effect参数指定可迭代对象。

from unittest import mock

mock_obj1 = mock.Mock(return_value=100)
print(mock_obj1())  # 100
mock_obj2 = mock.Mock(return_value=100, side_effect=[200, 300])
print(mock_obj2())  # 200

由上例可以看到,如果在构造mock对象的时候,只有return_value被指定,调用mock对象返回return_value指定的值。
side_effectreturn_value同时被指定时,side_effect就覆盖了return_value
那么既然side_effect接受的是一个可迭代对象,我们就可以多次调用它:

from unittest import mock

mock_obj1 = mock.Mock(return_value=100)
print(mock_obj1())  # 100
mock_obj2 = mock.Mock(return_value=100, side_effect=[200, 300])
print(mock_obj2())  # 200
print(mock_obj2())  # 300
print(mock_obj2())  # StopIteration

可以看到side_effect对象本质上是一个生成器。

为spec指定属性组成的列表
现在我们使用mock来模拟出来两V2EX的两个接口方法。

import unittest
from unittest import mock
from case_set import v2ex_info, v2ex_stats

# 为mock对象的spec参数传入属性(方法)组成的列表
spec_list = ['v2ex_info', 'v2ex_stats']
mock_obj = mock.Mock(spec=spec_list)
print(spec_list)  # ['v2ex_info', 'v2ex_stats']
# 根据真实的接口规则设置两个方法的返回值
mock_obj.v2ex_info.return_value = 'V2EX'
mock_obj.v2ex_stats.return_value = 466668  # 该接口只需要返回值是int即可

class TestCaseDemo(unittest.TestCase):

    def test_v2ex_stats(self):
        """ 测试 v2ex_stats 接口,返回: int类型"""
        self.assertIs(type(v2ex_stats()), int)

    def test_mock_v2ex_stats(self):
        """ mock v2ex_stats 接口,返回: int类型 """
        v2ex_stats = mock_obj.v2ex_stats
        self.assertIs(type(v2ex_stats()), int)

    def test_mock_v2ex_info(self):
        """ mock v2ex_info 接口, 返回: V2EX """
        v2ex_info = mock_obj.v2ex_info
        self.assertEqual(v2ex_info(), 'V2EX')

    def test_v2ex_info(self):
        """ 测试 v2ex_info 接口, 返回: V2EX """
        self.assertEqual(v2ex_info(), 'V2EX')

if __name__ == '__main__':
    unittest.main()

结果:

M:tests>python36 myMain.py -v
test_mock_v2ex_info (__main__.TestCaseDemo)
mock v2ex_info 接口, 返回: V2EX ... ok
test_mock_v2ex_stats (__main__.TestCaseDemo)
mock v2ex_stats 接口,返回: int类型 ... ok
test_v2ex_info (__main__.TestCaseDemo)
测试 v2ex_info 接口, 返回: V2EX ... ok
test_v2ex_stats (__main__.TestCaseDemo)
测试 v2ex_stats 接口,返回: int类型 ... ok

----------------------------------------------------------------------
Ran 4 tests in 3.154s

OK

由结果发现,我们用mock模拟的两个接口都通过了。
为spec指定类属性

from unittest.mock import Mock
class Foo(object):
    age = 20
    def f1(self):
        return 'this if f1'

    def f2(self, name):
        return name
mock_obj = Mock(spec=Foo)
print(mock_obj.f1)  # <Mock name='mock.f1' id='1847131683640'>
print(mock_obj.f2)  # <Mock name='mock.f2' id='1847131615128'>
print(mock_obj.age)  # <Mock name='mock.age' id='1847131718880'>
print(mock_obj.name)  # AttributeError: Mock object has no attribute 'name'

我们为mock对象指定了属性为Foo类,那么,类中的方法和属性都是mock对象的属性,这也是前三个打印没有问题的原因,而第4个打印报错了,显然,Foo类中没有一个叫name的属性或者方法。

mock断言语句#

由mock思维导图我们知道,mock关于断言有这些常用的:

  • assert_called_with(arg):检查函数调用参数是否正确。
  • assert_called_once_with(arg):检查函数调用参数是否正确,但是只调用一次。
  • assert_any_call():用于检查测试的mock对象在测试例程中是否调用了方法。
  • assert_has_calls():期望调用方法列表。

assert_called_with
assert_called_with检查mock方法是否获取了正确的参数,当至少有一个参数有错误的值或者类型时、当参数的个数出错时、当参数的顺序不正确时,断言失败。

from unittest.mock import Mock

class Foo(object):
    value = 20

    def f1(self, arg):
        return arg

    def f2(self, *args):
        return args

mock_obj = Mock(spec=Foo)
# f1正确的传参姿势
mock_obj.f1(222)
# mock_obj.f1.assert_called_with()  # 报错,没有传参
# mock_obj.f1.assert_called_with(11)  # 报错,瞎98传参
# mock_obj.f1.assert_called_with('6669')  # 报错,6翻了吧,传值的类型不对
# mock_obj.f1.assert_called_with(222)  # 噢啦,mock_obj.f1()传的就是 222

# f2正确传参姿势
mock_obj.f2(1, 2, 3)
# mock_obj.f2.assert_called_with() # 报错,没有传参
# mock_obj.f2.assert_called_with(1)  # 报错,少传了参数
# mock_obj.f2.assert_called_with(1, 3, 2)  # 报错,传参顺序不对
mock_obj.f2.assert_called_with(1, 2, 3)  # 噢啦,传参姿势很对

啥都不用说了吧,都在代码里。

assert_called_once_with
assert_called_once_with断言,当指定方法被多次调用的时候,断言失败。

from unittest.mock import Mock

class Foo(object):
    value = 20

    def f1(self, arg):
        return arg

    def f2(self, *args):
        return args
# 实例化mock对象
mock_obj = Mock(spec=Foo)
# 为f1方法赋返回值
mock_obj.f1.return_value = 222
print(mock_obj.f1())
mock_obj.f1.assert_called_once_with()  # 第一次调用,没问题
print(mock_obj.f1())
mock_obj.f1.assert_called_once_with()  # 第二次调用,报错 AssertionError: Expected 'f1' to be called once. Called 2 times.

这个断言相对简单。

assert_any_call
assert_any_call断言用于检查测试执行中的mock对象在测试中是否调用了方法。

from unittest.mock import Mock

class Foo(object):
    value = 20

    def f1(self, arg):
        return arg

    def f2(self, *args):
        return args


mock_obj = Mock(spec=Foo)
# mock对象调用了 f1() f1(100) f1(200) f1(200)
mock_obj.f1()
mock_obj.f1(100)
mock_obj.f1(200)
mock_obj.f1(200)

# 判断:mock对象调用了f1() f1(100) f1(200) f1(300) f2()
mock_obj.f1.assert_any_call()  # 没错
mock_obj.f1.assert_any_call(100)  # 没错
mock_obj.f1.assert_any_call(200)  # 没错
# mock_obj.f1.assert_any_call(300)  # AssertionError: f1(300) call not found
mock_obj.f2.assert_any_call()  # AssertionError: f2() call not found

上例,assert_any_call会判断整个测试中方法是否被调用了。而不管该方法是否被重复调用。
例如,在程序执行时执行了mock_obj.f1.assert_any_call(),那么就用mock_obj.f1.assert_any_call()判断刚才的方法是否执行过。执行过啥都不做,要是没执行过就报错。

assert_has_calls
assert_has_calls检查是否按照正确的顺序和正确的参数进行调用的。所以,我们需要给出一个方法的调用顺序,assert的时候按照这个顺序进行检查。

from unittest.mock import Mock
from unittest.mock import call  # 引入新的模块

class Foo(object):
    value = 20

    def f1(self, arg):
        return arg

mock_obj = Mock(spec=Foo)
# 正确的执行顺序是 f1() f1(100) f1(200)
mock_obj.f1()
mock_obj.f1(100)
mock_obj.f1(200)

# 报错, 现在的执行顺序是 f1() f1(100) f1(300)
# calls_list = [call.f1(), call.f1(100), call.f1(300)]  # 报错,没有 call.f1(300)
# mock_obj.assert_has_calls(calls_list)

# 报错,现在的执行顺序是 f1(200) f1() f1(300)
# calls_list = [call.f1(200), call.f1(), call.f1(200)]  # 报错,执行顺序不对
# mock_obj.assert_has_calls(calls_list)

# 对喽
calls_list = [call.f1(), call.f1(100), call.f1(200)]
mock_obj.assert_has_calls(calls_list)

首先,我们以列表的形式列出方法调用顺序,每个方法前使用call.f1()的形式,因为如果不加call来修饰的话, 解释器将不知道f1是一个方法,当然call在使用之前需要引入。

mock管理方法#

mock中,关于管理有这些常用方法:

  • attach_mock:将一个mock对象添加到另一个mock对象中。
  • configure_mock,更改mock对象的return_value值。
  • mock_add_spec:给mock对象添加新的属性。
  • reset_mock:将mock对象恢复到初始状态。

acttach_mock
acttach_mock将一个mock对象添加到另一个mock对象中。

from unittest.mock import Mock


class Foo(object):

    def f1(self, arg):
        return arg


class Bar(object):

    def f2(self, *args):
        pass

# 分别构造foo和bar的mock对象
mock_foo = Mock(spec=Foo)
mock_bar = Mock(spec=Bar)

# 打印也没问题
print(mock_foo, mock_bar)  # <Mock spec='Foo' id='57738096'> <Mock spec='Bar' id='130627728'>

# 分别为两个mock对象的方法添加返回值
mock_foo.f1.return_value = 'Foo.f1'
mock_bar.f2.return_value = 'Bar.f2'

# 正常的调用都没问题
print(mock_foo.f1())  # Foo.f1
print(mock_bar.f2())  # Bar.f2

# 使用attach_mock将mock_bar对象添加到mock_foo中
mock_foo.attach_mock(mock_bar, 'bar')

# 现在mock_bar对象成为了mock_foo mock对象的一个属性bar
print(mock_foo.bar)  # <Mock name='mock.bar' spec='Bar' id='132987120'>

# mock_foo.bar等于拿到了mock_bar对象,然后调用其中的f2方法,并且得到了之前赋值的返回值
print(mock_foo.bar.f2())  # Bar.f2

需要注意的是,attach_mock(self, mock, attribute)必须为添加进来的mock对象指定一个属性名。

configure_mock

configure_mock用来更改mock对象的return_value值。

from unittest.mock import Mock

class Foo(object):

    def f1(self, arg):
        return arg

    def f2(self, arg):
        return arg

# 实例化mock对象并添加属性和返回值
mock_obj = Mock(spec=Foo, return_value='abc')
# 正常调用mock对象得到预期的结果 abc
print(mock_obj())  # abc
# 使用configure_mock修改mock对象的return_value值
mock_obj.configure_mock(return_value='xyz')
# 修改成功
print(mock_obj())  # xyz

# 可以批量设置返回值,比如f1方法的返回值为 '100', f2方法的返回值为 200
spec_dict = {'f1.return_value': '100', 'f2.return_value': 200}
# 将字典打散后使用configure_mock设置到mock对象中
mock_obj.configure_mock(**spec_dict)
print(mock_obj())  # xyz
print(mock_obj.f1())  # 100  ps:字符串类型的100
print(mock_obj.f2())  # 2090

mock_add_spec
mock_add_spec(self, spec, spec_set=False)用来给mock对象添加一个新的属性,新的属性会覆盖掉原来的属性。spec_set指属性可读可写,默认是只读,但可写我没测试出来….欢迎留言指正。

from unittest.mock import Mock

class Foo(object):

    def f1(self, arg):
        return arg

class Bar(object):

    def f2(self, args):
        return args

def ace():
    pass

# 实例化mock对象
mock_obj = Mock(spec=Foo)
print(mock_obj.f1())  # <Mock name='mock.f1()' id='119946576'>

# 使用mock_add_spec给mock_obj添加一个新的属性
mock_obj.mock_add_spec(Bar)
print(mock_obj.f2())  # <Mock name='mock.f2()' id='46952912'>

# 正常的使用都没问题
mock_obj.f2.return_value = 'Bar.f2'
print(mock_obj.f2())  # Bar.f2

# 上面添加的属性是类,现在是函数,记得函数这里没有方法,别瞎点啊
mock_obj.mock_add_spec(ace)
mock_obj.return_value = 'function'
print(mock_obj())  # function

# 另外,新添加的属性会覆盖掉之前的属性。现在的mock对象模拟的函数ace对象,ace函数哪有什么f1啊
print(mock_obj.f1())  # AttributeError: Mock object has no attribute 'f1'

reset_mock
reset_mock将mock对象回复到初识状态,避免了重新构造mock对象带来的开销。

from unittest.mock import Mock

class Foo(object):

    def f1(self, arg):
        return arg

mock_obj = Mock(spec=Foo)
mock_obj.f1()
# 这里如果不使用 reset_mock, 那么f1方法就被调用了两次,下面的 assert_called_once_with就会报错,现在则不报错了
mock_obj.reset_mock()
mock_obj.f1()
mock_obj.f1.assert_called_once_with()

mock统计方法#

再来看mock关于统计的一些方法:

  • called:跟踪mock对象所做的任意调用的访问器。
  • mock_calls:显示工厂调用和方法调用。
  • call_args:mock对象的初始化参数。
  • call_args_list:调用中使用参数。
  • call_count:mock对象被调用次数。
  • method_calls:以列表的形式返回mock对象都调用了哪些方法。

called

from unittest.mock import Mock

def ace():
    pass

# 构造 mock对象并没有调用
mock_obj = Mock(spec=ace)
# OK,此时mock对象没有调用,所以mock_obj.called:False
print(mock_obj.called)  # False
# OK,现在调用了,那么 mock_obj.called:True
mock_obj()
print(mock_obj.called)  # True

called只要检测到mock对象被调用,就返回True。

call_count

from unittest.mock import Mock

def ace():
    pass

mock_obj = Mock(spec=ace)
mock_obj()
mock_obj()
mock_obj()
print(mock_obj.call_count)  # 3

call_count检查mock对象被调用了多少次。

call_args && call_args_list

from unittest.mock import Mock

mock_obj = Mock()
mock_obj()
print(mock_obj.call_args)  # call()
print(mock_obj.call_args_list)  # [call()]

call_args_list以列表的形式返回工厂调用时所有的参数。

method_calls

from unittest.mock import Mock

class Foo(object):

    def f1(self, arg):
        return arg

mock_obj = Mock(spec=Foo)
mock_obj()
mock_obj.f1()
print(mock_obj.call_args)  # call()
print(mock_obj.call_args_list)  # [call()]
print(mock_obj.method_calls)  # [call.f1()]

mock_calls

from unittest.mock import Mock

class Foo(object):

    def f1(self, arg):
        return arg

mock_obj = Mock(spec=Foo)
mock_obj()
mock_obj.f1()
print(mock_obj.mock_calls)  # [call(), call.f1()]

首先,mock对象被调用时,执行工厂call方法,完事第二次调用了f1方法,所以mock_calls返回了两个方法。


程序员灯塔
转载请注明原文链接:Mock
喜欢 (0)