Unittest框架的介绍及使用

介绍

基本概念

​ unittest是Python自带的一个单元测试框架, 它可以做单元测试, 也能用于编写和运行重复的测试工作。它给自动化测试用例开发和执行提供了丰富的断言方法, 判断测试用例是否通过, 并最终生成测试结果.

四大组件

• test case：就是我们的测试用例，unittest中提供了一个基本类TestCase，可以用来创建新的测试用例，一个TestCase的实例就是一个测试用例；unittest中测试用例方法都是以test开头的，且执行顺序会按照方法名的ASCII值排序。
• test fixure：测试夹具，用于测试用例环境的搭建和销毁。即用例测试前准备环境的搭建（SetUp前置条件），测试后环境的还原（TearDown后置条件），比如测试前需要登录获取token等就是测试用例需要的环境，运行完后执行下一个用例前需要还原环境，以免影响下一条用例的测试结果。
• test suite：测试套件，用来把需要一起执行的测试用例集中放到一块执行，相当于一个篮子。我们可以使用TestLoader来加载测试用例到测试套件中。
• test runner：用来执行测试用例的，并返回测试用例的执行结果。它还可以用图形或者文本接口，把返回的测试结果更形象的展现出来，如：HTMLTestRunner。

unittest的断言

​ 在python基础中，我们有讲过一个assert断言，使用方法比较简单，即assert 表达式, 提示信息，而unittest框架中也提供了一个自带的断言方式，主要有以下几种：

方法	检查
assertEqual(a, b,msg=None)	a ==b
assertNotEqual(a, b)	a !=b
assertTrue(x)	bool(x) is True
assertFalse(x)	Bool(x) is False
assertIs(a, b)	a is b
assertIsNot(a, b)	a is not b
assertIsNone(x)	x is None
assertIsNotNone(x)	x is not None
assertIn(a, b)	a in b
assertNotIn(a, b)	a not in b
assertIsInstance(a, b)	isinstance(a,b)
assertNotIsInstance(a, b)	not isinstance(a,b)

​ 使用代码自动的判断预期结果和实际结果是否相符,如果断言失败即不通过就会抛出一个AssertionError断言错误，成功则标识为通过，以上几种方式都有一个共同点，就是都有一个msg参数（表中只列了一个，其实都有），默认是None，即msg = None，如果指定msg参数的值，则将该信息作为失败的错误信息返回。

案例：

import unittest# assertEqual(预期结果，实际结果)
#   判断预期结果和实际结果是否相等，如果相等， 用例通过，如果不相等，抛出异常， 用例不通过class TestAssert(unittest.TestCase):def test_equal_1(self):self.assertEqual(10, 10)  # 用例通过def test_assert_2(self):self.assertEqual(10, 11)  # 用例不通过def test_in(self):# self.assertIn('admin', '欢迎 admin 登录')  # 包含 通过# self.assertIn('admin', '欢迎 adminnnnnnnn 登录')  # 包含 通过# self.assertIn('admin', '欢迎 aaaaaadminnnnnnnn 登录')  # 包含 通过# self.assertIn('admin', '欢迎 adddddmin 登录')  # 不包含 不通过self.assertIn('admin', 'admin')  # 包含 通过

TestCase测试用例

​ 编写测试用例前，我们需要建一个测试类继承unittest里面的TestCase类，继承这个类之后我们才是真正的使用unittest框架去写测试用例，编写测试用例的步骤如下

• 导入unittest模块
• 创建一个测试类，并继承unittest.TestCase()
• 定义测试方法，方法名必须以test_开头
• 调用unittest.main()方法来运行测试用例，unittest.main()方法会搜索该模块下所有以test开头的测试用例方法，并自动执行

案例：

# 1.导包unittest
import unittest# 2. 定义测试类, 只要继承 unittest.TestCase 类, 就是 测试类
class TestDemo(unittest.TestCase):# 3. 书写测试⽅法, ⽅法中的代码就是真正⽤例代码,def test_method1(self):print('测试⽅法⼀')def test_method2(self):print('测试⽅法⼆')# 4. 执⾏
if __name__ == '__main__':unittest.main()

TestSuite 和 TestRunner

TestSuite测试套件

unittest.TestSuite()类来表示一个测试用例集，把需要执行的用例类或模块存到一起，常用的方法如下：

• unittest.TestSuite()
  • addTest()：添加单个测试用例方法
  • addTest([..])：添加多个测试用例方法，方法名存在一个列表
• unittest.TestLoader()
  • loadTestsFromTestCase(测试类名)：添加一个测试类
  • loadTestsFromModule(模块名)：添加一个模块
  • discover(测试用例的所在目录)：指定目录去加载，会自动寻找这个目录下所有符合命名规则的测试用例

