Geekly articles weekly

Vertrautheit mit dem Testen in Python. Teil 1

Guten Tag an alle!

Von unserem Tisch zu Ihrem ... Das heißt, aus unserem Kurs "Python Developer" haben wir trotz des sich schnell nähernden neuen Jahres eine interessante Übersetzung für Sie über verschiedene Testmethoden in Python vorbereitet.

Dieses Handbuch richtet sich an Benutzer, die bereits eine coole Python-Anwendung geschrieben haben, für die sie jedoch noch nicht geschrieben haben
sie Tests.

Das Testen in Python ist ein umfangreiches Thema mit einer Reihe von Feinheiten, aber es ist nicht notwendig, die Dinge zu komplizieren. In wenigen einfachen Schritten können Sie einfache Tests für die Anwendung erstellen und die Komplexität basierend auf diesen schrittweise erhöhen.

In diesem Handbuch erfahren Sie, wie Sie einen Basistest erstellen, ausführen und alle Fehler finden, bevor Benutzer dies tun! Sie lernen die verfügbaren Tools zum Schreiben und Ausführen von Tests kennen, überprüfen die Anwendungsleistung und sehen sich sogar Sicherheitsprobleme an.



Codetests

Sie können den Code auf viele Arten testen. In diesem Handbuch lernen Sie die Methoden von den einfachsten bis zu den fortgeschrittensten kennen.

Automatisiert vs. Manuelles Testen

Gute Neuigkeiten! Höchstwahrscheinlich haben Sie den Test bereits durchgeführt, ihn aber noch nicht realisiert. Erinnern Sie sich, wie Sie die Anwendung zum ersten Mal gestartet und verwendet haben? Haben Sie die Funktionen getestet und damit experimentiert? Dieser Prozess wird als Erkundungstest bezeichnet und ist eine Form des manuellen Testens.

Forschungstests - Tests, die ohne Plan durchgeführt werden. Während der Forschungstests recherchieren Sie die Anwendung.

Um eine vollständige Liste manueller Tests zu erstellen, reicht es aus, eine Liste aller Funktionen der Anwendung, der verschiedenen Arten von Eingaben, die sie akzeptiert, und der erwarteten Ergebnisse zu erstellen. Jedes Mal, wenn Sie etwas im Code ändern, müssen Sie jedes der Elemente in dieser Liste erneut überprüfen.

Klingt düster, oder?

Daher sind automatische Tests erforderlich. Automatisches Testen - Die Ausführung des Testplans (Teile der Anwendung, die getestet werden müssen, die Reihenfolge der Tests und die erwarteten Ergebnisse) mithilfe eines Skripts und nicht von Menschenhand. Python verfügt bereits über eine Reihe von Tools und Bibliotheken, mit denen Sie automatisierte Tests für Ihre Anwendung erstellen können. Schauen wir uns diese Tools und Bibliotheken in unserem Tutorial an.

Unit Tests VS. Integrationstests

Die Welt des Testens ist voller Begriffe, und jetzt, da wir den Unterschied zwischen manuellen und automatisierten Tests kennen, werden wir eine Ebene tiefer gehen.

Überlegen Sie, wie Sie die Scheinwerfer eines Autos testen können? Sie schalten die Scheinwerfer ein (nennen wir es den Testschritt), steigen selbst aus dem Auto oder bitten einen Freund, zu überprüfen, ob die Scheinwerfer leuchten (und dies ist ein Testvorschlag). Das Testen mehrerer Komponenten wird als Integrationstest bezeichnet.

Denken Sie an alle Dinge, die richtig funktionieren sollten, damit eine einfache Aufgabe das richtige Ergebnis liefert. Diese Komponenten ähneln Teilen Ihrer Anwendung: all die Klassen, Funktionen und Module, die Sie geschrieben haben.

Die Hauptschwierigkeit beim Integrationstest tritt auf, wenn der Integrationstest nicht das richtige Ergebnis liefert. Es ist schwierig, das Problem zu bewerten, da der defekte Teil des Systems nicht isoliert werden kann. Wenn die Scheinwerfer nicht leuchten, sind die Lampen möglicherweise defekt. Oder ist die Batterie schwach? Oder liegt das Problem vielleicht im Generator? Oder sogar ein Absturz im Computer der Maschine?

