pytest之参数化parametrize的使用

参考：

https://www.cnblogs.com/benben-wu/p/11542411.html

https://blog.csdn.net/liudinglong1989/article/details/106206212

前言

unittest框架使用的第三方库ddt来参数化的，而pytest框架就直接使用装饰器@pytest.mark.parametrize来对测试用例进行传参。这个是针对测试方法来参数化，还有一种是针对前置处理函数来传参。但往往这两种是可以结合使用。

fixture之Params参数化(单个列表)

前面讲fixture函数时，它有个参数params用来传递参数，并且与request结合使用，先看单个：

import pytest
 
seq = [1, 2, 3]
 
 
@pytest.fixture(params=seq)
def test_data(request):
    print("参数")
    return request.param
 
 
class TestData:
    def test_1(self, test_data):
        print("用例", test_data)
 
 
if __name__ == '__main__':
      pytest.main()

—————————————————————————————————

运行结果：
fixture_test03.py::TestData::test_1[1] 参数
PASSED                            [ 33%]用例 1
 
fixture_test03.py::TestData::test_1[2] 参数
PASSED                            [ 66%]用例 2
 
fixture_test03.py::TestData::test_1[3] 参数
PASSED                            [100%]用例 3
 
 
============================== 3 passed in 0.05s ==============================

　　

　　

fixture之Params参数化(单个列表嵌套其他格式)

列表里有多个dict数据，request会自动化循环读取每个索引下的值，从0开始，看下面例子：

注意：params需要与request一起使用。

import pytest

seq = [{'a':1,'b':2},{'c':3,'d':4}]


@pytest.fixture(params=seq)
def test_data(request):
　　print("参数：%s"%request.param)
　　return request.param


class TestData:
def test_1(self, test_data):
　　print("用例", test_data)




if __name__ == '__main__':
　　　　pytest.main()
　　
—————————————————————————————————

　运行结果：

============================== 2 passed in 0.04s ==============================

Process finished with exit code 0
参数：{'a': 1, 'b': 2}
PASSED [ 50%]用例 {'a': 1, 'b': 2}
参数：{'c': 3, 'd': 4}
PASSED [100%]用例 {'c': 3, 'd': 4}
　　

装饰器@pytest.mark.parametrize参数化(单个列表)

# 方式一:直接写
@pytest.mark.parametrize("a", ['北京','上海','重庆'])
def test_add01(a):
    print(a)

data = ['北京','上海','重庆']
# 方式二:参数为列表
@pytest.mark.parametrize("a", data)
def test_add02(a):
    print(a)

装饰器@pytest.mark.parametrize参数化(单个列表嵌套其他格式)

import pytest
test_datas = [
    (11, 22, 33),
    (22, 33, 55)
]

datas_dict = [
    {"a": 1, "b": 2, "c": 3},
    {"a": 11, "b": 22, "c": 33},
    {"a": 111, "b": 222, "c": 333},
]

# 方式一:直接写
@pytest.mark.parametrize("a, b, c", [(1, 2, 3), (4, 5, 9)])
def test_add01(a, b, c):
    res = a + b
    assert res == c

# 方式二:参数为列表中嵌套元组
@pytest.mark.parametrize("data", test_datas)
def test_add02(data):
    res = data[0] + data[1]
    assert res == data[2]

# 方式三:参数为列表中嵌套字典
@pytest.mark.parametrize("data", datas_dict)
def test_add03(data):
    res = data["a"] + data["b"]
    assert res == data["c"]

装饰器@pytest.mark.parametrize参数化(多个组合)

#若要获得多个参数化参数的所有组合，可以堆叠参数化装饰器
 
import pytest
@pytest.mark.parametrize("a",[0,1])
@pytest.mark.parametrize("b",[3,4])
def test_01(a,b):
    print("测试数据组合：a->%s,b->%s"%(a,b))
 
if __name__ == "__main__":
    pytest.main(["-s", "test_3.py"])


_______________________________________________________运行结果：
test_123.py 测试数据组合：a->0,b->3
.测试数据组合：a->1,b->3
.测试数据组合：a->0,b->4
.测试数据组合：a->1,b->4

import pytest


