parameterized 0.9.0

安装

$ pip install parameterized

兼容性

是（大多数情况）。

§：nose和unittest2 - 这两个最后更新于2015年 - 很遗憾似乎不支持Python 3.10或3.11。

*：[py.test 2似乎在Python 3下不工作](https://github.com/wolever/parameterized/issues/71)，并且[py.test 3似乎在Python 3.10或3.11下不工作](https://github.com/wolever/parameterized/issues/154) (#71)。

**：py.test 4在[问题 #34](https://github.com/wolever/parameterized/issues/34)中尚未支持（但即将推出！）

†：py.test fixture的支持在[问题 #81](https://github.com/wolever/parameterized/issues/81)中有记录

依赖关系

（本节有意留空）

详尽的用法示例

@parameterized 和 @parameterized.expand 装饰器接受一个列表或元组的可迭代对象，或者一个返回列表或可迭代对象的函数。

from parameterized import parameterized, param

# A list of tuples
@parameterized([
    (2, 3, 5),
    (3, 5, 8),
])
def test_add(a, b, expected):
    assert_equal(a + b, expected)

# A list of params
@parameterized([
    param("10", 10),
    param("10", 16, base=16),
])
def test_int(str_val, expected, base=10):
    assert_equal(int(str_val, base=base), expected)

# An iterable of params
@parameterized(
    param.explicit(*json.loads(line))
    for line in open("testcases.jsons")
)
def test_from_json_file(...):
    ...

# A callable which returns a list of tuples
def load_test_cases():
    return [
        ("test1", ),
        ("test2", ),
    ]
@parameterized(load_test_cases)
def test_from_function(name):
    ...

注意，当使用迭代器或生成器时，在测试运行开始之前，所有项目都将被加载到内存中（我们这样做是为了确保在多进程或多线程测试环境中，生成器被完全耗尽一次）。

@parameterized 装饰器可以用于测试类方法和独立函数。

from parameterized import parameterized

class AddTest(object):
    @parameterized([
        (2, 3, 5),
    ])
    def test_add(self, a, b, expected):
        assert_equal(a + b, expected)

@parameterized([
    (2, 3, 5),
])
def test_add(a, b, expected):
    assert_equal(a + b, expected)

@parameterized.expand 可以在测试生成器无法使用的情况下生成测试方法（例如，当测试类是 unittest.TestCase 的子类时）。

import unittest
from parameterized import parameterized

class AddTestCase(unittest.TestCase):
    @parameterized.expand([
        ("2 and 3", 2, 3, 5),
        ("3 and 5", 3, 5, 8),
    ])
    def test_add(self, _, a, b, expected):
        assert_equal(a + b, expected)

将创建测试用例。

$ nosetests example.py
test_add_0_2_and_3 (example.AddTestCase) ... ok
test_add_1_3_and_5 (example.AddTestCase) ... ok

----------------------------------------------------------------------
Ran 2 tests in 0.001s

OK

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

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

import unittest
from parameterized import parameterized

def custom_name_func(testcase_func, param_num, param):
    return "%s_%s" %(
        testcase_func.__name__,
        parameterized.to_safe_name("_".join(str(x) for x in param.args)),
    )

class AddTestCase(unittest.TestCase):
    @parameterized.expand([
        (2, 3, 5),
        (2, 3, 5),
    ], name_func=custom_name_func)
    def test_add(self, a, b, expected):
        assert_equal(a + b, expected)

将创建测试用例。

$ nosetests example.py
test_add_1_2_3 (example.AddTestCase) ... ok
test_add_2_3_5 (example.AddTestCase) ... ok

----------------------------------------------------------------------
Ran 2 tests in 0.001s

OK

param(...) 辅助类存储特定测试用例的参数。它可以用来向测试用例传递关键字参数。

from parameterized import parameterized, param

@parameterized([
    param("10", 10),
    param("10", 16, base=16),
])
def test_int(str_val, expected, base=10):
    assert_equal(int(str_val, base=base), expected)

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

from parameterized import parameterized

@parameterized([
    (1, 2, 3),
    (4, 5, 9),
])
def test_add(a, b, expected):
    """ Test addition. """
    assert_equal(a + b, expected)

def my_doc_func(func, num, param):
    return "%s: %s with %s" %(num, func.__name__, param)

@parameterized([
    (5, 4, 1),
    (9, 6, 3),
], doc_func=my_doc_func)
def test_subtraction(a, b, expected):
    assert_equal(a - b, expected)

$ nosetests example.py
Test addition. [with a=1, b=2, expected=3] ... ok
Test addition. [with a=4, b=5, expected=9] ... ok
0: test_subtraction with param(*(5, 4, 1)) ... ok
1: test_subtraction with param(*(9, 6, 3)) ... ok

----------------------------------------------------------------------
Ran 4 tests in 0.001s

OK

最后，@parameterized_class 使用列表属性或应用于类的列表字典参数对整个类进行参数化。

from yourapp.models import User
from parameterized import parameterized_class

@parameterized_class([
   { "username": "user_1", "access_level": 1 },
   { "username": "user_2", "access_level": 2, "expected_status_code": 404 },
])
class TestUserAccessLevel(TestCase):
   expected_status_code = 200

   def setUp(self):
      self.client.force_login(User.objects.get(username=self.username)[0])

   def test_url_a(self):
      response = self.client.get('/url')
      self.assertEqual(response.status_code, self.expected_status_code)

   def tearDown(self):
      self.client.logout()


@parameterized_class(("username", "access_level", "expected_status_code"), [
   ("user_1", 1, 200),
   ("user_2", 2, 404)
])
class TestUserAccessLevel(TestCase):
   def setUp(self):
      self.client.force_login(User.objects.get(username=self.username)[0])

   def test_url_a(self):
      response = self.client.get("/url")
      self.assertEqual(response.status_code, self.expected_status_code)

   def tearDown(self):
      self.client.logout()

@parameterized_class 装饰器接受一个 class_name_func 参数，用于控制 @parameterized_class 生成的参数化类的名称。

from parameterized import parameterized, parameterized_class

def get_class_name(cls, num, params_dict):
    # By default the generated class named includes either the "name"
    # parameter (if present), or the first string value. This example shows
    # multiple parameters being included in the generated class name:
    return "%s_%s_%s%s" %(
        cls.__name__,
        num,
        parameterized.to_safe_name(params_dict['a']),
        parameterized.to_safe_name(params_dict['b']),
    )

@parameterized_class([
   { "a": "hello", "b": " world!", "expected": "hello world!" },
   { "a": "say ", "b": " cheese :)", "expected": "say cheese :)" },
], class_name_func=get_class_name)
class TestConcatenation(TestCase):
  def test_concat(self):
      self.assertEqual(self.a + self.b, self.expected)

$ nosetests -v test_math.py
test_concat (test_concat.TestConcatenation_0_hello_world_) ... ok
test_concat (test_concat.TestConcatenation_0_say_cheese__) ... ok

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

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

@mock.patch("os.getpid")
class TestOS(object):
   @parameterized(...)
   @mock.patch("os.fdopen")
   @mock.patch("os.umask")
   def test_method(self, param1, param2, ..., mock_umask, mock_fdopen, mock_getpid):
      ...

从 nose-parameterized 迁移到 parameterized

将代码库从 nose-parameterized 迁移到 parameterized

1. 更新您的需求文件，将 nose-parameterized 替换为 parameterized。

2. 将所有对 nose_parameterized 的引用替换为 parameterized

   $ perl -pi -e 's/nose_parameterized/parameterized/g' your-codebase/

3. 完成！

常见问题解答

Python 2.X、3.5 和 3.6 的支持发生了什么变化？

从版本 0.9.0 开始，parameterized 不再支持 Python 2.X、3.5 或 3.6。之前的 parameterized 版本（最新的是 0.8.1）将继续工作，但不会接收任何新功能或错误修复。

当你说“nose 受最佳支持”时，是什么意思？

在 py.test 和 unittest 中有一些小的注意事项：py.test 不显示参数值（例如，它将显示 test_add[0] 而不是 test_add[1, 2, 3]），而 unittest/unittest2 不支持测试生成器，因此必须使用 @parameterized.expand。

为什么不使用 @pytest.mark.parametrize？

因为拼写很难。此外，parameterized 不需要你重复参数名称，并且（使用 param）它支持可选关键字参数。

为什么使用 @parameterized.expand 时会得到 AttributeError: 'function' object has no attribute 'expand' 错误？

你很可能安装了 parametrized（注意缺少的 e）。请使用 parameterized（带有 e）代替，你将一切就绪。

nose-parameterized 发生了什么变化？

最初只支持 nose。但现在一切都被支持了，所以更改名称是合理的！