在Python的unittest中有没有一种方法可以设置测试用例运行的顺序?
在我的TestCase类中，一些测试用例具有副作用，可以设置其他条件以便其正确运行。现在我意识到正确的做法是使用setUp()来完成所有设置相关的事情，但我想实现一种设计，在这种设计中，每个后续的测试都会构建稍微多一点状态供下一个测试使用。我认为这更加优雅。
class MyTest(TestCase):
def test_setup(self):
# Do something
def test_thing(self):
# Do something that depends on test_setup()
理想情况下，我希望测试按照它们在类中出现的顺序运行。但似乎它们是按字母顺序运行的。
不要把它们作为相互独立的测试 - 如果你想要一个整体化的测试，就编写一个整体化的测试。
class Monolithic(TestCase):
def step1(self):
...
def step2(self):
...
def _steps(self):
for name in dir(self): # dir() result is implicitly sorted
if name.startswith("step"):
yield name, getattr(self, name)
def test_steps(self):
for name, step in self._steps():
try:
step()
except Exception as e:
self.fail("{} failed ({}: {})".format(step, type(e), e))
对于这样的期望，编写完整的单元测试是一个好的实践。然而，如果你像我一样很怪，那么你可以简单地按字母顺序编写难看的方法，使它们按照Python文档中提到的从a到b排序 - unittest — 单元测试框架
请注意，各个测试用例运行的顺序取决于将测试函数名称根据字符串的内置排序进行排序
def test_a_first():
print "1"
def test_b_next():
print "2"
def test_c_last():
print "3"
还有一种方法没有在相关问题中列出：使用 TestSuite。
另一种实现测试用例排序的方法是将测试用例添加到 unitest.TestSuite 中。这似乎尊重使用 suite.addTest(...) 添加到测试套件中的测试用例顺序。要实现这一点：
创建一个或多个 TestCase 子类，
class FooTestCase(unittest.TestCase):
def test_ten():
print('Testing ten (10)...')
def test_eleven():
print('Testing eleven (11)...')
class BarTestCase(unittest.TestCase):
def test_twelve():
print('Testing twelve (12)...')
def test_nine():
print('Testing nine (09)...')
def suite():
suite = unittest.TestSuite()
suite.addTest(BarTestCase('test_nine'))
suite.addTest(FooTestCase('test_ten'))
suite.addTest(FooTestCase('test_eleven'))
suite.addTest(BarTestCase('test_twelve'))
return suite
执行测试套件，例如：
if __name__ == '__main__':
runner = unittest.TextTestRunner(failfast=True)
runner.run(suite())
为了更好的理解，我需要这个功能但对其他选项不满意。我采用了以上的方式来进行测试排序。
在几个“单元测试顺序问题”中，我没有看到这种TestSuite方法的列表（例如，这个问题和其他一些问题，包括执行顺序，或改变顺序，或测试顺序）。
@classmethod，那么它们可以在实例之间保持状态。 - Nick ChapmansetUpClass 是否被调用？或者它需要手动运行？ - Nick Chapman@classmethod != @staticmethod!!! 要小心，它们是完全不同的东西。@staticmethod 允许您在没有类实例的情况下调用方法。@classmethod 让您可以访问类和类本身上可以存储信息。例如，如果您在类方法中执行 cls.somevar = 10，那么在运行该函数后，该类的所有实例和所有其他类方法都将看到 somevar = 10。类本身是可以绑定值的对象。 - Nick Chapman
class SequentialTestLoader(unittest.TestLoader):
def getTestCaseNames(self, testCaseClass):
test_names = super().getTestCaseNames(testCaseClass)
testcase_methods = list(testCaseClass.__dict__.keys())
test_names.sort(key=testcase_methods.index)
return test_names
然后
unittest.main(testLoader=utils.SequentialTestLoader())
unittest.TestLoader.sortTestMethodsUsing:
用于在
getTestCaseNames()和所有loadTestsFrom*()方法中对方法名进行排序时使用的函数。
最少使用：
import unittest
class Test(unittest.TestCase):
def test_foo(self):
""" test foo """
self.assertEqual(1, 1)
def test_bar(self):
""" test bar """
self.assertEqual(1, 1)
if __name__ == "__main__":
test_order = ["test_foo", "test_bar"] # could be sys.argv
loader = unittest.TestLoader()
loader.sortTestMethodsUsing = lambda x, y: test_order.index(x) - test_order.index(y)
unittest.main(testLoader=loader, verbosity=2)
输出:
test_foo (__main__.Test)
test foo ... ok
test_bar (__main__.Test)
test bar ... ok
import inspect
import unittest
class Test(unittest.TestCase):
def test_foo(self):
""" test foo """
self.assertEqual(1, 1)
def test_bar(self):
""" test bar """
self.assertEqual(1, 1)
if __name__ == "__main__":
test_src = inspect.getsource(Test)
unittest.TestLoader.sortTestMethodsUsing = lambda _, x, y: (
test_src.index(f"def {x}") - test_src.index(f"def {y}")
)
unittest.main(verbosity=2)
本文使用的是Python 3.8.0版本。
那些互相依赖的测试应该明确地链接在一个测试中。
那些需要不同级别设置的测试也可以拥有它们对应的setUp()方法来运行足够的设置 - 可以考虑多种方式。
否则，unittest默认按字母顺序处理测试类和测试类中的测试方法 (即使loader.sortTestMethodsUsing为 None)。内部使用dir()进行排序。
后一种行为可以用于提高实用性 - 例如，让最新的工作测试先运行以加快编辑 - 测试运行周期。但是，这种行为不应该用于建立真正的依赖关系。请注意，测试可以通过命令行选项等单独运行。
test_order = ['base']
def index_of(item, list):
try:
return list.index(item)
except:
return len(list) + 1
def order_methods(x, y):
x_rank = index_of(x[5:100], test_order)
y_rank = index_of(y[5:100], test_order)
return (x_rank > y_rank) - (x_rank < y_rank)
将其设置在类中的第三个位置：
class ClassTests(unittest.TestCase):
unittest.TestLoader.sortTestMethodsUsing = staticmethod(order_methods)
_），以使它们不被 unittest 模块视为测试，然后构建一个测试用例，该用例基于执行这些子操作的正确顺序构建。unittest 模块的排序顺序更好，因为明天可能会改变，并且实现顺序拓扑排序也不是很简单。test_table_not_set）或测试主键（test_primary_key）仍然并行，但只有在正确的顺序和前一个操作设置的状态下才需要进行CRUD测试。因此，这些测试已经被分离成单独的unit，而不是测试。然后，另一个测试 (test_CRUD) 构建这些操作的正确顺序并对其进行测试。import os
import sqlite3
import unittest
from sql30 import db
DB_NAME = 'review.db'
class Reviews(db.Model):
TABLE = 'reviews'
PKEY = 'rid'
DB_SCHEMA = {
'db_name': DB_NAME,
'tables': [
{
'name': TABLE,
'fields': {
'rid': 'uuid',
'header': 'text',
'rating': 'int',
'desc': 'text'
},
'primary_key': PKEY
}]
}
VALIDATE_BEFORE_WRITE = True
class ReviewTest(unittest.TestCase):
def setUp(self):
if os.path.exists(DB_NAME):
os.remove(DB_NAME)
def test_table_not_set(self):
"""
Tests for raise of assertion when table is not set.
"""
db = Reviews()
try:
db.read()
except Exception as err:
self.assertIn('No table set for operation', str(err))
def test_primary_key(self):
"""
Ensures, primary key is honored.
"""
db = Reviews()
db.table = 'reviews'
db.write(rid=10, rating=5)
try:
db.write(rid=10, rating=4)
except sqlite3.IntegrityError as err:
self.assertIn('UNIQUE constraint failed', str(err))
def _test_CREATE(self):
db = Reviews()
db.table = 'reviews'
# backward compatibility for 'write' API
db.write(tbl='reviews', rid=1, header='good thing', rating=5)
# New API with 'create'
db.create(tbl='reviews', rid=2, header='good thing', rating=5)
# Backward compatibility for 'write' API, without tbl,
# explicitly passed
db.write(tbl='reviews', rid=3, header='good thing', rating=5)
# New API with 'create', without table name explicitly passed.
db.create(tbl='reviews', rid=4, header='good thing', rating=5)
db.commit() # Save the work.
def _test_READ(self):
db = Reviews()
db.table = 'reviews'
rec1 = db.read(tbl='reviews', rid=1, header='good thing', rating=5)
rec2 = db.read(rid=1, header='good thing')
rec3 = db.read(rid=1)
self.assertEqual(rec1, rec2)
self.assertEqual(rec2, rec3)
recs = db.read() # Read all
self.assertEqual(len(recs), 4)
def _test_UPDATE(self):
db = Reviews()
db.table = 'reviews'
where = {'rid': 2}
db.update(condition=where, header='average item', rating=2)
db.commit()
rec = db.read(rid=2)[0]
self.assertIn('average item', rec)
def _test_DELETE(self):
db = Reviews()
db.table = 'reviews'
db.delete(rid=2)
db.commit()
self.assertFalse(db.read(rid=2))
def test_CRUD(self):
self._test_CREATE()
self._test_READ()
self._test_UPDATE()
self._test_DELETE()
def tearDown(self):
os.remove(DB_NAME)
test_CRUD中意外遗漏了对self._test_UPDATE()的调用。 - Peter Mortensenncoghlan的回答正是我在看到这个问题时正在寻找的。最终，我修改了它以允许每个步骤测试运行，即使先前的步骤已经抛出了错误；这有助于我（也许还有你！）发现和规划多线程数据库中错误的传播。
class Monolithic(TestCase):
def step1_testName1(self):
...
def step2_testName2(self):
...
def steps(self):
'''
Generates the step methods from their parent object
'''
for name in sorted(dir(self)):
if name.startswith('step'):
yield name, getattr(self, name)
def test_steps(self):
'''
Run the individual steps associated with this test
'''
# Create a flag that determines whether to raise an error at
# the end of the test
failed = False
# An empty string that the will accumulate error messages for
# each failing step
fail_message = ''
for name, step in self.steps():
try:
step()
except Exception as e:
# A step has failed, the test should continue through
# the remaining steps, but eventually fail
failed = True
# Get the name of the method -- so the fail message is
# nicer to read :)
name = name.split('_')[1]
# Append this step's exception to the fail message
fail_message += "\n\nFAIL: {}\n {} failed ({}: {})".format(name,
step,
type(e),
e)
# Check if any of the steps failed
if failed is True:
# Fail the test with the accumulated exception message
self.fail(fail_message)
sorted()并不是必需的，因为dir()按字母顺序保证返回步骤方法。这也是为什么unittest默认按字母顺序处理测试类和测试方法（即使sortTestMethodsUsing为None）- 这可以用于实用性，例如让最新的工作测试首先运行，以加快编辑 - 测试运行周期。 - kxr