单元测试----Unittest框架

落日映苍穹つ 2022-12-16 13:06 222阅读 0赞

## 一： Unittest核心要素： ##

### 1：核心要素概念 ###

*  TestCase:测试用例

> TestCase继承于 unittest.TestCase  
> 测试方法必须以test开头

*  TestSuit:测试套件

> 测试套件： 把多个测试用例集成在一起就是测试套件。  
> 1：实例化测试套件 suite = unittest.TestSuite()  
> 2: 将测试用例加入测试套件 suite.addTest(MyTest(‘test\_xxx’))

*  TextTestRunner:

> 测试执行器： 用来执行测试套件  
> 1: 实例化测试执行器： runner = unittest.TextTestRunner()  
> 2: 执行测试套件 ： runner.run(suite)

*  FixTure:概述：

> 测试用例类中实现了前置和后置方法，则这个测试类就是一个Fixture。  
> 例如实现了： setUp() 和 tearDown

### 2：测试流程图： ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center]

### 3: 案例演示执行流程： ###

# 1: 导包
    import unittest
    
    # 2： 准备测试类
    class MyTest(unittest.TestCase):
        def test_1(self):
            print("这是：test_1")
    
        def test_2(self):
            print("这是：test_2")
    
    
    if __name__ == '__main__':
    
        # 3: 将测试用例添加到  测试套件中。
        # 实例化测试套件
        suite = unittest.TestSuite()
        # 将测试用例添加到测试套件中。
        suite.addTest(MyTest('test_1'))
        suite.addTest(MyTest('test_2'))
    
        # 4：运行容器中的测试用例
        # 实例化测试执行器
        runner = unittest.TextTestRunner()
        runner.run(suite)

演示：  
![在这里插入图片描述][20201020143705374.png_pic_center]

### 4： defaultTestLoader：指定目录下测试用例自动添加到测试套件中 ###

# 1: 导包
    import unittest
    
    # 2： 准备测试类
    class MyTest(unittest.TestCase):
        def test_1(self):
            print("这是：test_1")
    
        def test_2(self):
            print("这是：test_2")
    
    
    if __name__ == '__main__':
    
        # 将当前目录下的test_1.demo.py中的测试用例全部加载到测试套件。
        suite = unittest.defaultTestLoader.discover("./", "test_1_demo.py")
        # 运行测试用例
        runner = unittest.TextTestRunner()
        runner.run(suite)

## 二： unittest的使用 ##

### 1：unittest使用步骤 ###

*  unittest默认加载脚本的顺序是：根据ASCII码的顺序加载，数字与字母的顺序为：0-9，A-Z，a-z

""" unittest的基本使用"""
    
    # 1： 导入unittest包
    import unittest
    
    # 2: 创建测试用例类
    class MyTest(unittest.TestCase):
        @classmethod
        def setUpClass(cls):
            print("setUpClass")
    
        @classmethod
        def tearDownClass(cls):
            print("tearDownClass")
    
        def setUp(self):
            print("setup")
    
        def tearDown(self):
            print("tearDown")
    
        def test_s(self):
            print("test_s")
            a = 1 + 1
            self.assertEqual(a, 2, "结果不为2")
    
        def test_b(self):
            print("test_b")
            b = 1 + 2
            self.assertEqual(b, 2, "结果不为2")
    
    if __name__ == '__main__':
        unittest.main()

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 1]

### 2: unittest提供的断言函数\[查表\] ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 5]

### 3：参数化： ###

问题： 如果一个测试用例需要传递参数，怎么传递呢？？  
1: 安装包：

pip install parameterized -i https://pypi.tuna.tsinghua.edu.cn/simple

2： 案例：

# 1:导包
    import unittest
    from parameterized import parameterized
    
    # 2： 创建测试类
    class MyTest(unittest.TestCase):
    
        @parameterized.expand([('renshanwen', 23), ('niuniu', 25)])
        def test_param(self, name, age):
            print("name: %s, age: %s" % (name, age))
    
    
    if __name__ == '__main__':
        unittest.main()

3： 运行效果：  
![在这里插入图片描述][20201020153543212.png_pic_center]

## 三: mock的使用： ##

### 1: mock的原理： ###

**Mock是Python中一个用于支持单元测试的库，它的主要功能是使用mock对象替代掉指定的Python对象，以达到模拟对象的行为。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 6]