Moderne Autos selbst werden Sie über eine kaputte Glühbirne informieren. Dies wird mit einem Unit-Test ermittelt.

Der Unit-Test (Unit-Test) ist ein kleiner Test, der den korrekten Betrieb einer einzelnen Komponente überprüft. Der Komponententest hilft dabei, die Störung zu isolieren und schneller zu beheben.

Wir haben über zwei Arten von Tests gesprochen:

  1. Ein Integrationstest, der die Komponenten des Systems und ihre Interaktion miteinander überprüft.
  2. Ein Komponententest, der eine einzelne Komponente einer Anwendung testet.
  3. Sie können beide Tests in Python erstellen. Um einen Test für die integrierte Funktion sum () zu schreiben, müssen Sie die Ausgabe von sum () mit bekannten Werten vergleichen.

Auf diese Weise können Sie beispielsweise überprüfen, ob die Summe der Zahlen (1, 2, 3) 6 beträgt:

>>> assert sum([1, 2, 3]) == 6, "Should be 6"

Die Werte sind korrekt, daher wird nichts an REPL ausgegeben. Wenn das Ergebnis von sum() falsch ist, wird ein AssertionError mit der Meldung "Sollte 6 sein" AssertionError . Überprüfen Sie die Anweisungsanweisung erneut, jetzt jedoch mit ungültigen Werten, um einen AssertionError :

 >>> assert sum([1, 1, 1]) == 6, "Should be 6" Traceback (most recent call last): File "<stdin>", line 1, in <module> AssertionError: Should be 6

In REPL wird AssertionError angezeigt, da der Wert sum() nicht 6 ist.

test_sum.py Sie dies anstelle von REPL in eine neue Python-Datei mit dem Namen test_sum.py und führen Sie es erneut aus:

 def test_sum(): assert sum([1, 2, 3]) == 6, "Should be 6" if __name__ == "__main__": test_sum() print("Everything passed")

Jetzt haben Sie einen schriftlichen Testfall (Testfall), eine Anweisung und einen Einstiegspunkt (Befehlszeile). Dies kann nun über die Befehlszeile erfolgen:

 $ python test_sum.py Everything passed

Sie sehen das erfolgreiche Ergebnis „Alles bestanden“.

sum() in Python akzeptiert jedes iterable als erstes Argument. Sie haben die Liste überprüft. Versuchen wir, das Tupel zu testen. Erstellen Sie eine neue Datei mit dem Namen test_sum_2.py mit dem folgenden Code:

 def test_sum(): assert sum([1, 2, 3]) == 6, "Should be 6" def test_sum_tuple(): assert sum((1, 2, 2)) == 6, "Should be 6" if __name__ == "__main__": test_sum() test_sum_tuple() print("Everything passed")

test_sum_2.py , gibt das Skript test_sum_2.py Fehler aus, da s um() (1, 2, 2) 5 und nicht 6 sein sollte. Als Ergebnis gibt das Skript eine Fehlermeldung, eine Codezeile und einen Traceback aus:

 $ python test_sum_2.py Traceback (most recent call last): File "test_sum_2.py", line 9, in <module> test_sum_tuple() File "test_sum_2.py", line 5, in test_sum_tuple assert sum((1, 2, 2)) == 6, "Should be 6" AssertionError: Should be 6

Sie können sehen, wie ein Fehler im Code einen Fehler in der Konsole verursacht, mit Informationen darüber, wo er aufgetreten ist und was das erwartete Ergebnis war.

Solche Tests eignen sich zur einfachen Überprüfung, aber was ist, wenn mehr Fehler als in einem vorhanden sind? Testläufer kommen zur Rettung. Test Executor ist eine spezielle Anwendung, mit der Tests durchgeführt, Ausgabedaten überprüft und Tools zum Debuggen und Diagnostizieren von Tests und Anwendungen bereitgestellt werden können.

Auswahl eines Test Executors

Für Python stehen viele Testläufer zur Verfügung. Zum Beispiel ist unittest in die Python-Standardbibliothek integriert. In diesem Handbuch werden Testfälle und unittest Test Executors verwendet. Unittest-Funktionsprinzipien können leicht an andere Frameworks angepasst werden. Wir listen die beliebtesten Testausführenden auf:

  • unittest;
  • Nase oder Nase2;
  • pytest.

