Python หน่วยทดสอบกับฐานและคลาสย่อย

ขณะนี้ฉันมีการทดสอบสองสามบทซึ่งใช้ชุดการทดสอบทั่วไป นี่คือตัวอย่าง:

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 ดั้งเดิมด้วยตัวเองและฉันต้องการกลไกเพื่อป้องกันไม่ให้เกิดขึ้น

ใช้การสืบทอดหลายคลาสดังนั้นคลาสของคุณที่มีการทดสอบทั่วไปจะไม่ได้รับมรดกจาก 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()

อย่าใช้มรดกหลายก็จะกัดคุณในภายหลัง

แต่คุณสามารถย้ายคลาสพื้นฐานของคุณไปยังโมดูลแยกหรือห่อด้วยคลาสเปล่า:

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

คุณสามารถแก้ปัญหานี้ด้วยคำสั่งเดียว:

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

คำตอบของ 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()

คุณพยายามทำอะไรให้สำเร็จ หากคุณมีรหัสทดสอบทั่วไป (การยืนยันการทดสอบเทมเพลตและอื่น ๆ ) จากนั้นให้วางรหัสในวิธีที่ไม่ได้นำหน้าด้วย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()

คำตอบของ Matthew คือคำตอบที่ฉันต้องการใช้ตั้งแต่ฉันยังอยู่ที่ 2.5 แต่เป็น 2.7 คุณสามารถใช้ตัวตกแต่ง @ unittest.skip () ในวิธีทดสอบใด ๆ ที่คุณต้องการข้าม

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

คุณจะต้องใช้มัณฑนากรข้ามของคุณเองเพื่อตรวจสอบประเภทฐาน ยังไม่เคยใช้คุณสมบัตินี้มาก่อน แต่ปิดส่วนบนของหัวคุณคุณสามารถใช้ BaseTest เป็นประเภทเครื่องหมายเพื่อกำหนดเงื่อนไขการข้าม:

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

วิธีที่ฉันคิดว่าจะแก้ปัญหานี้คือการซ่อนวิธีทดสอบถ้าใช้คลาสพื้นฐาน วิธีนี้ไม่มีการข้ามการทดสอบดังนั้นผลการทดสอบอาจเป็นสีเขียวแทนที่จะเป็นสีเหลืองในเครื่องมือการรายงานการทดสอบจำนวนมาก

เมื่อเทียบกับวิธีมิกซ์อินนั้น PyCharm ของ IDE จะไม่บ่นว่าวิธีทดสอบหน่วยจะหายไปจากคลาสฐาน

ถ้าคลาสพื้นฐานสืบทอดมาจากคลาสนี้คลาสนั้นจะต้องแทนที่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 = []

คุณสามารถเพิ่ม__test_ = Falseในคลาส BaseTest แต่ถ้าคุณเพิ่มโปรดระวังว่าคุณต้องเพิ่ม__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()

ตัวเลือกอื่นไม่ได้ทำงาน

unittest.main()

แทนที่จะเป็นเช่นนั้นคุณสามารถใช้

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

ดังนั้นคุณจะทำการทดสอบในชั้นเรียนเท่านั้น TestClass

ฉันทำเหมือนกันกับ @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())

และเราไปที่นั่น

ใน 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__รถที่มากความซับซ้อนมากขึ้น

เพียงเปลี่ยนชื่อเมธอด testCommon เป็นอย่างอื่น Unittest (ปกติ) ข้ามสิ่งที่ไม่มี 'ทดสอบ' ในนั้น

ง่ายและรวดเร็ว

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

ดังนั้นนี่คือเธรดเก่า แต่ฉันเจอปัญหานี้วันนี้และคิดถึงแฮ็คของฉันเอง มันใช้มัณฑนากรที่ทำให้ค่าของฟังก์ชั่นไม่มีเมื่อ acessed ผ่านชั้นฐาน ไม่จำเป็นต้องกังวลเกี่ยวกับการตั้งค่าและ setupclass เพราะถ้า baseclass ไม่มีการทดสอบพวกเขาจะไม่ทำงาน

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

นี่คือวิธีการแก้ปัญหาที่ใช้เฉพาะคุณสมบัติ unittest ที่หลีกเลี่ยงการมีสถานะ "ข้าม" ในผลการทดสอบของคุณ:

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เอกสารประกอบ "แต่ละกรณีของ TestCase จะเรียกใช้วิธีการฐานเดียว: วิธีที่ชื่อว่า methodName" "runTests" เริ่มต้นใช้งานวิธีการทดสอบ * ทั้งหมดในชั้นเรียนซึ่งเป็นวิธีที่อินสแตนซ์ของ TestCase ใช้งานได้ตามปกติ แต่เมื่อทำงานในคลาสพื้นฐานที่เป็นนามธรรมคุณสามารถลบล้างพฤติกรรมนั้นได้ด้วยวิธีการที่ไม่ทำอะไรเลย

ผลข้างเคียงคือการนับการทดสอบของคุณจะเพิ่มขึ้นทีละหนึ่ง: runNoTestsInBaseClass "การทดสอบ" จะถูกนับเป็นการทดสอบที่ประสบความสำเร็จเมื่อมันทำงานบน BaseClass

(สิ่งนี้ยังใช้งานได้ใน Python 2.7 หากคุณยังใช้งานอยู่ให้เปลี่ยนsuper()เป็นsuper(BaseTest, self))

เปลี่ยนชื่อเมธอด 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)

เอาท์พุท:

ทดสอบ 2 ครั้งใน 0.000 วินาที

การเรียก BaseTest: testCommon การเรียก
SubTest1: testSub1 การเรียก
BaseTest: testCommon การเรียก
SubTest2: testSub2

จากเอกสาร :

TestCase.setUp ()
วิธีการที่เรียกว่าเพื่อเตรียมการติดตั้งการทดสอบ สิ่งนี้ถูกเรียกทันทีก่อนเรียกวิธีการทดสอบ ข้อยกเว้นใด ๆ ที่เกิดขึ้นจากวิธีนี้จะถือเป็นข้อผิดพลาดมากกว่าความล้มเหลวในการทดสอบ การใช้งานเริ่มต้นไม่ทำอะไรเลย