自动化测试之七：unittest单元测试框架

雨点打透心脏的1/2处 2023-01-07 10:04 313阅读 0赞

### 前言： ###

###         单元测试是一项对技术要求很高的工作，只有白盒测试人员和软件开发人员才能胜任，但用单元测试框架做单元测试却十分简单，而且单元测试框架不仅可以用来做单元测试，还适用于不同类型的“自动化”测试，其功能主要有： ###

### （1） 提供用例组织和执行 ###

### （2） 提供丰富的断言方法 ###

### （3）提供丰富的日志 ###

### 1 认识 unittest ###

### **在python中有很多单元测试框架，如：doctest，unittest，pytest，nose等。现如今，unittest已经被作为一个标准模块放入python开发包中。** ###

### **1.1 认识单元测试** ###

**不用单元测试框架能写单元测试吗，当然可以！单元测试的本质上就是通过一端代码验证另外一段代码，所以不用单元测试框架也可以写出单元测试，例：**

**以下两个文件都放置在unittest\_use包下**

cal.py
    
    class Cal():
        """
        计算器类
        """
        def __init__(self, a, b):
            self.a = a
            self.b = b
    
        def add(self):
            """
            加法
            """
            return self.a + self.b
    
        def sub(self):
            """
            减法
            """
            return self.a - self.b
    
        def mul(self):
            """
            乘法
            """
            return self.a * self.b
    
        def div(self):
            """
            除法
            """
            return self.a / self.b

test_cal.py
    
    from unittest_use.cal import Cal
    
    
    def test_add():
        c = Cal(3, 5)
        result = c.add()
        print("add", result)
        assert result == 8, "加法运算失败"
    
    
    def test_sub():
        c = Cal(7, 2)
        result = c.sub()
        print("sub", result)
        assert result == 5, "减法运算失败"
    
    
    def test_mul():
        c = Cal(3, 3)
        result = c.mul()
        print("mul", result)
        assert result == 10, "乘法运算失败"
    
    
    def test_div():
        c = Cal(6, 2)
        result = c.div()
        print("div", result)
        assert result == 3, "除法运算失败"
    
    
    if __name__ == '__main__':
        test_add()
        test_sub()
        test_mul()
        test_div()

**运行test\_cal.py后结果如下：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L215bGlfYmluYmlu_size_16_color_FFFFFF_t_70][]

**这样虽然可以实现测试的效果，但是也存在着问题，比如，我们要自己实现断言失败的信息，最后结果无法统计等。当然，我们可以编写更多的代码来解决问题，但这就偏离了我们做单元测试的初衷，我们应该把重点放在测试本身，而不是其他上面，所以引入单元测试框架就能很好的解决问题。如下：**

test_cal_1.py
    
    
    import unittest
    from unittest_use.cal import Cal
    
    
    class Calculator(unittest.TestCase):
        def test_add(self):
            c = Cal(3, 5)
            result = c.add()
            self.assertEqual(result, 8)
    
        def test_sub(self):
            c = Cal(7, 2)
            result = c.sub()
            self.assertEqual(result, 5)
    
        def test_mul(self):
            c = Cal(3, 3)
            result = c.mul()
            self.assertEqual(result, 10)
    
        def test_div(self):
            c = Cal(6, 2)
            result = c.div()
            self.assertEqual(result, 3)
    
    
    if __name__ == '__main__':
        unittest.main()

**输出结果：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L215bGlfYmluYmlu_size_16_color_FFFFFF_t_70 1][]

**上面测试用例，就是用unittest编写的，但是，使用unittest就要遵循其“规则”！！！！！！！！！！！！！！！！：**

**（1）创建一个类，类名自己起，这是无所谓的，但是必须要继承unittest模块的TestCase类**

**（2）创建测试方法，该方法必须要以“test”开头**

**如上面测试用例所示，测试结果不再使用assert断言方法自己定义失败断言了，而是直接调用assertEqual()方法来断言结果与预期是否相同，该方法由TestCase提供，所以直接self.assertEqual()调用即可。最后使用unittest的main()方法来执行测试，它会按照上面说的两条规则查找测试用例**

**结果分析：**

**从上面输出结果可以看到丰富了很多，其中，用点（.）表示一条运行通过的测试用例，用 F 表示一条运行失败的用例，用 E 表示一条运行错误的测试用例， 用 s 表示一条运行跳过的测试用例。**

**本次统计运行了4条测试用例，用时0.003s，失败(failures)了一条测试用例，并且失败的测试用例也有清晰的说明。**

### **2 重要的概念** ###

**在unittest文档中，有四个重要的概念：Test Case，Test Suite， Test Runner， Test Fixture，只有理解了这几个概念，才能理解单元测试的基本特征。**

**2.1 Test Case**