Es ist wichtig, einen Testunternehmer zu wählen, der Ihren Anforderungen und Erfahrungen entspricht.

unittest

unittest ist seit Version 2.1 in die Python-Standardbibliothek integriert. Sie werden wahrscheinlich in kommerziellen Python-Anwendungen und Open Source-Projekten darauf stoßen.
Unittest hat ein Testframework und einen Testläufer. Beim Schreiben und Ausführen von Tests müssen Sie einige wichtige Anforderungen erfüllen.

unittest erfordert:

  • Setzen Sie Tests in Klassen als Methoden ein;
  • Verwenden Sie spezielle Genehmigungsmethoden. Die TestCase-Klasse anstelle des üblichen integrierten Assert-Ausdrucks.


Um ein zuvor geschriebenes Beispiel in einen unittest Testfall zu verwandeln, müssen Sie:

  1. Unittest aus der Standardbibliothek importieren;
  2. Erstellen Sie eine Klasse namens TestSum , die die TestCase Klasse erbt.
  3. Konvertieren Sie Testfunktionen in Methoden, indem Sie als erstes Argument self hinzufügen.
  4. Ändern Sie Anweisungen, indem Sie die Verwendung der self.assertEqual() -Methode in der TestCase Klasse TestCase .
  5. Ändern Sie den Einstiegspunkt in der Befehlszeile, um unittest.main() aufzurufen.

Erstellen Sie nach diesen Schritten eine neue Datei test_sum_unittest.py mit diesem Code:

 import unittest class TestSum(unittest.TestCase): def test_sum(self): self.assertEqual(sum([1, 2, 3]), 6, "Should be 6") def test_sum_tuple(self): self.assertEqual(sum((1, 2, 2)), 6, "Should be 6") if __name__ == '__main__': unittest.main()

Wenn Sie dies in der Befehlszeile tun, erhalten Sie einen erfolgreichen Abschluss (angezeigt durch.) Und einen erfolglosen Abschluss (angezeigt durch F):

 $ python test_sum_unittest.py .F ====================================================================== FAIL: test_sum_tuple (__main__.TestSum) ---------------------------------------------------------------------- Traceback (most recent call last): File "test_sum_unittest.py", line 9, in test_sum_tuple self.assertEqual(sum((1, 2, 2)), 6, "Should be 6") AssertionError: Should be 6 ---------------------------------------------------------------------- Ran 2 tests in 0.001s FAILED (failures=1)

Daher haben Sie zwei Tests mit dem unittest Test Runner durchgeführt.

Hinweis: Wenn Sie Testfälle für Python 2 und 3 schreiben, seien Sie vorsichtig. In Versionen von Python 2.7 und niedriger wird unittest als unittest 2 bezeichnet. Wenn Sie aus unittest importieren, erhalten Sie verschiedene Versionen mit unterschiedlichen Funktionen in Python 2 und Python 3.

Lesen Sie die Dokumentation zu unittest, um mehr über unittest zu erfahren.

Nase

Mit der Zeit wird es nach dem Schreiben von Hunderten oder sogar Tausenden von Tests für eine Anwendung immer schwieriger, unitteste Ausgabedaten zu verstehen und zu verwenden.

Die Nase ist mit allen Tests kompatibel, die mit einem unittest Framework geschrieben wurden, und kann den Test Executor ersetzen. Die Entwicklung von Nase als Open-Source-Anwendung begann sich zu verlangsamen, und Nase2 wurde erstellt. Wenn Sie bei Null anfangen, wird empfohlen, Nase2 zu verwenden.

Um mit Nase2 zu beginnen, müssen Sie es von PyPl installieren und in der Befehlszeile ausführen. nas2 versucht, alle Testskripte mit test*.py im Namen und alle von unittest.TestCase geerbten Testfälle in Ihrem aktuellen Verzeichnis zu finden:

 $ pip install nose2 $ python -m nose2 .F ====================================================================== FAIL: test_sum_tuple (__main__.TestSum) ---------------------------------------------------------------------- Traceback (most recent call last): File "test_sum_unittest.py", line 9, in test_sum_tuple self.assertEqual(sum((1, 2, 2)), 6, "Should be 6") AssertionError: Should be 6 ---------------------------------------------------------------------- Ran 2 tests in 0.001s FAILED (failures=1)

