前言

说到接口自动化，那肯定少不了参数化，这也是pytest的一个特色之一，相比与unitest实现起来更加方便好用。实验参数化常见的就是使用@pytest.mark.parametrize在测试函数或类中定义多组参数，在用例中实现参
数化。

# 参数化方式一

import pytest
@pytest.mark.parametrize("test_input,expected",[ ["3+5", 8], ["2+4", 6], ["6 * 9", 42] ])
def test_eval(test_input, expected):
  assert eval(test_input) == expected

1. 使用pytest_generate_tests实现参数化

由官方文档，可以知道，实现参数化的方式有三种，我们使用第三种方式进行实验，可以更适合本框架的开发。具体的实现方式如官方详细文档，实现的步骤就是：

1.在test函数中传指定的参数名称
2.conftest中实现hook函数：pytest_generate_tests
3.传入参数化数据，实现参数化

1.1 实现参数化示例

# test_demo3.py
# 用例的id名称
names = ["login nam1", "login name2"]
# 测试数据 list of dict
test_data = [{
    "url": "http://49.235.x.x:5000/api/v1/login/",
    "method": "POST",
    "json": {
    "username": "test",
    "password": "123456"
    }
},
{
    "url": "http://49.235.x.x:5000/api/v1/login/",
    "method": "POST",
    "json": {
    "username": "test",
    "password": "123456"
    }
}]
def test_login(param):
    print('---->', param)

# conftest.py
def pytest_generate_tests(metafunc):
  """ generate (multiple) parametrized calls to a test function."""
  if "param" in metafunc.fixturenames:
    metafunc.parametrize("param",
      metafunc.module.test_data,
      ids=metafunc.module.names,
      scope="function")

2 在yaml中实现参数化

在hook函数中，我们分为module级别的参数化，以及function级别的参数化，module级别就是在yml文件的config中传入的参数，function级别就是在单个用例中传入的参数，所以都支持。
所以可以知道，在yml中要实现参数化，需要解决2个问题：

1.在用例函数中需要传入fixtures参数，也就是需要将参数写在fixtures中，再传入用例函数。
2.在创建函数时，要设置参数属性，以及参数数据属性，即：在生成动态用例函数时，就要添加这2个属性

# conftest.py
def pytest_generate_tests(metafunc):
    """
    测试用例参数化：
    :param metafunc: 共有五个属性值
    1.matafunc.fixturenames: 参数化收集时的参数名称
    2.matafunc.module: 使用参数名称进行参数化的测试用例所在的模块对象
    3.matafunc.config: 测试用例会话
    4.matafunc.function: 测试用例对象，即函数或方法对象
    5.matafunc.cls: 测试用例所属的类的类对象
    :return: None
    """
    if hasattr(metafunc.module, 'module_params_data'):  # 检查函数对象
        params_data = getattr(metafunc.module, 'module_params_data')
        params_fixtures = getattr(metafunc.module, 'module_params_fixtures')

        params_len = 0  # 参数化，参数的个数
        if isinstance(params_data, list):
            if isinstance(params_data[0], list):  # 支持下面这种格式
                """fixtures: username, password
                   parameters:- [test1, '123456']
                              - [test2, '123456']"""
                params_len = len(params_data[0])
            elif isinstance(params_data[0], dict):  # 支持下面这种格式
                """parameters:
                            - {"username": "test1", "password": "123456"}
                            - {"username": "test2", "password": "1234562"}"""
                params_len = len(params_data[0].keys())
            else:
                params_len = 1
        params_args = params_fixtures[-params_len:]

        metafunc.parametrize(
            ','.join(params_args),
            params_data,
            scope="module"
        )
    # 用例级别
    if hasattr(metafunc.module, f'{metafunc.function.__qualname__}_params_data'): # __qualname__：获取用例函数名
        params_data = getattr(metafunc.module, f'{metafunc.function.__qualname__}_params_data')
        params_fixtures = getattr(metafunc.module, f'{metafunc.function.__qualname__}_params_fixtures')
        params_len = 0  # 参数化，参数的个数
        if isinstance(params_data, list):
            if isinstance(params_data[0], list):  # 支持下面这种格式
                """fixtures: username, password
                   parameters:- [test1, '123456']
                              - [test2, '123456']"""
                params_len = len(params_data[0])
            elif isinstance(params_data[0], dict):  # 支持下面这种格式
                """parameters:
                            - {"username": "test1", "password": "123456"}
                            - {"username": "test2", "password": "1234562"}"""
                params_len = len(params_data[0].keys())
            else:
                params_len = 1
        params_args = params_fixtures[-params_len:]
        metafunc.parametrize(
            ','.join(params_args),
            params_data,
            scope="function"
        )

