Python Unittest-Setup

1. Python unittest-Setup
2. Abschluss

Unit-Tests prüfen, ob eine bestimmte Code-Unit oder ein Modul die vom Entwickler erwartete Leistung erbringt. Meistens ist die Codeeinheit, die wir testen, eine Funktion.

Ebenso können wir alle Funktionen testen. Als Best Practice sollten wir zumindest im Entwicklungsprozess Unit-Tests durchführen.

So erkennt es in der frühen Phase des Entwicklungsprozesses Fehler, und wir können sie ohne großen Zeitaufwand beheben. Wenn wir diese Tests überspringen, wird es schwierig, die Fehler zu beheben, wenn wir mit dem Projekt fortfahren.

Python unittest-Setup

Python bietet ein anderes Framework für Unit-Tests namens unittest. Das Framework unittest bietet einige Features.

Die Tests, die wir mit dieser Methode durchführen, sind voneinander unabhängig. Mit anderen Worten, der Erfolg oder Misserfolg eines Tests hängt nicht von anderen Testergebnissen ab.

Es bietet auch die Funktionen setup() und teardown() sowie Testautomatisierung. Die Funktion setup() ermöglicht es uns, die Anweisungen festzulegen, die vor jeder Testmethode ausgeführt werden sollen.

Die Funktion teardown() beschreibt die Anweisungen, die nach jeder Testmethode ausgeführt werden.

unittest gibt uns einige wesentliche Konzepte zur Verwendung beim Unit-Testen an die Hand, wie z. B. Testfixture, Testfall, Testsuite und Testrunner. Dieser Artikel beschreibt den Aufbau einer setup()-Funktion für Unit-Tests mit dem unittest-Framework.

Erstellen Sie zu testende Funktionen

Zuerst müssen wir einige Funktionen zum Testen erstellen. Lassen Sie uns vier Funktionen erstellen, um zwei Zahlen zu addieren, zu subtrahieren, zu multiplizieren, zu dividieren und den Rest zu erhalten.

def add(a, b):
    return a + b


def subtract(a, b):
    return a - b


def multiply(a, b):
    return a * b


def divide(a, b):
    return a / b


def remainder(a, b):
    return a % b

Wir können die obigen Funktionen mit der Funktion print() testen, aber es ist nicht sehr praktisch bei Hunderten oder Tausenden von Codes. Lassen Sie uns also ein Modul erstellen, um die Funktionen zu testen.

Erstellen Sie das Testmodul

Wir sollten unser Testmodul gemäß der Namenskonvention benennen. Wir verwenden test_ als ersten Teil des Namens und dann den Namen des Moduls.

Lassen Sie uns unser Testmodul für dieses Tutorial als test_calc.py erstellen.

Namenskonvention:

test_ < name >

Dann müssen wir das unittest-Framework und das numCal-Modul in unser Testmodul importieren. unittest enthält es in der Standardbibliothek, sodass wir es direkt importieren können. numCal ist das Modul, das wir testen müssen.

import unittest
import numCal

Als nächsten Schritt können wir eine Klasse erstellen, die von unittest.TestCase erbt, sodass wir Zugriff auf mehr Testfunktionen innerhalb dieser Klasse haben.

class TestNumCal(unittest.TestCase):

Innerhalb der Klasse erstellen wir Methoden für jede Funktion. Wir müssen die Methoden bei der Benennung gemäß der Namenskonvention benennen.

Wenn wir das Testmodul ausführen, weiß es, welche Methode die Tests darstellt, da der erste Teil des Namens der Test ist. Andernfalls werden die Testmethoden nicht identifiziert und übersprungen.

Zuerst erstellen wir eine Testmethode für die Funktion add().

def test_add(self):
    self.assertEqual(numCal.add(10, 5), 15)

Wie bei jeder Methode ist self das erste Argument der Methode test_add(). Wir haben in der zweiten Zeile die Methode assertEqual() verwendet.

Da unsere Klasse TestNumCal von unittest.TestCase erbt, können wir auf alle verfügbaren Assert-Methoden zugreifen. Methoden wie assertEqual(), assertNotEqual(), assertTrue(), assertFalse() und assertIn() können beim Unit-Testing verwendet werden und es gibt noch viel mehr.

Die Methode assertEqual() überprüft die Gleichheit zwischen dem Wert, der von der Funktion zurückgegeben wird, und dem Wert, den wir erwarten.