Auf diese Weise wird der in test_sum_unittest.py erstellte Test vom test_sum_unittest.py . nas2 bietet viele Befehlszeilenflags zum Filtern ausführbarer Tests. Weitere Informationen finden Sie in der Dokumentation zu Nose 2 .

pytest

pytest unterstützt unittest Testfälle. Der eigentliche Vorteil von pytest sind jedoch die Testfälle. Die Pytest-Testfälle sind eine Reihe von Funktionen in einer Python-Datei mit test_ am Anfang des Namens.

Es gibt noch weitere nützliche Funktionen:

  • Unterstützung für integrierte Assert-Ausdrücke anstelle der Verwendung spezieller self.assert * () -Methoden;
  • Unterstützung für das Filtern von Testfällen;
  • Die Möglichkeit, nach dem letzten fehlgeschlagenen Test neu zu starten.
  • Ein Ökosystem aus Hunderten von Plugins, die die Funktionalität erweitern.

Ein Beispiel für einen TestSum-Testfall für Pytest sieht folgendermaßen aus:

 def test_sum(): assert sum([1, 2, 3]) == 6, "Should be 6" def test_sum_tuple(): assert sum((1, 2, 2)) == 6, "Should be 6"

Sie haben TestCase mithilfe von Klassen und Befehlszeilen-Einstiegspunkten entfernt.
Weitere Informationen finden Sie auf der Pytest-Dokumentationsseite .

Den ersten Test schreiben

Kombinieren Sie alles, was wir bereits gelernt haben, und testen Sie anstelle der integrierten Funktion sum() eine einfache Implementierung mit denselben Anforderungen.

Erstellen Sie einen neuen Ordner für das Projekt, in dem Sie einen neuen Ordner mit dem Namen my_sum erstellen. Erstellen Sie in my_sum eine leere Datei mit dem Namen _init_.py . Das Vorhandensein dieser Datei bedeutet, dass der Ordner my_sum als Modul aus dem übergeordneten Verzeichnis importiert werden kann.

Die Ordnerstruktur sieht folgendermaßen aus:

project/
│
└── my_sum/
└── __init__.py

Öffnen Sie my_sum/__init__.py und erstellen Sie eine neue Funktion namens sum() , die my_sum/__init__.py Eingaben (Liste, Tupel, Menge) übernimmt und die Werte hinzufügt.

 def sum(arg): total = 0 for val in arg: total += val return total

In diesem Beispiel wird eine Variable namens total , alle Werte in arg und zur total addiert. Nach Abschluss der Iteration wird das Ergebnis zurückgegeben.

Wo schreibe ich einen Test?

Sie können mit dem Schreiben eines Tests beginnen, indem Sie eine test.py Datei erstellen, die Ihren ersten Testfall enthält. Zum Testen sollte die Datei in der Lage sein, Ihre Anwendung zu importieren. test.py Sie daher test.py in den Ordner über dem Paket. Der Verzeichnisbaum sieht folgendermaßen aus:

project/
│
├── my_sum/
│ └── __init__.py
|
└── test.py

Sie werden feststellen, dass Ihre Datei beim Hinzufügen neuer Tests umständlicher und schwieriger zu warten ist. Wir empfehlen daher, den Ordner " tests/ erstellen und die Tests in mehrere Dateien aufzuteilen. test_ Sie sicher, dass die Namen aller Dateien mit test_ beginnen, damit Testläufer verstehen, dass Python-Dateien Tests enthalten, die ausgeführt werden müssen. Bei großen Projekten werden Tests je nach Zweck oder Verwendung in mehrere Verzeichnisse unterteilt.

Hinweis: Und was ist Ihre Anwendung ist ein einzelnes Skript?
Sie können beliebige __import__() importieren: Klassen, Funktionen oder Variablen mit der integrierten Funktion __import__() . Anstelle from my_sum import sum schreiben Sie Folgendes:

 target = __import__("my_sum.py") sum = target.sum