### 2：mock的基本使用 ###

#### return\_value的使用 ####

案例： 业务需求： 由于一段代码还没有实现，但是此时需要返回一个250的数字，此时需要使用mock代替未实现的代码，返回一个250的数字，目的是让测试流程跑通。

# 1:导包
    import unittest
    import unittest.mock
    
    # 2: 创建模拟的类
    class MyTest(unittest.TestCase):
    
        def test_return(self):
            # 创建一个能返回250的可调用对象
            mock_obj = unittest.mock.Mock(return_value=250)
            # 调用mocke对象，拿到返回值
            ret = mock_obj()
            print(ret)
    
    if __name__ == '__main__':
        unittest.main()

![在这里插入图片描述][20201020160050579.png_pic_center]

#### side\_effect的使用： ####

1： 利用side\_effect传递一个异常：

# 1:导包
    import unittest
    import unittest.mock
    
    # 2: 创建模拟的类
    class MyTest(unittest.TestCase):
    
        def test_return(self):
            # 创建一个能返回250的可调用对象
            mock_obj = unittest.mock.Mock(side_effect=BaseException("自定义异常"))
            # 调用mocke对象，拿到返回值
            ret = mock_obj()
            print(ret)
    
    if __name__ == '__main__':
        unittest.main()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 7]  
2：使用side\_effect传递一个数组：

import unittest.mock
    
    # 2: 创建模拟的类
    class MyTest(unittest.TestCase):
    
        def test_return(self):
            # 创建一个能返回250的可调用对象
            mock_obj = unittest.mock.Mock(side_effect=[1, 2, 3])
            # 调用mocke对象，拿到返回值
            for i in range(3):
                print(mock_obj())
    
    
    if __name__ == '__main__':
        unittest.main()

![在这里插入图片描述][20201020161112785.png_pic_center]  
3： 使用side\_effect传递一个函数:

# 1:导包
    import unittest
    import unittest.mock
    
    # 2: 创建模拟的类
    class MyTest(unittest.TestCase):
        def test_return(self):
            def sum_ab(a, b):
                return a + b
            # 创建一个能返回250的可调用对象
            mock_obj = unittest.mock.Mock(side_effect=sum_ab)
            # 调用mocke对象，拿到返回值
            print(mock_obj(1, 2))
    
    if __name__ == '__main__':
        unittest.main()

![在这里插入图片描述][20201020161535132.png_pic_center]

#### mock的案例： ####

业务需求： 现在有一个需求： A负责开发支付功能，但是A还没有开发完成。B负责支付状态模块，已经完成，B代码中调用A写的代码的支付函数了。现在要求C测试B写的代码是否符合要求，C如何测试？？

答： 使用mock替换A写的函数，然后调用B写的函数的时候就会调用我们的mock，不会调用A未完成的代码。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 8]

import unittest
    import unittest.mock
    import pay
    import pay_status
    
    class TestPay(unittest.TestCase):
        def test_success(self):
            # 用一个mock来代替pay中的pay_way函数
            pay.pay_way = unittest.mock.Mock(return_value={
        "result": "success", "reason":"null"})
            # 盗用要测试的函数
            ret = pay_status.pay_way_status() 
            self.assertEqual(ret, '支付成功', '支付失败')
    
        def test_fail(self):
            pay.pay_way = unittest.mock.Mock(return_value={
        "result": "fail", "reason":"余额不足"})
    
            ret = pay_status.pay_way_status() # 调用支付状态函数
            self.assertEqual(ret, '支付失败', '测试失败')
    
    if __name__ == '__main__':
        unittest.main()

![在这里插入图片描述][20201020171203380.png_pic_center]

#### mock的副作用： ####

提示： 当我们使用 mock 掉一个对象后，默认情况下，在后面执行的代码都会受到影响，比如其他的测试用例，其他的代码，只要是这些代码是在 mock 之后执行的都会受影响。

import unittest
    import unittest.mock
    import pay
    import pay_status
    
    class TestPay(unittest.TestCase):
        def test_success(self):
            # 用一个mock来代替pay中的pay_way函数
            pay.pay_way = unittest.mock.Mock(return_value={
        "result": "success", "reason":"null"})
            # 盗用要测试的函数
            ret = pay_status.pay_way_status()
            self.assertEqual(ret, '支付成功', '支付失败')
    
        def test_success2(self):
            # 盗用要测试的函数
            ret = pay_status.pay_way_status()
            self.assertEqual(ret, '支付成功', '支付失败')
    
    if __name__ == '__main__':
        unittest.main()

