一、引言

在自动化测试中，一个测试用例对应一个测试点，通常一组测试数据无法完全覆盖测试范围，所以，需要参数化来传递多组数据。pytest的测试用例参数化，使用 @pytest.mark.parametrize 装饰器完成。

说明：

@pytest.mark.parametrize(argnames, argvalues)

# argnames: 以逗号分隔的字符串

# argvaluse: 参数值列表，若有多个参数，一组参数以元组形式存在，包含多组参数的所有参数

# 以元组列表形式存在

@pytest.mark.parametrize(argnames, argvalues) 装饰器接收两个参数，一个参数（argnames）是以字符串的形式标识用例函数的参数，第二个参数（argvalues）以列表或元组的形式传递测试数据。

将定义的argnames，传递到测试用例中的参数中，作为形参。

二、参数化说明

参数化传递的都是列表，一个列表显示多组测试数据，每条测试用例，数据驱动一条测试数据，就像for循环遍历一样。

2.1、一个参数

class TestA:
    @pytest.mark.parametrize("number", [1, 2, 3])
    def test_a(self, number):
        print(f"参数化传递的数据是：{number}")
        assert 1 == 1

注意：其中装饰器定义的一个字符串参数，必须和用例中传递的参数一致。?

执行结果：

2.2、多个参数?

@pytest.mark.parametrize("number, code", [(1, "aa"), (2, "bb")])
def test_b(self, number, code):
    print(f"参数化传递的数据是：{number}和{code}")
    assert 1 == 1

?执行结果：?

2.3、字典参数化

日常自动化测试中运用最多的就是字典参数化了，读取csv、yaml、excel、json中的数据，进行参数化驱动。

常用的做法是将，第二个参数替换成读取csv、yaml、excel的路径。

@pytest.mark.parametrize("data", [{"name": "keke", "age": 18}, {"name": "susan", "age": 19}, {"name": "lisi", "age": 20}])
def test_c(self, data):
    print(f"参数化传递的name是：{data['name']}, age是：{data['age']}")
    assert 1 == 1

?执行结果：

2.4、笛卡尔积参数化

测试中，有时候，需要覆盖多种测试情况，可以使用多组参数化，然后去笛卡尔积。

@pytest.mark.parametrize("number1", [1, 2, 3])
@pytest.mark.parametrize("number2", [4, 5, 6])
def test_d(self, number1, number2):
    print(f"参数化传递的数据是：{number1}和{number2}")
    assert 1 == 1

执行结果：

2.5、测试类参数化

测试类的参数化，实际上是对类中的每个测试用例进行参数化。类中的每个测试用例的参数，必须与@pytest.mark.parametrize()中的标识的参数个数一致。

@pytest.mark.parametrize("a, b, c", [(1, 2, 3), (4, 5, 6)])
class TestB:
    def test_add1(self, a, b, c):
        print(f"参数化传递的数据是：{a}和{b}和{c}")

    def test_add2(self, a, b, c):
        print(f"参数化传递的数据是：{a}和{b}和{c}")

?执行结果：

2.6、修改显示结果名称

除外字典参数化，其余参数化运行结果，都是会显示组合数据，默认是根据 函数名[参数名]。但如果数据特别多的情况下，运行结果就会很长，不易阅读。

@pytest.mark.parametrize源码里还提供了ids，可以自动有修改显示结果名称。

class _ParametrizeMarkDecorator(MarkDecorator):
    def __call__(  # type: ignore[override]
        self,
        argnames: Union[str, List[str], Tuple[str, ...]],
        argvalues: Iterable[Union[ParameterSet, Sequence[object], object]],
        *,
        indirect: Union[bool, Sequence[str]] = ...,
        ids: Optional[
            Union[
                Iterable[Union[None, str, float, int, bool]],
                Callable[[Any], Optional[object]],
            ]
        ] = ...,
        scope: Optional[_Scope] = ...
    ) -> MarkDecorator:
        ...

data = [(1, 2, 3), (4, 5, 9), ('1', '2', '12')]
ids = [f'data{d}' for d in range(1, len(data) + 1)]


@pytest.mark.parametrize('a, b, c', data, ids=ids)
def test_add(a, b, c):
    print(f'a,b,c的值：{a},{b},{c}')
    assert 1 == 1

?执行结果：

2.7、indrect参数

（1）indirect=False时，argnames 参数被当成普通变量使用，默认indirect是False。不传indirect参数，就和前6条用法一致。

@pytest.fixture()
def fixture_demo(request):
    print('执行参数{}'.format(request.param))
    return request.param + 1


@pytest.mark.parametrize('fixture_demo', [1, 2, 3], indirect=False)
def test_demo1(fixture_demo):
    print(f'indirect=True, 返回结果：{fixture_demo}')

?执行结果

（2）indirect=True时，parametrize 中的 argnames 参数被当成函数执行，且 argvalues 值作为 argnames函数中的参数传参，并最终以fixture的执行结果返回。

这种使用场景，经常是连接数据库、登录。每次传参不一样，需要使用fixture去前置处理数据库连接、登录。

@pytest.fixture()
def fixture_demo(request):
    print('执行参数{}'.format(request.param))
    return request.param + 1


@pytest.mark.parametrize('fixture_demo', [1, 2, 3], indirect=True)
def test_demo1(fixture_demo):
    print(f'indirect=True, 返回结果：{fixture_demo}')

执行结果?