UnitTest(自动化测试框架)-单元测试、Fixture、断言、HTMLTestRunner自动生成测试报告

是凝璇呀

2024-01-24 帮助1人

什么是unitTest？

UnitTest是python自带的自动化测试框架
UnitTest主要包含的内容
- TestCase：测试用例
- TestSuite：测试套件，把多个TestCase集成到一个测试TestSuite
- TestRunner：执行测试用例
- TestLoader：自动从代码中加载多个测试用例TestCase
- Fixture：Test特性

TestCase

第一步：导入unittest模块
第二步：实现一个类，必须继承unittest.TestCase类
第三步：类中每一个方法代表一个测试用例，方法名必须以test开头

import unittest

def my_sum(a,b):
    return a   b

class my_test(unittest.TestCase):
    def test_001(self):
        print(my_sum(5,6))

    def test_002(self):
        print(my_sum(0,3))

学新通

如果鼠标右键不出现unittest选项，如下操作之后按下OK键

TestSuite

把多个测试用例整合成一个测试套件
使用方法
- import导入unittest
- import导入其他的包含测试用例的py文件
  - py文件的命名规则与变量名相同
- 实例化unittest.TestSuite类的对象
- 调用对象的addTest方法
  - addTest(py文件名.类名(“方法名”))

import unittest
import testcase_01

suite = unittest.TestSuite()    # 实例化
suite.addTest(testcase_01.my_test("test001"))
suite.addTest(testcase_01.my_test("test002"))
# 代码到这里只是把测试用例添加到了套件中，并不是执行测试用例

用unittest.makeSuite一次导入一个类中的所有测试方法

import unittest
import testcase_01

suite = unittest.TestSuite()    # 实例化
# suite.addTest(testcase_01.my_test("test001"))
# suite.addTest(testcase_01.my_test("test002"))
# 代码到这里只是把测试用例添加到了套件中，并不是执行测试用例
suite.addTest(unittest.makeSuite(testcase_01.my_test))   # 一次性导入一个类中的所有测试方法

TextTestRunner

作用：TextTestRunner是用来执行测试用例
使用方法
- 先实例化TextTestRunner的对象
- 调用对象的run方法
  - 只要把suite作为参数，放入到run方法里面去

import unittest
import testcase_01

suite = unittest.TestSuite()    # 实例化
# suite.addTest(testcase_01.my_test("test001"))
# suite.addTest(testcase_01.my_test("test002"))
# 代码到这里只是把测试用例添加到了套件中，并不是执行测试用例
suite.addTest(unittest.makeSuite(testcase_01.my_test))   # 一次性导入一个类中的所有测试方法

runner = unittest.TextTestRunner()     # 实例化TextTestRunner的对象
runner.run(suite)    # 调用对象的run方法

TestLoader

可以从指定目录查找指定py文件中的所有测试用例，自动加载到TestSuite中

import unittest
# 用TestLoader对象的discover方法来自动查找py，自动加载py文件中的方法
# 第一个参数是从哪里找py文件，“.”从当前目录开始查找py文件
# 第二个参数是指定py文件的文件名，可以用通配符
suite = unittest.TestLoader().discover(".","my*.py")
runner = unittest.TextTestRunner()
runner.run(suite)

TestSuite与TestLoader区别

TestSuite需要手动添加测试用例，可以添加测试类，也可以添加测试类中某个测试方法
- 当要执行py文件中多个测试用例的几个，而不是全部执行，那么适合用TestSuite的addTest加载指定的测试用例
TestLoader搜索指定目录下指定开头.py文件，并添加测试类中的所有测试方法，不能指定添加测试方法
- 当要执行py文件中的所有测试用例，适合使用TestLoader

小结

所有的测试用例最终都是用TextTestRunner来执行的
TextTestRunner指定的是TestSuite
一个TestSuite中可以有多个TestCase

Fixture

可以在测试用例执行之前自动调用指定的函数，在测试用例执行之后自动调用指定的函数
控制级别
- 方法级
  - 每个方法执行前和执行后都自动调用函数
- 类级
  - 不管类中有多少方法，一个类执行前后都自动调用函数
- 模块级
  - 不管一个模块(一个模块就是一个py文件)中有多少类，模块执行前后自动调用函数

方法级

在TestCase，也就是测试用例所在的class中定义方法
def setUp(self)当测试用例执行前，自动被调用
def tearDown(self)当测试用例执行后，自动被调用
如果一个TestCase中有多个测试用例，那么setUp和tearDown就会被自动调用多次。mytest.py内容修改如下：

import unittest

def my_sum(a,b):
    return a   b

class my_test(unittest.TestCase):
    def setUp(self):
        print("setUp被自动调用了")
    def tearDown(self):
        print("testDown被自动调用了")

    def test_001(self):
        print(my_sum(5,6))

    def test_002(self):
        print(my_sum(0,3))

类级