执行步骤：

• 导包 unittest
• 实例化套件对象 unittest.TestSuite()
• 添加⽤例⽅法

案例：

# 导包
import unittestimport test_register
from hm_02_testcase01 import TestDemo01
from hm_02_testcase02 import TestDemo02# 实例化套件对象
suite = unittest.TestSuite()# 方式一：添加多个测试用例
suite.addTest(TestDemo01('test_m1'))
suite.addTest(TestDemo01('test_m2'))
suite.addTest(TestDemo02('test_m1'))
# suite.addTest(TestDemo02('test_m2'))# 方式二：添加一个测试用例类
loader = unittest.TestLoader()  # 创建一个加载对象
suite.addTest(loader.loadTestsFromTestCase(TestDemo01))# 方式三：指定测试用例的所在的目录路径，进行加载
loader = unittest.TestLoader()
suite.addTest(loader.discover(r"d:\learn\python"))# 方式四，添加一个模块
loader = unittest.TestLoader()	# 创建一个加载对象
suite.addTest(loader.loadTestsFromModule(test_register))# 实例化执行对象
runner = unittest.TextTestRunner()# 执行对象执行套件对象 执行对象.run(套件对象)
runner.run(suite)

​ 通常我们使用方式三、四比较多，你可以根据实际情况来运用。其中方式三，还可以自定义匹配规则，默认是会寻找目录下test*.py文件，即所有以test开头命名的py文件，自定义如下：

loader = unittest.TestLoader()
# 匹配规则：所有以test_case开头的
suite.addTest(loader.discover(start_dir = r"d:\learn\python", pattern="test_case*.py"))		

TestRunner执行用例

​ test runner顾名思义就是用来执行测试用例的，并且可以生成相应的测试报告。测试报告有两种展示形式，一种是text文本，一种是html格式。

​ html格式的就是HTMLTestRunner了，HTMLTestRunner是 Python 标准库的 unittest 框架的一个扩展，它可以生成一个直观清晰的 HTML 测试报告。使用的前提就是要下载 HTMLTestRunner.py，下载完后放在python的安装目录下的scripts目录下即可。

​ text文本相对于html来说过于简陋，与控制台输出的没有什么区别，也几乎没有人使用，这里不作演示，使用方法是一样的。我们结合前面的测试套件来演示一下如何生成html格式的测试报告：

执行步骤：

• 导包 unittest
• 实例化套件对象 unittest.TestSuite()
• 添加⽤例⽅法
  • 套件对象.addTest(测试类名('测试⽅法名'))
• 实例化 执⾏对象 unittest.TextTestRunner()
• 执⾏对象执⾏ 套件对象 执⾏对象.run(套件对象)

案例：

# 1. 导包  unittest
import unittest
from hm_02_testcase1 import TestDemo1
from hm_02_testcase2 import TestDemo2# 2. 实例化套件对象 unittest.TestSuite()
suite = unittest.TestSuite()
# 3. 添加⽤例⽅法# 3.1 套件对象.addTest(测试类名('测试⽅法名'))  # 建议复制
suite.addTest(TestDemo1('test_method1'))
suite.addTest(TestDemo1('test_method2'))
suite.addTest(TestDemo2('test_method1'))
suite.addTest(TestDemo2('test_method2'))# 4. 实例化 执⾏对象 unittest.TextTestRunner()
runner = unittest.TextTestRunner()
# 5. 执⾏对象执⾏ 套件对象 执⾏对象.run(套件对象)
runner.run(suite)

案例2:

# run_test.py，与test_register.py、register.py同一目录下
import unittest
import test_register
from HTMLTestRunner import HTMLTestRunner# 创建测试套件
suite = unittest.TestSuite()# 通过模块加载测试用例
loader = unittest.TestLoader()
suite.addTest(loader.loadTestsFromModule(test_register))# 创建测试运行程序启动器
runner = HTMLTestRunner(stream=open("report.html", "wb"),  # 打开一个报告文件，将句柄传给streamtester="miki",                    # 报告中显示的测试人员description="注册接口测试报告",        # 报告中显示的描述信息title="自动化测试报告")                 # 报告的标题# 使用启动器去执行测试套件里的用例
runner.run(suite)

相关参数说明：

• stream：指定输出的方式

• tester：报告中要显示的测试人员的名字

• description：报告中要显示的面熟信息

• title：测试报告的标题

•   verbosity
  

  ：表示测试报告信息的详细程度，一共三个值，默认是2

  • 0 (静默模式)：你只能获得总的测试用例数和总的结果，如：总共100个 失败10 成功90
  • 1 (默认模式)：类似静默模式，只是在每个成功的用例前面有个. 每个失败的用例前面有个F
  • 2 (详细模式)：测试结果会显示每个测试用例的所有相关的信息

  运行完毕，你会发现你的项目目录下已经生成了一个report.html文件，在浏览器中打开，就可以查看测试报告了。

TestFixure测试夹具

​ unittest的测试夹具有两种使用方式，一种是以测试方法为维度的setUp()和tearDown()，一种是以测试类为维度的setUpClass()和tearDownClass()。以注册功能为例，但这个注册代码比较简单，没有真正需要用到测试夹具的地方，因此这只是个用法演示。

# test_register.py
import unittest
from register import register  # 导入被测试的代码class TestRegister(unittest.TestCase):"""注册接口测试用例类"""def setUp(self):# 每条用例执行之前都会执行print("用例{}开始执行--".format(self))def tearDown(self):# 每条用例执行之后都会执行print("用例{}执行结束--".format(self))@classmethod  # 指明这是个类方法以类为维度去执行的def setUpClass(cls):# 整个测试用例类中的用例执行之前，会先执行此方法print("-----setup---class-----")@classmethoddef tearDownClass(cls):# 整个测试用例类中的用例执行完之后，会执行此方法print("-----teardown---class-----")def test_register_success(self):"""注册成功"""data = ("mikitest", "miki123", "miki123")  # 测试数据expected = {"code": 1, "msg": "注册成功！"}  # 预期结果result = register(*data)  # 把测试数据传到被测的代码，接收实际结果self.assertEqual(expected, result)  # 断言，预期和实际是否一致，一致即用例通过def test_username_isnull(self):"""注册失败-用户名为空"""data = ("", "miki123", "miki123")expected = {"code": 0, "msg": "所有参数不能为空！"}result = register(*data)self.assertEqual(expected, result)# 如果直接运行这个文件，需要使用unittest中的main函数来执行测试用例
if __name__ == '__main__':unittest.main()

运行结果：

Testing started at 22:19 ...
C:\software\python\python.exe "C:\Program Files\JetBrains\PyCharm Community Edition 2019.1.3\helpers\pycharm\_jb_unittest_runner.py" --path D:/learn/python/test_register.py
Launching unittests with arguments python -m unittest D:/learn/python/test_register.py in D:\learn\python
-----setup---class-----用例test_pwd1_not_pwd2 (test_register.RegisterTestCase)开始执行--
用例test_pwd1_not_pwd2 (test_register.RegisterTestCase)执行结束--
用例test_register_success (test_register.RegisterTestCase)开始执行--
用例test_register_success (test_register.RegisterTestCase)执行结束--
用例test_username_isnull (test_register.RegisterTestCase)开始执行--
用例test_username_isnull (test_register.RegisterTestCase)执行结束--
用例test_username_lt6 (test_register.RegisterTestCase)开始执行--
用例test_username_lt6 (test_register.RegisterTestCase)执行结束--
-----teardown---class-----Ran 4 tests in 0.003sOKProcess finished with exit code 0

参数化

​ 通过参数的方式来传递数据，从而实现数据和脚本分离。并且可以实现用例的重复执行。(在书写用例方法的时候，测试数据使用变量代替，在执行的时候进行据说传递)

​ unittest 测试框架，本身不支持参数化，但是可以通过安装unittest扩展插 件 parameterized 来实现。

环境准备

因为参数化的插件 不是 unittest 自带的，所以想要使用 需要进行安装
Python 中 包(插件，模块) 的安装，使用 pip 工具
pip install parameterized 
pip install -i https://pypi.douban.com/simple/  parameterized  
# 在终端(cmd)中执行pip  list  # 查看安装的所有的插件

使用

• 导包 from para... import para...
• 修改测试方法，将测试方法中的测试数据使用 变量表示
• 组织测试数据，格式 [(), (), ()], 一个元组就是一组测试数据
• 参数化，在测试方法上方使用装饰器 @parameterized.expand(测试数据)
• 运行(直接 TestCase 或者 使用 suite 运行)

import unittest
from parameterized import parameterized
from tools import adddata = [(1, 2, 3), (4, 7, 11), (1, 1, 2), (10, 10, 20), (34, 34, 68)]class TestAdd(unittest.TestCase):@parameterized.expand(data)def test_add(self, a, b, expect):print(f'a:{a}  b:{b}  expect:{expect}')self.assertEqual(expect, add(a, b))if __name__ == '__main__':unittest.main()

练习

将测试数据 定义为 json 文件， 读取 json 文件，完成参数化

• json 文件

[[1, 1, 2],[1, 2, 3],[2, 3, 5],[4, 5, 9],[10, 20, 30]]

• 读取 json 文件

import json
def build_add_data():with open('add_data.json') as f:data = json.load(f)  # [[], [], []]  ---> [(), ()]return data

• 代码文件

import unittest
from read_data import build_add_data
from tools import addfrom parameterized import parameterizeddata = [(1, 1, 2), (1, 2, 3), (2, 3, 5), (4, 5, 9)]class TestAdd(unittest.TestCase):@parameterized.expand(build_add_data())def test_add(self, a, b, expect):print(f'a:{a}, b:{b}, expect：{expect}')self.assertEqual(expect, add(a, b))if __name__ == '__main__':unittest.main()

测试报告

使用第三方的报告模版，生成报告 HTMLTestReport, 本质是 TestRunner

• 安装
  pip install -i https://pypi.douban.com/simple/ HTMLTestReport
• 使用

1. 导包 unittest、HTMLTestReport
2. 组装用例(套件， loader )
3. 使用 HTMLTestReport 中的 runner 执行套件
4. 查看报告

import unittestfrom htmltestreport import HTMLTestReport
from hm_04_pa1 import TestAdd# 套件suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TestAdd))# 运行对象
# runner = HTMLTestReport(报告的文件路径后缀.html, 报告的标题, 其他的描述信息)
runner = HTMLTestReport('test_add_report.html', '加法用例测试报告', 'xxx')
runner.run(suite)

使用绝对路径

将来的项目是分目录书写的, 使用相对路径,可能会出现找不到文件的情况,此时需要使用 绝对路径

方法:

1. 在项目的根目录,创建一个 Python 文件(app.py 或者 config.py)
2. 在这个文件中 获取项目的目录,在其他代码中使用 路径拼接完成绝对路径的书写

案例：

import os# __file__ 特殊的变量,表示当前代码文件名
# path1 = os.path.abspath(__file__)
# print(path1)
# path2 = os.path.dirname(path1)
# print(path2)# BASE_DIR = os.path.dirname(os.path.abspath(__file__))
BASE_DIR = os.path.dirname(__file__)if __name__ == '__main__':print(BASE_DIR)

案例：

1. 对登录函数进行测试, 登录函数 定义在 tools.py 中
2. 在 case 目录中书写用例对login 函数进行测试, 使用断言
3. 将 login 函数的测试数据定义在 json 文件中,完成参数化, data 目录中
4. 生成测试报告 report 目录中

def login(username, password):if username == 'admin' and password == '123456':return '登录成功'else:return '登录失败'

• 测试数据

[
]
{"desc": "正确的用户名和密码","username": "admin","password": "123456","expect": "登录成功"
},
{"desc": "错误的用户名","username": "root","password": "123456","expect": "登录失败"
},
{"desc": "错误的密码","username": "admin","password": "123123","expect": "登录失败"
},
{"desc": "错误的用户名和密码","username": "root","password": "123123","expect": "登录失败"
}

• 读取测试数据的方法

def build_login_data():with open(BASE_DIR + '/data/login_data.json', encoding='utf-8') as f:data_list = json.load(f)  # [{}, {}] ---> [()]new_list = []for data in data_list:# 字典中的 desc 不需要username = data.get('username')password = data.get('password')expect = data.get('expect')new_list.append((username, password, expect))return new_list

• 测试用例代码

import unittestfrom common.read_data import build_login_data
from tools import login
from parameterized import parameterizedclass TestLogin(unittest.TestCase):@parameterized.expand(build_login_data())def test_login(self, username, password, expect):print(f'username: {username}, password: {password}, expect: {expect}')self.assertEqual(expect, login(username, password))

• Suite 报告代码

import unittestfrom app import BASE_DIR
from case.test_login import TestLogin
from htmltestreport import HTMLTestReportsuite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TestLogin))runner = HTMLTestReport(BASE_DIR + '/report/login_report.html', '登录测试报告', 'V1.0')
runner.run(suite)

跳过skip

​ 对于一些未完成的或者不满足测试条件的测试函数和测试类，可以跳过执行(简单来说, 不想执行的测试方法,可以 设置为跳过)

• 直接将测试函数标记成跳过:

​ @unittest.skip('跳过的原因')

• 根据条件判断测试函数是否跳过

​ @unittest.skipIf(判断条件, reason='原因') # 判断条件为 True, 执行跳过

import unittestversion = 29class TestSkip(unittest.TestCase):@unittest.skip('没什么原因,就是不想执行')def test_1(self):print('方法一')@unittest.skipIf(version >= 30, '版本号大于等于 30, 测方法不用执行')def test_2(self):print('方法二')def test_3(self):print('方法三')if __name__ == '__main__':unittest.main()