Unit-test框架

介绍

是Python自带的自动化测试框架

TestCast 测试用例

案例:
定义一个实现加法操作的函数，并对该函数进行测试。
心
定义测试用例:
1、导包:import unittest;
2、定义测试类:新建测试类必须继承unittest.TestCase;
3、定义测试方法:测试方法名称命名必须以test开头;
4、调用unittest.main()执行测试用例;

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(3,4))

TestSuit 测试套件 把多个TestCase集成在一个TestSuit

# 导入unittest
import unittest
# 导入包含其他测试用例的
import TestCase
# 实例化unittest.TestSuite()方法
suite = unittest.TestSuite()
# 调用添加suite.addTest()方法
# addTest(测试用例.例名("方法名"))
suite.addTest(TestCase.my_test("test_001"))
suite.addTest(TestCase.my_test("test_002"))
# 目前只是把测试用例添加到测试套件中，并不是执行测试用例


# unittest.makeTest() 一次可以导入多个方法
#suite.addTest(unittest.makeTest(TestCase.my_test)

TestRunner 执行测试用例

		作用,执行在suite中的测试用例·使用方法
		先实力化TextTextRunner的对象。调用对象的run方法
		只要把suite做为参数,放入到run方法里面

# 导入unittest
import unittest
# 导入包含其他测试用例的
import TestCase
# 实例化unittest.TestSuite()方法
suite = unittest.TestSuite()
# 调用添加suite.addTest()方法
# addTest(测试用例.例名("方法名"))
# suite.addTest(TestCase.my_test("test_001"))
# suite.addTest(TestCase.my_test("test_002"))
# 目前只是把测试用例添加到测试套件中，并不是执行测试用例
# unittest.makeTest() 一次可以导入多个方法
suite.addTest(unittest.makeSuite(TestCase.my_test))

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

TestLoader z自动从代码中加载多个测试用例 TestCast

import unittest
# 当前目录下以TestCase	开头的python文件
#用TestLoader对象的discover方法来自动查找py，自动加载py文件中的方法
#第一个参数是从哪里找py文件,"."从当前目录开始查找py文件
#第二个参数是指定py文件的文件名，可以用通配符

suite = unittest.TestLoader().discover("./","TestCase*.py")
runner = unittest.TextTestRunner()
runner.run(suite)

TestSuite 与TestLoader区别

TestSuite需要手动添加测试用例（可以添加测试类，也可以添加测试类中某
个测试方法);

TestLoader搜索指定目录下指定开头.py文件,并添加测试类中的所有的测试
方法，不能指定添加测试方法;

当只是要执行py文件中多个测试用例中的几个,而不是全部执行那么适合用TestSuite的addTest加载指定的测试用例
当要执行所有的py文件中的所有的测试用例,那么适合使用TestLoader

**

Fixture （UnitTest 特性）

在测试用例前后自动调用指定的函数
**
对一个测试用例的初始化和销毁 就是一个Fixture

控制级别

方法级
每个方法执行前和执行后都自动调用函数

import unittest
def my_sum(a,b):
    return a+b
class my_test(unittest.TestCase):
    def setUp(self):
        print("setup被执行了")
    def tearDown(self):
        print("tearDown被执行了")
    def test_001(self):
         print(my_sum(5,6))

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

类级
·不管类中有多少方法,一个类执行前后都自动调用函数。

不管类中有多少方法,一个类开始的时候自动调用函数,结束的之后自动调用函数类级的fixture一定要是类方法
@classmethod def setupclass(cls)类开始时自动调用的方法
@clasmethod def tearDownclass(cls)类结束的时候自动调用的方法

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("tearDown被执行了")
    def test_001(self):
         print(my_sum(5,6))

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

模块级
不管一个模块(一个模块就是一个py文件)中有多少类,模块执行前后自动调用函数

import unittest
def setUpModule():
    print("setUpModule自动执行了")
def tearDownModule():
    print("tearDownModule自动被执行了")
def my_sum(a,b):
    return a+b
class _001(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print("setupclass自动执行了")
    @classmethod
    def tearDownClass(cls):
        print("tearDownclass自动被执行了")
    def setUp(self):
        print("setup被执行了")
    def tearDown(self):
        print("tearDown被执行了")
    def test_001(self):
         print(my_sum(5,6))

    def test_002(self):
         print(my_sum(3,4))
class my_test_002(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print("setupclass自动执行了")
    @classmethod
    def tearDownClass(cls):
        print("tearDownclass自动被执行了")
    def setUp(self):
        print("setup被执行了")
    def tearDown(self):
        print("tearDown被执行了")
    def test_001(self):
         print(my_sum(5,6))

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

不管py文件中有多少个类,以及类中有多少方法,只自动执行一次
def setUpModule()在py文件开始的时候自动调用
def tearDownModule()在py文件结束的时候自动调用

Fixture 小结

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

断言

让程序判断测试用例执行结果是否和预期结果一直

常用断言

断言

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

unittest断言

• assertEqual(参数1, 参数2)
  • 如果参数1,参数2的值相等,断言成功,否则断言失败
  • 两个参数,有一个存放实际结果,有一个存放预期结果

修改后的mytest.py内容

import unittest

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

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

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("teardown被自动调用了")

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VExrYT20-1639120409773)(assets/image-20200804142600047.png)]

