python mock打桩 python mock框架

1、断言方法

1、mock常用断言方法：

assert_not_called：模拟从未被调用过。
assert_called：至少调用了一次模拟。
assert_called_once：仅调用了一次模拟。
assert_called_with：使用指定的参数调用模拟。
assert_called_once_with：模拟完全被调用了一次，并且该调用使用了指定的参数。
assert_any_call：已使用指定的参数调用了模拟。

 

2、创建Demo.py文件（创建被测试类：People类）。

脚本代码：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
被测试类
"""
# People类里有两个成员方法（一个有参数，一个无参数）、一个静态方法
class People:

    def __init__(self):
        self.__age = 20

    def name(self,firstName,lastName):
        return firstName + ' ' + lastName

    def age(self):
        return self.__age

    @staticmethod
    def class_name():
        return People.__name__

 

1.1、assert_not_called

assert_not_called：模拟从未被调用过。

1、创建MockTest_assert.py文件（创建PeopleTest测试类）。

脚本代码：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
断言方法（检验是否调用）
"""
from method.Demo import People
from unittest import mock
import unittest

class PeopleTest(unittest.TestCase):

    def test_name(self):
        # 调用被测试类People()
        p = People()
        p.name = mock.Mock(return_value='Hello Mock')
        p.name.assert_not_called()
      
if __name__ == '__main__':
    unittest.main(verbosity=2)

 

2、执行MockTest_assert.py文件，运行结果：

没有调用p.name()，执行成功。

 

1.2、assert_called

assert_called：至少调用了一次模拟。

1、创建MockTest_assert.py文件（创建PeopleTest测试类）。

脚本代码：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
断言方法（检验是否调用）
"""
from method.Demo import People
from unittest import mock
import unittest

class PeopleTest(unittest.TestCase):

    def test_name(self):
        # 调用被测试类People()
        p = People()
        p.name = mock.Mock(return_value='Hello Mock')
        p.name('a', 'b')
        p.name('1', '2')
        p.name.assert_called() 

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

 

2、执行MockTest_assert.py文件，运行结果：

调用2次p.name()，执行成功。

1.3、assert_called_once

assert_called_once：仅调用了一次模拟。

1、创建MockTest_assert.py文件（创建PeopleTest测试类）。

脚本代码：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
断言方法（检验是否调用）
"""
from method.Demo import People
from unittest import mock
import unittest

class PeopleTest(unittest.TestCase):

    def test_name(self):
        # 调用被测试类People()
        p = People()
        p.name = mock.Mock(return_value='Hello Mock')
        p.name('a', 'b')
        p.name.assert_called_once() 
             
if __name__ == '__main__':
    unittest.main(verbosity=2)

 

2、执行MockTest_assert.py文件，运行结果：

调用1次p.name()，执行成功。

 

1.4、assert_called_with

assert_called_with：使用指定的参数调用模拟。

1、创建MockTest_assert.py文件（创建PeopleTest测试类）。

脚本代码：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
断言方法（检验是否调用）
"""
from method.Demo import People
from unittest import mock
import unittest

class PeopleTest(unittest.TestCase):

    def test_name(self):
        # 调用被测试类People()
        p = People()
        p.name = mock.Mock(return_value='Hello Mock')
        p.name('a', 'b')
        p.name('a', 'b')
        p.name.assert_called_with('a', 'b')
             
if __name__ == '__main__':
    unittest.main(verbosity=2)

      

2、执行MockTest_assert.py文件，运行结果：

调用2次p.name()且使用指定的参数调用，执行成功。

 

1.5、assert_called_once_with

assert_called_once_with：模拟完全被调用了一次，并且该调用使用了指定的参数。

1、创建MockTest_assert.py文件（创建PeopleTest测试类）。

脚本代码：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
断言方法（检验是否调用）
"""
from method.Demo import People
from unittest import mock
import unittest

class PeopleTest(unittest.TestCase):

    def test_name(self):
        # 调用被测试类People()
        p = People()
        p.name = mock.Mock(return_value='Hello Mock')
        p.name('a', 'b')
        p.name.assert_called_once_with('a', 'b')

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

 

2、执行MockTest_assert.py文件，运行结果：

调用1次p.name()且使用指定的参数调用，执行成功。

 

1.6、assert_any_call

assert_any_call：已使用指定的参数调用了模拟。

1、创建MockTest_assert.py文件（创建PeopleTest测试类）。