Wenn Sie __import__() Sie den Projektordner nicht in ein Paket verwandeln, und Sie können den Dateinamen angeben. Dies ist nützlich, wenn der Dateiname mit den Namen der Standardpaketbibliotheken in Konflikt steht. Zum Beispiel, wenn math.py mit dem Mathematikmodul in Konflikt steht.

So strukturieren Sie einen einfachen Test

Bevor Sie Tests schreiben, müssen Sie einige Fragen lösen:

  1. Was möchten Sie testen?
  2. Schreiben Sie einen Unit-Test oder einen Integrationstest?

Sie testen derzeit sum() . Sie können verschiedene Verhaltensweisen dafür testen, zum Beispiel:

  • Ist es möglich, eine Liste von ganzen Zahlen zusammenzufassen?
  • Ist es möglich, ein Tupel oder eine Menge zusammenzufassen?
  • Kann ich eine Liste von Gleitkommazahlen zusammenfassen?
  • Was passiert, wenn Sie der Eingabe einen schlechten Wert geben: eine einzelne Ganzzahl oder eine Zeichenfolge?
  • Was passiert, wenn einer der Werte negativ ist?

Der einfachste Weg zum Testen ist eine Liste von ganzen Zahlen. Erstellen Sie eine test.py Datei mit dem folgenden Code:

 import unittest from my_sum import sum class TestSum(unittest.TestCase): def test_list_int(self): """ Test that it can sum a list of integers """ data = [1, 2, 3] result = sum(data) self.assertEqual(result, 6) if __name__ == '__main__': unittest.main()

Der Code in diesem Beispiel:

  • Importiert sum() aus dem von Ihnen erstellten Paket my_sum() .
  • Definiert eine neue Testfallklasse namens TestSum, die unittest.TestCase erbt.
  • Definiert eine Testmethode .test_list_int() zum Testen einer Ganzzahlliste. Die Methode .test_list_int() führt die folgenden .test_list_int()
::
  1. Deklariert eine Datenvariable mit einer Liste von Werten (1, 2, 3) ;
  2. my_sum.sum(data) Wert my_sum.sum(data) variable result .
  3. Bestimmt, dass der Wert des Ergebnisses 6 ist, indem die Methode .assertEqual() für die Klasse .assertEqual() .

  • Definiert einen Befehlszeilen-Einstiegspunkt, der den .main() startet.

Wenn Sie nicht wissen, was self ist oder wie .assertEqual() definiert ist, können Sie Ihr Wissen über objektorientierte Programmierung mit Python 3 Object-Oriented Programming auffrischen.

Wie schreibe ich Anweisungen

Der letzte Schritt beim Schreiben eines Tests besteht darin, zu überprüfen, ob die Ausgabe mit bekannten Werten übereinstimmt. Dies wird als Behauptung bezeichnet. Es gibt mehrere allgemeine Richtlinien zum Schreiben von Aussagen:

  • Stellen Sie sicher, dass die Tests wiederholbar sind, und führen Sie sie mehrmals aus, um sicherzustellen, dass sie jedes Mal die gleichen Ergebnisse liefern.
  • Überprüfen und bestätigen Sie die Ergebnisse, die für Ihre Eingabe gelten. Stellen Sie sicher, dass das Ergebnis tatsächlich die Summe der Werte im Beispiel sum() .

Unittest verfügt über viele Methoden zum Bestätigen der Werte, Typen und Existenz von Variablen. Hier sind einige der am häufigsten verwendeten Methoden:

MethodeÄquivalent
.assertEqual (a, b)a == b
.assertTrue (x)bool (x) ist wahr
.assertFalse (x)bool (x) ist falsch
.assertIs (a, b)a ist b
.assertIsNone (x)x ist Keine
.assertIn (a, b)a in b
.assertIsInstance (a, b)isinstance (a, b)


.assertIs() , .assertIsNone() , .assertIn() und .assertIsInstance() haben entgegengesetzte Methoden, die als .assertIsNot() usw. bezeichnet werden.

Nebenwirkungen

