blocks|key|1561558|text|使用元类可以很好地解决这个问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1561559|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_%25s"+%25+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()|code-block|syntax|javascript|1561560|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This can be solved elegantly using Metaclasses:

<pre><code>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()
</code></pre>

blocks|key|1776758|text|load_tests是2.7中引入的一种鲜为人知的动态创建TestSuite的机制。使用它，您可以轻松地创建参数化测试。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1776759|例如：|1776760|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|code-block|syntax|javascript|1776761|该代码将运行load_tests返回的TestSuite中的所有TestCases。发现机制不会自动运行任何其他测试。|1776762|或者，您也可以使用继承，如此票证所示：http://bugs.python.org/msg151444|1776763|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/library/unittest.html#load-tests-protocol|1|http://bugs.python.org/msg151444^0|0|A|0|0|0|0|0|J|W|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@$A|16|B|17|1|18]]|C|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|X]]]]

<a href="https://docs.python.org/2/library/unittest.html#load-tests-protocol">load_tests</a> is a little known mechanism introduced in 2.7 to dynamically create a TestSuite. With it, you can easily create parametrized tests.

For example:

<pre><code>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
</code></pre>

That code will run all the TestCases in the TestSuite returned by load_tests. No other tests are automatically run by the discovery mechanism.

Alternatively, you can also use inheritance as shown in this ticket: <a href="http://bugs.python.org/msg151444">http://bugs.python.org/msg151444</a>

blocks|key|1561627|text|这可以通过使用pytest来完成。只需编写包含内容的文件test_me.py：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1561628|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|code-block|syntax|javascript|1561629|并使用命令py.test+--tb=short+test_me.py运行测试。然后输出将如下所示：|1561630|===========================+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+====================|1561631|这很简单！此外，pytest还具有更多功能，如fixtures、mark、assert等。|1561632|entityMap|0|LINK|mutability|MUTABLE|url|http://pytest.org/|1^0|S|A|7|6|0|0|0|5|T|0|0|N|8|W|4|11|6|8|6|1|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@$9|12|A|13|1|14]]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@$9|1H|A|1I|1|1J]]|E|$]]|$1|Q|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]|Y|$5|T|U|V|E|$W|X]]]]

It can be done by using <a href="http://pytest.org" rel="nofollow noreferrer">pytest</a>. Just write the file <code>test_me.py</code> with content:
<pre class="lang-python prettyprint-override"><code>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
</code></pre>
And run your test with command <code>py.test --tb=short test_me.py</code>. Then the output will look like:
<pre class="lang-none prettyprint-override"><code>=========================== 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 ====================
</code></pre>
It is simple! Also <a href="http://pytest.org" rel="nofollow noreferrer">pytest</a> has more features like <code>fixtures</code>, <code>mark</code>, <code>assert</code>, etc.

blocks|key|1561677|text|使用ddt库。它为测试方法添加了简单的装饰器：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1561678|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))|code-block|syntax|javascript|1561679|此库可以与pip一起安装。它不需要nose，并且可以很好地与标准库unittest模块配合使用。|style|CODE|1561680|entityMap|0|LINK|mutability|MUTABLE|url|https://technomilk.wordpress.com/2012/02/12/multiplying-python-unit-test-cases-with-different-sets-of-data/^0|2|3|0|0|0|5|3|H|4|X|8|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$A|10|B|11|K|L]|$A|12|B|13|K|L]|$A|14|B|15|K|L]]|9|@]|C|$]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Use the <a href="https://technomilk.wordpress.com/2012/02/12/multiplying-python-unit-test-cases-with-different-sets-of-data/" rel="noreferrer">ddt</a> library. It adds simple decorators for the test methods:

<pre><code>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))
</code></pre>

This library can be installed with <code>pip</code>. It doesn't require <code>nose</code>, and works excellent with the standard library <code>unittest</code> module.

blocks|key|1776853|text|只需使用元类即可，如下所示；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1776854|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|code-block|syntax|javascript|1776855|输出：|1776856|test_sample+(ExampleTestCase)+...+OK|1776857|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Just use metaclasses, as seen here;

<pre><code>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
</code></pre>

Output:

<pre><code>test_sample (ExampleTestCase) ... OK
</code></pre>

blocks|key|1776929|text|还有Hypothesis，它添加了模糊或基于属性的测试。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1776930|这是一种非常强大的测试方法。|1776931|entityMap|0|LINK|mutability|MUTABLE|url|https://pypi.python.org/pypi/hypothesis^0|2|A|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

There's also <a href="https://pypi.python.org/pypi/hypothesis" rel="nofollow noreferrer">Hypothesis</a> which adds fuzz or property based testing.
This is a very powerful testing method.

blocks|key|1776995|text|您可以使用TestSuite和自定义TestCase类。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1776996|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)|code-block|syntax|javascript|1776997|entityMap^0|5|9|I|8|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

You can use <code>TestSuite</code> and custom <code>TestCase</code> classes. 