在run.py文件中我们分别添加module级别的和用例级别的代码。

  def run(self):

    ...
    # 收集config中的fixtures
        config_fixtures = self.raw.get('config').get('fixtures', [])
        # 多个则变成list形式存储
        if isinstance(config_fixtures, str):
            config_fixtures = [item.strip(' ') for item in config_fixtures.split(',')]  # 这里做了优化，需要去掉item中的" "，否则fixture传入的不合法

    # 在收集config——fixtures这里，我们添加收集parameters参数data
    config_param_data = self.raw.get('config').get('parameters', [])
    # 2.先渲染config_variables

    ...

    # # --------------给module加参数化-------
    config_param_data = render_template_obj.rend_template_any(config_param_data, **self.context)
    config_param_fixtures = render_template_obj.rend_template_any(config_fixtures, **self.context)
    # # config中支持2种格式，把他们合并然后返回一种统一处理
    config_param_fixtures, config_param_data = self.parameters_data(config_param_fixtures, config_param_data)
    if config_param_data:
          # 向module中加入参数化的属性
          setattr(self.module, 'module_params_data', config_param_data)
          setattr(self.module, 'module_params_fixtures', config_param_fixtures)
     # # -------------------end----------------

    ...
    # 在用例这里，添加用例级别的代码
    case = {}  # 收集用例名称和执行内容
    for case_name, case_value in self.raw.items():
      ...
    # 用例中的fixtures
    case_fixtures = []
    if 'fixtures' in case[case_name][0]:  # fixtures写在第一个步骤中
        case_raw_fixtures = case[case_name][0].get('fixtures', [])
        case_fixtures = render_template_obj.rend_template_any(case_raw_fixtures, **self.context)
        # 如果有多个,则变成list的形式
        if isinstance(case_fixtures, str):  # fixtures: run_fixt or [run_fixt1, run_fixt2] --> list  # 这里做了修改优化，放到了if层级下
            case_fixtures = case_fixtures.split(',')
    # --------------用例级别的参数化----------
    if 'parameters' in case[case_name][0]:
        case_raw_parameters = case[case_name][0].get('parameters', [])
        case_parameters = render_template_obj.rend_template_any(case_raw_parameters, **self.context)
        case_fixtures, case_parameters = self.parameters_data(case_fixtures, case_parameters)
        if case_parameters:
            # 向module中加入参数化数据和属性
            setattr(self.module, f'{case_name}_params_data', case_parameters)
            setattr(self.module, f'{case_name}_params_fixtures', case_fixtures)
    # -------------end--------------------

    # 新增函数：对传入的2种方式，做了统一处理，统一返回：参数（传入的fixtures），value（参数数据）的形式
    def parameters_data(self, fixtures, parameters):
        """
        参数化实现2种方式：
        方式1：
        config:
        name: post示例
        fixtures: username, password
        parameters:
            - [test1, '123456']
            - [test2, '123456']
        方式2：
        config:
        name: post示例
        parameters:
            - {"username": "test1", "password": "123456"}
            - {"username": "test2", "password": "1234562"}
        :returns 统一合并：key和value
            fixtures: 用例需要用到的fixtures: ['username', 'password']
            parameters: 参数化的数据list of list : [['test1', '123456'], ['test2', '123456']]
        """
        #1.将fixtures的str换成list
        if isinstance(fixtures, str):
            fixtures = [item.strip(' ') for item in fixtures.split(',')]
        if isinstance(parameters, list) and len(parameters) >= 1:  # 收集方式二中的key和value
            if isinstance(parameters[0], dict):
                params = list(parameters[0].keys())
                new_parameters = []
                for item in parameters:
                    new_parameters.append(list(item.values()))
                for param in params:
                    if param not in fixtures:
                        fixtures.append(param)
                return fixtures, new_parameters
            else:
                return fixtures, parameters
        else:
            # 没有参数化数据，直接返回[]
            fixtures, []

上面增加的代码解决了：1.将参数作为fixtures传入到用例函数中，2.动态生成用例函数前，先增加module中的属性：参数名和参数数据
创建test_x.yml文件

config:
  fixtures: user, psw
  parameters:
    - [a, 'b']
    - [c, d]

test_x1:
  name: 用例1
  parameters:
    - {"username": "test1", "password": "123456"}
    - {"username": "test2", "password": "1234562"}
  print: "1-${user}"

test_x2:
  name: 用例2
  print: "2-${user}"

由参数化数据，可知，该yml文件参数化，生成6条case。运行：pytest .\test_x.yml

本栏目推荐文章
• Jmeter 参数化之用户参数
• C++实现文件内查找字符串
• 函数的参数类型
• IDEA项目名称后面出现中括号，模块Modules的名子和文件夹名称不同，可以右键修改名称也可以在File->Project Structure 修改Modules的Name(快捷键ctrl+Shift+Alt+s)
• 和利时MACS6通过dat文件实现任意时间范围与测点的历史数据提取与科研分析
• 手把手教你MongoDB 数据库连接URL 格式、authSource参数
• 类模板分文件编写
• Linux文件IO之二 [补档-2023-07-21]
• 11-函数进阶-参数类型
• Linux文件IO之一 [补偿-2023-07-21]

关键字 参数 关键 文件 yaml关键字 关键 文件yaml 关键字 参数 关键 文件 关键字 关键yaml 02 yaml框架 关键字 关键 关键字 关键pytest yaml 关键字 参数 关键16 参数 关键字 关键python 参数 关键字 位置 关键 关键字 参数 关键 参数 关键字 名字 关键