如何在python中生成动态(参数化)单元测试？

How do you generate dynamic (parameterized) unit tests in python?

我有某种测试数据，并且想为每个项目创建一个单元测试。我的第一个想法是这样做：

1
2
3
4
5
6
7
8
9
10
11
12

import unittest

l = [["foo","a","a",], ["bar","a","b"], ["lee","b","b"]]

class TestSequence(unittest.TestCase):
def testsample(self):
for name, a,b in l:
print"test", name
self.assertEqual(a,b)

if __name__ == '__main__':
unittest.main()

不利的一面是它在一次测试中处理所有数据。我想即时为每个项目生成一个测试。有什么建议么？

我用这样的东西：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import unittest

l = [["foo","a","a",], ["bar","a","b"], ["lee","b","b"]]

class TestSequense(unittest.TestCase):
pass

def test_generator(a, b):
def test(self):
self.assertEqual(a,b)
return test

if __name__ == '__main__':
for t in l:
test_name = 'test_%s' % t[0]
test = test_generator(t[1], t[2])
setattr(TestSequense, test_name, test)
unittest.main()

parameterized软件包可用于自动执行此过程：

1
2
3
4
5
6
7
8
9
10

from parameterized import parameterized

class TestSequence(unittest.TestCase):
@parameterized.expand([
["foo","a","a",],
["bar","a","b"],
["lee","b","b"],
])
def test_sequence(self, name, a, b):
self.assertEqual(a,b)

将会生成测试：

1
2
3
4
5
6
7
8
9
10
11
12
13

test_sequence_0_foo (__main__.TestSequence) ... ok
test_sequence_1_bar (__main__.TestSequence) ... FAIL
test_sequence_2_lee (__main__.TestSequence) ... ok

======================================================================
FAIL: test_sequence_1_bar (__main__.TestSequence)
----------------------------------------------------------------------
Traceback (most recent call last):
File"/usr/local/lib/python2.7/site-packages/parameterized/parameterized.py", line 233, in <lambda>
standalone_func = lambda *a: func(*(a + p.args), **p.kwargs)
File"x.py", line 12, in test_sequence
self.assertEqual(a,b)
AssertionError: 'a' != 'b'

使用unittest(从3.4开始)

从Python 3.4开始，标准库unittest包具有subTest上下文管理器。

请参阅文档：

26.4.7。使用子测试区分测试迭代
分测验

例：

1
2
3
4
5
6
7
8
9

from unittest import TestCase

param_list = [('a', 'a'), ('a', 'b'), ('b', 'b')]

class TestDemonstrateSubtest(TestCase):
def test_works_as_expected(self):
for p1, p2 in param_list:
with self.subTest():
self.assertEqual(p1, p2)

您还可以为subTest()指定自定义消息和参数值：

1	with self.subTest(msg="Checking if p1 equals p2", p1=p1, p2=p2):

用鼻子

鼻子测试框架支持这一点。

示例(下面的代码是包含测试的文件的全部内容)：

1
2
3
4
5
6
7
8

param_list = [('a', 'a'), ('a', 'b'), ('b', 'b')]

def test_generator():
for params in param_list:
yield check_em, params[0], params[1]

def check_em(a, b):
assert a == b

osentests命令的输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

> nosetests -v
testgen.test_generator('a', 'a') ... ok
testgen.test_generator('a', 'b') ... FAIL
testgen.test_generator('b', 'b') ... ok

======================================================================
FAIL: testgen.test_generator('a', 'b')
----------------------------------------------------------------------
Traceback (most recent call last):
File"/usr/lib/python2.5/site-packages/nose-0.10.1-py2.5.egg/nose/case.py", line 203, in runTest
self.test(*self.arg)
File"testgen.py", line 7, in check_em
assert a == b
AssertionError

----------------------------------------------------------------------
Ran 3 tests in 0.006s

FAILED (failures=1)

这可以使用元类优雅地解决：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

import unittest

l = [["foo","a","a",], ["bar","a","b"], ["lee","b","b"]]

class TestSequenceMeta(type):
def __new__(mcs, name, bases, dict):

def gen_test(a, b):
def test(self):
self.assertEqual(a, b)
return test

for tname, a, b in l:
test_name ="test_%s" % tname
dict[test_name] = gen_test(a,b)
return type.__new__(mcs, name, bases, dict)

class TestSequence(unittest.TestCase):
__metaclass__ = TestSequenceMeta

if __name__ == '__main__':
unittest.main()