<pre><code>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)
</code></pre>

blocks|key|1561864|text|我在一种非常特殊的参数化测试中遇到了麻烦。我们所有的Selenium测试都可以在本地运行，但它们也应该能够在SauceLabs上的几个平台上远程运行。基本上，我希望使用大量已经编写好的测试用例，并用尽可能少的代码更改来参数化它们。此外，我需要能够将参数传递给setUp方法，这是我在其他地方看不到的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1561865|这是我的想法：|1561866|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|code-block|syntax|javascript|1561867|这样，我所要做的就是向每个常规的旧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的连接就是在那里初始化的。|1561868|无论如何，我希望这会对那些希望对他们的测试进行类似的“全局”参数化的人有所帮助！|1561869|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I'd been having trouble with a very particular style of parameterized tests. All our Selenium tests can run locally, but they also should be able to be run remotely against several platforms on SauceLabs. Basically, I wanted to take a large amount of already-written test cases and parameterize them with the fewest changes to code possible. Furthermore, I needed to be able to pass the parameters into the setUp method, something which I haven't seen any solutions for elsewhere.

Here's what I've come up with:

<pre><code>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
</code></pre>

With this, all I had to do was add a simple decorator @sauce_labs() to each regular old TestCase, and now when running them, they're wrapped up and rewritten, so that all the test methods are parameterized and renamed. LoginTests.test_login(self) runs as LoginTests.test_login_internet_explorer_10.0(self), LoginTests.test_login_internet_explorer_11.0(self), and LoginTests.test_login_firefox_43.0(self), and each one has the parameter self.platform to decide what browser/platform to run against, even in LoginTests.setUp, which is crucial for my task since that's where the connection to SauceLabs is initialized.

Anyway, I hope this might be of help to someone looking to do a similar "global" parameterization of their tests!

blocks|key|1561902|text|此解决方案适用于Python2和Python3的unittest和nose：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1561903|#!/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()|code-block|syntax|javascript|1561904|entityMap^0|O|8|X|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

This solution works with <code>unittest</code> and <code>nose</code> for Python 2 and Python 3:

<pre><code>#!/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()
</code></pre>

blocks|key|1561909|text|import+unittest

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

def+add_test_methods(test_class):
++++#+The+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_%25s"+%25+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)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1561910|结果：|unstyled|1561911|>>>
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)|1561912|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>import unittest

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

def add_test_methods(test_class):
 # The first element of list is variable &quot;a&quot;, then variable &quot;b&quot;, 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, &quot;test_%s&quot; % 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)
</code></pre>
RESULT:
<pre class="lang-none prettyprint-override"><code>&gt;&gt;&gt;
Setup
FTearDown
Setup
TearDown
.Setup
TearDown
.
======================================================================
FAIL: test_one (__main__.TestAuto)
----------------------------------------------------------------------
Traceback (most recent call last):
 File &quot;D:/inchowar/Desktop/PyTrash/test_auto_3.py&quot;, line 5, in test
 self.assertEqual(a, b)
AssertionError: 2 != 3

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

FAILED (failures=1)
</code></pre>

blocks|key|1561976|text|基于元类的答案在Python3中仍然有效，但是必须使用metaclass参数而不是__metaclass__属性，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1561977|class+ExampleTestCase(TestCase,metaclass=DocTestMeta):
++++pass|code-block|syntax|javascript|1561978|entityMap^0|R|9|15|D|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

The metaclass-based answers still work in Python 3, but instead of the <code>__metaclass__</code> attribute, one has to use the <code>metaclass</code> parameter, as in:
<pre><code>class ExampleTestCase(TestCase,metaclass=DocTestMeta):
 pass
</code></pre>

blocks|key|1777212|text|我在为setUpClass做这些工作时遇到了麻烦。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1777213|这是一个Javier's+answer版本，它允许setUpClass访问动态分配的属性。|1777214|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|code-block|syntax|javascript|1777215|输出|1777216|1
2
..
3
4
..
----------------------------------------------------------------------
Ran+4+tests+in+0.000s

OK|1777217|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/23508426/5932228^0|3|A|0|P|A|4|F|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@$9|14|A|15|1|16]]|E|$]]|$1|H|3|I|5|J|7|17|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|18|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|19|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

I had trouble making these work for <code>setUpClass</code>.
Here's a version of <a href="https://stackoverflow.com/a/23508426/5932228">Javier's answer</a> that gives <code>setUpClass</code> access to dynamically allocated attributes.
<pre><code>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
</code></pre>
<h3>Outputs</h3>
<pre class="lang-none prettyprint-override"><code>1
2
..
3
4
..
----------------------------------------------------------------------
Ran 4 tests in 0.000s

OK
</code></pre>