脚本代码：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
断言方法（检验是否调用）
"""
from method.Demo import People
from unittest import mock
import unittest

class PeopleTest(unittest.TestCase):

    def test_name(self):
        # 调用被测试类People()
        p = People()
        p.name = mock.Mock(return_value='Hello Mock')
        p.name('a', 'b')
        p.name('1', '2')
        p.name.assert_any_call('a', 'b')

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

 

2、执行MockTest_assert.py文件，运行结果：

调用2次p.name()且已使用指定的参数调用，执行成功。

2、统计方法

 

 

1、mock常用统计方法：

called：表示是否调用过。
call_count：返回调用的次数。
call_args：获取调用时的参数。
call_args_list：获取调用的所有参数，结果是一个列表。
method_calls：测试对象对mock方法的调用，结果是一个列表，每一项显示了方法的名称和它的参数。
mock_calls：测试对象对mock对象所有的调用，结果是一个列表。

 

2、创建Demo.py文件（创建被测试类：People类）。

脚本代码：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
被测试类
"""
# People类里有两个成员方法（一个有参数，一个无参数）、一个静态方法
class People:

    def __init__(self):
        self.__age = 20

    def name(self,firstName,lastName):
        return firstName + ' ' + lastName

    def age(self):
        return self.__age

    @staticmethod
    def class_name():
        return People.__name__

 

2.1、called

called：表示是否调用过。

1、创建MockTest_call.py文件（创建PeopleTest测试类）。

脚本代码：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
统计方法
"""
from method.Demo import People
from unittest import mock
import unittest

class PeopleTest(unittest.TestCase):

    def test_name(self):
        p = mock.Mock(spec = People,return_value='Hello Mock')
        p.name('a', 'b')
        print(p.name.called)

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

 

2、执行MockTest_call.py文件，运行结果：

调用p.name()方法，则调用过标记为True。

2.2、call_count

call_count：返回调用的次数。

1、创建MockTest_call.py文件（创建PeopleTest测试类）。

脚本代码：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
统计方法
"""
from method.Demo import People
from unittest import mock
import unittest

class PeopleTest(unittest.TestCase):

    def test_name(self):
        p = mock.Mock(spec = People,return_value='Hello Mock')
        p.name('a', 'b')
        p.name('1', '2')
        print(p.name.call_count)

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

 

2、执行MockTest_call.py文件，运行结果：

调用p.name()方法2次，则调用次数标记为2。

 

2.3、call_args

call_args：获取调用时的参数。

1、创建MockTest_call.py文件（创建PeopleTest测试类）。

脚本代码：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
统计方法
"""
from method.Demo import People
from unittest import mock
import unittest

class PeopleTest(unittest.TestCase):

    def test_name(self):
        p = mock.Mock(spec = People,return_value='Hello Mock')
        p.name('a', 'b')
        print(p.name.call_args)

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

 

2、执行MockTest_call.py文件，运行结果：

调用p.name()方法，获取调用时的参数（'a', 'b'）。

 

2.4、call_args_list

call_args_list：获取调用的所有参数，结果是一个列表。

1、创建MockTest_call.py文件（创建PeopleTest测试类）。

脚本代码：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
统计方法
"""
from method.Demo import People
from unittest import mock
import unittest

class PeopleTest(unittest.TestCase):

    def test_name(self):
        p = mock.Mock(spec = People,return_value='Hello Mock')
        p.name('a', 'b')
        p.name('1', '2')
        print(p.name.call_args_list)

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

 

2、执行MockTest_call.py文件，运行结果：

调用p.name()方法2次，获取调用时的所有参数（'a', 'b'）、（'1', '2'），以列表展现。

 

2.5、method_calls

method_calls：测试对象对mock方法的调用，结果是一个列表，每一项显示了方法的名称和它的参数。

1、创建MockTest_call.py文件（创建PeopleTest测试类）。

脚本代码：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
统计方法
"""
from method.Demo import People
from unittest import mock
import unittest

class PeopleTest(unittest.TestCase):

    def test_name(self):
        p = mock.Mock(spec = People,return_value='Hello Mock')
        p.name('a', 'b')
        p.name('1', '2')
        p.age()
        p.class_name()
        print(p.method_calls)
             
if __name__ == '__main__':
    unittest.main(verbosity=2)

 

2、执行MockTest_call.py文件，运行结果：

调用p.name()方法2次、p.age()方法1次、p.class_name()方法1次，每一项显示方法的名称和它的参数，以列表展现。

 

2.6、mock_calls

mock_calls：测试对象对mock对象所有的调用，结果是一个列表。

1、创建MockTest_call.py文件（创建PeopleTest测试类）。

脚本代码：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
统计方法
"""
from method.Demo import People
from unittest import mock
import unittest

class PeopleTest(unittest.TestCase):

    def test_name(self):
        p = mock.Mock(spec = People,return_value='Hello Mock')
        p.name('a', 'b')
        p.name('1', '2')
        p.age()
        p.class_name()
        print(p.mock_calls)

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

   2、执行MockTest_call.py文件，运行结果：

调用p.name()方法2次、p.age()方法1次、p.class_name()方法1次，每一项显示方法的名称和它的参数，以列表展现。