从Python 3.4开始，为此引入了子测试来进行单元测试。有关详细信息，请参见文档。 TestCase.subTest是一个上下文管理器，它允许隔离测试中的断言，以便使用参数信息报告失败，但不会停止测试执行。这是文档中的示例：

1
2
3
4
5
6
7
8
9

class NumbersTest(unittest.TestCase):

def test_even(self):
"""
Test that numbers between 0 and 5 are all even.
"""
for i in range(0, 6):
with self.subTest(i=i):
self.assertEqual(i % 2, 0)

测试运行的输出为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

======================================================================
FAIL: test_even (__main__.NumbersTest) (i=1)
----------------------------------------------------------------------
Traceback (most recent call last):
File"subtests.py", line 32, in test_even
self.assertEqual(i % 2, 0)
AssertionError: 1 != 0

======================================================================
FAIL: test_even (__main__.NumbersTest) (i=3)
----------------------------------------------------------------------
Traceback (most recent call last):
File"subtests.py", line 32, in test_even
self.assertEqual(i % 2, 0)
AssertionError: 1 != 0

======================================================================
FAIL: test_even (__main__.NumbersTest) (i=5)
----------------------------------------------------------------------
Traceback (most recent call last):
File"subtests.py", line 32, in test_even
self.assertEqual(i % 2, 0)
AssertionError: 1 != 0

这也是unittest2的一部分，因此可用于早期版本的Python。

load_tests是2.7中引入的鲜为人知的机制，用于动态创建TestSuite。有了它，您可以轻松创建参数化测试。

例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import unittest

class GeneralTestCase(unittest.TestCase):
def __init__(self, methodName, param1=None, param2=None):
super(GeneralTestCase, self).__init__(methodName)

self.param1 = param1
self.param2 = param2

def runTest(self):
pass # Test that depends on param 1 and 2.

def load_tests(loader, tests, pattern):
test_cases = unittest.TestSuite()
for p1, p2 in [(1, 2), (3, 4)]:
test_cases.addTest(GeneralTestCase('runTest', p1, p2))
return test_cases

该代码将运行load_tests返回的TestSuite中的所有TestCases。发现机制不会自动运行其他测试。

另外，您也可以使用此票证中所示的继承：http://bugs.python.org/msg151444

可以使用pytest完成。只需将内容写入文件test_me.py：

1
2
3
4
5
6
7

import pytest

@pytest.mark.parametrize('name, left, right', [['foo', 'a', 'a'],
['bar', 'a', 'b'],
['baz', 'b', 'b']])
def test_me(name, left, right):
assert left == right, name

然后使用命令py.test --tb=short test_me.py运行测试。然后输出将如下所示：

1
2
3
4
5
6
7
8
9
10
11
12

=========================== test session starts ============================
platform darwin -- Python 2.7.6 -- py-1.4.23 -- pytest-2.6.1
collected 3 items

test_me.py .F.

================================= FAILURES =================================
_____________________________ test_me[bar-a-b] _____________________________
test_me.py:8: in test_me
assert left == right, name
E AssertionError: bar
==================== 1 failed, 2 passed in 0.01 seconds ====================

很简单！ pytest还具有更多功能，例如fixtures，mark，assert等。

使用ddt库。它为测试方法添加了简单的装饰器：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import unittest
from ddt import ddt, data
from mycode import larger_than_two

@ddt
class FooTestCase(unittest.TestCase):

@data(3, 4, 12, 23)
def test_larger_than_two(self, value):
self.assertTrue(larger_than_two(value))

@data(1, -3, 2, 0)
def test_not_larger_than_two(self, value):
self.assertFalse(larger_than_two(value))

可以使用pip安装该库。它不需要nose，并且可以与标准库unittest模块一起很好地工作。

您可以从TestScenarios库中受益。

testscenarios provides clean dependency injection for python unittest style tests. This can be used for interface testing (testing many implementations via a single test suite) or for classic dependency injection (provide tests with dependencies externally to the test code itself, allowing easy testing in different situations).

还有一个假设添加了模糊测试或基于属性的测试：https://pypi.python.org/pypi/hypothesis

这是一种非常强大的测试方法。

您可以使用鼻子-ittr插件(pip install nose-ittr)。

与现有测试集成非常容易，只需最少的更改(如果有)。它还支持鼻子多处理插件。

并非每个测试都可以具有自定义的setup函数。

1
2
3

