学习目标

unittest 框架的基本使⽤⽅法(组成)

断⾔的使⽤ (让程序⾃动的判断预期结果和实际结果是否相符)

参数化(多个测试数据, 测试代码写⼀份 传参)

⽣成测试报告

复习python

unittest 框架的介绍

什么是框架

1. framework
2. 为了解决⼀类事情的功能集合

Unittest 框架

是 Python ⾃带的单元测试框架

• ⾃带的, 可以直接使⽤, 不需要单外安装
• 测试⼈员 ⽤来做⾃动化测试, 作为⾃动化测试的执⾏框架,即 管理和执⾏⽤例的

核⼼要素(组成)

1. TestCase 测试⽤例, 这个测试⽤例是 unittest 的组成部分,作⽤是 ⽤来书写真正的⽤例代码(脚本)

2. Testsuite 测试套件, 作⽤是⽤来组装(打包)

TestCase(测试⽤例) 的,即 可以将多个⽤例脚本⽂件 组装到⼀起

3. TestRunner 测试执⾏(测试运⾏), 作⽤ 是⽤例执⾏TestSuite(测试套件)的

4. TestLoader 测试加载, 是对 TestSuite(测试套件) 功能的补充, 作⽤是⽤来组装(打包) TestCase(测试⽤例) 的

5. Fixture 测试夹具, 是⼀种代码结构, 书写 前置⽅法(执⾏⽤例之前的⽅法)代码 和后置⽅法(执⾏⽤例之后的⽅法) 代码 ,即 ⽤例执⾏顺序 前置 —> ⽤例 —> 后置

TestCase 测试⽤例

书写真正的⽤例代码(脚本)
单独⼀个测试⽤例 也是可以执⾏

• 步骤

1. 导包 unittest
2. 定义测试类, 需要继承 unittest.TestCase 类, 习惯性类名以 Test 开头
3. 书写测试⽅法, 必须以 test 开头
4. 执⾏

注意事项

1. 代码⽂件名字 要满⾜标识符的规则
2. 代码⽂件名 不要使⽤中⽂

"""
学习 TestCase(测试用例) 的使用
"""

# 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.1.1 在类名后边, 执行类中的所有的测试方法
# 4.1.2 在方法名后边, 只执行当前的测试方法

# 4.1 在主程序使用使用 unittest.main()  来执行,
if __name__ == '__main__':
    unittest.main()

TestSuite 和 TestRunner

TestSuite(测试套件)

将多条⽤例脚本集合在⼀起,就是套件, 即⽤来组装⽤例的

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

TestRunner(测试执⾏)

1. 导包 unittest
2. 实例化 执⾏对象 unittest.TextTestRunner()
3. 执⾏对象执⾏ 套件对象 执⾏对象.run(套件对象)

整体步骤

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

代码案例

# 1. 导包 unittest
import unittest
# 2. 定义测试类, 只要继承 unittest.TestCase 类, 就是测试类
class TestDemo1(unittest.TestCase):
	# 3. 书写测试⽅法, ⽅法中的代码就是真正⽤例代码,⽅法名必须以 test 开头
	def test_method1(self):
		print('测试⽅法1-1')
	def test_method2(self):
		print('测试⽅法1-2')

# 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)

TestLoader 测试加载

作⽤和 TestSuite 作⽤⼀样,组装⽤例代码, 同样也需要使⽤TextTestRunner() 去执⾏
10 个⽤例脚本 makeSuite()

import unittest
# 实例化加载对象并加载⽤例,得到套件对象
# suite = unittest.TestLoader().discover('⽤例所在的⽬录', '⽤例代码⽂件名*.py')
suite = unittest.TestLoader().discover('.','hm_02*.py')
# 实例化执⾏对象并执⾏
# runner = unittest.TextTestRunner()
# runner.run(suite)
unittest.TextTestRunner().run(suite)

练习

TestLoader 练习

1. 创建⼀个⽬录 case, 作⽤就是⽤来存放⽤例脚本,
2. 在这个⽬录中创建 5 个⽤例代码⽂件 , test_case1.py...
3. 使⽤ TestLoader 去执⾏⽤例

