Python-Unit-Test mit Basis- und Unterklasse

Ich habe derzeit einige Unit-Tests, die eine gemeinsame Reihe von Tests teilen. Hier ist ein Beispiel:

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()

Die Ausgabe der oben genannten ist:

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

OK

Gibt es eine Möglichkeit, das Obige so umzuschreiben, dass das allererste testCommonnicht aufgerufen wird?

BEARBEITEN: Anstatt 5 Tests oben auszuführen, möchte ich, dass nur 4 Tests ausgeführt werden, 2 vom SubTest1 und weitere 2 vom SubTest2. Es scheint, dass Python unittest den ursprünglichen BaseTest alleine ausführt, und ich brauche einen Mechanismus, um dies zu verhindern.

Verwenden Sie die Mehrfachvererbung, damit Ihre Klasse mit allgemeinen Tests nicht selbst von TestCase erbt.

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()

Verwenden Sie keine Mehrfachvererbung, sie wird Sie später beißen .

Stattdessen können Sie Ihre Basisklasse einfach in das separate Modul verschieben oder mit der leeren Klasse umschließen:

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()

Die Ausgabe:

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

OK

Sie können dieses Problem mit einem einzigen Befehl lösen:

del(BaseTest)

Der Code würde also so aussehen:

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()

Die Antwort von Matthew Marshall ist großartig, erfordert jedoch, dass Sie in jedem Ihrer Testfälle von zwei Klassen erben, was fehleranfällig ist. Stattdessen benutze ich dies (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()

Was versuchst du zu erreichen? Wenn Sie allgemeinen Testcode haben (Zusicherungen, Vorlagentests usw.), platzieren Sie diese in Methoden, denen kein Präfix vorangestellt ist, testdamit unittestsie nicht geladen werden.

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()

Matthews Antwort ist die, die ich verwenden musste, da ich immer noch auf 2.5 bin. Ab 2.7 können Sie den Dekorator @ unittest.skip () für alle Testmethoden verwenden, die Sie überspringen möchten.

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

Sie müssen Ihren eigenen überspringenden Dekorateur implementieren, um den Basistyp zu überprüfen. Haben Sie diese Funktion nicht vor verwendet, aber aus der Spitze von meinem Kopf konnte man BaseTest als verwendet Marker Art den Sprung zu konditionieren:

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

Eine Möglichkeit, dies zu lösen, besteht darin, die Testmethoden auszublenden, wenn die Basisklasse verwendet wird. Auf diese Weise werden die Tests nicht übersprungen, sodass die Testergebnisse in vielen Testberichtstools grün statt gelb sein können.

Im Vergleich zur Mixin-Methode beklagen sich Ideen wie PyCharm nicht darüber, dass Unit-Test-Methoden in der Basisklasse fehlen.

Wenn eine Basisklasse von dieser Klasse erbt, muss sie die Methoden setUpClassund überschreiben 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 = []

Sie können die __test_ = FalseBaseTest-Klasse hinzufügen. Wenn Sie sie jedoch hinzufügen, müssen Sie __test__ = Trueabgeleitete Klassen hinzufügen , um Tests ausführen zu können.

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()

Eine andere Option ist nicht auszuführen

unittest.main()

Stattdessen können Sie verwenden

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

Sie führen also nur die Tests in der Klasse aus TestClass

Ich habe ungefähr das Gleiche gemacht wie @Vladim P. ( https://stackoverflow.com/a/25695512/2451329 ), aber leicht modifiziert:

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())

und los geht's.

Ab Python 3.2 können Sie einem Modul eine test_loader- Funktion hinzufügen, um zu steuern, welche Tests (falls vorhanden) vom Testerkennungsmechanismus gefunden werden.

Im Folgenden werden beispielsweise nur die Originalposter SubTest1und SubTest2Testfälle geladen, wobei Folgendes ignoriert wird Base:

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

Es sollte möglich sein , iterieren standard_tests(a TestSuiteund kopieren Sie alle Tests der Standard - loader Enthalten gefunden) , aber Basezu suitestatt, aber die verschachtelte Natur TestSuite.__iter__macht , dass viel mehr kompliziert.

Benennen Sie die testCommon-Methode einfach in etwas anderes um. Unittest überspringt (normalerweise) alles, was keinen "Test" enthält.

Schnell und einfach

  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()`

Das ist also eine Art alter Thread, aber ich bin heute auf dieses Problem gestoßen und habe mir meinen eigenen Hack dafür ausgedacht. Es wird ein Dekorator verwendet, der die Werte der Funktionen None festlegt, wenn er über die Basisklasse aufgerufen wird. Sie müssen sich keine Gedanken über Setup und Setup-Klasse machen, denn wenn die Basisklasse keine Tests enthält, werden sie nicht ausgeführt.

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()

Ändern Sie den Namen der BaseTest-Methode in 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)

Ausgabe:

Lief 2 Tests in 0,000s

Aufrufen von BaseTest: testCommon Aufrufen von
SubTest1: testSub1 Aufrufen von
BaseTest: testCommon Aufrufen von
SubTest2: testSub2

Aus der Dokumentation :

TestCase.setUp ()
Methode zur Vorbereitung der Testvorrichtung . Dies wird unmittelbar vor dem Aufruf der Testmethode aufgerufen. Jede durch diese Methode ausgelöste Ausnahme wird eher als Fehler als als Testfehler betrachtet. Die Standardimplementierung führt nichts aus.