Python框架之UnitTest

unittest 是python 的单元测试框架，unittest 单元测试提供了创建测试用例，测试套件以及批量执行的方案， unittest 在安装pyhton 以后就直接自带了，直接import unittest 就可以使用，测试人员用UnitTest来做自动化测试，即管理和执行用例。
一、UnitTest基本组成
测试人员使用此框架的原因：能够组织多个用例去执行、提供丰富的断言方法、能够生成测试报告。
1、测试发现：从多个py文件中收集并加载测试用例；
2、测试执行：将测试用例按照一定的顺序和条件去执行并生成结果；
3、测试判断：通过断言去判断结果是否正确；
4、测试报告：统计测试进度，通过率，生成报告；
UnitTest的组成部分：
1、TestCase：用来写测试用例
2、TestSuite:测试套件，用来组装测试用例，即打包TestCase
3、TestRunner：测试执行，用来执行TestSuite
4、TestLoader:测试加载，对TestSuite功能的补充，用来组装TestCase
5、Fixture:测试夹具，是一种代码结构，前置方法和后置方法
TestCase测试用例
步骤：
（1）导包 unittest
（2）定义测试类，只需要继承unittest.TestCase类就是测试类
（3）书写测试方法，方法名必须以test开头
（4）执行代码

（1）导包 unittest

import unittest

（2）定义测试类,只需要继承unittest.TestCase类就是测试类

class TestDemo(unittest.TestCase):
# （3）书写测试方法,方法名必须以test开头
def test_method1(self):
print(‘测试方法一’)

def test_method2(self):
    print('测试方法二')

（4）执行代码

4.1在类名或者方法名后面右键运行。类名后面运行：执行类中所有的测试方法；在方法名后面，只执行当前的测试方法

4.2 在主程序中使用unittest.main()来执行

if name == ‘main’:
unittest.main()
复制代码
TestSuite和TestRunner
TestSuite（测试套件），用来组装测试用例，将多个测试用例脚本集合在一起。
使用步骤：

实例化测试套件：suite = unittest.TestSuite()

添加用例：suite.addTest(ClassName(“MethodName”))
ClassName：为类名；MethodName：为方法名

添加扩展：suite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(ClassName))

添加扩展：suite.addTest(unittest.makeSuite(测试类名))
把指定ClassName类中的测试用例全部添加到测试套件中
案例： 两个用例文件testcase1.py和testcase2.py
testcase1.py文件中的代码为；

import unittest

class TestDemo1(unittest.TestCase):

def test_method1(self):
    print('测试方法1-1')

def test_method2(self):
    print('测试方法1-2')

复制代码
testcase2.py文件中的代码为；

1、导包

import unittest

2、定义测试类，继承unittest.TestCase就是测试类

class TestDemo2(unittest.TestCase):
# 3、写测试方法，方法中的代码是真正的测试用例代码，方法名必须以test开头
def test_method1(self):
print(‘测试方法2-1’)

def test_method2(self):
    print('测试方法2-2')

复制代码
测试套件和执行testsuite_testrunner.py文件中代码为(第一种添加测试套件的方法)：

1、导包

import unittest
from testcase1 import TestDemo1

2、实例化套件对象unittest.TestSuite()

from testcase2 import TestDemo2

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、执行 执行对象

runner.run(suite)
复制代码
执行结果：

附加：测试套件和执行testsuite_testrunner.py文件中代码为(第二种添加测试套件的方法)：

1、导包

import unittest
from testcase1 import TestDemo1

2、实例化套件对象unittest.TestSuite()

from testcase2 import TestDemo2

suite = unittest.TestSuite()

3、添加用例方法

3.2 添加整个测试类，套件对象.addTest(unittest.makeSuite(测试类名))

suite.addTest(unittest.makeSuite(TestDemo1))
suite.addTest(unittest.makeSuite(TestDemo2))

4、实例化、执行对象unittest.TextTestRunner()

runner = unittest.TextTestRunner()去执行

()

5、执行 执行对象

runner.run(suite)
复制代码
TestLoader 测试加载
用来加载TestCase到TestSuite中，即加载满足条件的测试用例，并把测试用例封装成测试套件
suite = unittest.TestLoader().discover(test_dir, pattern=‘test*.py’)
自动搜索指定目录下指定开头的.py文件，并将查找到的测试用例组装到测试套件
test_dir: 为指定的测试用例的目录
pattern：为查找的.py文件的格式，默认为’test*.py’
import unittest

