【自动化测试必学语言】python：UnitTest框架

概念： UnitTest 是 Python 自带的⼀个单元测试框架，用它来做单元测试。 ---- 自带的框架（官方）：不需要单外安装，只要安装了 Python ，就可以使用 random ， json ， os ， time 第三方框架：想要使用需要先安装后使用（ pytest ） selenium， appium ， requests ---- 单元测试框架：主要用来做单元测试，⼀般单元测试是开发做的 . 对于测试来说， unittest 框架的作用是自动化脚本（用例代码）执行框架（使用 unittest 框架来管理运行多个测试用例的）

为什么使用UnitTest框架?

能够组织多个用例去执行
提供丰富的断言方法（让程序代码代替人工自动的判断预期结果和实际结果是否相符）
能够生成测试报告

UnitTest核心要素（unitest 的组成部分）

1.TestCase（最核心的模块）

TestCase （测试用例），注意这个测试用例是 unittest 框架的组成部分，不是手工和自动化中我们所说的用例（ TestCase ）主要作用：每个 TestCase （测试用例）都是⼀个代码文件，在这个代码文件中来书写真正的用例代码

2.TestSuite

TestSuite （测试套件），用来管理组装（打包）多个 TestCase （测试用例）的

3.TestRunner

TestRunner （测试执行，测试运行），来执行 TestSuite （测试套件）的

4.TestLoader

TestLoader （测试加载），功能是对 TestSuite （测试套件）功能的补充，管理组装（打包）多个 TestCase （测试用例）的

5.Fixture

Fixture （测试夹具），书写在 TestCase （测试用例）代码中，是⼀个代码结构，可以在每个方法执行前后都会执行的内容举例：登录的测试用例，每个用例中重复的代码就可以写在 Fixture 代码结构中，只写⼀遍，但每次用例方法的执行，都会执行 Fixture 中的代码 1. 打开浏览器 2. 输入网址

TestCase（测试用例）

1. 是⼀个代码文件，在代码文件中来书写真正的用例代码 2. 代码文件的名字必须按照标识符的规则来书写（可以将代码的作用在文件的开头使用注释说明）

步骤

1. 导包 ( unittest ) 2. 自定义测试类 3. 在测试类中书写测试方法 4. 执行用例

代码

"""
代码的⽬的: 学习 TestCase(测试⽤例)模块的书写⽅法
"""
# 1  导包
import unittest

# 2  ⾃定义测试类, 需要继承 unittest 模块中的TestCase 类即可
class TestDemo(unittest.TestCase):
    # 3, 书写测试⽅法, 即 ⽤例代码. ⽬前没有真正的⽤例代码, 使⽤ print 代替
    # 书写要求, 测试⽅法 必须以 test_ 开头(本质是以test 开头)
    def test_method1(self):
        print('测试⽅法 1')
    def test_method2(self):
        print('测试⽅法 2')
# 4   执⾏⽤例(⽅法)
# 4.1 将光标放在 类名的后边 运⾏, 会执⾏类中的所有的测试⽅法
# 4.2 将光标放在 ⽅法名的后边 运⾏, 只执⾏当前的⽅法

问题1 代码文件的命名不规范

1. 代码文件的名字以数字开头 2. 代码文件名字中有空格 3. 代码文件名字有中文 4. 其他的特殊符号（数字，字母，下划线组成，不能以数字开头）

问题 2 代码运行没有结果

右键运行没有 unittests for 的提示，出现的问题解决方案：方案 1. 重新新建⼀个代码文件，将写好的代码复制进去方案 2. 删除已有的运行方式

问题 3 没有找到用例

测试方法中不是以 test _ 开头的，或者单词写错了

TestSuite & TestRunner

TestSuite （测试套件）：管理打包组装 TestCase （测试用例）文件的 TestRunner （测试执行）：执行 TestSuite （套件）

步骤

1. 导包 ( unittest ) 2. 实例化 ( 创建对象 ) 套件对象 3. 使⽤套件对象添加用例方法 4. 实例化运行对象 5. 使用运行对象去执行套件对象

代码

TestSuite （测试套件）：是用来管理多个 TestCase （测试用例）的，先创建多个 TestCase （测试用例）文件

"""
学习 TestSuite 和 TestRunner 的使⽤
"""
# 1. 导包(unittest)
import unittest
from hm_07_testcase1 import TestDemo1
from hm_07_testcase2 import TestDemo2

# 2. 实例化(创建对象)套件对象,
suite = unittest.TestSuite()

# 3. 使⽤套件对象添加⽤例⽅法
# ⽅式⼀, 套件对象.addTest(测试类名('⽅法名')) #
建议测试类名和⽅法名直接去复制,不要⼿写
suite.addTest(TestDemo1('test_method1'))
suite.addTest(TestDemo1('test_method2'))
suite.addTest(TestDemo2('test_method1'))
suite.addTest(TestDemo2('test_method2'))

# 4. 实例化运⾏对象
runner = unittest.TextTestRunner()
# 5. 使⽤运⾏对象去执⾏套件对象
# 运⾏对象.run(套件对象)
runner.run(suite)