![在这里插入图片描述][20201020171519310.png_pic_center]

对于上面的代码，test\_success2，我们并没有使用mock来代替，结果也使用了mock。原因就是mock一旦被使用，后面执行的测试用例只能使用mock，不能使用原来的函数了。

#### 限制mock只作用于当前函数的两种方式 ####

1: patch装饰器：

> 1: 方法上面加上装饰器: @mock.patch(‘被代替的函数路径’)  
> 2： 函数另外增加一个传入值。  
> 3： 函数内部直接使用 传入值的名字.return\_value = \{返回值键值对\}

import unittest
    from unittest import mock
    
    import pay
    import pay_status
    
    class TestPay(unittest.TestCase):
    
        @mock.patch('pay.pay_way')
        def test_success(self, mock_pay_way):
            # 用一个mock来代替pay中的pay_way函数
            mock_pay_way.return_value={
        "result": "success", "reason":"null"}
            # 盗用要测试的函数
            ret = pay_status.pay_way_status()
            self.assertEqual(ret, '支付成功', '支付失败')
    
    if __name__ == '__main__':
        unittest.main()

2： patch上下文管理器：

> 1: 函数内部使用 : with mock.patch(‘被替代的函数路径’) as 别名：  
> 2: 别名.return\_value = \{返回值键值对\}

import unittest
    from unittest import mock
    
    import pay
    import pay_status
    
    class TestPay(unittest.TestCase):
        def test_success(self):
            with mock.patch('pay.pay_way') as mock_pay_way:
                # 用一个mock来代替pay中的pay_way函数
                mock_pay_way.return_value={
        "result": "success", "reason":"null"}
                # 盗用要测试的函数
                ret = pay_status.pay_way_status()
                self.assertEqual(ret, '支付成功', '支付失败')
    
    if __name__ == '__main__':
        unittest.main()

#### 类方法的替换： ####

*  mock.patch.object(类, ‘方法名’)返回指定类的函数的mock对象  
    刚刚上面被替换的都是一些函数，如果想要替换一个类中的某个函数如何操作呢？？？

from unittest import mock
    import unittest
    
    class Pay(object):
        def pay_way(self):
            """假设这里是一个支付的功能,未开发完
            支付成功返回：{"result": "success", "reason":"null"}
            支付失败返回：{"result": "fail", "reason":"余额不足"}
            reason返回失败原因
            """
            raise NotImplementedError('代码还没有实现')
    
        def pay_way_status(self):
            """根据支付的结果success或fail，判断跳转到对应页面
            假设这里的功能已经开发完成"""
    
            # todo 此时pay_way()函数并未完成！你先假定他完成了
            result = self.pay_way()
            print(result)
    
            if result["result"] == "success":
                return "支付成功"
            if result["result"] == "fail":
                return "支付失败"

方案一： 传统方式：

> 1: 先实例化这个类  
> 2：对象.被替换函数 = mock.Mock(return\_value = \{返回的键值对\})  
> 3：对象.被测函数()

class TestPayStatues(unittest.TestCase):
        '''单元测试用例'''
    
        def test_success1(self):
            '''测试支付成功场景'''
            p = Pay() # 实例化对象
            p.pay_way = mock.Mock(return_value = {
        "result": "success", "reason":"null"})
            statues = p.pay_way_status()
            print(statues)
            self.assertEqual(statues, "支付成功")

方案二： 装饰器

> 1： 在测试函数上增加装饰器:@mock.patch.object(类, ‘被代替的方法名’)  
> 2： 在增加一个函数传值，def test\_success2(self, mock\_obj):  
> 3： 使用新传值.return\_value = \{返回的键值对\}  
> 4： 实例化类.被测试函数()

class TestPayStatues(unittest.TestCase):
        @mock.patch.object(Pay, 'pay_way')
        def test_success2(self, mock_obj):
            '''测试支付成功场景'''
            mock_obj.return_value = {
        "result": "success", "reason":"null"}
            # 根据支付结果测试页面跳转
            statues = Pay().pay_way_status()
            print(statues)
            self.assertEqual(statues, "支付成功")