@ittr(number=[1, 2, 3, 4])
def test_even(self):
assert_equal(self.number % 2, 0)

也可以像通过其内置插件attrib一样传递nosetest参数，这样，您只能使用特定参数运行特定测试：

1	nosetest -a number=2

前几天，我在看ra的源代码时遇到了ParamUnittest(github回购中的示例用法)。它应与其他扩展TestCase的框架(如Nose)一起使用。

这是一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import unittest
import paramunittest

@paramunittest.parametrized(
('1', '2'),
#(4, 3), <---- uncomment to have a failing test
('2', '3'),
(('4', ), {'b': '5'}),
((), {'a': 5, 'b': 6}),
{'a': 5, 'b': 6},
)
class TestBar(TestCase):
def setParameters(self, a, b):
self.a = a
self.b = b

def testLess(self):
self.assertLess(self.a, self.b)

我使用元类和装饰器来生成测试。您可以检查我的实现python_wrap_cases。该库不需要任何测试框架。

你的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13

import unittest
from python_wrap_cases import wrap_case

@wrap_case
class TestSequence(unittest.TestCase):

@wrap_case("foo","a","a")
@wrap_case("bar","a","b")
@wrap_case("lee","b","b")
def testsample(self, name, a, b):
print"test", name
self.assertEqual(a, b)

控制台输出：

1
2
3
4
5
6

testsample_u'bar'_u'a'_u'b' (tests.example.test_stackoverflow.TestSequence) ... test bar
FAIL
testsample_u'foo'_u'a'_u'a' (tests.example.test_stackoverflow.TestSequence) ... test foo
ok
testsample_u'lee'_u'b'_u'b' (tests.example.test_stackoverflow.TestSequence) ... test lee
ok

您也可以使用发电机。例如，此代码使用参数a__list和b__list生成所有可能的测试组合

1
2
3
4
5
6
7
8
9
10

import unittest
from python_wrap_cases import wrap_case

@wrap_case
class TestSequence(unittest.TestCase):

@wrap_case(a__list=["a","b"], b__list=["a","b"])
def testsample(self, a, b):
self.assertEqual(a, b)

控制台输出：

1
2
3
4

testsample_a(u'a')_b(u'a') (tests.example.test_stackoverflow.TestSequence) ... ok
testsample_a(u'a')_b(u'b') (tests.example.test_stackoverflow.TestSequence) ... FAIL
testsample_a(u'b')_b(u'a') (tests.example.test_stackoverflow.TestSequence) ... FAIL
testsample_a(u'b')_b(u'b') (tests.example.test_stackoverflow.TestSequence) ... ok

您可以使用TestSuite和自定义TestCase类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import unittest

class CustomTest(unittest.TestCase):
def __init__(self, name, a, b):
super().__init__()
self.name = name
self.a = a
self.b = b

def runTest(self):
print("test", self.name)
self.assertEqual(self.a, self.b)

if __name__ == '__main__':
suite = unittest.TestSuite()
suite.addTest(CustomTest("Foo", 1337, 1337))
suite.addTest(CustomTest("Bar", 0xDEAD, 0xC0DE))
unittest.TextTestRunner().run(suite)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import unittest

def generator(test_class, a, b):
def test(self):
self.assertEqual(a, b)
return test

def add_test_methods(test_class):
#First element of list is variable"a", then variable"b", then name of test case that will be used as suffix.
test_list = [[2,3, 'one'], [5,5, 'two'], [0,0, 'three']]
for case in test_list:
test = generator(test_class, case[0], case[1])
setattr(test_class,"test_%s" % case[2], test)

class TestAuto(unittest.TestCase):
def setUp(self):
print 'Setup'
pass

def tearDown(self):
print 'TearDown'
pass

_add_test_methods(TestAuto) # It's better to start with underscore so it is not detected as a test itself

if __name__ == '__main__':
unittest.main(verbosity=1)

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

>>>
Setup
FTearDown
Setup
TearDown
.Setup
TearDown
.
======================================================================
FAIL: test_one (__main__.TestAuto)
----------------------------------------------------------------------
Traceback (most recent call last):
File"D:/inchowar/Desktop/PyTrash/test_auto_3.py", line 5, in test
self.assertEqual(a, b)
AssertionError: 2 != 3

----------------------------------------------------------------------
Ran 3 tests in 0.019s

FAILED (failures=1)