@pytest.mark.parametrize("a", [0, 1])
@pytest.mark.parametrize("b", [3, 4])
@pytest.mark.parametrize("c", [2, 6])
def test_01(a, b, c):
    print("测试数据组合：a->%s,b->%s,c->%s" % (a, b, c))


if __name__ == "__main__":
    pytest.main(["-s", "test_123.py"])

———————————————————————————————————
运行结果：
test_123.py 测试数据组合：a->0,b->3,c->2
.测试数据组合：a->1,b->3,c->2
.测试数据组合：a->0,b->4,c->2
.测试数据组合：a->1,b->4,c->2
.测试数据组合：a->0,b->3,c->6
.测试数据组合：a->1,b->3,c->6
.测试数据组合：a->0,b->4,c->6
.测试数据组合：a->1,b->4,c->6
.

 

单个fixture与@pytest.mark.parametrize组合

如果装饰器@pytest.mark.parametrize与request结合使用，如果测试方法写在类中，则@pytest.mark.parametrize的参数名称要与@pytest.fixture函数名称保持一致。并且要添加indirect=True参数，目的是把ss_data当做函数去执行，而不是参数。

根据开关indirect自由控制，默认是False当做参数。indirect是True则当做函数

单个参数--例子1.1  参数是列表格式，indirect=True

import pytest
seq = [1,2,3]
@pytest.fixture()
def ss_data(request):
    print("参数：%s"%request.param)
    return request.param
 
 
 
class TestData:
    @pytest.mark.parametrize("ss_data",seq,indirect=True)
    def test_1(self,ss_data):
        print("用例", ss_data)
 
if __name__ == '__main__':
    pytest.main()


—————————————————————————————————运行结果：
test_123.py 参数：1
用例 1
.参数：2
用例 2
.参数：3
用例 3
.

单个参数--例子1.2  参数是列表格式，indirect=False

如果不使用fixture装饰器函数，也不使用外部函数，也是可以的，indirect默认是False例子如下：

import pytest
seq = [1,2,3]
 
class TestData:
    @pytest.mark.parametrize("x",seq,indirect=False)
    def test_1(self,x):
        print("用例", x)
 
if __name__ == '__main__':
    pytest.main()

———————————————————————————————————运行结果：
test_123.py 用例 1
.用例 2
.用例 3
.

单个参数--例子2  参数是列表嵌套元组格式，indirect=True

import pytest
seq = [(1,2),(3,4)]
 
@pytest.fixture()
def get_data(request):
    x = request.param[0]
    y = request.param[1]
    print(x,111)
    print(y,222)
    # print(request.param)
    pass
 
# indirect=True声明x是个函数
@pytest.mark.parametrize("get_data",seq,indirect=True) 
def test_data(get_data):
　　print(get_data) 

if __name__ == '__main__': 
　　pytest.main() 
————————————————————————————————— 
运行结果：

test_123.py 1 111
2 222
None
.3 111
4 222
None
.

多个fixture与@pytest.mark.parametrize组合

参数化装饰器也可以叠加，使用parametrize装饰器叠加时，用例组合是2个参数个数相乘

import pytest
 
seq1 = [1,2,3]
seq2 = [4,5,6]
 
@pytest.fixture()
def get_seq1(request):
    seq1 = request.param
    print("seq1:",seq1)
    return seq1
 
@pytest.fixture()
def get_seq2(request):
    seq2 = request.param
    print("seq2:", seq2)
    return seq2
 
@pytest.mark.parametrize("get_seq1",seq1,indirect=True)
@pytest.mark.parametrize("get_seq2",seq2,indirect=True)
def test_1(get_seq1,get_seq2):
    print(get_seq1,11)
    print(get_seq2,22)
 
if __name__ == '__main__':
    pytest.main()

—————————————————————————————————

运行结果：
test_123.py seq1: 1
seq2: 4
1 11
4 22
.seq1: 2
seq2: 4
2 11
4 22
.seq1: 3
seq2: 4
3 11
4 22
.seq1: 1
seq2: 5
1 11
5 22
.seq1: 2
seq2: 5
2 11
5 22
.seq1: 3
seq2: 5
3 11
5 22
.seq1: 1
seq2: 6
1 11
6 22
.seq1: 2
seq2: 6
2 11
6 22
.seq1: 3
seq2: 6
3 11
6 22
.