**Test Case是最小的测试单元，用于检查特定输入集合的特定返回值。unittest提供了TestCase基类，我们创建的测试类需要继承该基类，它可以用来创建新的测试用例。**

**2.2 Test Suite**

**测试套件是测试用例、测试套件或者两者的组合，用于组装一组要运行的测试。unittest提供了TestSuite类来创建测试套件。**

**2.3 Test Runner**

**Test Runner是一个组件，用于协调测试的执行并向用户提供结果。Test Runner可以使用图形界面，文本界面或返回特殊值来展示执行测试的结果。unittest提供了TextTestRunner类运行测试用例，为了生成Html格式的测试报告，后面还会选择使用HTMLTestRunner运行类。**

**2.4 Test Fixture**

**Test Fixture代表执行一个或多个测试所需的环境准备，以及关联的清理动作。例如，创建临时或代理数据库、目录，或者启动服务器京城。unittest中提供了setUp()/tearDown()、setUpClass()/tearDownClass()等方法来完成这些操作。**

**在理解了上面的几个概念之后，我们使用新的测试用例来进行测试，如下：**

import unittest
    from unittest_use.cal import Cal
    
    
    class Calculator(unittest.TestCase):
        # 测试用例前置动作
        def setUp(self):
            print("this is setUp")
    
        # 测试用例后置动作
        def tearDown(self):
            print("this is tearDown")
    
        def test_add(self):
            c = Cal(3, 5)
            result = c.add()
            self.assertEqual(result, 8)
    
        def test_sub(self):
            c = Cal(7, 2)
            result = c.sub()
            self.assertEqual(result, 5)
    
        def test_mul(self):
            c = Cal(3, 3)
            result = c.mul()
            self.assertEqual(result, 10)
    
        def test_div(self):
            c = Cal(6, 2)
            result = c.div()
            self.assertEqual(result, 3)
    
    
    if __name__ == '__main__':
        # 创建测试套件
        suit = unittest.TestSuite()
        suit.addTest(Calculator("test_add"))
        suit.addTest(Calculator("test_sub"))
        suit.addTest(Calculator("test_mul"))
        suit.addTest(Calculator("test_div"))
    
        # 创建测试运行器
        runner = unittest.TextTestRunner()
        runner.run(suit)

**测试结果如下：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L215bGlfYmluYmlu_size_16_color_FFFFFF_t_70 2][]

**改动说明：**

**①：在类中增加了setUp和tearDown方法，用于定义测试用例的前置动作和后置动作；**

**②：测试用例执行的修改，就是** **if \_\_name\_\_ == '\_\_main\_\_':下面的修改，这里不再使用unittest的main方法，而是调用了TestSuite类下的addTest方法来添加测试用例。因为一次只能添加一个测试用例，所以需要制定测试类及测试方法，然后再调用TextTestRunner类下面的run运行测试套件。**

**优缺点：**

**缺点：比直接使用main方法要麻烦很多**

**优点：①：测试用例的制定顺序可以由测试套件的添加顺序控制，main方法只能按照测试类，方法的名称来执行测试用例；②：当一个测试文件中有很多的测试用例时，但并不是每次都要执行所有的测试用例，尤其是比较耗时的UI自动化测试，通过测试套件和测试运行器可以灵活的控制要执行的测试用例。**

**结果分析：**

**setUp/tearDown作用于每一条测试用例的开始位置和结束位置**

### **3 断言方法** ###

**在执行测试用例的过程中，最终测试用例执行成功与否，是通过测试得到的实际结果与预期结果进行比较得到的。unittest框架的TestCase类提供的常用的用于测试结果的断言方法如下：**

# 断言 first == second
    assertEqual(self, first, second, msg=None)
    
    # 断言 first != second
    assertNotEqual(self, first, second, msg=None)
    
    # 断言 bool(expr) is True
    assertTrue(self, expr, msg=None)
    
    # 断言 bool(expr) is False
    assertFalse(self, expr, msg=None)
    
    # 断言 expr1 is expr2
    assertIs(self, expr1, expr2, msg=None)
    
    # 断言 expr1 is not expr2
    assertIsNot(self, expr1, expr2, msg=None)
    
    # 断言 obj is None
    assertIsNone(self, obj, msg=None)
    
    # 断言 obj is not None
    assertIsNotNone(self, obj, msg=None)
    
    # 断言 member in container
    assertIn(self, member, container, msg=None)
    
    # 断言 member not in container
    assertNotIn(self, member, container, msg=None)
    
    # 断言 obj 是 cls对象
    assertIsInstance(self, obj, cls, msg=None)
    
    # 断言 obj 不是 cls对象
    assertNotIsInstance(self, obj, cls, msg=None)

**断言方法的使用，如下：**