将来的代码 ⽤例都是单独的⽬录 中存放的
test_项⽬_模块_功能.py

import unittest


class TestDemo(unittest.TestCase):
    def test_1(self):
        print('测试方法1')

import unittest


class TestDemo(unittest.TestCase):
    def test_1(self):
        print('测试方法2')

import unittest

suite = unittest.TestLoader().discover('case', 'test*.py')

unittest.TextTestRunner().run(suite)

练习 2

1. 定义⼀个 tools 模块, 在这个模块中 定义 add 的⽅法,可以对两个数字求和,返回求和结果
2. 书写⽤例, 对 add() 函数进⾏测试
1, 1, 2
1, 2, 3
3, 4, 7
4, 5, 9
-----
之前的测试⽅法,直接⼀个 print
这个案例中的 测试⽅法,调⽤ add 函数, 使⽤ if 判断,来判断
预期结果和实际结果是否相符
预期结果 2 3 7 9
实际结果 调⽤ add()

import unittest

from tools import add


class TestAdd(unittest.TestCase):
    def test_1(self):
        """1,1,2"""
        if 2 == add(1, 1):
            print(f'用例 {1}, {1}, {2}通过')
        else:
            print(f'用例 {1}, {1}, {2}不通过')

    def test_2(self):
        if 3 == add(1, 2):
            print(f'用例 {1}, {2}, {3}通过')
        else:
            print(f'用例 {1}, {2}, {3}不通过')

    def test_3(self):
        if 7 == add(3, 4):
            print(f'用例 {3}, {4}, {7}通过')
        else:
            print(f'用例 {3}, {4}, {7}不通过')

    def test_4(self):
        if 9 == add(4, 5):
            print(f'用例 {4}, {5}, {9}通过')
        else:
            print(f'用例 {4}, {5}, {9}不通过')

from hm_06_test_add import TestAdd

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

unittest.TextTestRunner().run(suite)

Fixture

代码结构, 在⽤例执⾏前后会⾃动执⾏的代码结构
tpshop 登录
1. 打开浏览器 (⼀次)
2. 打开⽹⻚,点击登录 (每次)
3. 输⼊⽤户名密码验证码1,点击登录 (每次, 测试⽅法)
4. 关闭⻚⾯ (每次)
2. 打开⽹⻚,点击登录 (每次)
3. 输⼊⽤户名密码验证码2,点击登录 (每次, 测试⽅法)
4. 关闭⻚⾯ (每次)
2. 打开⽹⻚,点击登录 (每次)
3. 输⼊⽤户名密码验证码3,点击登录 (每次, 测试⽅法)
4. 关闭⻚⾯ (每次)
5. 关闭浏览器 (⼀次)

⽅法级别 Fixture

在每个⽤例执⾏前后都会⾃动调⽤, ⽅法名是固定的

def setUp(self): # 前置
 # 每个⽤例执⾏之前都会⾃动调⽤
 pass
def tearDown(self): # 后置
 # 每个⽤例执⾏之后 都会⾃动调⽤
 pass
# ⽅法前置 ⽤例 ⽅法后置
# ⽅法前置 ⽤例 ⽅法后置

类级别 Fixture

在类中所有的测试⽅法执⾏前后 会⾃动执⾏的代码, 只执⾏⼀次

# 类级别的 Fixture 需要写作类⽅法
@classmethod
def setUpClass(cls): # 类前置
 pass
@classmethod
def tearDownClass(cls): # 后置
 pass
# 类前置 ⽅法前置 ⽤例 ⽅法后置 ⽅法前置 ⽤例 ⽅法后置类后置

模块级别Fixture(了解)

模块, 就是代码⽂件
模块级别 在这个代码⽂件执⾏前后执⾏⼀次

# 在类外部定义函数
def setUpModule():
 pass
def tearDownModule():
 pass

登录练习

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,点击登录 ')

    def test_2(self):
        print('3. 输入用户名密码验证码2,点击登录 ')

    def test_3(self):
        print('3. 输入用户名密码验证码3,点击登录 ')

断言

