python UnitTest

UnitTest介绍

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

TestCase

  • 第一步:导入unittest模块
  • 第二步:实现一个类,这个类必须继承自unittest.TestCase类
  • 第三步:类中每个方法代表一个测试用例,方法名必须以test开头
    python UnitTest_第1张图片
import unittest

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

class my_test1(unittest.TestCase):
    def test1_oo1(self):
        print(my_sum(5,3))

    def test1_002(self):
        print(my_sum(2,8))
  • 如果鼠标右键不出现unittest运行选项的处理方法
    python UnitTest_第2张图片
    python UnitTest_第3张图片

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("test_001"))
suite.addTest(testcase_01.my_test("test_002"))
# 只是把测试用例添加到了测试套件中,并不是执行测试用例

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

import unittest
import testcase_01

suite =unittest.TestSuite()
# suite.addTest(testcase_01.my_test("test_001"))
# suite.addTest(testcase_01.my_test("test_002"))
# 只是把测试用例添加到了测试套件中,并不是执行测试用例
suite.addTest(unittest.makeSuite(testcase_01.my_test))   # 导入一个类中的所有测试方法

TextTestRunner

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

python UnitTest_第4张图片

import unittest
import testcase_01

suite =unittest.TestSuite()
# suite.addTest(testcase_01.my_test("test_001"))
# suite.addTest(testcase_01.my_test("test_002"))
# 只是把测试用例添加到了测试套件中,并不是执行测试用例
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的使用区别

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

小结

  • 所有的TestCase最终都是用TextTestRunner来执行
  • TextTestRunner执行的是TestSuite
  • 一个TestSuite中可以有多个TestCase

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

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

    def test_002(self):
        print(my_sum(2,8))

类级

  • 不管一个类中有多少方法,一个类开始的时候自动调用函数,结束之后自动调用方法
  • 类级的Fixture一定要是类方法
  • @classmethod def setUpClass(cla) 类开始时自动调用的方法
  • @classmethod def tearDowenClass 类结束时自动调用的方法
    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("tearDown被自动调用了")

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

    def test_002(self):
        print(my_sum(2,8))

模块级

  • 不管py文件中有多少个类,以及类中有多少方法,只自动执行一次
  • def setUpModule() 在py文件开始的时候自动调用
  • def tearDownModule() 在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):
        print(my_sum(5,3))

    def test_002(self):
        print(my_sum(2,8))

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

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

    def test_002(self):
        print(my_sum(2,8))

Fixture小结

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

3、断言

  • 让程序来判断测试用例执行结果是否符合预期
    python UnitTest_第5张图片

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

    def test_002(self):
        num1=my_sum(2,8)
        self.assertEqual(num1,10)

在这里插入图片描述

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

    def test_002(self):
        num1 = my_sum(2, 8)
        self.assertEqual(num1, 10)

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

python UnitTest_第6张图片

参数化

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

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

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

    def test_002(self):
        num1 = my_sum(2, 8)
        self.assertEqual(num1, 10)

    def test_003(self):
        num1 = my_sum(-2, 8)
        self.assertEqual(num1, 6)

    def test_004(self):
        num1 = my_sum(-2, -8)
        self.assertEqual(num1, 10)
        # 以上测试用例基本一样,测试用例的数据和预期结果不同       
  • 第一步:导入 from parameterized import parameterized
  • 第二步:在方法上用 @parameterized.expend() 修饰方法
    • 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,11),(-1,3,2)])
    def test_001(self,a,b,c):
        num1 = my_sum(a,b)  # 定义变量num1得到my_sum函数的返回值
        self.assertEqual(num1,c)  # num1里存放的是实际结果,11是预期结果
        # 实际结果与预期结果相符,代表测试用例测试通过
        # 不相符代表测试用例测试失败

python UnitTest_第7张图片
参数化场景二

import unittest
from parameterized import parameterized

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

list1=[(1,2,3),(5,6,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(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_date():   # 定义了一个函数,返回一个列表
    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_date())
    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 方法名():
    @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","w""wb")   # wb代表用二进制写方式打开文件
runner=HTNLTestRunner(stream=file,title="我的第一个html测试报告")
runner.run(suite)
file.close()

练习

python UnitTest_第8张图片

import  unittest
from parameterized import parameterized

def digital(str1):
    sum = 0
    for n in str1:
        if n >= "0" and n <= "9":
            sum += 1
    return sum

class Test(unittest.TestCase):
    @parameterized.expand([("hello 123", 3), ("1a3b", 2), ("你好", 0)])
    def test01(self, a, b):
        result = digital(a)
        self.assertEqual(result, b)

你可能感兴趣的:(python,开发语言)