• 自动化测试如何进行参数化？使用什么工具进行参数化？一文详解parameterized的使用以及如何在自动化中使用。

    1.数据参数化介绍

    只要你是负责编写自动化测试脚本的，数据参数化这个思想你就肯定会用 ，数据参数化的工具你肯定的懂一些 ，因为它能大大的提高我们自动化脚本编写效率 。

    1.1什么是数据参数化

    所谓的数据参数化 ，是指所执行的测试用例步骤相同、而数据不同 ，每次运行用例只变化的是数据 ，于是将这些数据专门放在一起进行批量循环运行 ，从而完成测试用例执行的目的 。

    以登录功能为例 ，若一个登录功能每次操作的步骤是 ：

    1. 输入用户名

    2. 输入密码

    3. 点击登录按钮 。

    但是，因为每次输入的数据不同，导致生成的测试用例就不同了 ，同样还是这个登录功能，加上数据就变为以下的用例了 。

    • case1 ： 输入正确的用户名 ，输入正确的密码 ，点击登录

    • case2 : 输入正确的用户，输入错误的密码，点击登录

    • case3 ：输入正确的用户名，输入空的密码，点击登录

    • casen : ...

    可以看到 ，在这些用例中，每条用例最大的不同是什么呢 ？其实就是数据不同 。但是由于数据不同，从而生成了多条测试用例 ，在功能测试中，这些用例是需要分别写、分别执行 。

    1.2.为什么要进行数据参数化 ？

    在功能测试中，即使是相同的步骤 ，只是数据不同 ，我们亦然也要尽量分开编写每一条用例 ，比如像上面的编写方式 ，因为这些编写它的易读性更好 ，功能测试设计测试用例和执行用例往往不是一个人 ，所以用例编写的易读性是就是一个很重要的因素 。

    但是如果将上面的用例进行自动化实现 ，虽然按照一条用例对应一个方法是一种很清晰的思路 ，但是它的最大问题就是代码冗余 ，当一个功能中步骤相同，只是数据不同时，你的数据越多，代码冗余度就越高 。你会发现每个测试方法中的代码就会是相同的 。

    像代码冗余这种问题，在编写自动化时是必须要考虑的一个问题，因为随着代码量越多 ，冗余度越高、越难维护 。

    以下就是是通过正常方式实现登录的自动化脚本 ：

    1. import unittest
    2. from package_unittest.login import login
    3.  
    4.  
    5. class TestLogin(unittest.TestCase):
    6.  
    7.     # case1 : 输入正确的用户名和正确的密码进行登录
    8.     def test_login_success(self):
    9.         expect_reslut = 0
    10.         actual_result = login('admin','123456').get('code')
    11.         self.assertEqual(expect_reslut,actual_result)
    12.  
    13.     # case2 ： 输入正确的用户名和错误的密码进行登录
    14.     def test_password_is_wrong(self):
    15.         expect_reslut = 3
    16.         actual_result = login('admin', '1234567').get('code')
    17.         self.assertEqual(expect_reslut, actual_result)
    18.  
    19.     # case3 : 输入正确的用户名和空的密码进行登录
    20.     def test_password_is_null(self):
    21.         expect_reslut = 2
    22.         actual_result = login('admin', '').get('code')
    23.         self.assertEqual(expect_reslut, actual_result)
    24.

    可以看到，三条用例对应三个测试方法，虽然清晰 ，代码每个方法中的代码几乎是相同的。

    那如果用参数化实现的代码是什么呢 ？ 可以看下面的这段代码 ：

    1. class TestLogin(unittest.TestCase):
    2.  
    3.     @parameterized.expand(cases)
    4.     def test_login(self,expect_result,username,password):
    5.         actual_result = login(username,password).get('code')
    6.         self.assertEqual(expect_result,actual_result)

    以上代码只有一条用例 ，不管这个功能有几条都能执行 。

    通过上面两种形式的比较可以看出 ：为什么要进行数据参数化呢 ？其实就是降低代码冗余、提高代码复用度 ，将主要编写测试用例的时间转化为编写测试数据上来 。

    1.3.如何进行数据参数化

    在代码中实现数据参数化都需要借助于外部工具 ，比如专门用于unittest的ddt , 既支持unittest、也支持pytest的parameterized ，专门在pytest中使用的fixture.params .

    参数化工具支持测试框架备注
    ddtunittest第三方包，需要下载安装
    parameterizednose,unittest,pytest第三方包，需要下载安装
    @pytest.mark.parametrizepytest本身属于pytest中的功能
    @pytest.fixture(params=[])pytest本身属于pytest中的功能

    以上实现数据参数化的工具有两个共同点：

    • 都能实现数据参数化

    • 都时装饰器来作用于测试用例脚本 。

    2.模块介绍

    1.下载安装 ：

    1. # 下载 
    2. pip install parameterized
    3.  
    4. # 验证 ：
    5. pip show parameterized

     2.导包

    1. # 直接导入parameterized类
    2. from parameterized import parameterized

    3.官网示例

    @parameterized 和 @parameterized.expand 装饰器接受列表 或元组或参数（...）的可迭代对象，或返回列表或 可迭代：

    1. from parameterized import parameterized, param
    2.  
    3. # A list of tuples
    4. @parameterized([
    5.     (2, 3, 5),
    6.     (3, 5, 8),
    7. ])
    8. def test_add(a, b, expected):
    9.     assert_equal(a + b, expected)
    10.  
    11. # A list of params
    12. @parameterized([
    13.     param("10", 10),
    14.     param("10", 16, base=16),
    15. ])
    16. def test_int(str_val, expected, base=10):
    17.     assert_equal(int(str_val, base=base), expected)
    18.  
    19. # An iterable of params
    20. @parameterized(
    21.     param.explicit(*json.loads(line))
    22.     for line in open("testcases.jsons")
    23. )
    24. def test_from_json_file(...):
    25.     ...
    26.  
    27. # A callable which returns a list of tuples
    28. def load_test_cases():
    29.     return [
    30.         ("test1", ),
    31.         ("test2", ),
    32.     ]
    33. @parameterized(load_test_cases)
    34. def test_from_function(name):
    35.     ...

    请注意，使用迭代器或生成器时，将加载所有项 在测试运行开始之前放入内存（我们显式执行此操作以确保 生成器在多进程或多线程中只耗尽一次 测试环境）。

    @parameterized装饰器可以使用测试类方法，并且可以独立使用 功能：

    1. from parameterized import parameterized
    2.  
    3. class AddTest(object):
    4.     @parameterized([
    5.         (2, 3, 5),
    6.     ])
    7.     def test_add(self, a, b, expected):
    8.         assert_equal(a + b, expected)
    9.  
    10. @parameterized([
    11.     (2, 3, 5),
    12. ])
    13. def test_add(a, b, expected):
    14.     assert_equal(a + b, expected)

    @parameterized.expand可用于生成测试方法 无法使用测试生成器的情况（例如，当测试 类是单元测试的一个子类。测试用例）：

    1. import unittest
    2. from parameterized import parameterized
    3.  
    4. class AddTestCase(unittest.TestCase):
    5.     @parameterized.expand([
    6.         ("2 and 3", 2, 3, 5),
    7.         ("3 and 5", 3, 5, 8),
    8.     ])
    9.     def test_add(self, _, a, b, expected):
    10.         assert_equal(a + b, expected)

    将创建测试用例：

    1. $ nosetests example.py
    2. test_add_0_2_and_3 (example.AddTestCase) ... ok
    3. test_add_1_3_and_5 (example.AddTestCase) ... ok
    4.  
    5. ----------------------------------------------------------------------
    6. Ran 2 tests in 0.001s
    7.  
    8. OK

    请注意，@parameterized.expand 的工作原理是在测试上创建新方法 .class。如果第一个参数是字符串，则该字符串将添加到末尾 的方法名称。例如，上面的测试用例将生成方法test_add_0_2_and_3和test_add_1_3_and_5。

    @parameterized.expand 生成的测试用例的名称可以是 使用 name_func 关键字参数进行自定义。该值应 是一个接受三个参数的函数：testcase_func、param_num、 和参数，它应该返回测试用例的名称。testcase_func是要测试的功能，param_num将是 参数列表中测试用例参数的索引，参数（参数的实例）将是将使用的参数。

    1. import unittest
    2. from parameterized import parameterized
    3.  
    4. def custom_name_func(testcase_func, param_num, param):
    5.     return "%s_%s" %(
    6.         testcase_func.__name__,
    7.         parameterized.to_safe_name("_".join(str(x) for x in param.args)),
    8.     )
    9.  
    10. class AddTestCase(unittest.TestCase):
    11.     @parameterized.expand([
    12.         (2, 3, 5),
    13.         (2, 3, 5),
    14.     ], name_func=custom_name_func)
    15.     def test_add(self, a, b, expected):
    16.         assert_equal(a + b, expected)

    将创建测试用例：

    1. $ nosetests example.py
    2. test_add_1_2_3 (example.AddTestCase) ... ok
    3. test_add_2_3_5 (example.AddTestCase) ... ok
    4.  
    5. ----------------------------------------------------------------------
    6. Ran 2 tests in 0.001s
    7.  
    8. OK

    param（...） 帮助程序类存储一个特定测试的参数 箱。它可用于将关键字参数传递给测试用例：

    1. from parameterized import parameterized, param
    2.  
    3. @parameterized([
    4.     param("10", 10),
    5.     param("10", 16, base=16),
    6. ])
    7. def test_int(str_val, expected, base=10):
    8.     assert_equal(int(str_val, base=base), expected)

    如果测试用例具有文档字符串，则该测试用例的参数将为 附加到文档字符串的第一行。可以控制此行为 doc_func参数：

    1. from parameterized import parameterized
    2.  
    3. @parameterized([
    4.     (1, 2, 3),
    5.     (4, 5, 9),
    6. ])
    7. def test_add(a, b, expected):
    8.     """ Test addition. """
    9.     assert_equal(a + b, expected)
    10.  
    11. def my_doc_func(func, num, param):
    12.     return "%s: %s with %s" %(num, func.__name__, param)
    13.  
    14. @parameterized([
    15.     (5, 4, 1),
    16.     (9, 6, 3),
    17. ], doc_func=my_doc_func)
    18. def test_subtraction(a, b, expected):
    19.     assert_equal(a - b, expected)
    20. $ nosetests example.py
    21. Test addition. [with a=1, b=2, expected=3] ... ok
    22. Test addition. [with a=4, b=5, expected=9] ... ok
    23. 0: test_subtraction with param(*(5, 4, 1)) ... ok
    24. 1: test_subtraction with param(*(9, 6, 3)) ... ok
    25.  
    26. ----------------------------------------------------------------------
    27. Ran 4 tests in 0.001s
    28.  
    29. OK

    最后@parameterized_class参数化整个类，使用 属性列表或将应用于 .class：

    1. from yourapp.models import User
    2. from parameterized import parameterized_class
    3.  
    4. @parameterized_class([
    5.    { "username": "user_1", "access_level": 1 },
    6.    { "username": "user_2", "access_level": 2, "expected_status_code": 404 },
    7. ])
    8. class TestUserAccessLevel(TestCase):
    9.    expected_status_code = 200
    10.  
    11.    def setUp(self):
    12.       self.client.force_login(User.objects.get(username=self.username)[0])
    13.  
    14.    def test_url_a(self):
    15.       response = self.client.get('/url')
    16.       self.assertEqual(response.status_code, self.expected_status_code)
    17.  
    18.    def tearDown(self):
    19.       self.client.logout()
    20.  
    21.  
    22. @parameterized_class(("username", "access_level", "expected_status_code"), [
    23.    ("user_1", 1, 200),
    24.    ("user_2", 2, 404)
    25. ])
    26. class TestUserAccessLevel(TestCase):
    27.    def setUp(self):
    28.       self.client.force_login(User.objects.get(username=self.username)[0])
    29.  
    30.    def test_url_a(self):
    31.       response = self.client.get("/url")
    32.       self.assertEqual(response.status_code, self.expected_status_code)
    33.  
    34.    def tearDown(self):
    35.       self.client.logout()

    @parameterized_class装饰器接受class_name_func论点， 它控制由 @parameterized_class 生成的参数化类的名称：

    1. from parameterized import parameterized, parameterized_class
    2.  
    3. def get_class_name(cls, num, params_dict):
    4.     # By default the generated class named includes either the "name"
    5.     # parameter (if present), or the first string value. This example shows
    6.     # multiple parameters being included in the generated class name:
    7.     return "%s_%s_%s%s" %(
    8.         cls.__name__,
    9.         num,
    10.         parameterized.to_safe_name(params_dict['a']),
    11.         parameterized.to_safe_name(params_dict['b']),
    12.     )
    13.  
    14. @parameterized_class([
    15.    { "a": "hello", "b": " world!", "expected": "hello world!" },
    16.    { "a": "say ", "b": " cheese :)", "expected": "say cheese :)" },
    17. ], class_name_func=get_class_name)
    18. class TestConcatenation(TestCase):
    19.   def test_concat(self):
    20.       self.assertEqual(self.a + self.b, self.expected)
    21. $ nosetests -v test_math.py
    22. test_concat (test_concat.TestConcatenation_0_hello_world_) ... ok
    23. test_concat (test_concat.TestConcatenation_0_say_cheese__) ... ok

    使用单个参数

    如果测试函数只接受一个参数并且该值不可迭代， 然后可以提供值列表，而无需将每个值包装在 元：

    1. @parameterized([1, 2, 3])
    2. def test_greater_than_zero(value):
    3.    assert value > 0

    但请注意，如果单个参数是可迭代的（例如列表或 元组），那么它必须包装在元组、列表或 param（...） 装饰器中：

    1. @parameterized([
    2.    ([1, 2, 3], ),
    3.    ([3, 3], ),
    4.    ([6], ),
    5. ])
    6. def test_sums_to_6(numbers):
    7.    assert sum(numbers) == 6

    虽然看似以上功能支持的挺多 ，但其实真正用的不多 ，因为它跟框架有很大关系的 。具体说明下 ：

    总结：

    • 它支持nose是最好的 . 如果你的自动化中使用nose，那么以上功能基本都能用到 。

    • 如果你用的测试框架是unittest ,你只能用到它的expand()这个函数 ，不过有这个函数也就够了 。

    • 如果你用的测试框架是pytest ， 它支持了Pytest3的版本，再高版本的就不支持了，同时pytest也有自己的参数化工具，一般也不用它了。

    3.项目实践

    通过数据参数胡重新编写登录测试用例 ，将以前yaml中的登录用例数据转化为paramterized的数据格式 ，它的数据格式要求为：[(),(),()] . 所以，编写测试用例的数据就变为了以下的代码 。

    1. # 将登录数据转化为paramterize所识别的格式。
    2. def get_data():
    3.     yaml_path = get_file_path('login.yaml')  # 获取login.yaml的全路径
    4.     result = read_yaml(yaml_path)  # 转化为python对象
    5.     login_data = result.get('login')  # 获取字典中login的值
    6.     logger.debug("登录结果:{}".format(login_data))
    7.     return (login_data)  # 获取字典中login的值
    8.  
    9.  
    10.  
    11. @allure.epic("vshop")
    12. @allure.story("登录")
    13. class TestLogin(unittest.TestCase):
    14.  
    15.     # case1 : 测试登录功能
    16.     @parameterized.expand(get_data())
    17.     def test_login(self,case_name,username,password,code,message):
    18.         logger.info("从参数化获取的数据:{}|{}|{}|{}|{}".format(case_name,username,password,code,message))
    19.         with allure.step("执行用例:{},输入用户名:{},输入密码:{}".format(case_name,username,password)):
    20.             login_result = login(username,password)
    21.         self.assertEqual(code, login_result.get('errno'))
    22.         self.assertEqual(message, login_result.get('errmsg'))

    这样的话，我们只编写了一条测试用例 ，但是在测试数据中有几条数据 ，都可以正常运行 。

    4.项目总结

    至此，我们已经实现了五步了 ，分别是 ：

    第一 、如何编写一个接口自动化框架 ，在第一篇博文中介绍了 。

    第二、如何使用unittest编写测试用例 ，已经在第二篇博文中介绍了 。

    第三、如何使用requests实现接口请求 ，并和测试用例如何对接 ，已经在第三篇博文中介绍了。

    第四、如何使用yaml编写测试数据 ，已经在第四篇博文中介绍了 。

    第五，如何使用allure生成测试报告，已经在第五篇博文中介绍了 。

    第六 ，如何使用loguru记录日志 ，已经在第六篇博文中介绍了 。

    第七，如何使用pymysql连接数据库，已经在第七篇博文中介绍了 。

    第八，如何进行数据参数化 ，也就是本篇博文了 。

  • 相关阅读:
    Mall脚手架总结(二) —— SpringData操作Elasticsearch
    python+Web自动化打包exe+配置文件
    关于西门子plc的CPU
    python 笔记（3）——request、爬虫、socket、多线程
    mysql配置所有人可连接_mysql配置允许外界连接
    linux和windows的共享文件夹的设置(ubuntu18.04)
    jdiixjxjs
    数字图像1-opencv c++基本操作
    Auddly Music Server的编译和安装
    三万字盘点Spring/Boot的那些常用扩展点
  • 原文地址：https://blog.csdn.net/venustech0919/article/details/133929446