只需使用元类，如此处所示；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class DocTestMeta(type):
"""
Test functions are generated in metaclass due to the way some
test loaders work. For example, setupClass() won't get called
unless there are other existing test methods, and will also
prevent unit test loader logic being called before the test
methods have been defined.
"""
def __init__(self, name, bases, attrs):
super(DocTestMeta, self).__init__(name, bases, attrs)

def __new__(cls, name, bases, attrs):
def func(self):
"""Inner test method goes here"""
self.assertTrue(1)

func.__name__ = 'test_sample'
attrs[func.__name__] = func
return super(DocTestMeta, cls).__new__(cls, name, bases, attrs)

class ExampleTestCase(TestCase):
"""Our example test case, with no methods defined"""
__metaclass__ = DocTestMeta

输出：

1	test_sample (ExampleTestCase) ... OK

我发现这很适合我的目的，尤其是当我需要生成对数据集合的过程做些微改动的测试时。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

import unittest

def rename(newName):
def renamingFunc(func):
func.__name__ == newName
return func
return renamingFunc

class TestGenerator(unittest.TestCase):

TEST_DATA = {}

@classmethod
def generateTests(cls):
for dataName, dataValue in TestGenerator.TEST_DATA:
for func in cls.getTests(dataName, dataValue):
setattr(cls,"test_{:s}_{:s}".format(func.__name__, dataName), func)

@classmethod
def getTests(cls):
raise(NotImplementedError("This must be implemented"))

class TestCluster(TestGenerator):

TEST_CASES = []

@staticmethod
def getTests(dataName, dataValue):

def makeTest(case):

@rename("{:s}".format(case["name"]))
def test(self):
# Do things with self, case, data
pass

return test

return [makeTest(c) for c in TestCluster.TEST_CASES]

TestCluster.generateTests()

TestGenerator类可用于生成不同的测试用例集，例如TestCluster。

可以将TestCluster视为TestGenerator接口的实现。

我在使用非常特殊的参数化测试样式时遇到了麻烦。我们所有的Selenium测试都可以在本地运行，但是它们也应该能够在SauceLabs上的多个平台上远程运行。基本上，我想使用大量已编写的测试用例，并以尽可能少的代码更改对它们进行参数化。此外，我需要能够将参数传递到setUp方法中，这在其他地方还没有任何解决方案。

这是我想出的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import inspect
import types

test_platforms = [
{'browserName':"internet explorer", 'platform':"Windows 7", 'version':"10.0"},
{'browserName':"internet explorer", 'platform':"Windows 7", 'version':"11.0"},
{'browserName':"firefox", 'platform':"Linux", 'version':"43.0"},
]

def sauce_labs():
def wrapper(cls):
return test_on_platforms(cls)
return wrapper

def test_on_platforms(base_class):
for name, function in inspect.getmembers(base_class, inspect.isfunction):
if name.startswith('test_'):
for platform in test_platforms:
new_name = '_'.join(list([name, ''.join(platform['browserName'].title().split()), platform['version']]))
new_function = types.FunctionType(function.__code__, function.__globals__, new_name,
function.__defaults__, function.__closure__)
setattr(new_function, 'platform', platform)
setattr(base_class, new_name, new_function)
delattr(base_class, name)

return base_class

这样，我要做的就是为每个常规的旧TestCase添加一个简单的装饰器@sauce_labs()，现在在运行它们时，将它们包装起来并重写，以便对所有测试方法进行参数化和重命名。 LoginTests.test_login(self)以LoginTests.test_login_internet_explorer_10.0(self)，LoginTests.test_login_internet_explorer_11.0(self)和LoginTests.test_login_firefox_43.0(self)运行，并且每个参数都有参数self.platform来决定使用哪种浏览器/平台甚至可以在LoginTests.setUp中运行，这对我的任务至关重要，因为这是初始化与SauceLabs的连接的地方。

无论如何，我希望这对希望对测试进行类似"全局"参数化的人有所帮助！

此解决方案适用于unittest和nose：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#!/usr/bin/env python
import unittest

def make_function(description, a, b):
def ghost(self):
self.assertEqual(a, b, description)
print description
ghost.__name__ = 'test_{0}'.format(description)
return ghost

class TestsContainer(unittest.TestCase):
pass

testsmap = {
'foo': [1, 1],
'bar': [1, 2],
'baz': [5, 5]}

def generator():
for name, params in testsmap.iteritems():
test_func = make_function(name, params[0], params[1])
setattr(TestsContainer, 'test_{0}'.format(name), test_func)

generator()

