Kein guter Entwickler stellt Code ohne gründliche Tests bereit. Unit-Tests sind der Prozess des Testens der einzelnen Module eines großen Programms.
In diesem Artikel wird erläutert, wie Sie Komponententests Ihres Codes mit dem Python-Unittest-Modul durchführen können. Lassen Sie uns zunächst verstehen, welche Arten von Tests es gibt.
Beim Testen gibt es manuelles Testen und automatisches Testen. Manuelles Testen ist eine Testtechnik, bei der Menschen den Test nach Abschluss der Entwicklung manuell durchführen. Automatisierungstests sind eine Testtechnik, bei der Programme den Test automatisch durchführen und uns die Ergebnisse liefern.
Sie hätten verstanden, dass manuelles Testen zeitaufwändig und schwer durchzuführen ist. Die Entwickler schreiben also Code zum Durchführen von Tests (automatisches Testen). Beim automatisierten Testen gibt es verschiedene Arten von Tests. Einige davon sind Unit-Tests, Integrationstests, End-to-End-Tests, Stresstests usw.
Sehen wir uns den Standardablauf des Testens an.
- Schreiben oder aktualisieren Sie den Code.
- Schreiben oder aktualisieren Sie Tests für verschiedene Fälle für Ihren Code.
- Führen Sie die Tests durch (entweder manuell oder mit einem Testrunner).
- Sehen Sie sich die Testergebnisse an. Wenn es Fehler gibt, beheben Sie diese und wiederholen Sie die Schritte.
Hier werden wir den wichtigsten und grundlegendsten Testtyp namens Unit-Tests besprechen. Lassen Sie uns ohne weiteres in das eigentliche Tutorial eintauchen.
Inhaltsverzeichnis
Was ist Unit-Testing?
Unit-Tests sind eine Technik zum Testen eines kleinen Blocks unabhängigen Codes. Der Small-Block-Code wird in den meisten Fällen eine Funktion sein. Das Wort unabhängig bedeutet, dass es nicht von anderen Codeteilen im Projekt abhängt.
Nehmen wir an, wir müssen prüfen, ob ein String gleich „wdzwdz“ ist oder nicht. Dafür haben wir eine Funktion geschrieben, die ein Argument akzeptiert und zurückgibt, ob es gleich „wdzwdz“ ist oder nicht.
def is_equal_to_geekflare(string): return string == "wdzwdz"
Die obige Funktion hat keine Abhängigkeiten von anderem Code. Wir können es also unabhängig testen, indem wir verschiedene Eingaben machen. Das unabhängige Stück Code kann im gesamten Projekt verwendet werden.
Bedeutung von Unit-Tests
Generell kann der Independent Blocks Code projektweit verwendet werden. Es muss also gut geschrieben und getestet sein. Unit-Tests sind die Tests, die verwendet werden, um diese Arten von unabhängigen Codeblöcken zu testen. Was passiert, wenn wir für unser Projekt keine Komponententests verwenden?
Nehmen wir an, wir haben keine kleinen Codeblöcke getestet, die im gesamten Projekt verwendet werden. Alle anderen Tests wie Integrationstests, End-to-End-Tests usw., die die anderen kleinen Codeblöcke verwenden, können fehlschlagen. Dadurch wird die Anwendung unterbrochen. Deshalb müssen die Grundbausteine des Codes gut getestet werden.
Jetzt wissen wir, wie wichtig Unit-Tests und schriftliche Unit-Tests für alle unabhängigen Codeblöcke sind. Da wir Unit-Tests durchgeführt haben, werden andere Tests wie Integrationstests, End-to-End-Tests usw. aufgrund des unabhängigen Codeblocks nicht fehlschlagen.
In den kommenden Abschnitten werden wir sehen, was das Python-Unittest-Modul ist und wie wir das Unittest-Modul verwenden, um Unit-Tests in Python zu schreiben.
Hinweis: Wir gehen davon aus, dass Sie mit Python-Klassen, -Modulen usw. vertraut sind. Wenn Sie mit Python-Zwischenkonzepten wie Klassen, Modulen usw. nicht vertraut sind, werden Sie möglicherweise Schwierigkeiten haben, die folgenden Abschnitte zu verstehen.
Was ist Python-Unittest?
Python unittest ist ein integriertes Testframework zum Testen von Python-Code. Es verfügt über einen Testrunner, der es uns ermöglicht, die Tests ohne großen Aufwand durchzuführen. So können wir das eingebaute Unittest-Modul zum Testen verwenden, ohne die Module von Drittanbietern zu verwenden. Aber es ändert sich je nach Ihren Anforderungen. Das eingebaute Unittest-Modul ist gut, um mit dem Testen in Python zu beginnen.
Wir müssen die folgenden Schritte ausführen, um den Python-Code mit dem Unittest-Modul zu testen.
#1. Schreiben Sie den Code.
#2. Importieren Sie das Unittest-Modul.
#3. Erstellen Sie eine Datei, die mit dem Schlüsselwort test beginnt. Zum Beispiel test_prime.py. Das Schlüsselwort test wird verwendet, um die Testdateien zu identifizieren.
#4. Erstellen Sie eine Klasse, die die Klasse unittest.TestCase erweitert.
#5. Schreiben Sie Methoden (Tests) innerhalb der Klasse. Jede Methode enthält verschiedene Testfälle basierend auf Ihren Anforderungen. Wir müssen die Methode beginnend mit dem Schlüsselwort test benennen.
#6. Führen Sie die Tests durch. Wir können die Tests auf verschiedene Arten durchführen.
- Führen Sie den Befehl python -m unittest test_filename.py aus.
- Wir führen die Testdateien wie allgemeine Python-Dateien mit dem Befehl python test_filename.py aus. Damit diese Methode funktioniert, müssen wir die Hauptmethode von unittest in der Testdatei aufrufen.
- Und schließlich die Verwendung von discover. Wir können die Tests mit dem Befehl python -m unittest discover automatisch ausführen, ohne den Dateinamen des Tests zu erwähnen. Es findet die Tests anhand der von uns befolgten Namenskonvention. Daher müssen wir unsere Testdateien zu Beginn mit dem Schlüsselwort test benennen.
Im Allgemeinen vergleichen wir beim Testen die Ausgabe des Codes mit der erwarteten Ausgabe. Um die Ausgaben zu vergleichen, bietet unittest also verschiedene Methoden. Sie finden die Liste der Vergleichsfunktionen hier.
Sie können sie ohne Schwierigkeiten leicht verstehen. Sie sind unkompliziert.
Das ist viel Theorie. Wir müssen jetzt in die Codierung einsteigen.
Hinweis: Wenn Sie Fragen zum Unittest-Modul haben, können Sie zu gehen Dokumentation und räumen Sie Ihre Zweifel aus. Lassen Sie uns ohne weitere Verzögerung das Unittest-Modul verwenden.
Komponententests in Python mit unittest
Wir werden zuerst einige Funktionen schreiben und uns dann auf das Schreiben der Tests konzentrieren. Öffnen Sie zunächst einen Ordner in Ihrem bevorzugten Code-Editor. Und erstellen Sie eine Datei namens utils.py. Fügen Sie den folgenden Code in die Datei ein.
import math
def is_prime(n):
if n < 0:
return 'Negative numbers are not allowed'
if n <= 1:
return False
if n == 2:
return True
if n % 2 == 0:
return False
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return False
return True
def cubic(a):
return a * a * a
def say_hello(name):
return "Hello, " + name
Wir haben drei verschiedene Funktionen in der Datei utils.py. Nun müssen wir jede Funktion mit verschiedenen Testfällen testen. Lassen Sie uns die Tests für die erste Funktion is_prime schreiben.
#1. Erstellen Sie eine Datei namens test_utils.py im Beispielordner als utils.py.
#2. Importieren Sie die Module utils und unittest.
#3. Erstellen Sie eine Klasse mit dem Namen TestUtils, die die Klasse unittest.TestCase erweitert. Der Name der Klasse kann beliebig sein. Versuchen Sie, der Klasse einen aussagekräftigen Namen zu geben.
#4. Schreiben Sie innerhalb der Klasse eine Methode namens test_is_prime, die self als Argument akzeptiert.
#5. Schreiben Sie verschiedene Testfälle mit Argumenten in is_prime und vergleichen Sie die Ausgabe mit der erwarteten Ausgabe.
#6. Beispieltestfall self.assertFalse(utils.is_prime(1)).
#7. Wir erwarten, dass die Ausgabe von is_prime(1) im obigen Fall falsch sein wird.
#8. Ähnlich wie im obigen Fall werden wir verschiedene Testfälle basierend auf der Funktion, die wir testen, durchführen.
Sehen wir uns die Tests an.
import unittest
import utils
class TestUtils(unittest.TestCase):
def test_is_prime(self):
self.assertFalse(utils.is_prime(4))
self.assertTrue(utils.is_prime(2))
self.assertTrue(utils.is_prime(3))
self.assertFalse(utils.is_prime(8))
self.assertFalse(utils.is_prime(10))
self.assertTrue(utils.is_prime(7))
self.assertEqual(utils.is_prime(-3),
"Negative numbers are not allowed")
if __name__ == '__main__':
unittest.main()
Wir rufen die Hauptmethode unittest des Moduls auf, um die Tests mit dem Befehl python filename.py auszuführen. Führen Sie nun die Tests durch.
Sie sehen eine Ausgabe, die der folgenden Ausgabe ähnelt.
$ python test_utils.py . ---------------------------------------------------------------------- Ran 1 test in 0.001s OK
Versuchen Sie nun, die Testfälle auch für andere Funktionen zu schreiben. Denken Sie sich verschiedene Fälle für die Funktionen aus und schreiben Sie Tests dafür. Werfen Sie einen Blick auf die folgenden Tests, die der oben genannten Klasse hinzugefügt wurden.
...
class TestUtils(unittest.TestCase):
def test_is_prime(self):
...
def test_cubic(self):
self.assertEqual(utils.cubic(2), 8)
self.assertEqual(utils.cubic(-2), -8)
self.assertNotEqual(utils.cubic(2), 4)
self.assertNotEqual(utils.cubic(-3), 27)
def test_say_hello(self):
self.assertEqual(utils.say_hello("wdzwdz"), "Hello, wdzwdz")
self.assertEqual(utils.say_hello("Chandan"), "Hello, Chandan")
self.assertNotEqual(utils.say_hello("Chandan"), "Hi, Chandan")
self.assertNotEqual(utils.say_hello("Hafeez"), "Hi, Hafeez")
...
Wir haben nur einige der Vergleichsfunktionen aus dem Unittest-Modul verwendet. Sie finden die vollständige Liste hier.
Wir haben gelernt, wie man Unit-Tests mit dem Unittest-Modul schreibt. Jetzt ist es an der Zeit, verschiedene Möglichkeiten zum Ausführen der Tests zu sehen.
So führen Sie Tests mit unittest durch
Wir haben bereits eine Möglichkeit gesehen, die Testfälle im obigen Abschnitt auszuführen. Sehen wir uns die beiden anderen Möglichkeiten an, die Tests mit dem Unittest-Modul auszuführen.
#1. Verwenden des Dateinamens und des Unittest-Moduls.
Bei dieser Methode verwenden wir das Unittest-Modul und den Dateinamen, um die Tests auszuführen. Der Befehl zum Ausführen der Tests lautet python -m unittest filename.py. In unserem Fall lautet der Befehl zum Ausführen der Tests python -m unittest test_utils.py.
#2. Mit der Discover-Methode
Wir werden die Discover-Methode des Unittest-Moduls verwenden, um alle Testdateien automatisch zu erkennen und auszuführen. Um die Testdateien automatisch zu erkennen, müssen wir sie beginnend mit dem Schlüsselwort test benennen.
Der Befehl zum Ausführen der Tests mit der Discover-Methode lautet python -m unittest discover. Der Befehl erkennt alle Dateien, deren Namen mit test beginnen, und führt sie aus.
Fazit 👩💻
Unit-Tests sind grundlegende Tests in der Programmierwelt. Es gibt viele andere Tests in der realen Welt. Versuchen Sie, sie nacheinander zu lernen. Ich hoffe, dieses Tutorial hilft Ihnen beim Schreiben grundlegender Tests in Python mit dem Modul unittest. Es gibt Bibliotheken von Drittanbietern wie pytest, Robot Framework, Nase, Nase2, Schrägstrich usw. Sie können sie basierend auf Ihren Projektanforderungen erkunden.
Viel Spaß beim Testen 😎
Sie könnten auch an Fragen und Antworten zu Python-Interviews interessiert sein.