suite = unittest.TestLoader().discover(‘E:\pythonProject\pythonUnitTest’, ‘testcase*.py’)
runner = unittest.TextTestRunner()
runner.run(suite)
复制代码
Fixture：测试夹具
测试夹具是一种代码结构。Fixture控制级别：方法级别、类级别、模块级别（了解即可）。
方法级别（在每个测试用例执行前后都会自动调用，方法名是固定的）：
使用方式：
初始化(前置处理):def setUp(self) --> 开始自动执行
销毁(后置处理):def tearDown(self) --> 最后自动执行
类级别（在类中，所有的测试方法执行前后，会自动执行一次，方法名是固定的）：
使用方式：
初始化(前置处理):
@classmethod

def setUpClass(cls):
复制代码
销毁(后置处理):
@classmethod

def tearDownClass(cls):
复制代码
方法名固定的本质是：继承unittest的方法，并且进行覆盖是重写
模块级别 [了解]
运行于整个模块的始末，即：整个模块只会运行一次setUpModule和tearDownModule
使用方式：
初始化(前置处理):def setUpModule()
销毁(后置处理):def tearDownModule()
案例分析：
登录功能的测试用例：
（1）打开浏览器–1次
（2）打开网页，点击登录–每次
（3）输入用户名密码验证码1，点击登录–每次，测试方法1
（4）关闭网页–每次
…
（2）打开网页，点击登录–每次
（3）输入用户名密码验证码2，点击登录–每次，测试方法2
（4）关闭网页–每次
…
（2）打开网页，点击登录–每次
（3）输入用户名密码验证码3，点击登录–每次，测试方法3
（4）关闭网页–每次
以上案例分析有很多重复的代码，我们可以使用测试夹具优化代码
import unittest

class TestLogin(unittest.TestCase):
def setUp(self) -> None:
print(‘2、打开网页，点击登录–每次–前置’)

def tearDown(self) -> None:
    print('4、关闭网页--每次--后置')

@classmethod
def setUpClass(cls) -> None:
    print('1、打开浏览器--类前置')

@classmethod
def tearDownClass(cls) -> None:
    print('5、关闭浏览器--类后置')

def test_1(self):
    print('3、输入用户名密码验证码1，点击登录--每次，测试方法1')

def test_2(self):
    print('3、输入用户名密码验证码1，点击登录--每次，测试方法2')

def test_3(self):
    print('3、输入用户名密码验证码1，点击登录--每次，测试方法3')

复制代码

二、断言
断言：让程序代替人为判断测试程序执行结果是否符合预期结果的过程
常用的UnitTest断言方法

对于自动化测试人员来说，重点掌握：
（1）assertEqual(预期结果,实际结果)
判断预期结果和实际结果是否相等，如果相等，用例通过，如果不相等，抛出异常，用例不通过
（2）assertIn(预期结果,实际结果)
判断预期结果是否包含在实际结果中，如果存在，用例通过，如果不存在，抛出异常，用例不通过
import unittest

class TestAssert(unittest.TestCase):
def test_equal_1(self):
self.assertEqual(10, 10) # 用例通过

def test_assert_2(self):
    self.assertEqual(10, 20)    # 用例不通过

def test_in01(self):
    self.assertIn('admin', '欢迎admin登录系统！')  # 包含...用例通过

def test_in02(self):
    self.assertIn('addddmin', '欢迎登录系统！')  # 不包含...用例不通过

复制代码
案例：
工具类中有一个求和的测试方法：
def add(a, b):
sum = a+b
return sum
复制代码
使用断言测试该求和方法是正确：
import unittest
from tools import add

class TestAdd(unittest.TestCase):
def test_1(self):
self.assertEqual(3, add(1, 2))

def test_1(self):
    self.assertEqual(5, add(3, 2))

def test_1(self):
    self.assertEqual(7, add(4, 3))

def test_1(self):
    self.assertEqual(13, add(8, 5))

复制代码
三、参数化
通过参数的方式来传递数据，从而实现数据和脚本分离。并且可以实现用例的重复执行。
unittest测试框架，本身不支持参数化，但是可以通过安装unittest扩展插件parameterized来实现。
安装parameterized：pip install parameterized

