【测试】unittest单元测试、assert断言、parameterized参数化、mock替代

柔光的暖阳◎ 2022-12-16 10:57 178阅读 0赞

#### 1. unittest基本概念 ####

**1.1 unittest**  
unittest是python官方提供的测试框架，可以同时执行多个测试用例，还有丰富的测试结果展示。下面是执行过程  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MTQ3Mjk5_size_16_color_FFFFFF_t_70_pic_center]

**1.2 TestCase**  
TestCase（测试用例）就是一个完整的测试流程，我们称之为一个测试用例

import unittest
    # 1.继承unittest.TestCase 
    # 2.测试用例名要以test开头
    class MyTest(unittest.TestCase):
        def test_demo1(self):
            pass

**1.3 TestSuite**  
TestSuite（测试套件）就是多个测试用例的集合，即多个TestCase

import unittest
    class MyTest(unittest.TestCase):
        def test_demo1(self):
            pass
    suite = unittest.TestSuite()
    # 可添加TestCase或TestSuite
    suite.addTest(MyTest('test_demo1'))

**1.4 TextTestRunner**  
TextTestRunner（测试执行）是用来执行测试套件的

import unittest
    ...
    suite.addTest(MyTest('test_demo1'))
    runner = unittest.TextTestRunner()
    runner.run(suite)

**1.5 Fixture**  
Fixture是指一个测试用例环境的搭建和销毁，比如说实现了setUp()和tearDown()

**1.6 defaultTestLoader**  
我们可以调用defaultTestLoader.discover()自动把测试用例添加到测试套件中，返回一个suite对象

import unittest
    
    if __name__ == '__main__':
        # 参数1：指定搜索的路径
        # 参数2：指定匹配文件，默认为'test*.py'
        suite = unittest.defaultTestLoader.discover('./', 'test_2_fixture.py')
        runner = unittest.TextTestRunner()
        runner.run(suite)

#### 2.assert断言 ####

断言的意思就是，程序执行到某一步，确定它是否符合预期结果，若不符合预期，则抛出异常。以下是常用的断言

布尔类型

<table> 
 <thead> 
  <tr> 
   <th>assert</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>assertEqual(arg1, arg2, msg=None) <br>assertNotEqual(arg1, arg2, msg=None)</td> 
   <td>arg1是否等于arg2</td> 
  </tr> 
  <tr> 
   <td>assertTrue(expr, msg=None)<br> assertFalse(expr, msg=None)</td> 
   <td>expr表达式结果是否为True</td> 
  </tr> 
  <tr> 
   <td>assertIs(arg1, arg2, msg=None) <br>assertIsNot(arg1, arg2, msg=None)</td> 
   <td>arg1与arg2是否为同一对象</td> 
  </tr> 
  <tr> 
   <td>assertIn(arg1, arg2, msg=None)<br> assertNotIn(arg1, arg2, msg=None)</td> 
   <td>arg1是否arg2的子串</td> 
  </tr> 
  <tr> 
   <td>assertIsInstance(obj, cls, msg=None) <br>assertNotIsInstance(obj, cls, msg=None)</td> 
   <td>obj是否cls的实例</td> 
  </tr> 
 </tbody> 
</table>

数据结构类型

