Test unitario Python con base e sottoclasse

Al momento ho alcuni test unitari che condividono un set comune di test. Ecco un esempio:

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

L'output di quanto sopra è:

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

OK

C'è un modo per riscrivere quanto sopra in modo che il primo testCommonnon venga chiamato?

EDIT: Invece di eseguire 5 test sopra, voglio che esegua solo 4 test, 2 da SubTest1 e altri 2 da SubTest2. Sembra che Python unittest stia eseguendo il BaseTest originale da solo e ho bisogno di un meccanismo per impedire che ciò accada.

Usa l'ereditarietà multipla, quindi la tua classe con test comuni non eredita di per sé da 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()

Non utilizzare l'ereditarietà multipla, ti morderà in seguito .

Invece puoi semplicemente spostare la tua classe base nel modulo separato o avvolgerla con la classe vuota:

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

Il risultato:

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

OK

Puoi risolvere questo problema con un singolo comando:

del(BaseTest)

Quindi il codice sarebbe simile al seguente:

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

La risposta di Matthew Marshall è ottima, ma richiede che tu erediti da due classi in ciascuno dei tuoi casi di test, che è soggetto a errori. Invece, lo uso (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()

Cosa stai cercando di ottenere? Se disponi di un codice di test comune (asserzioni, test dei modelli, ecc.), Inseriscili in metodi che non hanno il prefisso, testquindi unittestnon li caricherai.

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

La risposta di Matthew è quella che dovevo usare dato che sono ancora in 2.5. Ma a partire da 2.7 puoi usare il decoratore @ unittest.skip () su tutti i metodi di test che vuoi saltare.

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

Dovrai implementare il tuo decoratore di salti per verificare il tipo di base. Non ho mai usato questa funzione prima, ma dalla parte superiore della mia testa potresti usare BaseTest come tipo di marker per condizionare il salto:

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

Un modo in cui ho pensato di risolverlo è nascondere i metodi di test se si utilizza la classe base. In questo modo i test non vengono saltati, quindi i risultati del test possono essere verdi anziché gialli in molti strumenti di reporting dei test.

Rispetto al metodo di mixin, ide come PyCharm non si lamenterà del fatto che i metodi unit test mancano nella classe base.

Se una classe base eredita da questa classe, dovrà sovrascrivere i metodi setUpClasse 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 = []

È possibile aggiungere la __test_ = Falseclasse BaseTest, ma se lo si aggiunge, tenere presente che è necessario aggiungere le __test__ = Trueclassi derivate per poter eseguire i test.

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

Un'altra opzione è di non eseguire

unittest.main()

Invece di quello che puoi usare

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

Quindi esegui solo i test nella classe TestClass

Ho fatto lo stesso di @Vladim P. ( https://stackoverflow.com/a/25695512/2451329 ) ma leggermente modificato:

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

e eccoci.

A partire da Python 3.2, è possibile aggiungere una funzione test_loader a un modulo per controllare quali test (se presenti) vengono rilevati dal meccanismo di rilevamento test.

Ad esempio, quanto segue caricherà solo i poster SubTest1e i SubTest2casi di test originali, ignorando Base:

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

Dovrebbe essere possibile iterare standard_tests(una TestSuitecontenente le prove loader predefinito pensa) e copiare quasi Basea suiteposto, ma la natura nidificata di TestSuite.__iter__marchi che molto più complicata.

Rinomina il metodo testCommon in qualcos'altro. Unittest (di solito) salta tutto ciò che non ha "test" al suo interno.

Veloce e semplice

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

Quindi questa è una specie di vecchio thread, ma oggi ho riscontrato questo problema e ho pensato al mio hack per questo. Usa un decoratore che rende i valori delle funzioni Nessuno quando acceduto attraverso la classe base. Non devi preoccuparti di setup e setupclass perché se la baseclass non ha test non funzioneranno.

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

Ecco una soluzione che utilizza solo funzionalità unittest documentate e che evita di avere uno stato "salta" nei risultati del test:

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

Come funziona: secondo la unittest.TestCasedocumentazione , "Ogni istanza di TestCase eseguirà un singolo metodo di base: il metodo denominato methodName." Il "runTest" predefinito esegue tutti i metodi test * sulla classe, ecco come funzionano normalmente le istanze TestCase. Ma quando si esegue nella stessa classe base astratta, è possibile semplicemente ignorare quel comportamento con un metodo che non fa nulla.

Un effetto collaterale è che il conteggio dei test aumenta di uno: il "test" runNoTestsInBaseClass viene conteggiato come test riuscito quando viene eseguito su BaseClass.

(Funziona anche in Python 2.7, se ci sei ancora. Basta passare super()a super(BaseTest, self).)

Modifica il nome del metodo BaseTest 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)

Produzione:

Ho eseguito 2 test in 0.000 secondi

Chiamata BaseTest: testCommon Chiamata
SubTest1: testSub1 Chiamata
BaseTest: testCommon Chiamata
SubTest2: testSub2

Dalla documentazione :

TestCase.setUp ()
Metodo chiamato per preparare l'apparecchiatura di prova. Questo viene chiamato immediatamente prima di chiamare il metodo di test; qualsiasi eccezione sollevata da questo metodo sarà considerata un errore piuttosto che un fallimento del test. L'implementazione predefinita non fa nulla.