import unittest
    
    
    class TestAssert(unittest.TestCase):
    
        def test_equal(self):
            self.assertEqual(2 + 3, 5)
            self.assertEqual("li", "li")
            self.assertEqual("python", "python")
    
        def test_in(self):
            self.assertIn("a", ["a", "b"])
            self.assertIn("he", "hello")
    
        def test_true(self):
            self.assertTrue(True)
            self.assertTrue(False)
    
    
    if __name__ == '__main__':
        unittest.main()

**结果如下：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L215bGlfYmluYmlu_size_16_color_FFFFFF_t_70 3][]

### 4 测试用例的组织与discover方法 ###

**你是否发现前面的测试用例有什么问题，或者存在什么缺陷？**

**首先，一个功能对应一条测试用例显然是不够的，要写多少测试用例取决于你对功能需求与测试方法的理解，其次，是测试用例的划分，建议一个测试类对应一个被测试功能**

**如下：**

**我们可以在一个测试文件中定义多个测试类，只要它遵循测试用例的“规则”即可，main方法就可以找到并执行它们，但是，我们要测试的类或方法可能有很多**

import unittest
    from unittest_use.cal import Cal
    
    
    class TestAdd(unittest.TestCase):
        """add()方法测试"""
    
        def test_add_integer(self):
            """测试整数相加"""
            c = Cal(3, 5)
            result = c.add()
            self.assertEqual(result, 8)
    
        def test_add_str(self):
            """测试字符串整数相加"""
            c = Cal("4", "6")
            result = c.add()
            self.assertEqual(result, 10)
    
        def test_add_decimal(self):
            """测试小数相加"""
            c = Cal(3.5, 5.3)
            result = c.add()
            self.assertEqual(result, 8)
    
        # ......
    
    
    class TestSub(unittest.TestCase):
        pass
    
    
    if __name__ == '__main__':
        unittest.main()

**到此为止我们已经写了好几个测试文件，那么你有没有想过这么多的测试文件，我们能不能一次执行执行多个测试文件呢？**

**当然可以！！！，下面就介绍一下unittes中的TestLoader类提供的discover方法，它可以从多个文件中查找测试用例。**

**该类根据各种标准加载测试用例，并将它们返回给测试套件。正常情况下，不需要创建这个类的实例，unittest提供了可以共享的defaultTestLoader类，可以使用其子类或方法创建实例，discover方法就是其中之一**

discover(self, start_dir, pattern='test*.py', top_level_dir=None)
    
    start_dir：待测试的模块名或测试用例目录
    
    patterns：测试用例文件名的匹配规则
    
    top_level_dir：测试模块的顶层目录，如果没有顶层目录，则默认为None

**下面使用该方法测试：**

**这里的test\_dir使用的时候需要注意，因为我之前的所有测试文件和下面要测试的文件在同一个包内，我想测试的就是该包内所有的测试文件，所以获取的其父目录的路径！！！！！！！！！！**

import unittest
    import os
    test_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)))
    print(test_dir)
    
    suits = unittest.defaultTestLoader.discover(test_dir, pattern="test*.py")
    
    
    if __name__ == '__main__':
        runner = unittest.TextTestRunner()
        runner.run(suits)

**说明：discover会自动根据测试用例目录test\_dir查找测试用例文件test\*.py，并将找到的测试用例添加到测试套件中，因此，可以直接通过run方法执行测试套件suits。这种方式极大的简化了测试用例的查找，我们需要做的就是按照文件的匹配规则创建测试文件即可**

### **5 关于unittest还需要知道的** ###

**5.1 测试用例的执行顺序**

**测试用例的执行顺序设计多个层级，多个测试目录 > 多个测试文件 > 多个测试类 > 多个测试方法（测试用例）。unittest提供的main方法和discover方法是按照什么顺序查找测试用例的呢？**

**    unittest默认会根据ASCII码的顺醋加载测试用例（数字与字母的顺序为0-9，A-Z, a-z），它并不是按照测试用例的创建顺序从上到下执行的**

**    discover方法和main方法的执行顺序都一样，对于测试目录和测试文件来说，上面的规律同样适用。所以，如果想让某个测试文件先执行，可以在命名上加以控制**

**    除命名外，我们可以通过声明测试套件TestSuite类，通过addTest方法按照一定的顺序来加载测试用例**

**5.2 执行多级目录的测试用例**

![20210116233628777.png][]

**当测试用例达到一定量时，就要考虑划分目录，根据不同功能或者其他分类划分不同的目录，那么如果将disvocer方法中的start\_dir定义为test1的路径，那么只能加载c.py中的测试用例，那么如何让unittest查找test2和test3目录下的测试文件呢，      那就是将这两个目录改为包就可以了！！！！！！！！！！**

**5.3 跳过测试和预期失败**

**在运行处测试用例时，有时候需要直接跳过某些测试用例，或者当测试用例符合某个条件时跳过测试，又或者直接将测试用例设置为失败。unittest提供了实现这些需求的装饰器**

