Python 单元测试

本是古典何须时尚 2023-09-29 20:42 16阅读 0赞

## 测试代码 ##

编写函数或类时，可以为其编写测试单元，通过测试，可以确定代码面对各种输入都能按照要求那样工作，在添加新代码时也可以对其进行测试，确保不会破坏既有程序。

### 1、测试函数 ###

首先编写一个程序 name\_functions.py，里面包含一个函数 get\_formatted\_name()，用以处理名和姓，得到全名full\_name：

# name_functions.py
    def get_formatted_name(first, last):
        """获得一个全名"""
        full_name = first + ' ' + last
        return full_name.title()

再编写一个程序 name.py：

# name.py
    from name_functions import get_formatted_name
    
    print("Enter 'q' at any time to quit")
    while True:
        first = input('\nFirst name: ')
        if first == 'q':
            break
        last = input('\nLast name: ')
        if last == 'q':
            break
        
        formatted_name = get_formatted_name(first, last)
        print('\Neatly formatted name: ' + formatted_name + '.')

上述程序只能处理名和姓，当有中间名的时候，我们需要修改 get\_formatted\_name（），使其能处理中间名（middle），又不破坏只有名和姓的方式，为此，我们每次都要在修改 get\_formatted\_name（）后进行测试，这样太繁琐了，索性，python提供了自动测试函数输出的高效方式。

#### 1.1、单元测试和测试用例 ####

python 标准库中的 unittest 模块提供了代码测试工具：

*  单元测试：

用于核实函数的某个方面没有问题

*  测试用例：

是一组单元测试，这些单元测试一起核实函数在各种情形下的行为都符合预期

**良好的测试用例考虑到了函数可能收到的各种输入，包含针对所有这些情形的测试，全覆盖式测试用例包含一整套单元测试，涵盖了各种可能的函数使用方式，大型项目要实现全覆盖可能很难，最初一般只要针对代码的重要行为编写测试即可，等项目被广泛使用时再考虑全覆盖。**

#### 1.2、可通过的测试 ####

要为函数创建测试用例，可先导入 unittest 模块以及要测试的函数，再创建一个继承 unittest.TestCase 的类，并编写一系列方法对函数的行为的不同方面进行测试。

下面是一个只包含一个方法的测试用例，它检查函数 get\_formatted\_name（）在给定名和姓时能否正确地工作：

# test_name_function.py
    import unittest
    from name_function import get_formatted_name
    
    class NameTestCase(unittest.TestCase):
        """测试name_function.py"""
        
        def test_first_last_name(self):
            """能处理如Janis Joplin 这样的姓名吗？"""
            formatted_name = get_formatted_name('janis', 'joplin')
    （3）       self.assertEqual(formatted_name, 'Janis Joplin')
            
    unittest.main()
    ----------------------------
    Ran 1 tests in o.001s     # 测试通过
    
    OK

首先，我们导入了模块 unittest 和要测试的函数，接下来我们创建了一个名为NameTestCase 的类（类名随意，最好包含Test），用于包含一系列针对函数的单元测试，这个类继承unittest.TestCase 类，这样python才知道如何运行你编写的测试。

在（3）处，我们使用了 unittest 类最有用的功能之一：一个断言方法，该方法可以用来判断是否与预期一致，有2个参数，第1个为“测试结果”，第2个为“预期结果”，在这里我们是期望 formatted\_name 的值为 Janis Joplin。如果相等就好，否则就输出错误信息。

#### 1.3、未通过的测试 ####

上述程序测试的是只有名和姓的情况，如果我在函数 get\_formatted\_name（）中再指定一个中间名（middle），那么再运行刚才的测试，就会出错：

# name_function.py
    def get_formatted_name(first, middle, last):
        """获得全名"""
        full_name = first + ' ' + middle + ' ' + last
        return full_name.title()

再运行测试程序 test\_name\_function.py：