不管类中有多少方法，一个类开始的时候自动调用函数，结束之后自动调用函数
类级的fixture一定要是类方法
@classmethond def setUpClass(cls)类开始时自动调用的方法
@classmethond def tearDownClass(cls)类结束时自动调用的方法
mytest.py修改如下：

import unittest

def my_sum(a,b):
    return a   b

class my_test(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print("setupclass自动调用了")
    @classmethod
    def tearDownClass(cls):
        print("tearDownClass自动调用了")
    def setUp(self):
        print("setUp被自动调用了")
    def tearDown(self):
        print("testDown被自动调用了")

    def test_001(self):
        print(my_sum(5,6))

    def test_002(self):
        print(my_sum(0,3))

模块级

不管py文件中有多少个类，以及类中有多少方法，只自动执行一次
def setUpModule()在py文件开始时自动调用
def tearDownModule()在py文件结束时自动调用
mytest.py文件修改如下：

import unittest

def setUpModule():
    print("setUpModule自动调用了")

def tearDownModule():
    print("tearDwonModule自动调用了")

def my_sum(a,b):
    return a   b

class my_test1(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print("setupclass自动调用了")
    @classmethod
    def tearDownClass(cls):
        print("tearDownClass自动调用了")
    def setUp(self):
        print("setUp被自动调用了")
    def tearDown(self):
        print("testDown被自动调用了")

    def test_001(self):
        print(my_sum(5,6))

    def test_002(self):
        print(my_sum(0,3))


class my_test2(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print("setupclass自动调用了")
    @classmethod
    def tearDownClass(cls):
        print("tearDownClass自动调用了")
    def setUp(self):
        print("setUp被自动调用了")
    def tearDown(self):
        print("testDown被自动调用了")

    def test_001(self):
        print(my_sum(5,6))

    def test_002(self):
        print(my_sum(0,3))

小结

一定要在继承于unittest.TestCase这个类的子类中使用
setUp,tearDown，每个方法执行开始和完毕后自动调用
setUpClass，tearDwonClass，每个类开始时和结束时自动调用
setUpModule，tearDownModule，每个py文件开始和结束的时候自动调用

断言

让程序来判断测试用例执行结果是否符合预期

UnitTest常用断言方法

assertEqual(参数1，参数2)，参数顺序可以颠倒
- 如果参数1(实际结果)与参数2(预期结果)的值相同，断言成功没否则断言失败
- 修改后的mytest.py：

import unittest

def setUpModule():
    print("setUpModule自动调用了")

def tearDownModule():
    print("tearDwonModule自动调用了")

def my_sum(a,b):
    return a   b

class my_test1(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print("setupclass自动调用了")
    @classmethod
    def tearDownClass(cls):
        print("tearDownClass自动调用了")
    def setUp(self):
        print("setUp被自动调用了")
    def tearDown(self):
        print("testDown被自动调用了")

    def test_001(self):
        num1 = print(my_sum(5,6))    #定义变量num1得到函数的返回值
        self.assertEqual(num1,11)    # num1存在实际结果，11时预期结果
        # 实际结果与预期结果相符，代表测试用例测试通过

    def test_002(self):
        num1 = print(my_sum(0,3))
        self.assertEqual(num1,3)

assertIn(参数1,参数2)
- 如果参数1在参数2里面，则断言成功，否则断言失败。修改后的mytest.py如下：

import unittest
import random

def setUpModule():
    print("setUpModule自动调用了")

def tearDownModule():
    print("tearDwonModule自动调用了")

def my_sum(a,b):
    return a   b

def my_rand():     # 返回1到5之间的随机数
    return random.randint(10,50)

class my_test1(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print("setupclass自动调用了")
    @classmethod
    def tearDownClass(cls):
        print("tearDownClass自动调用了")
    def setUp(self):
        print("setUp被自动调用了")
    def tearDown(self):
        print("testDown被自动调用了")

    def test_001(self):
        num1 = my_sum(1,6)  #定义变量num1得到函数的返回值
        self.assertEqual(num1,7)    # num1存在实际结果，11时预期结果
        # 实际结果与预期结果相符，代表测试用例测试通过

    def test_002(self):
        num1 = my_sum(0,3)
        self.assertEqual(num1,3)

    def test_003(self):
        num1 = my_rand()
        self.assertIn(num1,[1,2,3,4,5])

测试用例中使用参数化的场景

多个测试用例代码相同，只是测试数据和预期结果不同，可以把多个测试用例通过参数化技术合并为一个测试用例

参数化场景一

第一步：导入from parameterized import parameterized
第二步：在方法上面用 @parameterized.expand()修饰方法
- expand()里面是一个列表
- 列表里面放多个元组，每个元组中的成员就代表调用方法使用的实参
- 列表中有几个元组，方法就会自动被调用几次

import unittest
from parameterized import parameterized

def my_sum(a,b):
    return a   b

class my_test1(unittest.TestCase):

     # a是调用my_sum的第一个参数
     # b是调用my_sum的第一个参数
     # c是预期结果
    @parameterized.expand([(1,2,3),(5,7,11),(-1,3,2)])
    def test_001(self,a,b,c):
        num1 = my_sum(1,6)  #定义变量num1得到函数的返回值
        self.assertEqual(num1,7)    # num1存在实际结果，11是预期结果
        # 实际结果与预期结果相符，代表测试用例测试通过

参数化场景二

import unittest
from parameterized import parameterized

def my_sum(a,b):
    return a   b

list1 = [(1,2,3),(5,7,11),(-1,3,2)]

class my_test1(unittest.TestCase):

     # a是调用my_sum的第一个参数
     # b是调用my_sum的第一个参数
     # c是预期结果
    @parameterized.expand(list1)
    def test_001(self,a,b,c):
        num1 = my_sum(1,6)  #定义变量num1得到函数的返回值
        self.assertEqual(num1,7)    # num1存在实际结果，11时预期结果
        # 实际结果与预期结果相符，代表测试用例测试通过

参数化场景三

import unittest
from parameterized import parameterized

def my_sum(a,b):
    return a   b

def get_data():  #定义了一个函数，返回一个列表
    return [(1,2,3),(5,7,11),(-1,3,2)]

class my_test1(unittest.TestCase):

     # a是调用my_sum的第一个参数
     # b是调用my_sum的第一个参数
     # c是预期结果
    @parameterized.expand(get_data())
    def test_001(self,a,b,c):
        num1 = my_sum(1,6)  #定义变量num1得到函数的返回值
        self.assertEqual(num1,7)    # num1存在实际结果，11时预期结果
        # 实际结果与预期结果相符，代表测试用例测试通过

跳过

可以通过@unittest.skip跳过指定的方法或函数
语法：

@unitteat.skip
def 方法名():

 @unittest.skip
    def test_002(self):
        print("test002")

通过TextTestRunner生成测试报告

在实例化TextTestRunner对象的时候，需要写参数

stream=file,verbosity=2
file代表用open打开的一个文件
verbosity=2，固定

第一步：用open，w方式打开测试报告文件
第二步，实例化TextTestRunner对象
第三步：调用对象的run方法执行测试套件
第四步：关闭open打开的文件

import unittest
# 用TestLoader对象的discover方法来自动查找py，自动加载py文件中的方法
# 第一个参数是从哪里找py文件，“.”从当前目录开始查找py文件
# 第二个参数是指定py文件的文件名，可以用通配符
suite = unittest.TestLoader().discover(".","my*.py")
# runner = unittest.TextTestRunner()
file = open("test01.txt","w",encoding="utf8")
runner = unittest.TextTestRunner(stream=file,verbosity=2)
runner.run(suite)
file.close()

HTML测试报告

把文件HTMLTestRunner.py拷贝到项目目录下
在代码中导入模块from HTMLTestRunner import HTMLTestRunner
调用HTMLTestRunner(stream=file,title=“我的第一个html测试报告”)
- 第一个参数是用open打开的文件，扩展名一定是.html
- open打开文件的时候用wb，不用指定字符集
调用runner对象的run方法执行测试套件
关闭open打开的文件

import unittest
from HTMLTestRunner import HTMLTestRunner
# 用TestLoader对象的discover方法来自动查找py，自动加载py文件中的方法
# 第一个参数是从哪里找py文件，“.”从当前目录开始查找py文件
# 第二个参数是指定py文件的文件名，可以用通配符
suite = unittest.TestLoader().discover(".","my*.py")
# runner = unittest.TextTestRunner()
file = open("test01.html","wb")  # 用wb代表用二进制方式打开文件
# runner = unittest.TextTestRunner(stream=file,verbosity=2)
runner = HTMLTestRunner(stream=file,title="我的第一个html测试报告")
runner.run(suite)
file.close()

这篇文章转载于：学新通

搜索

UnitTest(自动化测试框架)-单元测试、Fixture、断言、HTMLTestRunner自动生成测试报告

什么是unitTest？

TestCase

TestSuite

TextTestRunner

TestLoader

TestSuite与TestLoader区别

小结

Fixture

方法级

类级

模块级

小结

断言

UnitTest常用断言方法

测试用例中使用参数化的场景

参数化场景一

参数化场景二

参数化场景三

跳过

通过TextTestRunner生成测试报告

HTML测试报告

photoshop保存的图片太大微信发不了怎么办

word里面弄一个表格后上面的标题会跑到下面怎么办

微信公众号没有声音提示怎么办

ChatGPT 通过谷歌算法面试，年薪 18.3 万美金

photoshop扩展功能面板显示灰色怎么办

excel打印预览压线压字怎么办

微信小程序看不了广告怎么办

抖音国际版要用什么加速器能流畅刷Tiktok的加速器

photoshop怎么修脸

《学习通》视频自动暂停处理方法