带有基类和子类的 Python 单元测试

Question

我目前有一些单元测试共享一组通用测试。这是一个例子：

import unittest

class BaseTest(unittest.TestCase):

    def testCommon(self):
        print 'Calling BaseTest:testCommon'
        value = 5
        self.assertEquals(value, 5)

class SubTest1(BaseTest):

    def testSub1(self):
        print 'Calling SubTest1:testSub1'
        sub = 3
        self.assertEquals(sub, 3)


class SubTest2(BaseTest):

    def testSub2(self):
        print 'Calling SubTest2:testSub2'
        sub = 4
        self.assertEquals(sub, 4)

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

上面的输出是：

Calling BaseTest:testCommon
.Calling BaseTest:testCommon
.Calling SubTest1:testSub1
.Calling BaseTest:testCommon
.Calling SubTest2:testSub2
.
----------------------------------------------------------------------
Ran 5 tests in 0.000s

OK

有没有办法重写上面的代码，使第一个testCommon 不被调用？

编辑： 而不是运行上面的 5 个测试，我希望它只运行 4 个测试，2 个来自 SubTest1，另外 2 个来自 SubTest2。似乎 Python unittest 正在自行运行原始 BaseTest，我需要一种机制来防止这种情况发生。

Answer 1

不要使用多重继承，它会咬你later。

相反，您可以将基类移动到单独的模块中或用空白类包装它：

class BaseTestCases:

    class BaseTest(unittest.TestCase):

        def testCommon(self):
            print('Calling BaseTest:testCommon')
            value = 5
            self.assertEqual(value, 5)


class SubTest1(BaseTestCases.BaseTest):

    def testSub1(self):
        print('Calling SubTest1:testSub1')
        sub = 3
        self.assertEqual(sub, 3)


class SubTest2(BaseTestCases.BaseTest):

    def testSub2(self):
        print('Calling SubTest2:testSub2')
        sub = 4
        self.assertEqual(sub, 4)

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

输出：

Calling BaseTest:testCommon
.Calling SubTest1:testSub1
.Calling BaseTest:testCommon
.Calling SubTest2:testSub2
.
----------------------------------------------------------------------
Ran 4 tests in 0.001s

OK

Answer 2

使用多重继承，因此您的具有常见测试的类本身不会从 TestCase 继承。

import unittest

class CommonTests(object):
    def testCommon(self):
        print 'Calling BaseTest:testCommon'
        value = 5
        self.assertEquals(value, 5)

class SubTest1(unittest.TestCase, CommonTests):

    def testSub1(self):
        print 'Calling SubTest1:testSub1'
        sub = 3
        self.assertEquals(sub, 3)


class SubTest2(unittest.TestCase, CommonTests):

    def testSub2(self):
        print 'Calling SubTest2:testSub2'
        sub = 4
        self.assertEquals(sub, 4)

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

Answer 3

你可以用一个命令解决这个问题：

del(BaseTest)

所以代码应该是这样的：

import unittest

class BaseTest(unittest.TestCase):

    def testCommon(self):
        print 'Calling BaseTest:testCommon'
        value = 5
        self.assertEquals(value, 5)

class SubTest1(BaseTest):

    def testSub1(self):
        print 'Calling SubTest1:testSub1'
        sub = 3
        self.assertEquals(sub, 3)


class SubTest2(BaseTest):

    def testSub2(self):
        print 'Calling SubTest2:testSub2'
        sub = 4
        self.assertEquals(sub, 4)

del(BaseTest)

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

Answer 4

Matthew Marshall 的回答很棒，但它要求您从每个测试用例中的两个类继承，这很容易出错。相反，我使用这个（python>=2.7）：