if __name__ == '__main__':
unittest.main()

基于元类的答案在Python3中仍然有效，但是必须使用metaclass参数代替__metaclass__属性，如下所示：

1 2	class ExampleTestCase(TestCase,metaclass=DocTestMeta): pass

元编程很有趣，但是可以继续前进。这里的大多数解决方案都很难：

有选择地启动测试
指向指定测试名称的代码

因此，我的第一个建议是遵循简单/明确的路径(适用于任何测试运行程序)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import unittest

class TestSequence(unittest.TestCase):

def _test_complex_property(self, a, b):
self.assertEqual(a,b)

def test_foo(self):
self._test_complex_property("a","a")
def test_bar(self):
self._test_complex_property("a","b")
def test_lee(self):
self._test_complex_property("b","b")

if __name__ == '__main__':
unittest.main()

因为我们不应该重复自己，所以我的第二个建议建立在@Javier的答案上：接受基于属性的测试。假设库：

"对于测试用例的生成要比对我们单纯的人类更加不懈地弯曲"
将提供简单的计数示例
与任何测试跑步者一起使用
具有更多有趣的功能(统计信息，附加测试输出等)

类TestSequence(unittest.TestCase)：

1
2
3
@given(st.text(), st.text())
def test_complex_property(self, a, b):
self.assertEqual(a,b)

要测试您的特定示例，只需添加：

1
2
3

@example("a","a")
@example("a","b")
@example("b","b")

要仅运行一个特定示例，可以注释掉其他示例(首先运行提供的示例)。您可能要使用@given(st.nothing())。另一种选择是将整个块替换为：

1	@given(st.just("a"), st.just("b"))

好的，您没有不同的测试名称。但也许您只需要：

被测属性的描述性名称。
哪个输入会导致失败(伪造的示例)。

有趣的例子

派对晚了，但是我很难为setUpClass做这些工作。

这是@Javier答案的一个版本，它允许setUpClass访问动态分配的属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import unittest

class GeneralTestCase(unittest.TestCase):
@classmethod
def setUpClass(cls):
print ''
print cls.p1
print cls.p2

def runTest1(self):
self.assertTrue((self.p2 - self.p1) == 1)

def runTest2(self):
self.assertFalse((self.p2 - self.p1) == 2)

def load_tests(loader, tests, pattern):
test_cases = unittest.TestSuite()
for p1, p2 in [(1, 2), (3, 4)]:
clsname = 'TestCase_{}_{}'.format(p1, p2)
dct = {
'p1': p1,
'p2': p2,
}
cls = type(clsname, (GeneralTestCase,), dct)
test_cases.addTest(cls('runTest1'))
test_cases.addTest(cls('runTest2'))
return test_cases

输出

1
2
3
4
5
6
7
8
9
10

1
2
..
3
4
..
----------------------------------------------------------------------
Ran 4 tests in 0.000s

OK

除了使用setattr之外，我们还可以从python 3.2开始使用load_tests。请参阅博客文章blog.livreuro.com/en/coding/python/how-to-generate-discoverable-unit-tests-in-python-dynamically/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

class Test(unittest.TestCase):
pass

def _test(self, file_name):
open(file_name, 'r') as f:
self.assertEqual('test result',f.read())

def _generate_test(file_name):
def test(self):
_test(self, file_name)
return test

def _generate_tests():
for file in files:
file_name = os.path.splitext(os.path.basename(file))[0]
setattr(Test, 'test_%s' % file_name, _generate_test(file))

test_cases = (Test,)

def load_tests(loader, tests, pattern):
_generate_tests()
suite = TestSuite()
for test_class in test_cases:
tests = loader.loadTestsFromTestCase(test_class)
suite.addTests(tests)
return suite

if __name__ == '__main__':
_generate_tests()
unittest.main()

以下是我的解决方案。在以下情况下，我认为这很有用：
1.应该用于unittest.Testcase和unittest发现
2.为不同的参数设置运行一组测试。
3.非常简单，不依赖其他软件包
导入单元测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class BaseClass(unittest.TestCase):
def setUp(self):
self.param = 2
self.base = 2

def test_me(self):
self.assertGreaterEqual(5, self.param+self.base)

def test_me_too(self):
self.assertLessEqual(3, self.param+self.base)

class Child_One(BaseClass):
def setUp(self):
BaseClass.setUp(self)
self.param = 4

class Child_Two(BaseClass):
def setUp(self):
BaseClass.setUp(self)
self.param = 1