方案三：使用whith上下文

> 1: with mock.patch.object(类, ‘被代替的方法名’) as 新名字  
> 2：新名字.return\_value = \{\}  
> 3: 实例化类.被测试函数()

class TestPayStatues(unittest.TestCase):
        def test_success3(self):
            '''测试支付成功场景'''
            with mock.patch.object(Pay, 'pay_way') as mock_obj:
                mock_obj.return_value = {
        "result": "success", "reason":"null"}
                # 根据支付结果测试页面跳转
                statues = Pay().pay_way_status()
                print(statues)
                self.assertEqual(statues, "支付成功")

#### mock的两个属性： ####

*  mock.called: 决定mock是否被调用过。
 *  mock.call\_count : 决定mock被调用的次数。

案例测试：

import unittest
    import unittest.mock
    
    
    class MockTest(unittest.TestCase):
    
        def test_return_value(self):
            mock_obj = unittest.mock.Mock(return_value=1999)
            result = mock_obj()
            print(result)  # 打印 1999
    
            print(mock_obj.called)  # 是否被调用过, 返回布尔值
            print(mock_obj.call_count)  # 获取调用测试, 返回调用测试
    
    
    if __name__ == '__main__':
        unittest.main()

![在这里插入图片描述][20201020192254495.png_pic_center]

## 四： 测试报告 ##

### 1：HTMLTestRunner ###

1： 安装包：

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple htmltestrunner-python3

2：核心代码：

if __name__ == '__main__':
        # 1. 把测试用例添加到suite容器中
        suite = unittest.defaultTestLoader.discover('./', 'test_1_html.py')
    
        # 2. 打开文件，是一个文件对象
        with open('./HTMLTestRunner.html', 'w', encoding='utf-8') as f:
            # 3. HTMLTestRunner()创建一个runner对象
            runner = HTMLTestRunner(
                stream=f,  # 测试报告需要写入到的文件
                verbosity=2,  # 控制台输出信息的详细程度, 默认为1
                title='这是报告标题',  # 测试报告的标题
                description='这是一个测试报告'  # 测试报告的描述
            )
            # 4. runner把容器中测试用例运行
            runner.run(suite)

#### 2： BeautifulReport ####

1: 安装包：

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple beautifulreport

2： 核心代码：

if __name__ == '__main__':
        # 1. 把测试用例添加到suite容器中
        suite = unittest.defaultTestLoader.discover('./', 'test_2_beautiful.py')
    
        # 2. 创建runner对象，同时把suite传参进入
        runner = BeautifulReport(suite)
    
        # 3. 运行，同时生成测试报告
        # 参数1：生成文件的注释， 参数2：生成文件的filename, 参数3：生成report的文件存储路径
        runner.report('报告描述必须有，在报告中显示为用例名称', '测试报告文件名', './')

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/fb6bbe160e0b4fff9fc77fe4bd1048e3.png
[20201020143705374.png_pic_center]: /images/20221123/319c41a77f6a4445a9ad7b042c0f1634.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/48c35cc1ef3b4d76afa1af17aeb71c82.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/4ee125080ee5417b8b35686ad415717c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/8aa23974dc664453a93be482f7689a33.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/ddcf7aefdca44f7fae7c701c19013964.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/98f6053b77074abcb1606e1d6d50d109.png
[20201020153543212.png_pic_center]: /images/20221123/bb4beed04d444dde9ae1b47f5efafddc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/7e83d5bae0d0438fb3aa557986c804be.png
[20201020160050579.png_pic_center]: /images/20221123/79bfec2dd2e84e0b9806466ca4c25fcc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/88aef22769464b87a0967353fc7e6eb8.png
[20201020161112785.png_pic_center]: /images/20221123/0c5075708403427e94c6ec1121adf560.png
[20201020161535132.png_pic_center]: /images/20221123/85e1c38bec93487daca648f131f6644d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221123/4289ed7dbfd545589904215908d3177f.png
[20201020171203380.png_pic_center]: /images/20221123/f57245abab414ff29a10c914f864d4ff.png
[20201020171519310.png_pic_center]: /images/20221123/0bd6fb13e81c4beaaed079e3d9354cd5.png
[20201020192254495.png_pic_center]: /images/20221123/a6a302e6bdd048908450177005a42007.png