# test_name_function.py
    Ran 1 test in 0.004s
    
    FAILED (errors=1)     # 测试未通过
    
    Error
    Traceback (most recent call last):
      File "C:\Users\hj\AppData\Local\Programs\Python\Python36-32\lib\unittest\case.py", line 59, in testPartExecutor
        yield
      File "C:\Users\hj\AppData\Local\Programs\Python\Python36-32\lib\unittest\case.py", line 605, in run
        testMethod()
      File "C:\Users\hj\PycharmProjects\package\test_get_formatted_name.py", line 7, in test_get_formatted_name
        formatted_name = get_formatted_name('tom', 'jerry')
    TypeError: get_formatted_name() missing 1 required positional argument: 'middle'   # 提示缺少一个实参

#### 1.4、测试未通过怎么办 ####

测试未通过，都会提示错误信息，根据信息修改原程序，而非测试程序；

在上述示例中，测试未通过提示我们确实一个实参（middle），那么我们修改 函数get\_formatted\_name（），将middle 设置为可选参数：

# get_formatted_name.py
    def get_formatted_name(first, last, middle=''):
        """获得全名"""
        if middle:
            full_name = first + ' ' + middle + ' ' + last
        else:
            full_name = first + ' ' + last
        return full_name.title()

运行测试程序 test\_name\_function.py：

# test_name_function.py
    Ran 1 test in 0.001s
    
    OK

#### 1.5、添加新测试 ####

再编写测试程序，确定其能处理包含中间名的姓名，为此我们在NameTestCase 类中添加个方法：

# test_name_function.py
    from unittest import TestCase
    from name_function import get_formatted_name
    
    
    class NameTestCase(TestCase):
        def test_first_last_name(self):
            """能处理如Janis Joplin 这样的姓名吗？"""
            formatted_name = get_formatted_name('tom', 'jerry')
            self.assertEqual(formatted_name, 'Tom Jerry')
    
        def test_middle(self):     # 添加新方法用以处理如Tom Li Jerry 这样的名字
            """能处理如Tom Li Jerry 这样的名字？"""
            formatted_name = get_formatted_name('tom', 'jerry', 'li')
            self.assertEqual(formatted_name, 'Tom Li Jerry')
            
    unittest.main()
    -----------------------------
    Ran 2 tests in 0.001s      # 测试通过，说明程序能够处理.......
    
    OK

> **踩坑提醒**

上述例子通过测试，在 python 自带 IDLE 中，能够正常运行，而使用 pycharm 进行测试函数时，修改原程序函数 get\_formatted\_name（），再运行测试程序，发现测试结果没有变化，上网查阅了资料得以确定是编辑器的原因，诸如pycharm 类似的编辑器在运行测试程序时，会优先运行本身自带的 unittest 组件，导致修改原函数结果没有变化（绕的我自己都糊涂了），为此在使用 pycharm 测试函数时，我们可以如下操作：（可参考：http://blog.csdn.net/u010816480/article/details/72821535）

*  鼠标选择要测试的函数，ctrl+shift+T，在弹出的窗口选择 creat new test （自动创建测试程序）
 *  创建测试程序只是一个框架，为此需要我们补充完成
 *  测试时，鼠标选择测试的类，右键选择 Run unittest xxxx 即可

测试代码如下：

# test_name_function.py
    from unittest import TestCase   # 直接导入unittest 模块的TestCase 类，而不是只导入模块
    from name_function import get_formatted_name
    
    class NameTestCase(TestCase): 
    	def test_first_last_name(self): 
    		formatted_name = get_formatted_name('tom', 'jerry') 
    		self.assertEqual(formatted_name, 'Tom Jerry')

### 2、测试类 ###

#### 2.1、各种断言方法 ####

python 在 unittest.TestCase 类中提供了很多断言方法，使用这些方法可核实返回的值等于或不等于预期的值、返回的值为 True 或 False、返回的值是否在列表中：

