Test jednostkowy Pythona z klasą podstawową i podrzędną

Obecnie mam kilka testów jednostkowych, które mają wspólny zestaw testów. Oto przykład:

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

Wynik powyższego to:

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

OK

Czy istnieje sposób na przepisanie powyższego, aby testCommonnie było wywoływane pierwsze ?

EDYCJA: Zamiast uruchamiać 5 testów powyżej, chcę, aby uruchamiał tylko 4 testy, 2 z SubTest1 i kolejne 2 z SubTest2. Wygląda na to, że Python unittest samodzielnie uruchamia oryginalny BaseTest i potrzebuję mechanizmu, aby temu zapobiec.

Użyj dziedziczenia wielokrotnego, aby Twoja klasa z typowymi testami sama nie dziedziczyła po 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()

Nie używaj dziedziczenia wielokrotnego, bo ugryzie Cię to później .

Zamiast tego możesz po prostu przenieść swoją klasę bazową do oddzielnego modułu lub opakować ją pustą klasą:

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

Wyjście:

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

OK

Możesz rozwiązać ten problem za pomocą jednego polecenia:

del(BaseTest)

Więc kod wyglądałby tak:

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

Odpowiedź Matthew Marshalla jest świetna, ale wymaga dziedziczenia z dwóch klas w każdym z przypadków testowych, co jest podatne na błędy. Zamiast tego używam tego (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()

Co próbujesz osiągnąć? Jeśli masz wspólny kod testowy (potwierdzenia, testy szablonów itp.), Umieść je w metodach, które nie są poprzedzone prefiksem, testwięc unittestich nie załaduje.

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

Odpowiedź Matthew to ta, której potrzebowałem, ponieważ wciąż jestem na 2.5. Ale od wersji 2.7 możesz używać dekoratora @ unittest.skip () na dowolnych metodach testowych, które chcesz pominąć.

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

Aby sprawdzić typ podstawowy, musisz zaimplementować własny dekorator pomijający. Nie korzystałem wcześniej z tej funkcji, ale na myśl możesz użyć BaseTest jako typu markera do warunkowania przeskoku:

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

Sposób, w jaki myślałem o rozwiązaniu tego problemu, polega na ukryciu metod testowych, jeśli używana jest klasa bazowa. Dzięki temu testy nie są pomijane, więc wyniki testów mogą być zielone zamiast żółtego w wielu narzędziach do raportowania testów.

W porównaniu z metodą mixin, idee, takie jak PyCharm, nie będą narzekać, że w klasie bazowej brakuje metod testów jednostkowych.

Jeśli klasa bazowa dziedziczy po tej klasie, będzie musiała zastąpić metody setUpClassi 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 = []

Możesz dodać __test_ = Falseklasę BaseTest, ale jeśli ją dodasz, pamiętaj, że musisz dodać __test__ = Trueklasy pochodne, aby móc uruchamiać testy.

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

Inną opcją jest niewykonanie

unittest.main()

Zamiast tego możesz użyć

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

Więc wykonujesz testy tylko w klasie TestClass

Zrobiłem mniej więcej to samo co @Vladim P. ( https://stackoverflow.com/a/25695512/2451329 ), ale nieco zmodyfikowałem:

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

i gotowe.

Począwszy od Pythona 3.2, możesz dodać test_loader do modułu, aby kontrolować, które testy (jeśli istnieją) są wyszukiwane przez mechanizm wykrywania testów.

Na przykład poniższe załadują tylko oryginalny plakat SubTest1i SubTest2przypadki testowe, ignorując Base:

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

To powinno być możliwe do iteracyjnego standard_tests(a TestSuitezawierający testy ładowarka domyślny znalezione) i skopiować wszystko, ale Baseaby suitezamiast, ale zagnieżdżony charakter TestSuite.__iter__powoduje, że dużo bardziej skomplikowane.

Po prostu zmień nazwę metody testCommon na coś innego. Unittest (zwykle) pomija wszystko, co nie zawiera słowa „test”.

Szybko i prosto

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

To trochę stary wątek, ale dzisiaj natknąłem się na ten problem i pomyślałem o swoim własnym hacku. Używa dekoratora, który nadaje wartości funkcji None, gdy są dostępne za pośrednictwem klasy bazowej. Nie musisz martwić się konfiguracją i klasą konfiguracji, ponieważ jeśli klasa podstawowa nie ma testów, nie zostaną one uruchomione.

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

Zmień nazwę metody BaseTest na 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)

Wynik:

Przeprowadziłem 2 testy w 0,000s

Wywołanie BaseTest: testCommon Calling
SubTest1: testSub1 Calling
BaseTest: testCommon Calling
SubTest2: testSub2

Z dokumentacji :

TestCase.setUp ()
Metoda wywołana w celu przygotowania osprzętu testowego. Jest to wywoływane bezpośrednio przed wywołaniem metody testowej; każdy wyjątek zgłoszony przez tę metodę będzie traktowany jako błąd, a nie niepowodzenie testu. Domyślna implementacja nic nie robi.