blocks|key|1562089|text|我发现这对我的目的很有效，特别是当我需要生成对数据集合进行细微差别处理的测试时。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1562090|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()|code-block|syntax|javascript|1562091|TestGenerator类可用于生成不同的测试用例集，如TestCluster。|offset|length|style|CODE|1562092|可以将TestCluster看作是TestGenerator接口的一个实现。|1562093|entityMap^0|0|0|0|D|T|B|0|3|B|H|D|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@$I|Y|J|Z|K|L]|$I|10|J|11|K|L]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|P|$]]

I have found that this works well for my purposes, especially if I need to generate tests that do slightly difference processes on a collection of data.

<pre><code>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()
</code></pre>

The <code>TestGenerator</code> class can be used to spawn different sets of test cases like <code>TestCluster</code>.

<code>TestCluster</code> can be thought of as an implementation of the <code>TestGenerator</code> interface.

blocks|key|1562100|text|import+unittest

def+generator(test_class,+a,+b,c,d,name):
++++def+test(self):
++++++++print('Testexecution=',name)
++++++++print('a=',a)
++++++++print('b=',b)
++++++++print('c=',c)
++++++++print('d=',d)

++++return+test

def+add_test_methods(test_class):
++++test_list+=+[[3,3,5,6,+'one'],+[5,5,8,9,+'two'],+[0,0,5,6,+'three'],[0,0,2,3,'Four']]
++++for+case+in+test_list:
++++++++print('case=',case[0],+case[1],case[2],case[3],case[4])
++++++++test+=+generator(test_class,+case[0],+case[1],case[2],case[3],case[4])
++++++++setattr(test_class,+"test_%25s"+%25+case[4],+test)


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

++++def+tearDown(self):
++++++++print+('TearDown')
++++++++pass

add_test_methods(TestAuto)

if+__name__+==+'__main__':
++++unittest.main(verbosity=1)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1562101|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>import unittest

def generator(test_class, a, b,c,d,name):
 def test(self):
 print('Testexecution=',name)
 print('a=',a)
 print('b=',b)
 print('c=',c)
 print('d=',d)

 return test

def add_test_methods(test_class):
 test_list = [[3,3,5,6, 'one'], [5,5,8,9, 'two'], [0,0,5,6, 'three'],[0,0,2,3,'Four']]
 for case in test_list:
 print('case=',case[0], case[1],case[2],case[3],case[4])
 test = generator(test_class, case[0], case[1],case[2],case[3],case[4])
 setattr(test_class, &quot;test_%s&quot; % case[4], test)


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

 def tearDown(self):
 print ('TearDown')
 pass

add_test_methods(TestAuto)

if __name__ == '__main__':
 unittest.main(verbosity=1)
</code></pre>

blocks|key|1562142|text|这实际上与前一个答案中提到的parameterized相同，但特定于unittest|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1562143|def+sub_test(param_list):
++++"""Decorates+a+test+case+to+run+it+as+a+set+of+subtests."""

++++def+decorator(f):

++++++++@functools.wraps(f)
++++++++def+wrapped(self):
++++++++++++for+param+in+param_list:
++++++++++++++++with+self.subTest(**param):
++++++++++++++++++++f(self,+**param)

++++++++return+wrapped

++++return+decorator|code-block|syntax|javascript|1562144|示例用法：|1562145|class+TestStuff(unittest.TestCase):
++++@sub_test([
++++++++dict(arg1='a',+arg2='b'),
++++++++dict(arg1='x',+arg2='y'),
++++])
++++def+test_stuff(self,+a,+b):
++++++++...|1562146|entityMap^0|E|D|Y|8|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

This is effectively the same as <code>parameterized</code> as mentioned in a previous answer, but specific to <code>unittest</code>:
<pre class="lang-py prettyprint-override"><code>def sub_test(param_list):
 &quot;&quot;&quot;Decorates a test case to run it as a set of subtests.&quot;&quot;&quot;

 def decorator(f):

 @functools.wraps(f)
 def wrapped(self):
 for param in param_list:
 with self.subTest(**param):
 f(self, **param)

 return wrapped

 return decorator
</code></pre>
Example usage:
<pre><code>class TestStuff(unittest.TestCase):
 @sub_test([
 dict(arg1='a', arg2='b'),
 dict(arg1='x', arg2='y'),
 ])
 def test_stuff(self, a, b):
 ...
</code></pre>

I have some kind of test data and want to create a unit test for each item. My first idea was to do it like this:
<pre><code>import unittest

l = [[&quot;foo&quot;, &quot;a&quot;, &quot;a&quot;,], [&quot;bar&quot;, &quot;a&quot;, &quot;b&quot;], [&quot;lee&quot;, &quot;b&quot;, &quot;b&quot;]]

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

if __name__ == '__main__':
 unittest.main()
</code></pre>
The downside of this is that it handles all data in one test. I would like to generate one test for each item on the fly. Any suggestions?

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

单元测试

Windows

Python

Linux

我有一些测试数据，并希望为每个项目创建一个单元测试。我的第一个想法是这样做：import unittestl = [["foo", "a", "a",], ["bar", "a", "b"], ["lee", "b", "b"]]class TestSequence(unittest.TestCase):    def...

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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