<table> 
 <thead> 
  <tr> 
   <th>assert</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>assertListEqual(list1, list2, msg = None)</td> 
   <td>list1是否等于list2</td> 
  </tr> 
  <tr> 
   <td>assertTupleEqual (tuple1, tuple2, msg = None)</td> 
   <td>tuple1是否等于tuple2</td> 
  </tr> 
  <tr> 
   <td>assertDictEqual (expected, actual, msg = None</td> 
   <td>dict1是否等于dict2</td> 
  </tr> 
  <tr> 
   <td>assertSetEqual (set1, set2, msg = None)</td> 
   <td>set1是否等于set2</td> 
  </tr> 
 </tbody> 
</table>

计算表达式类型

<table> 
 <thead> 
  <tr> 
   <th>assert</th> 
   <th>断言</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>assertAlmostEqual (first, second, places = 7, msg = None, delta = None) <br>assertNotAlmostEqual (first, second, places, msg, delta)</td> 
   <td>fist约等于second，places是精确到小数点位数，若指定了delta，两者差值要&lt;=delta</td> 
  </tr> 
  <tr> 
   <td>assertGreater (first, second, msg = None) <br>assertGreaterEqual (first, second, msg = None)</td> 
   <td>first大于second</td> 
  </tr> 
  <tr> 
   <td>assertLess (first, second, msg = None)<br>assertLessEqual (first, second, msg = None)</td> 
   <td>first小于second</td> 
  </tr> 
 </tbody> 
</table>

正则表达式类型

<table> 
 <thead> 
  <tr> 
   <th>assert</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>assertRegexpMatches (text, regexp, msg = None)</td> 
   <td>使用expexp表达式是否匹配到text</td> 
  </tr> 
  <tr> 
   <td>assertNotRegexpMatches (text, regexp, msg = None)</td> 
   <td>使用expexp表达式是否匹配不到text</td> 
  </tr> 
 </tbody> 
</table>

#### 3.parameterized参数化 ####

上面的测试用例都是不能传递参数的，如果想要参数，我们可以使用parameterized，不过得要先安装

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

简单使用

import unittest
    from parameterized import parameterized
    
    class MyParamsTest(unittest.TestCase):
    	# 参数格式是列表套字典
        params = [('yun', '123'), ('han', '456'), ('liu', '789')]
    
        @parameterized.expand(params)
        def test_params(self, name, password):
            print("name:%s, password:%s" % (name, password))
    
    if __name__ == '__main__':
        unittest.main()

运行结果

...
    ----------------------------------------------------------------------
    Ran 3 tests in 0.000s
    
    OK
    name:yun, password:123
    name:han, password:456
    name:liu, password:789

#### 4.mock替代 ####

假如在开发工程中需要用到一个未完成的函数，又想模拟该函数返回应有的结果，这个时候我们可以使用mock。mock的作用就是使用mock对象替代指定的python对象

##### 4.1 mock 对象 #####

mock对象有一些常用的属性和方法，可以让我们更方便进行测试

<table> 
 <thead> 
  <tr> 
   <th>属性或方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>calledproperty</td> 
   <td>是否被调用过</td> 
  </tr> 
  <tr> 
   <td>call_count</td> 
   <td>获取调用测试, 返回调用测试</td> 
  </tr> 
  <tr> 
   <td>assert_called<br>assert_not_called</td> 
   <td>是否被调用过</td> 
  </tr> 
  <tr> 
   <td>assert_called_once()</td> 
   <td>是否只被调用过一次</td> 
  </tr> 
  <tr> 
   <td>call_args</td> 
   <td>返回最后一次调用使用的参数</td> 
  </tr> 
 </tbody> 
</table>

##### 4.2 return\_value #####

pay.py

def pay():
        # 格式： {"result":"success","errmsg":"ok"}
        raise NotImplemented("支付功能还没写好")

pay\_status.py

import pay
    
    def pay_status():
        result = pay.pay()
        if result["result"] == "success":
            return "支付成功"
        else:
            return "支付失败"

test\_pay.py

import unittest
    import pay,pay_status
    import mock
    
    
    class TestPay(unittest.TestCase):
        def test_success(self):
            pay.pay = mock.Mock(return_value={ "result":"success","errmsg":"ok"})
            ret = pay_status.pay_status()
            self.assertEqual(ret,"支付成功","支付失败")
    
    if __name__ == '__main__':
        unittest.main()

注意：如果是旧版本的python可能需要单独安装mock，新版本已集成到unittest

##### 4.3 patch 装饰器 #####

mock.patch()可以通过字符串描述路径参数，返回一个mock对象。通过装饰器的方法，我们修改上面的代码如下

test\_pay.py

import unittest
    import pay_status
    import mock
    
    class TestPay(unittest.TestCase):
        @mock.patch('pay.pay') # 使用装饰器，上面就不用导包了
        # pay.pay()被替换成mock_pay传入
        def test_success(self,mock_pay):
            # 修改return_value的值
            mock_pay.return_value={ "result":"success","errmsg":"ok"}
    
            ret = pay_status.pay_status()
            self.assertEqual(ret,"支付成功","支付失败")
    
    if __name__ == '__main__':
        unittest.main()

##### 4.4 patch 上下文管理器 #####

patch方法，除了使用装饰器，我们还可以使用上下文管理器

test\_pay.py

import unittest
    import pay_status
    import mock
    
    class TestPay(unittest.TestCase):
    
        def test_success(self):
        	# 指定路径，上面就不用导包啦，并且命名为mock_obj
            with mock.patch('pay.pay') as mock_obj:
                # 修改return_value的值
                mock_obj.return_value={ "result":"success","errmsg":"ok"}
    
                ret = pay_status.pay_status()
                self.assertEqual(ret,"支付成功","支付失败")
    
    if __name__ == '__main__':
        unittest.main()

##### 4.5 mock 类方法替换 #####

上面的写法是直接调用某个方法，如果把方法都封装在一个类里，我们可以使用类方法替换实现mock模拟

`mock.patch.object(类, '方法名')` 返回指定类的函数的mock对象

改写代码如下

from unittest import mock
    import unittest
    
    class Pay(object):
        def pay(self):
            # 格式： {"result":"success","errmsg":"ok"}
            raise NotImplemented("支付功能还没写好")
    
        def pay_status(self):
            result = self.pay()
            if result["result"] == "success":
                return "支付成功"
            else:
                return "支付失败"
    
    class TestPayStatus(unittest.TestCase):
        def test_success1(self):
            p = Pay()
            p.pay = mock.Mock(return_value={ "result": "success", "errmsg": "ok"})
            ret = p.pay_status()
            self.assertEqual(ret, "支付成功", "支付失败")
    
        # 使用装饰器的方式
        @mock.patch.object(Pay, 'pay')
        def test_success2(self, mock_obj):
            mock_obj.return_value = { "result": "success", "errmsg": "ok"}
            ret = Pay().pay_status()
            self.assertEqual(ret, "支付成功", "支付失败")
    
        # 使用with上下的方式
        def test_success3(self):
            with mock.patch.object(Pay, 'pay') as mock_obj:
                mock_obj.return_value = { "result": "success", "errmsg": "ok"}
                ret = Pay().pay_status()
                self.assertEqual(ret, "支付成功", "支付失败")
    
    if __name__ == '__main__':
        unittest.main()

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MTQ3Mjk5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/5f3a8cc768f84faa85336832f9ae3161.png