使用代码自动的判断预期结果和实际结果是否相符
assertEqual(预期结果，实际结果)
- 判断预期结果和实际结果是否相等，如果相等， 用例通过，如果不相等，抛出异常， 用例不通过
assertIn(预期结果，实际结果)
- 判断预期结果是否包含在 实际结果中， 如果存在，用例通过， 如果不存在，抛出异常，用例不通过

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')  # 包含 通过

from hm_02_assert import TestAssert

suite = unittest.TestSuite()

suite.addTest(unittest.makeSuite(TestAssert))
unittest.TextTestRunner().run(suite)

练习

1. 定义一个 tools 模块, 在这个模块中 定义 add 的方法,可以对两个数字求和,返回求和结果
2. 书写用例, 对 add() 函数进行测试
1, 1, 2
1, 2, 3
3, 4, 7
4, 5, 9

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

    def test_2(self):
        self.assertEqual(3, add(1, 2))

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

    def test_4(self):
        self.assertEqual(9, add(4, 5))

参数化

• 通过参数的方式来传递数据，从而实现数据和脚本分离。并且可以实现用例的重复执行。(在书写用例方法的时候，测试数据使用变量代替，在执行的时候进行据说传递)
• unittest 测试框架，本身不支持参数化，但是可以通过安装unittest扩展插 件 parameterized 来实现。

环境准备

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

使用

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

import unittest

from tools import add
from parameterized import parameterized

data = [(1, 1, 2), (1, 2, 3), (2, 3, 5), (4, 5, 9)]


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
from app import BASE_DIR

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

    return data


def build_add_data_1():
    with open('../data/add_data_1.json') as f:
        data_list = json.load(f)  # [{}, {}, {}]  ----> [(), ()]

        new_list = []
        for data in data_list:  # data 字典
            # 字典中的值，是否都需要
            a = data.get('a')
            b = data.get('b')
            expect = data.get('expect')
            new_list.append((a, b, expect))

        return new_list


def build_add_data_2():
    with open(BASE_DIR + '/data/add_data_1.json') as f:
        data_list = json.load(f)  # [{}, {}, {}]  ----> [(), ()]

        new_list = []
        for data in data_list:  # data 字典
            # 字典中的值，是否都需要
            new_list.append(tuple(data.values()))

        return new_list


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


if __name__ == '__main__':
    # print(build_add_data_2())
    print(build_login_data())

import unittest

from common.read_data import build_add_data_2
from tools import add
from parameterized import parameterized

data = [(1, 1, 2), (1, 2, 3), (2, 3, 5), (4, 5, 9)]


class TestAdd(unittest.TestCase):
    # @parameterized.expand(build_add_data())
    # @parameterized.expand(build_add_data_1())
    @parameterized.expand(build_add_data_2())
    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

使用第三方的报告模版，生成报告 HTMLTestReport, 本质是 TestRunner
- 安装
pip install -i https://pypi.douban.com/simple/ HTMLTestReport
- 使用
1. 导包 unittest、HTMLTestReport
2. 组装用例(套件， loader )
3. 使用 HTMLTestReport 中的 runner 执行套件
4. 查看报告

import unittest

from 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 = HTMLTestReport('./report/test_add_report.html', '加法用例测试报告', 'xxx')
runner = HTMLTestReport('report/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 '登录失败'


def add(a, b):
    return a + b

测试的数据

[
  {
    "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 unittest

from common.read_data import build_login_data
from tools import login
from parameterized import parameterized


class 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))

suit报告代码

import unittest

from app import BASE_DIR
from case.test_login import TestLogin
from htmltestreport import HTMLTestReport

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

runner = HTMLTestReport(BASE_DIR + '/report/login_report.html', '登录测试报告', 'V1.0')
runner.run(suite)

跳过

跳过:对于一些未完成的或者不满足测试条件的测试函数和测试类，可以跳过执行(简单来说, 不想执行的测试方法,可以
设置为跳过)
- 直接将测试函数标记成跳过
@unittest.skip('跳过的原因')
- 根据条件判断测试函数是否跳过
@unittest.skipIf(判断条件, reason='原因') # 判断条件为 True, 执行跳过

class 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()

import unittest

from hm_06_skip import TestSkip

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

unittest.TextTestRunner().run(suite)