参数化实现
导包：from parameterized import parameterized
使用@parameterized.expand装饰器可以为测试函数的参数进行参数化
我们继续对以上的求和方法使用参数化的方式进行测试，代码运行的时候，可以使用多种方式运行，比如：直接右键运行、main方法运行、suite运行等
import unittest
from tools import add
from parameterized import parameterized

data = [(1, 1, 2), (2, 3, 5), (3, 4, 7), (10, 11, 21)]

class TestAdd(unittest.TestCase):
@parameterized.expand(data)
def test_1(self, a, b, expect):
self.assertEqual(expect, add(a, b))

if name == ‘main’:
unittest.main()
复制代码
扩展：
我们将参数化的测试数据保存在json文件中，如下；
[
[1, 1, 2],
[2, 3, 5],
[3, 4, 7],
[10, 11, 21]
]
复制代码

读取json文件中的数据：
import json

def build_add_data():
with open(‘add_data.json’,encoding=‘utf-8’)as f:
data = json.load(f)

return data

复制代码

将读取的json文件中的数据当作参数传到测试用例中：
import unittest

from read_json import build_add_data
from tools import add
from parameterized import parameterized

class TestAdd(unittest.TestCase):
@parameterized.expand(build_add_data)
def test_1(self, a, b, expect):
self.assertEqual(expect, add(a, b))

if name == ‘main’:
unittest.main()
复制代码

以上就是将数据保存在json文件中实现参数化，json文件中的数据复杂的时候，我们可以使用如下方式定义（并且推荐此方法）：

此时读取json文件的方法需要修改为：
def build_add_data():
with open(‘add_data.json’, encoding=‘utf-8’)as f:
data_list = json.load(f)
new_list = []
for data in data_list:
a = data.get(‘a’)
b = data.get(‘b’)
expect = data.get(‘expect’)
new_list.append((a, b, expect))
return new_list
复制代码
四、生成HTML测试报告
安装：pip install HTMLTestReport
测试报告生成步骤：
（1）导包
（2）封装测试套件
（3）实例化HTMLTestReport对象
report = HTMLTestReport(file_path, [title], [description])
参数说明：
file_path：测试报告文件路径
title：可选参数，为报告标题，如XXX测试报告
description：可选参数，为报告描述信息
（4）执行测试套件report.run(suite)
继续使用上述示例，针对求和的方法进行测试报告的生成
import unittest
from htmltestreport import HTMLTestReport
from testadd_paramterized import TestAdd

测试套件

suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TestAdd))

运行对象

runner = HTMLTestReport(‘test_add_report.html’, ‘求和运算测试报告’, ‘这是报告的描述！’)
runner.run(suite)
复制代码
运行之后将生成的html报告文件，使用浏览器打开，查看生成的报告，报告中执行失败的用例是故意写错，用来查看执行失败的情况：

使用绝对路径保存测试报告
在实际项目中往往会出现文件找不到的情况，此时需要使用绝对路径。
步骤：
（1）在项目的根目录中创建一个配置文件（app.py或者config.py）
（2）在这个文件中获取项目的目录，在其他代码中拼接起来，完成绝对路径
获取当前文件的绝对路径：abspath = os.path.abspath(file)
获取文件路径的目录名称：dirname = os.path.dirname(filepath)
案例：
app.py中的代码内容
import os

获取当前文件的绝对路径

path1 = os.path.abspath(file)
print(path1)

获取文件路径的目录名称

path2 = os.path.dirname(path1)
print(path2)

实际中直接合起来写就行

BASE_DIR = os.path.dirname(os.path.abspath(file))

if name == ‘main’:
print(BASE_DIR)
复制代码
运行结果：

代码中的使用

测试套件

suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TestAdd))

运行对象

report_path = app.BASE_DIR + “test_add_report.html” # 报告的路径
runner = HTMLTestReport(report_path, ‘求和运算测试报告’, ‘这是报告的描述！’)
runner.run(suite)
复制代码
五、测试用例跳过
直接将测试函数标记成跳过@unittest.skip(‘代码未完成’)
根据条件判断测试函数是否跳过@unittest.skipIf(condition, reason)
示例：
import unittest

ver = 10

class TestSkip(unittest.TestCase):
@unittest.skip(‘此用例跳过，这是跳过的原因’)
def test_1(self):
print(‘测试方法一’)

@unittest.skipIf(ver >= 10, '迭代版本大于等于10，此用例跳过')
def test_2(self):
    print('测试方法二')

def test_3(self):
    print('测试方法三')

if name == ‘main’:
unittest.main()