# 无条件的跳过装饰的测试，需要说明跳过的原因
    
    unittest.skip(reason)  
    
    
    # 如果条件为真，则跳过装饰的测试
    
    unittest.skipIf(condition, reason)
    
    # 当条件为真时，执行装饰的测试
    
    unittest.skipUunless(condition, reason)
    
    # 不管执行结果是否失败，都将测试标记为失败
    
    unittest.expectedFailure()

**如下：**

import unittest
    
    class Test(unittest.TestCase):
    
        @unittest.skip("直接跳过测试")
        def test_skip(self):
            print("test skip")
    
        @unittest.skipIf(True, "当条件为真时跳过")
        def test_skipif(self):
            print("test skipif")
    
        @unittest.skipUnless(True, "当条件为真时执行")
        def test_skip_unless(self):
            print("test skip_unless")
    
        @unittest.expectedFailure
        def test_expected_failure(self):
            print("test expected failure")
    
    
    if __name__ == '__main__':
        unittest.main()

**结果：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L215bGlfYmluYmlu_size_16_color_FFFFFF_t_70 4][]

**5.4 Fixture**

**我们可以把Fixture看做是夹心饼干外层的两片饼干，这两片饼干就是setUp/tearDown，中间的夹层就是测试用例，除了我们前面提到过的setUp/tearDown之外，unittest还提供了更大范围的Fixture，如测试类和模块的Fixture。**

import unittest
    
    def setUpModule():
        print("test module start...........")
    
    def tearDownModule():
        print("test moudule end..............")
    
    class MyTest(unittest.TestCase):
        @classmethod
        def setUpClass(cls):
            print("test class start ---------->")
    
        @classmethod
        def tearDownClass(cls):
            print("test class end ------------>")
    
        def setUp(self):
            print("test case start ==========")
    
        def tearDown(self):
            print("test case end ============")
    
        def test_case(self):
            print("case 1")
    
        def test_casel(self):
            print(" case 2")
    
    
    if __name__ == '__main__':
        unittest.main()

**结果如下：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L215bGlfYmluYmlu_size_16_color_FFFFFF_t_70 5][]

**结果分析：**

setUpModule/tearDownModule：在整个模块的开始与结束时被执行

setUpClass/tearDownClass：在测试类的开始与结束时被执行

setUp/tearDown： 在测试用例的开始与结束时被执行

### **需要注意的是：****setUpClass/tearDownClass为类方法，需要通过@classmethod进行装饰** ###

### **6 编写Web自动化测试** ###

import unittest
    from time import sleep
    from selenium import webdriver
    
    chrome_driver_path = r"C:\Users\Administrator\Envs\selenuimAutoTest\Lib\site-packages\selenium\webdriver\chrome\chromedriver.exe"
    
    
    class TestBaiDu(unittest.TestCase):
    
        @classmethod
        def setUpClass(cls):
            cls.driver = webdriver.Chrome(executable_path=chrome_driver_path)
            cls.base_url = "http://www.baidu.com"
    
        def baidu_search(self, search_key):
            self.driver.get(self.base_url)
            self.driver.find_element_by_id("kw").send_keys(search_key)
            self.driver.find_element_by_id("su").click()
            sleep(2)
    
        def test_search_selenium(self):
            search_key = "selenium"
            self.baidu_search(search_key)
            self.assertEqual(self.driver.title, search_key + "_百度搜索")
    
        def test_search_unittest(self):
            search_key = "unittest"
            self.baidu_search(search_key)
            self.assertEqual(self.driver.title, search_key + "_百度搜索")
    
        @classmethod
        def tearDownClass(cls):
            cls.driver.quit()
    
    
    if __name__ == '__main__':
        unittest.main()

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L215bGlfYmluYmlu_size_16_color_FFFFFF_t_70]: /images/20221119/4ddc07f8cc214a688345a0a85fbb7943.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L215bGlfYmluYmlu_size_16_color_FFFFFF_t_70 1]: /images/20221119/7a011ae59e08431bb94f66d1d2e1a8ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L215bGlfYmluYmlu_size_16_color_FFFFFF_t_70 2]: /images/20221119/6e8a01f1095647aabe2795fdd05b9188.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L215bGlfYmluYmlu_size_16_color_FFFFFF_t_70 3]: /images/20221119/07012fda013a408fb55bdd774d0636b9.png
[20210116233628777.png]: /images/20221119/14548506bd114438b7f147c71f7f172b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L215bGlfYmluYmlu_size_16_color_FFFFFF_t_70 4]: /images/20221119/0659cb0c2cbc4cc289122b7a6f0507c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L215bGlfYmluYmlu_size_16_color_FFFFFF_t_70 5]: /images/20221119/4821200c04da4d03a83aa1bad2dfa6ad.png