<table> 
 <thead> 
  <tr> 
   <th align="center">方法</th> 
   <th align="center">用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">assertEqual(a, b)</td> 
   <td align="center">核实 a == b</td> 
  </tr> 
  <tr> 
   <td align="center">assertNotEqual(a, b)</td> 
   <td align="center">核实 a ！== b</td> 
  </tr> 
  <tr> 
   <td align="center">assertTrue(x)</td> 
   <td align="center">核实 x 为True</td> 
  </tr> 
  <tr> 
   <td align="center">assertFalse(x)</td> 
   <td align="center">核实 x 为False</td> 
  </tr> 
  <tr> 
   <td align="center">assertIn(item, list)</td> 
   <td align="center">核实 item 在list 中</td> 
  </tr> 
  <tr> 
   <td align="center">assertNotIn(item, list)</td> 
   <td align="center">核实 item 不在 list 中</td> 
  </tr> 
 </tbody> 
</table>

#### 2.2、一个测试的类 ####

编写一个类来进行测试，用来管理匿名调查的类：

# survey.py
    class AnonymousSurvey():
        """收集匿名调查问卷的答案"""
            def __init__(self, question):
            """存储一个问题，并未存储答案做准备"""
            self.question = question
            self.responses = []
    
        def show_question(self):
            """显示调查问题"""
            print(self.question)
    
        def store_response(self, new_response):
            """存储单份调查问卷答案"""
            self.responses.append(new_response)
    
        def show_results(self):
            """显示调查文件答案"""
            print('Survey result: ')
            for response in self.responses:
                print('-' + response)

为证明 AnonymousSurvey 类能够正确地工作，我们编写一个使用它的程序 language\_survey.py：

# language_survey.py
    from language_survey import AnonymousSurvey
    
    # 定义一个问题，并创建一个表示调查的AnonymousSurvey对象
    question = 'What language did you first learn to speak?'
    my_survey = AnonymousSurvey(question)
    
    
    # 显示问题并存储答案
    my_survey.show_question()
    print("Enter 'q' at any time to quit.\n")
    while True:
        response = input('Language: ')
        if response == 'q':
            break
        my_survey.store_response(response)
    
    # 显示调查结果
    print('\nThank you to survey who participated in the survey!')
    my_survey.show_results()
    ----------------------------
    
    What language did you first learn to speak?
    Enter 'q' at any time to quit.
    
    Language: english
    Language: q
    
    Thank you to survey who participated in the survey!
    Survey result: 
    -english

将AnonymousSurvey 类存放在 模块 survey.py 中，并想进一步改进，让每位用户都可以输入多个答案，编写一个方法，它列出不同答案，并指出每个答案出现了多少次，再编写一个类，用于管理非匿名调查，经过上述修改可能存在风险，可能会影响 AnonymousSurvey 类的当前行为，为此我们可以编写针对这个类的测试。

#### 2.3、测试 AnonymousSurvey 类 ####

# test_anonymousSurvey.py         
    from unittest import TestCase          # 导入测试模块的类
    from survey import AnonymousSurvey     # 导入测试类
    
    class TestAnonymousSurvey(TestCase):
        """针对 AnonymousSurvey 类的测试"""
        
        def test_store_response(self):         # 测试单个答案
            """测试单个答案会被妥善地存储"""
            question = 'What language did you first learn to speak?'
            my_survey = AnonymousSurvey(question)   # 创建实例，传入实参 question
            my_survey.store_response('English')   # 调用store_response方法，将答案存储到属性responses（列表）中
    
            self.assertIn('English', my_survey.responses)  # 使用断言方法，判断是否在属性responses中
    
        def test_store_three_response(self):
            """测试三个答案会被妥善存储"""
            question = 'What language did you first learn to speak?'
            my_survey = AnonymousSurvey(question)
            responses = ['English', 'Spanish', 'Mandarin']   # 创建一个列表，将答案存储其中
            for response in responses:
                my_survey.store_response(response)       # 调用store_response方法，将答案存储到属性responses（列表）中
    
            for responses in  responses:
                self.assertIn(response, my_survey.responses)  # 使用断言方法，判断是否在属性responses中
    -------------------------------------
    
    
    Ran 2 tests in 0.002s       # 测试通过
    
    OK