class BaseTest(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        if cls is BaseTest:
            raise unittest.SkipTest("Skip BaseTest tests, it's a base class")
        super(BaseTest, cls).setUpClass()

Answer 5

您可以在 BaseTest 类中添加 __test__ = False，但如果添加它，请注意您必须在派生类中添加 __test__ = True 才能运行测试。

import unittest

class BaseTest(unittest.TestCase):
    __test__ = False

    def testCommon(self):
        print 'Calling BaseTest:testCommon'
        value = 5
        self.assertEquals(value, 5)

class SubTest1(BaseTest):
    __test__ = True

    def testSub1(self):
        print 'Calling SubTest1:testSub1'
        sub = 3
        self.assertEquals(sub, 3)


class SubTest2(BaseTest):
    __test__ = True

    def testSub2(self):
        print 'Calling SubTest2:testSub2'
        sub = 4
        self.assertEquals(sub, 4)

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

Answer 6

你想达到什么目的？如果您有通用测试代码（断言、模板测试等），请将它们放在不以test 为前缀的方法中，这样unittest 就不会加载它们。

import unittest

class CommonTests(unittest.TestCase):
      def common_assertion(self, foo, bar, baz):
          # whatever common code
          self.assertEqual(foo(bar), baz)

class BaseTest(CommonTests):

    def testCommon(self):
        print 'Calling BaseTest:testCommon'
        value = 5
        self.assertEquals(value, 5)

class SubTest1(CommonTests):

    def testSub1(self):
        print 'Calling SubTest1:testSub1'
        sub = 3
        self.assertEquals(sub, 3)

class SubTest2(CommonTests):

    def testSub2(self):
        print 'Calling SubTest2:testSub2'
        sub = 4
        self.assertEquals(sub, 4)

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

Answer 7

另一种选择是不执行

unittest.main()

你可以使用

suite = unittest.TestLoader().loadTestsFromTestCase(TestClass)
unittest.TextTestRunner(verbosity=2).run(suite)

所以你只执行TestClass类中的测试

Answer 8

马修的答案是我需要使用的答案，因为我还在 2.5 上。 但从 2.7 开始，您可以在任何要跳过的测试方法上使用 @unittest.skip() 装饰器。

http://docs.python.org/library/unittest.html#skipping-tests-and-expected-failures

您需要实现自己的跳过装饰器来检查基本类型。以前没有使用过此功能，但在我看来，您可以使用 BaseTest 作为 ma​​rker 类型来调节跳过：

def skipBaseTest(obj):
    if type(obj) is BaseTest:
        return unittest.skip("BaseTest tests skipped")
    return lambda func: func

Answer 9

我想到的一种解决方法是在使用基类时隐藏测试方法。这样就不会跳过测试，因此在许多测试报告工具中测试结果可以是绿色而不是黄色。

相比于 mixin 方法，ide 之类的 PyCharm 不会抱怨基类中缺少单元测试方法。

如果基类继承自此类，则需要重写 setUpClass 和 tearDownClass 方法。

class BaseTest(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls._test_methods = []
        if cls is BaseTest:
            for name in dir(cls):
                if name.startswith('test') and callable(getattr(cls, name)):
                    cls._test_methods.append((name, getattr(cls, name)))
                    setattr(cls, name, lambda self: None)

    @classmethod
    def tearDownClass(cls):
        if cls is BaseTest:
            for name, method in cls._test_methods:
                setattr(cls, name, method)
            cls._test_methods = []

Answer 10

我制作的内容与@Vladim P. (https://stackoverflow.com/a/25695512/2451329) 大致相同，但稍作修改：

import unittest2


from some_module import func1, func2


def make_base_class(func):

    class Base(unittest2.TestCase):

        def test_common1(self):
            print("in test_common1")
            self.assertTrue(func())

        def test_common2(self):
            print("in test_common1")
            self.assertFalse(func(42))

    return Base



class A(make_base_class(func1)):
    pass


class B(make_base_class(func2)):

    def test_func2_with_no_arg_return_bar(self):
        self.assertEqual("bar", func2())

我们去吧。

Answer 11

从 Python 3.2 开始，您可以向模块添加 test_loader 函数，以控制测试发现机制找到哪些测试（如果有）。

例如下面将只加载原发帖者的SubTest1和SubTest2测试用例，忽略Base：

def load_tests(loader, standard_tests, pattern):
    suite = TestSuite()
    suite.addTests([SubTest1, SubTest2])
    return suite

应该可以遍历standard_tests（一个TestSuite，其中包含默认加载程序找到的测试）并将除Base之外的所有内容复制到suite，但是TestSuite.__iter__的嵌套性质使得复杂得多。

Answer 12

这是一个仅使用记录在案的单元测试功能的解决方案，可避免在测试结果中出现“跳过”状态：

class BaseTest(unittest.TestCase):

    def __init__(self, methodName='runTest'):
        if self.__class__ is BaseTest:
            # don't run these tests in the abstract base implementation
            methodName = 'runNoTestsInBaseClass'
        super().__init__(methodName)

    def runNoTestsInBaseClass(self):
        pass

    def testCommon(self):
        # everything else as in the original question

它是如何工作的：根据unittest.TestCase documentation，“TestCase 的每个实例都将运行一个基本方法：名为 methodName 的方法。”默认的“runTests”运行类上的所有 test* 方法——这就是 TestCase 实例正常工作的方式。但是当在抽象基类本身中运行时，您可以简单地用一个什么都不做的方法覆盖该行为。

副作用是您的测试计数将增加一：runNoTestsInBaseClass“测试”在 BaseClass 上运行时被计为成功测试。

（这也适用于 Python 2.7，如果您仍在使用它。只需将 super() 更改为 super(BaseTest, self)。）

Answer 13

只需将 testCommon 方法重命名为其他名称即可。单元测试（通常）会跳过任何没有“测试”的内容。

快速简单

  import unittest

  class BaseTest(unittest.TestCase):

   def methodCommon(self):
       print 'Calling BaseTest:testCommon'
       value = 5
       self.assertEquals(value, 5)

  class SubTest1(BaseTest):

      def testSub1(self):
          print 'Calling SubTest1:testSub1'
          sub = 3
          self.assertEquals(sub, 3)


  class SubTest2(BaseTest):

      def testSub2(self):
          print 'Calling SubTest2:testSub2'
          sub = 4
          self.assertEquals(sub, 4)

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

Answer 14

所以这是一个旧线程，但我今天遇到了这个问题并想到了我自己的破解方法。它使用一个装饰器，当通过基类访问时，该装饰器使函数的值变为无。无需担心 setup 和 setupclass，因为如果基类没有测试，它们将无法运行。

import types
import unittest


class FunctionValueOverride(object):
    def __init__(self, cls, default, override=None):
        self.cls = cls
        self.default = default
        self.override = override

    def __get__(self, obj, klass):
        if klass == self.cls:
            return self.override
        else:
            if obj:
                return types.MethodType(self.default, obj)
            else:
                return self.default


def fixture(cls):
    for t in vars(cls):
        if not callable(getattr(cls, t)) or t[:4] != "test":
            continue
        setattr(cls, t, FunctionValueOverride(cls, getattr(cls, t)))
    return cls


@fixture
class BaseTest(unittest.TestCase):
    def testCommon(self):
        print('Calling BaseTest:testCommon')
        value = 5
        self.assertEqual(value, 5)


class SubTest1(BaseTest):
    def testSub1(self):
        print('Calling SubTest1:testSub1')
        sub = 3
        self.assertEqual(sub, 3)


class SubTest2(BaseTest):

    def testSub2(self):
        print('Calling SubTest2:testSub2')
        sub = 4
        self.assertEqual(sub, 4)

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

Answer 15

将 BaseTest 方法名称更改为 setUp：

class BaseTest(unittest.TestCase):
    def setUp(self):
        print 'Calling BaseTest:testCommon'
        value = 5
        self.assertEquals(value, 5)


class SubTest1(BaseTest):
    def testSub1(self):
        print 'Calling SubTest1:testSub1'
        sub = 3
        self.assertEquals(sub, 3)


class SubTest2(BaseTest):
    def testSub2(self):
        print 'Calling SubTest2:testSub2'
        sub = 4
        self.assertEquals(sub, 4)

输出：

在 0.000 秒内运行 2 次测试

调用 BaseTest:testCommon 调用
SubTest1:testSub1 调用
BaseTest:test 常用调用
SubTest2:testSub2

来自documentation：

TestCase.setUp()
调用的方法 准备测试夹具。这是 在调用之前立即调用 测试方法;引发的任何异常 这种方法将被视为 错误而不是测试失败。这 默认实现什么都不做。