python+unittest+ddt
ddt模块是一个很好玩且很有用的应用,其迭代传参与拆解刚开始不好理解,但仔细研究一下还是很值得玩味的。
简介
ddt模块包含了一个类的装饰器ddt和两个方法的装饰器:
装饰器: @ddt.ddt;
data:包含多个你想要传给测试用例的参数;
file_data:会从json或yaml中加载数据;
unpanck:通常data中包含的每一个值都会作为一个单独的参数传给测试方法,如果这些值是用元组或者列表传进来的,可以用unpack方法将其自动分解成多个参数
用例
# coding: utf-8
# author:
# email:
# createDate:
# updateDate:
import unittest
import ddt #第三方库
list_data=[1,2,3,4]
arr_data=[[1,2],[3,4],[5,6]]
spe_data=[[1,2,3],[4,5,6],[7,8,9]]
@ddt.ddt
class MyTestCase(unittest.TestCase):
# 只有一个变量参数时
@ddt.data(1)
def test_00(self,a):
print('test_00:',a)
# 只有一个列表参数时
@ddt.data([1,2,3,4])
def test_01(self,a):
print('test_01:',a)
# 多个参数
@ddt.data(1,2,3,4)
def test_02(self,a):
print('test_02:',a)
# 多个参数,采用列表地址传参list_data=[1,2,3,4], 相当于传达了四个参数,结果同上
@ddt.data(*list_data)
def test_03(self,a):
print('test_03:',a)
# # 只有一个列表参数时, 一个元素,只会输出一次,被拆解了,必须使用四个参数去接收,否则报错
# @ddt.data([1,2,3,4])
# @ddt.unpack
# def test_04(self,a):
# print('test_04:',a)
#
# # 只有一个列表参数时, 一个元素,只会输出一次,被拆解了,必须使用四个参数去接收,否则报错
# @ddt.data([1,2,3,4])
# @ddt.unpack
# def test_05(self,a,b):
# print('test_05:',a,b)
#
# # 只有一个列表参数时, 一个元素,只会输出一次,被拆解了,必须使用四个参数去接收,否则报错
# @ddt.data([1,2,3,4])
# @ddt.unpack
# def test_06(self,a,b,c):
# print('test_06:',a,b,c)
# 只有一个列表参数时, 一个元素,只会输出一次,被拆解了,必须使用四个参数去接收,否则报错
@ddt.data([1,2,3,4])
@ddt.unpack
def test_07(self,a,b,c,d):
print('test_07:',a,b,c,d)
# 只有一个列表参数时arr_data=[[1,2],[3,4],[5,6]]
@ddt.data([[1,2],[3,4],[5,6]])
def test_10(self,a):
print('test_10:',a)
# 多个参数
@ddt.data([1,2],[3,4],[5,6])
def test_11(self,a):
print('test_11:',a)
# 多个参数,采用列表地址传参arr_data=[[1,2],[3,4],[5,6]], 相当于传达了三个参数,结果同上
@ddt.data(*arr_data)
def test_12(self,a):
print('test_12:',a)
# # 只有一个列表参数时 arr_data=[[1,2],[3,4],[5,6]],报错
# @ddt.data([[1,2],[3,4],[5,6]])
# @ddt.unpack
# def test_13(self,a):
# print('test_13:',a)
# # 只有一个列表参数时 arr_data=[[1,2],[3,4],[5,6]],报错
# @ddt.data([[1,2],[3,4],[5,6]])
# @ddt.unpack
# def test_14(self,a,b):
# print('test_14:',a,b)
# # 表示可变参数取值为arr_data=[[1,2],[3,4],[5,6]],报错
# @ddt.data([1,2],[3,4],[5,6])
# @ddt.unpack
# def test_15(self,a):
# print('test_15:',a)
# 表示可变参数取值为arr_data=[[1,2],[3,4],[5,6]],三个元素,会循环三次,又被拆解了,每个元素必须使用两个参数去接收
@ddt.data([1,2],[3,4],[5,6])
@ddt.unpack
def test_16(self,a,b):
print('test_16:',a,b)
# 只有一个列表参数时spe_data=[[1,2,3],[4,5,6],[7,8,9]]
@ddt.data([[1,2,3],[4,5,6],[7,8,9]])
def test_20(self,a):
print('test_20:',a)
# 多个参数
@ddt.data([1,2,3],[4,5,6],[7,8,9])
def test_21(self,a):
print('test_21:',a)
# 多个参数,采用列表地址传参spe_data=[[1,2,3],[4,5,6],[7,8,9]], 相当于传达了三个参数,结果同上
@ddt.data(*spe_data)
def test_22(self, a):
print('test_22:', a)
# # 只有一个列表参数时 spe_data=[[1,2,3],[4,5,6],[7,8,9]],报错
# @ddt.data([[1,2,3],[4,5,6],[7,8,9]])
# @ddt.unpack
# def test_23(self,a):
# print('test_23:',a)
# # 只有一个列表参数时 spe_data=[[1,2,3],[4,5,6],[7,8,9]],报错
# @ddt.data([[1,2,3],[4,5,6],[7,8,9]])
# @ddt.unpack
# def test_24(self,a,b):
# print('test_24:',a,b)
# 只有一个列表参数时 spe_data=[[1,2,3],[4,5,6],[7,8,9]],拆分列表,单个元素还是一个列表,查分了三个,所以必须三个参数来接收
@ddt.data([[1,2,3],[4,5,6],[7,8,9]])
@ddt.unpack
def test_25(self,a,b,c):
print('test_25:',a,b,c)
# # 多参,每个参数被查分,必须三个参数接收,一个参数接收会报错
# @ddt.data([1,2,3],[4,5,6],[7,8,9])
# @ddt.unpack
# def test_26(self,a):
# print('test_26:',a)
# # 多参,每个参数被查分,必须三个参数接收,两个参数接收会报错
# @ddt.data([1,2,3],[4,5,6],[7,8,9])
# @ddt.unpack
# def test_27(self,a,b):
# print('test_27:',a,b)
# 多参,每个参数被查分,必须三个参数接收
@ddt.data([1,2,3],[4,5,6],[7,8,9])
@ddt.unpack
def test_28(self,a,b,c):
print('test_28:',a,b,c)
# 多个参数,采用列表地址传参spe_data=[[1,2,3],[4,5,6],[7,8,9]], 相当于传达了三个参数[1,2,3],[4,5,6],[7,8,9],结果同上
@ddt.data(*spe_data)
@ddt.unpack
def test_30(self,a,b,c):
print('test_30:',a,b,c)
# # 多个参数,采用列表地址传参spe_data=[[1,2,3],[4,5,6],[7,8,9]], 相当于传达了三个参数[1,2,3],[4,5,6],[7,8,9],接收参数不能少,否则报错
# @ddt.data(*spe_data)
# @ddt.unpack
# def test_31(self,a):
# print('test_31:',a)
# # 多个参数,采用列表地址传参spe_data=[[1,2,3],[4,5,6],[7,8,9]], 相当于传达了三个参数[1,2,3],[4,5,6],[7,8,9],接收参数不能少,否则报错
# @ddt.data(*spe_data)
# @ddt.unpack
# def test_32(self,a,b):
# print('test_32:',a,b)
# 一个参数,采用列表地址传参spe_data=[[1,2,3],[4,5,6],[7,8,9]], 相当于传达了一个参数[1,2,3],不拆分
@ddt.data(spe_data[0])
def test_40(self,a):
print('test_40:',a)
# 一个参数,采用列表地址传参spe_data=[[1,2,3],[4,5,6],[7,8,9]], 相当于传达了一个参数[1,2,3],拆分
@ddt.data(spe_data[0])
@ddt.unpack
def test_41(self,a,b,c):
print('test_41:',a,b,c)
# # 一个参数,采用列表地址传参spe_data=[[1,2,3],[4,5,6],[7,8,9]], 相当于传达了一个参数[1,2,3],拆分后接收参数不能少,否则报错
# @ddt.data(spe_data[0])
# @ddt.unpack
# def test_42(self,a,b):
# print('test_42:',a,b)
# # 一个参数,采用列表地址传参spe_data=[[1,2,3],[4,5,6],[7,8,9]], 相当于传达了一个参数[1,2,3],拆分后接收参数不能少,否则报错
# @ddt.data(spe_data[0])
# @ddt.unpack
# def test_43(self,a):
# print('test_43:',a)
# 一个参数,采用列表地址传参spe_data=[[1,2,3],[4,5,6],[7,8,9]], 相当于传达了一个参数1,不能拆分且接收参数不能多,否则报错
@ddt.data(spe_data[0][0])
def test_44(self,a):
print('test_44:',a)
# # 一个参数,采用列表地址传参spe_data=[[1,2,3],[4,5,6],[7,8,9]], 相当于传达了一个参数1,不能拆分且接收参数不能多,否则报错
# @ddt.data(spe_data[0][0])
# @ddt.unpack
# def test_45(self,a):
# print('test_45:',a)
if __name__ =='__main__':
unittest.main()
附(运行结果,供理解):
test_00: 1
test_01: [1, 2, 3, 4]
test_02: 1
test_02: 2
test_02: 3
test_02: 4
test_03: 1
test_03: 2
test_03: 3
test_03: 4
test_07: 1 2 3 4
test_10: [[1, 2], [3, 4], [5, 6]]
test_11: [1, 2]
test_11: [3, 4]
test_11: [5, 6]
test_12: [1, 2]
test_12: [3, 4]
test_12: [5, 6]
test_16: 1 2
test_16: 3 4
test_16: 5 6
test_20: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
test_21: [1, 2, 3]
test_21: [4, 5, 6]
test_21: [7, 8, 9]
test_22: [1, 2, 3]
test_22: [4, 5, 6]
test_22: [7, 8, 9]
test_25: [1, 2, 3] [4, 5, 6] [7, 8, 9]
test_28: 1 2 3
test_28: 4 5 6
test_28: 7 8 9
test_30: 1 2 3
test_30: 4 5 6
test_30: 7 8 9
test_40: [1, 2, 3]
test_41: 1 2 3
test_44: 1