"""
学习 TestSuite 和 TestRunner 的使⽤
"""
# 1. 导包(unittest)
import unittest

# 2. 实例化(创建对象)套件对象,
from hm_07_testcase1 import TestDemo1
from hm_07_testcase2 import TestDemo2
suite = unittest.TestSuite()

# 3. 使⽤套件对象添加⽤例⽅法
# ⽅式⼆ 将⼀个测试类中的所有⽅法进⾏添加
# 套件对象.addTest(unittest.makeSuite(测试类名))
# 缺点: makeSuite() 不会提示
suite.addTest(unittest.makeSuite(TestDemo1))
suite.addTest(unittest.makeSuite(TestDemo2))

# 4. 实例化运⾏对象
runner = unittest.TextTestRunner()
# 5. 使⽤运⾏对象去执⾏套件对象
# 运⾏对象.run(套件对象)
runner.run(suite)

练习

1. 在 tools 模块中定义 add 函数，对两个数字进行求和计算 2. 书写 TestCase 代码对 add () 进行测试用例 1 : 1 , 2 , 3 用例 2 : 10 , 20 , 30 用例 3 : 2 , 3 , 5

用例代码

"""案例练习"""
# 1,导包
import unittest
from tools import add

# 2, ⾃定义测试类

class TestAdd(unittest.TestCase):
    # 3. 书写测试⽅法, 就是测试⽤例代码
    def test_method1(self):
        # 1, 2, 3 判断实际结果和预期结果是否相符
        if add(1, 2) == 3:
            print('测试通过')
        else:
            print('测试不通过')
    def test_method2(self):
        if add(10, 20) == 30:
            print('测试通过')
        else:
            print('测试不通过')
 
    def test_method3(self):
        # 1, 2, 3 判断实际结果和预期结果是否相符
        if add(2, 3) == 5:
            print('测试通过')
        else:
            print('测试不通过')

套件和执行的代码

import unittest

# 实例化套件对象
from hm_08_test import TestAdd

suite = unittest.TestSuite()
# 添加测试⽅法
suite.addTest(unittest.makeSuite(TestAdd))
# 实例化执⾏对象
runner = unittest.TextTestRunner()
runner.run(suite)

unittest 组成

TestLoader （测试加载）

TestLoader （测试加载），作用和 TestSuite 的作用是一样的，对 TestSuite 功能的补充，用来组装测试用例的比如：如果 TestCase 的代码文件有很多，（ 10，20 ， 30 ） - 使用步骤 1. 导包 2. 实例化测试加载对象并添加用例 ---> 得到的是 suite 对象 3. 实例化运行对象 4. 运行对象执行套件对象

代码实现

在一个项目中 TestCase （测试用例）的代码，一般放在一个单独的目录（ case ）

"""TestLoader 的使用"""
# 1, 导包
import unittest

# 2, 实例化加载对象并添加用例
# unittest.TestLoader().discover('用例所在的路径', '用例的代码文件名')
# 用例所在的路径,建议使用相对路径, 用例的代码文件名可以使用 *(任意多个任意字符) 通配符
# suite = unittest.TestLoader().discover('./case', 'hm*.py')
# suite = unittest.TestLoader().discover('./case', '*test*.py')
# suite = unittest.TestLoader().discover('./case', '*test*')
suite = unittest.TestLoader().discover('./case', '*case1.py')

# 3, 实例化运行对象
# runner = unittest.TextTestRunner()
# # 4, 执行
# runner.run(suite)

# 可以将 3 4 步 变为一步
unittest.TextTestRunner().run(suite)

# 1. 导包
# 2. 使用默认的加载对象并加载用例
# 3. 实例化运行对象并运行

"""TestLoader 的使用"""
# 1, 导包
import unittest

# 2, 使用默认的加载对象并加载用例
suite = unittest.defaultTestLoader.discover('case', 'hm_*.py')

# 可以将 3 4 步 变为一步
unittest.TextTestRunner().run(suite)

Fixture（测试夹具）

Fixture （测试夹具）是一种代码结构在某些特定的情况下会自动执行

方法级别【掌握】

在每个测试方法（用例代码）执行前后都会自动调用的结构

# 方法执行之前
def setUp(self):
    每个测试方法执行之前都会执行
    pass

# 方法执行之后
def tearDown(self):
    每个测试方法执行之后都会执行
    pass

类级别【掌握】

在每个测试类中所有方法执行前后都会自动调用的结构（在整个类中执行之前执行之后个一次）

# 类级别的Fixture 方法, 是一个 类方法
# 类中所有方法之前
@classmethod
def setUpClass(cls):
    pass
# 类中所有方法之后
@classmethod
def tearDownClass(cls):
    pass

模块级别【了解】

模块：代码文件在每个代码文件执行前后执行的代码结构

# 模块级别的需要写在类的外边直接定义函数即可
# 代码文件之前
def setUpModule():
    pass

# 代码文件之后
def tearDownModule():
    pass

方法级别和类级别的前后的方法，不需要同时出现，根据用例代码的需要自行的选择使用

标签：套件,python,代码,必学,用例,测试,suite,unittest,UnitTest
From： https://blog.csdn.net/isun1/article/details/141401007