Das Schreiben von Tests ist schwieriger als nur das Betrachten des Rückgabewerts einer Funktion. Durch die Codeausführung werden häufig andere Teile der Umgebung geändert: Klassenattribute, Dateisystemdateien, Werte in der Datenbank. Dies ist ein wichtiger Teil des Testens, der als Nebenwirkungen bezeichnet wird. Entscheiden Sie, ob Sie eine Nebenwirkung testen, bevor Sie sie in Ihre Schadensliste aufnehmen.

Wenn Sie feststellen, dass der Codeblock, den Sie testen möchten, viele Nebenwirkungen aufweist, verstoßen Sie gegen das Prinzip der alleinigen Verantwortung . Ein Verstoß gegen das Prinzip der alleinigen Verantwortung bedeutet, dass ein Code zu viele Dinge tut und ein Refactoring erfordert. Das Befolgen des Prinzips der alleinigen Verantwortung ist eine hervorragende Möglichkeit, Code zu entwerfen, für den es nicht schwierig sein wird, einfache, wiederholbare Komponententests zu schreiben und letztendlich zuverlässige Anwendungen zu erstellen.

Start des ersten Tests

Sie haben den ersten Test erstellt und müssen nun versuchen, ihn auszuführen. Es ist klar, dass es bestanden wird, aber bevor Sie komplexere Tests erstellen, müssen Sie sicherstellen, dass auch solche Tests erfolgreich sind.

Ausführen von Test Executors

Test Executor - Eine Python-Anwendung, die Testcode ausführt, Zusicherungen überprüft und Testergebnisse in der Konsole anzeigt. Fügen Sie am Ende von test.py diesen kleinen Code hinzu:

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

Dies ist der Einstiegspunkt für die Befehlszeile. Wenn Sie dieses Skript ausführen, indem Sie python test.py in der Befehlszeile unittest.main() , wird unittest.main() aufgerufen. Dadurch wird der Testläufer unittest.TestCase alle Klassen in dieser Datei unittest.TestCase werden, die von unittest.TestCase erben.

Dies ist eine von vielen Möglichkeiten, um den unittest Test Runner auszuführen. Wenn Sie eine einzelne Testdatei mit dem Namen test.py , ist der Aufruf von python test.py eine gute Möglichkeit, um loszulegen.

Eine andere Möglichkeit besteht darin, die unittest-Befehlszeile zu verwenden. Versuchen wir mal:

 $ python -m unittest test

Dadurch wird dasselbe Testmodul ( test ) über die Befehlszeile ausgeführt. Sie können zusätzliche Parameter hinzufügen, um die Ausgabe zu ändern. Einer von ihnen ist -v für ausführlich. Versuchen wir Folgendes:

 $ python -m unittest -v test test_list_int (test.TestSum) ... ok ---------------------------------------------------------------------- Ran 1 tests in 0.000s

Wir haben einen Test von test.py ausgeführt und die Ergebnisse an die Konsole ausgegeben. Im ausführlichen Modus wurden die Namen der durchgeführten Tests und die Ergebnisse der einzelnen Tests aufgelistet.

Anstatt den Namen des Moduls anzugeben, das die Tests enthält, können Sie die automatische Erkennung wie folgt anfordern:

 $ python -m unittest discover

Dieser Befehl sucht im aktuellen Verzeichnis nach Dateien mit dem Namen test*.py im Namen, um sie zu testen.

Wenn Sie mehrere Testdateien haben und dem test*.py folgen, können Sie den Verzeichnisnamen mit dem Flag -s und dem Ordnernamen übergeben.

 $ python -m unittest discover -s tests

unittest führt alle Tests in einem einzigen Testplan aus und erstellt die Ergebnisse.
Wenn sich Ihr Quellcode nicht im Stammverzeichnis befindet, sondern in einem Unterverzeichnis, z. B. in einem Ordner namens src /, können Sie unittest mit dem Flag -t mitteilen, wo die Tests ausgeführt werden sollen, um die Module korrekt zu importieren:

 $ python -m unittest discover -s tests -t src

unittest findet alle test*.py Dateien im Verzeichnis src/ in tests und führt sie dann aus.

Testergebnisse verstehen

Dies war ein sehr einfaches Beispiel, bei dem alles gut lief. Versuchen wir also, die Ausgabe eines fehlgeschlagenen Tests zu verstehen.

