Uji unit python dengan basis dan sub kelas

Saat ini saya memiliki beberapa unit test yang berbagi serangkaian tes umum. Ini sebuah contoh:

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

Output di atas adalah:

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

OK

Apakah ada cara untuk menulis ulang di atas sehingga yang pertama testCommontidak dipanggil?

EDIT: Alih-alih menjalankan 5 tes di atas, saya ingin hanya menjalankan 4 tes, 2 dari SubTest1 dan 2 dari SubTest2. Tampaknya Python unittest menjalankan BaseTest sendiri dan saya perlu mekanisme untuk mencegah hal itu terjadi.

Gunakan multiple inheritance, jadi kelas Anda dengan tes umum tidak dengan sendirinya mewarisi dari 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()

Jangan gunakan banyak pewarisan, itu akan menggigit Anda nanti .

Sebagai gantinya, Anda bisa memindahkan kelas dasar ke modul terpisah atau membungkusnya dengan kelas kosong:

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

Hasil:

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

OK

Anda dapat memecahkan masalah ini dengan satu perintah:

del(BaseTest)

Jadi kodenya akan terlihat seperti ini:

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

Jawaban Matthew Marshall bagus, tetapi mengharuskan Anda mewarisi dari dua kelas di setiap kasus uji Anda, yang rawan kesalahan. Sebagai gantinya, saya menggunakan ini (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()

Apa yang ingin Anda capai? Jika Anda memiliki kode tes umum (pernyataan, tes templat, dll), kemudian tempatkan dalam metode yang tidak diawali dengan testjadi unittesttidak akan memuatnya.

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

Jawaban Matthew adalah yang perlu saya gunakan karena saya masih di 2,5. Tetapi mulai 2.7 Anda dapat menggunakan dekorator @ unittest.skip () pada metode pengujian apa pun yang ingin Anda lewati.

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

Anda harus menerapkan dekorator lompatan Anda sendiri untuk memeriksa jenis dasar. Belum pernah menggunakan fitur ini sebelumnya, tetapi dari atas kepala saya, Anda dapat menggunakan BaseTest sebagai jenis penanda untuk mengkondisikan lompatan:

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

Salah satu cara yang saya pikirkan untuk menyelesaikan ini adalah dengan menyembunyikan metode tes jika kelas dasar digunakan. Dengan cara ini tes tidak dilewati, sehingga hasil tes bisa menjadi hijau, bukan kuning di banyak alat pelaporan pengujian.

Dibandingkan dengan metode mixin, ide seperti PyCharm tidak akan mengeluh bahwa metode unit test hilang dari kelas dasar.

Jika kelas dasar mewarisi dari kelas ini, itu perlu mengganti metode setUpClassdan 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 = []

Anda bisa menambahkan __test_ = Falsedi kelas BaseTest, tetapi jika Anda menambahkannya, ketahuilah bahwa Anda harus menambahkan __test__ = Truedi kelas turunan untuk dapat menjalankan tes.

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

Pilihan lain adalah tidak mengeksekusi

unittest.main()

Alih-alih itu bisa Anda gunakan

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

Jadi, Anda hanya menjalankan tes di kelas TestClass

Saya membuat hal yang sama dari @Vladim P. ( https://stackoverflow.com/a/25695512/2451329 ) tetapi sedikit dimodifikasi:

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

dan di sana kita pergi.

Pada Python 3.2, Anda bisa menambahkan fungsi test_loader ke modul untuk mengontrol tes mana (jika ada) yang ditemukan oleh mekanisme penemuan tes.

Misalnya, berikut ini hanya akan memuat poster asli SubTest1dan SubTest2Kasus Uji, mengabaikan Base:

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

Ini seharusnya mungkin untuk iterate atas standard_tests(a TestSuiteyang berisi tes loader bawaan ditemukan) dan copy semua tapi Baseuntuk suitesebaliknya, tetapi sifat bersarang TestSuite.__iter__merek yang lebih banyak rumit.

Ubah nama metode testCommon menjadi sesuatu yang lain. Unittest (biasanya) melewatkan apa pun yang tidak memiliki 'tes' di dalamnya.

Cepat dan sederhana

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

Jadi ini semacam utas lama tapi saya menemukan masalah ini hari ini dan memikirkan hack saya sendiri untuk itu. Ia menggunakan dekorator yang membuat nilai-nilai fungsi Tidak ada ketika diakses melalui kelas dasar. Tidak perlu khawatir tentang pengaturan dan pengaturan kelas karena jika baseclass tidak memiliki tes mereka tidak akan berjalan.

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

Berikut adalah solusi yang hanya menggunakan fitur unittest yang terdokumentasi dan yang menghindari status "lewati" dalam hasil pengujian Anda:

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

Cara kerjanya: sesuai unittest.TestCasedokumentasi , "Setiap instance TestCase akan menjalankan metode basis tunggal: metode ini bernama methodName." "RunTests" default menjalankan semua metode tes * di kelas — begitulah cara kerja TestCase biasanya. Tetapi ketika menjalankan dalam kelas dasar abstrak itu sendiri, Anda bisa menimpa perilaku itu dengan metode yang tidak melakukan apa-apa.

Efek sampingnya adalah jumlah tes Anda akan bertambah satu: "tes" runNoTestsInBaseClass akan dihitung sebagai tes yang berhasil ketika dijalankan pada BaseClass.

(Ini juga bekerja dengan Python 2.7, jika Anda masih pada itu. Hanya perubahan super()ke super(BaseTest, self).)

Ubah nama metode BaseTest untuk mengatur:

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)

Keluaran:

Berlari 2 tes dalam 0,000s

Calling BaseTest: testCommon Calling
SubTest1: testSub1 Calling
BaseTest: testCommon Calling
SubTest2: testSub2

Dari dokumentasi :

TestCase.setUp ()
Metode dipanggil untuk menyiapkan perlengkapan tes. Ini dipanggil segera sebelum memanggil metode pengujian; setiap pengecualian yang diajukan oleh metode ini akan dianggap sebagai kesalahan daripada kegagalan pengujian. Implementasi default tidak melakukan apa pun.