#### 2.4、方法 setUp（） ####

在之前的 test\_anonymousSurvey.py 中，每个测试方法，我们都创建了一个 AnonymousSurvey 实例对象，并在每个方法中都创建了一个答案，平白多了几行代码；

而unittest.TestCase 类中包含了方法 setUp（），我们只需在方法 setUp（）创建一次实例对象，下面的每个测试方法都将能使用它们，python 也是优先运行它，为此省去了多余的代码：

# test_anonymousSurvey.py         
    from unittest import TestCase          # 导入测试模块的类
    from survey import AnonymousSurvey     # 导入测试类
    
    class TestAnonymousSurvey(TestCase):
        """针对 AnonymousSurvey 类的测试"""
        
        def setUp(self):
            """创建一个调查对象和一组答案，供测试方法使用"""
            question = 'What language did you first learn to speak?'
            self.my_survey = AnonymousSurvey(question)     # 创建实例对象
            self.responses = ['English', 'Spanish', 'Mandarin']  # 创建文件答案
            
        def test_store_single_response(self):
            """测试单个答案，并存储"""
            self.my_survey.store_response(self.responses[0])  # 调用store_response，并将答案存储到属性responses 中
            self.assertIn(self.response[0], self.my_surver.responses)  # 断言方法，判断是否在属性responses 中
            
        def test_store_three_response(self):
            """测试三个答案，并存储"""
            for response in self.responses:
                self.my_survey.store_response(response)
                
            for response in self.responses:
                self.assertIn(response, self.my_survey.responses)
               
      -------------------------------
    
    Ran 2 tests in 0.002s
    
    OK

> 注意

运行测试时，每完成一个单元测试，python 都会打印一个字符：通过打印一个句点，错误打印一个E，测试导致断言失败打印一个F。

在项目中包含初步测试，将使程序更趋完美，在用户报告bug 之前，把问题考虑在内，在项目早期，不要试图去编写全覆盖的测试用例，除非有充分的理由。

> 练习

编写一个名为 Employee 的类，其方法 **init** 接受名、姓和年薪，并将他们存储到属性中，编写一个名为 give\_raise（）的方法，它默认将年薪增加 5000 美元，但也能接受其他的年薪增加量。

为 Employee 编写一个测试用例，包含两个测试方法：test\_default\_raise（）和 test\_give\_custom\_raise（），使用方法 setUp（），以免在每个测试方法都创建新的雇员实例，运行这个测试用例，确认两个测试都通过了。

# name_employee.py
    class Employee():
        """编写一个类接受雇员姓名和年薪"""
        
        def __init__(self, first, last, salary ):
            """初始化雇员姓名和年薪"""
            self.first_name = first
            self.last_name = last
            self.salary = salary
            
        def give_raise(self, raise=5000):
            """设置年薪增加量"""
            self.salary += raise

# test_employee.py
    from unittest import TestCase
    from name_employee import Employee
    
    class TestEmployee(TestCase):
        """测试 Employee 类 """
        def setUp(self):
            """给 Employee 类创建实例化对象，以供测试使用"""
            self.someone = Employee('li', 'la', 65000)      
            
        def test_give_default(self):
            """测试默认年薪增加量为 5000 美元"""
            self.someone.give_raise()
            self.assertEqual(self.someone.salary, 70000)
            
        def test_give_custom_raise(self):
            """测试能接受其他年薪增加量"""
            self.someone.give_raise(6000)
            self.assertEqual(self.someone.salary, 71000)
    -------------------------------------------------------------------------
    
    
    Ran 2 tests in 0.057s
    
    OK