Schließen Sie bestimmte Fälle mit Python unittest aus

Zusammenfassung

• Schreiben Sie eine Möglichkeit, die zu entdeckenden Zielklassen mit unittest einzuschränken.
• Schreiben Sie in der ersten Hälfte auf, wann Sie es benötigen.
• Später werden wir den Code schreiben.
• Es gibt ein Codebeispiel für load_tests ().

Einführung

Selbst wenn es in der realen Welt mehrere Transportmittel gibt, um das Ziel zu erreichen, wie z. B. zu Fuß, mit dem Auto oder mit öffentlichen Verkehrsmitteln, ist das Ziel eines der Ziele, aber wie stark jedes Mittel von Preis, Zeit und Unfall beeinflusst werden kann. Es gibt Vor- und Nachteile wie.

Ebenso kann es beim Schreiben von Code mehrere Möglichkeiten geben, dasselbe Ziel zu erreichen.

Beispielsweise gibt es bei der Suche in einem Baum mehrere Suchmethoden wie Tiefenpriorität und Breitenpriorität sowie Vor- und Nachteile. Der Sortieralgorithmus ist ähnlich. Es ist etwas übertrieben, aber ähnliche Fälle können in Fällen wie dem Strategie-Entwurfsmuster auftreten.

Wenn Sie in einigen Fällen die Tiefenpriorität und in einigen Fällen die Breitenpriorität auswählen, wird jeder Testfall in den Code eingefügt. Wenn Sie einen Black-Box-Test durchführen möchten, der den Inhalt des Codes nicht kennt, implementieren Sie ihn ehrlich Dann wird es einen ähnlichen Testcode geben.

In einem solchen Fall werde ich eine Geschichte schreiben, in der Sie Code schreiben können, der Testfälle mit load_tests () einschränkt.

Code

Betrachten Sie als Beispiel die Implementierung der Multiplikation der ganzen Zahlen x und y auf zwei Arten: "y x-mal addieren" und "multiplizieren" und Implementierung jedes Tests.

1) Implementierung und Prüfung der Addition und Multiplikation

Eine naive Implementierung würde zu folgendem Code führen. Kommentar Der als "redundant" geschriebene Teil ist redundant.

import unittest

class MultiplyBase(object):
    def multiply(self, n1: int, n2: int) -> int:
        raise NotImplementedError()

class MultiplyPlus(MultiplyBase):
    def multiply(self, n1: int, n2: int) -> int:
        ret = 0
        for i in range(0, n1):
            ret += n2
        return ret

class MultiplyAsterisk(MultiplyBase):
    def multiply(self, n1: int, n2: int) -> int:
        return n1 * n2

class TestMultiplyBase(unittest.TestCase):
    def test_multiply(self):
        obj: MultiplyBase = MultiplyBase()
        with self.assertRaises(NotImplementedError):
            obj.multiply(2, 3)

class TestMultiplyPlus(unittest.TestCase):
    def test_multiply(self):
        obj: MultiplyBase = MultiplyPlus()
        self.assertEqual(obj.multiply(2, 3), 6)  #Redundant!!

class TestMultiplyAsteriskClass(unittest.TestCase):
    def test_multiply(self):
        obj: MultiplyBase = MultiplyAsterisk()
        self.assertEqual(obj.multiply(2, 3), 6)  #Redundant!!

Diese Menge interessiert mich nicht wirklich, aber es ist schwer, wenn sie groß ist.

2) Implementierung und Test, die redundante Teile eliminieren

Wir werden einen Testfall in der TestCaseHelper-Klasse implementieren und diesen Testfall ableiten, um einen konkreten Testfall zu erstellen.

Mit TestCaseHelper muss jede Testfallklasse nur implementieren, welche Objektklasse sie verwendet. Dadurch wird redundanter Code eliminiert.

In diesem Fall wird die TestCaseHelper-Klasse jedoch mit dem Standardverhalten von unittest erkannt. Aus diesem Grund schlägt der Testfall immer fehl, sodass load_tests () verhindert, dass TestCaseHelper als Testfall betrachtet wird.

import unittest

class MultiplyBase(object):
    def multiply(self, n1: int, n2: int) -> int:
        raise NotImplementedError()

class MultiplyPlus(MultiplyBase):
    def multiply(self, n1: int, n2: int) -> int:
        ret = 0
        for i in range(0, n1):
            ret += n2
        return ret

class MultiplyAsterisk(MultiplyBase):
    def multiply(self, n1: int, n2: int) -> int:
        return n1 * n2

class TestCaseHelper(unittest.TestCase):
    def _get_multiply_obj(self) -> MultiplyBase:
        raise NotImplementedError()

    def test_multiply(self):
        obj: MultiplyBase = self._get_multiply_obj()
        self.assertEqual(obj.multiply(2, 3), 6)

class TestMultiplyBase(TestCaseHelper):
    def _get_multiply_obj(self) -> MultiplyBase:
        return MultiplyBase()

    def test_multiply(self):
        obj: MultiplyBase = self._get_multiply_obj()
        with self.assertRaises(NotImplementedError):
            obj.multiply(2, 3)

class TestMultiplyPlus(TestCaseHelper):
    def _get_multiply_obj(self) -> MultiplyBase:
        return MultiplyPlus()

class TestMultiplyAsterisk(TestCaseHelper):
    def _get_multiply_obj(self) -> MultiplyBase:
        return MultiplyAsterisk()

def load_tests(loader, tests, patterns):
    test_cases = (TestMultiplyBase, TestMultiplyPlus, TestMultiplyAsterisk)
    suite = unittest.TestSuite()
    for test_class in test_cases:
        tests = loader.loadTestsFromTestCase(test_class)
        suite.addTests(tests)
    return suite

Sie haben jetzt einige Testfälle mit load_tests () erfolgreich ausgeschlossen.