• assertIn(参数1, 参数2)
  • 如果参数1在参数2里面,断言通过,否则断言失败

修改后的mytest.py内容如下:

import unittest
import random

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

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

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

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

class my_test1(unittest.TestCase):
    def test_001(self):
        num1 = my_sum(5, 6)  # 定义变量num1得到my_sum函数的返回值
        self.assertEqual(num1, 11)  # 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])

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PBxW2jkD-1639120409775)(assets/image-20200804143921968.png)]

参数化

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

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

import unittest
import random

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

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

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

class my_test1(unittest.TestCase):
    def test_001(self):
        num1 = my_sum(5, 6)  # 定义变量num1得到my_sum函数的返回值
        self.assertEqual(num1, 11)  # num1里存放的是实际结果,11是预期结果
        # 实际结果与预期结果相符,代表测试用例测试通过
        # 不相符代表测试用例测试失败

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

    def test_003(self):
        num1 = my_sum(-3, 7)
        self.assertEqual(num1, 4)

    def test_004(self):
        num1 = my_sum(-4, -20)
        self.assertEqual(num1, -24)

    # 以上的测试用例,基本是一样的,测试用例的数据和预期结果不同

手工安装py包的过程

• 把parameterized目录和parameterized-0.7.4.dist-info拷贝到python安装目录的Lib/site-packages下
• 在pycharm中新建项目的时候,注意一个选项
  • 第一步:先新建了一个文件夹c:\file\mycode

参数化

• 第一步:导入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, 6, 110), (-1, 3, 2)])
    def test_001(self, a, b, c):
        num1 = my_sum(a, b)  # 定义变量num1得到my_sum函数的返回值
        self.assertEqual(num1, c)  # num1里存放的是实际结果,11是预期结果
        # 实际结果与预期结果相符,代表测试用例测试通过
        # 不相符代表测试用例测试失败

执行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HcXIs9AI-1639120409781)(assets/image-20200804154024006.png)]

参数化场景二

import unittest
from parameterized import parameterized

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

list1 = [(1, 2, 3), (5, 6, 110), (-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(a, b)  # 定义变量num1得到my_sum函数的返回值
        self.assertEqual(num1, c)  # num1里存放的是实际结果,11是预期结果
        # 实际结果与预期结果相符,代表测试用例测试通过
        # 不相符代表测试用例测试失败

参数化场景三:

import unittest
from parameterized import parameterized

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

def get_data():  # 定义了一个函数,返回一个列表
    return [(1, 2, 3), (5, 6, 110), (-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(a, b)  # 定义变量num1得到my_sum函数的返回值
        self.assertEqual(num1, c)  # num1里存放的是实际结果,11是预期结果
        # 实际结果与预期结果相符,代表测试用例测试通过
        # 不相符代表测试用例测试失败

跳过(了解即可)

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

@unittest.skip
def 方法名():

import unittest
from parameterized import parameterized

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

def get_data():  # 定义了一个函数,返回一个列表
    return [(1, 2, 3), (5, 6, 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(a, b)  # 定义变量num1得到my_sum函数的返回值
        self.assertEqual(num1, c)  # num1里存放的是实际结果,11是预期结果
        # 实际结果与预期结果相符,代表测试用例测试通过
        # 不相符代表测试用例测试失败
    @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()
# 用wb代表用二进制写方式打开文件
file = open("test01.html", "wb")  
# runner = unittest.TextTestRunner(stream=file, verbosity=2)
runner = HTMLTestRunner(stream=file, title="我的第一个html测试报告")
runner.run(suite)
file.close()

作业例题

# 导包
import unittest
from parameterized import parameterized
from HTMLTestRunner import HTMLTestRunner

# 参数str1的值分别为”hello 123”和”1a3b”, “你好”
def digital(str1):
    sum = 0
    for n in str1:
        if n >= "0" and n <= "9":
            sum += 1
    return sum
#定义测试类:新建测试类必须继承unittest.TestCase
class test(unittest.TestCase):
    @parameterized.expand([("hello 123",3),("1a3b",2),("你好",0)])
#定义测试方法:测试方法名称命名必须以test开头
    def test_001(self,a,b):
        result = digital(a)
        self.assertEqual(result,b)
#用TestLoader对象的discover方法来自动查找py,自动加载py文件中的方法
suite = unittest.TestLoader().discover(".", "test*.py")
# 用wb代表用二进制写方式打开文件
file = open("test01.html", "wb")
runner = HTMLTestRunner(stream=file, title="我的第一个html测试报告")
runner.run(suite)
file.close()