sum() muss andere Listen eines numerischen Typs akzeptieren, z. B. Brüche.

test.py am Anfang des Codes in test.py einen Ausdruck hinzu, um den Fraction Typ aus dem fractions Modul der Standardbibliothek zu importieren.

 from fractions import Fraction

Fügen Sie nun einen Test mit einer Anweisung hinzu und erwarten Sie einen falschen Wert. In unserem Fall erwarten wir, dass die Summe von ¼, ¼ und ⅖ gleich 1 ist:

 import unittest from my_sum import sum class TestSum(unittest.TestCase): def test_list_int(self): """ Test that it can sum a list of integers """ data = [1, 2, 3] result = sum(data) self.assertEqual(result, 6) def test_list_fraction(self): """ Test that it can sum a list of fractions """ data = [Fraction(1, 4), Fraction(1, 4), Fraction(2, 5)] result = sum(data) self.assertEqual(result, 1) if __name__ == '__main__': unittest.main()

Wenn Sie die Tests erneut mit python -m unittest test ausführen, erhalten Sie Folgendes:

 $ python -m unittest test F. ====================================================================== FAIL: test_list_fraction (test.TestSum) ---------------------------------------------------------------------- Traceback (most recent call last): File "test.py", line 21, in test_list_fraction self.assertEqual(result, 1) AssertionError: Fraction(9, 10) != 1 ---------------------------------------------------------------------- Ran 2 tests in 0.001s FAILED (failures=1)

In dieser Ausgabe sehen Sie Folgendes:

  • Die erste Zeile zeigt die Ergebnisse aller Tests: einer fehlgeschlagen (F), einer bestanden (.);
  • FAIL zeigt einige Details des fehlgeschlagenen Tests:

  1. Der Name der Testmethode ( test_list_fraction );
  2. test ( test ) und Testfall ( TestSum );
  3. Traceback-Strings mit einem Fehler;
  4. Details der Aussage mit dem erwarteten Ergebnis (1) und dem tatsächlichen Ergebnis (Bruch (9, 10))

Denken Sie daran, dass Sie der Testausgabe zusätzliche Informationen hinzufügen können, indem Sie dem python -m unittest das Flag -v hinzufügen.

Ausführen von Tests von PyCharm

Wenn Sie die PyCharm-IDE verwenden, können Sie unittest oder pytest ausführen, indem Sie die folgenden Schritte ausführen:

  1. Wählen Sie im Projekt-Tool-Fenster das Testverzeichnis aus.
  2. Wählen Sie im Kontextmenü den Befehl unittest run aus. Zum Beispiel "Unittests in meinen Tests ...".

Dies führt unittest im Testfenster aus und gibt die Ergebnisse in PyCharm zurück:



Weitere Informationen finden Sie auf der PyCharm-Website .

Ausführen von Tests aus Visual Studio-Code

Wenn Sie die Microsoft Visual Studio-Code-IDE verwenden, ist die Unterstützung für Unittest, Nose und Pytest bereits im Python-Plugin integriert.

Wenn Sie es installiert haben, können Sie die Testkonfiguration konfigurieren, indem Sie die Befehlspalette mit Strg + Umschalt + P öffnen und "Python-Test" schreiben. Sie sehen eine Liste mit Optionen:



Wählen Sie Alle Komponententests debuggen aus. Anschließend sendet VSCode eine Anforderung zum Konfigurieren des Testframeworks. Klicken Sie auf das Zahnrad, um den Testläufer (unittest) und das Ausgangsverzeichnis (.) Auszuwählen.

Nach Abschluss des Setups sehen Sie den Status der Tests am unteren Bildschirmrand. Sie können schnell auf die Testprotokolle zugreifen und die Tests neu starten, indem Sie auf die folgenden Symbole klicken:



Wir sehen, dass die Tests durchgeführt werden, aber einige von ihnen sind fehlgeschlagen.

DAS ENDE

Im nächsten Teil des Artikels werden wir Tests für Frameworks wie Django und Flask untersuchen.

Wir warten hier auf Ihre Fragen und Kommentare und wie immer können Sie an einem Tag der offenen Tür nach Stanislav fahren .

Zweiter Teil

Source: https://habr.com/ru/post/de433358/

More articles:


All Articles