Dann müssen wir das Testmodul so einstellen, dass es direkt aus dem Editor ausgeführt wird. Andernfalls wird es nicht ausgeführt, wenn wir versuchen, das Testmodul auszuführen.

Dafür können wir den folgenden Code verwenden.

if __name__ == "__main__":
    unittest.main()

Jetzt sollte unser Code so aussehen.

import unittest
import numCal


class TestNumCal(unittest.TestCase):
    def test_add(self):
        self.assertEqual(numCal.add(10, 5), 15)


if __name__ == "__main__":
    unittest.main()

Jetzt können wir die Funktion add() testen, indem wir das Modul test_calc.py ausführen.

Ausgang:

Hier zeigt der Punkt an, dass der Test bestanden wurde. Schlägt der Test fehl, erscheint F und im Fehlerfall erscheint eine Fehlermeldung.

Unten zeigt der Punkt, wie viele Einheiten getestet wurden.

Lassen Sie uns nun vier weitere Testmethoden erstellen, um die verbleibenden Funktionen zu testen.

import unittest
import numCal


class TestNumCal(unittest.TestCase):
    def test_add(self):
        self.assertEqual(numCal.add(10, 5), 15)

    def test_subtract(self):
        self.assertEqual(numCal.subtract(10, 5), 5)

    def test_multiply(self):
        self.assertEqual(numCal.multiply(10, 5), 50)

    def test_divide(self):
        self.assertEqual(numCal.divide(10, 5), 2)

    def test_remainder(self):
        self.assertEqual(numCal.remainder(10, 5), 0)


if __name__ == "__main__":
    unittest.main()

Je nach Funktion sollten wir den Namen der Testmethode ändern.

Ausgang:

Der schwierige Teil hier ist, dass der Wert für jede Funktion in jeder Testmethode eingestellt werden muss. Es wird ein Problem, wenn wir Hunderte von Testmethoden haben.

Wenn die Werte geändert werden müssen, müssen wir jede Testmethode überprüfen und ändern.

Wir können die Funktion setup() bauen, um dies zu überwinden. Durch diese Methode müssen wir die Werte nur einmal deklarieren. Dann wird es vor jeder Methode ausgeführt.

Erstellen Sie die Funktion setUp()

def setUp(self):
    print("\nsetUp")
    self.num1 = 10
    self.num2 = 5

Nach dem Einrichten der Funktion setup() müssen auch die Argumente für die Funktionen geändert werden. Als erstes ändern wir die Methode test_add.

def test_add(self):
    print("Add")
    self.assertEqual(numCal.add(self.num1, self.num2), 15)

Wie oben erwähnt, können wir die Änderungen an den verbleibenden Methoden vornehmen, und unser vollständiger Code sollte wie unten aussehen.

Vollständiger Code:

import unittest
import numCal


class TestNumCal(unittest.TestCase):
    def setUp(self):
        print("\nsetUp")
        self.num1 = 10
        self.num2 = 5

    def test_add(self):
        print("Add")
        self.assertEqual(numCal.add(self.num1, self.num2), 15)

    def test_subtract(self):
        print("Subtract")
        self.assertEqual(numCal.subtract(self.num1, self.num2), 5)

    def test_multiply(self):
        print("Multiply")
        self.assertEqual(numCal.multiply(self.num1, self.num2), 50)

    def test_divide(self):
        print("Divide")
        self.assertEqual(numCal.divide(self.num1, self.num2), 2)

    def test_remainder(self):
        print("remainder")
        self.assertEqual(numCal.remainder(self.num1, self.num2), 0)


if __name__ == "__main__":
    unittest.main()

Ausgang:

In der Ausgabe geben fünf Punkte an, dass die Tests bestanden wurden, und die Anzahl der ausgeführten Tests. Darunter wurden die Werte vor jedem Test eingestellt; Um das zu erkennen, haben wir print()-Funktionen eingefügt.

Bevor also die Testmethoden starten, führt die Funktion setup() die definierten Anweisungen aus, und die Tests finden mit ihnen statt.

Abschluss

In diesem Artikel haben wir gelernt, was Unit-Tests und das unittest-Framework sind und wie man ein Testmodul erstellt. Am wichtigsten ist, dass wir gelernt haben, wie man die Funktion setup() verwendet, um einige definierte Anweisungen festzulegen, die vor jeder Testmethode ausgeführt werden sollen.

Die Funktion setup() ist praktisch, wenn viele Tests ausgeführt werden müssen und wenn wir die Werte für die Argumente ändern müssen.