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