Ein Leitfaden zu Python Unit -Tests mit untestestem und PyTest

Dieser Artikel untersucht die Bedeutung von Softwaretests und warum Sie darauf achten sollten. Wir lernen, wie man Unit -Tests entwirft und wie man Python -Unit -Tests schreibt. Insbesondere werden wir zwei der am häufigsten verwendeten Unit -Tests -Frameworks in Python untersuchen: unittest und pytest.

Schlüsselpunkte

• Unit -Tests sind ein entscheidender Bestandteil der Softwareentwicklung, mit der Entwickler bestimmte Komponenten oder Einheiten eines Programms testen können, um sicherzustellen, dass sie wie erwartet ausgeführt werden. Zu den beliebten Rahmenbedingungen für Unit -Tests in Python gehören Unittest und PyTest.
• gut gestaltete Unit-Tests sollten schnell, unabhängig, wiederholbar, zuverlässig und gut benannt sein. Der Modus „Vorbereitung, Ausführung, Behauptung (AAA)“ wird häufig verwendet, um Unit -Tests zu organisieren, das Einrichten, die Ausführung und die Überprüfung zu trennen.
• Das unittestes Framework ist Teil der Python Standard Library und inspiriert von jungit, dem Rahmen für den Unit -Test in Java. Es verwendet eine spezielle Assertionsmethode und erfordert, dass der Test als Methode einer Klasse geschrieben wird, die aus der unittest.testcase -Klasse geerbt wurde.
• Das PyTest-Framework ermöglicht komplexe Tests mit weniger Code, unterstützt unittestes Testsuit und bietet über 800 externe Plug-Ins. Im Gegensatz zu Unittest verwendet PyTest normale Python -Behauptungsmethoden, um es einfacher und intuitiver zu machen.
• Obwohl Unit -Tests viele Vorteile haben, muss erinnert werden, dass Tests nur die Existenz von Defekten beweisen können, jedoch nicht das Fehlen von Defekten. Auch wenn alle Tests bestehen, kann es nicht beweisen, dass das Softwaresystem keine Fehler hat.

Einführung in Software -Tests

Softwaretests ist ein Prozess der Überprüfung des Verhaltens von Softwareprodukten zur Bewertung und Überprüfung, ob sie die Spezifikationen entsprechen. Ein Softwareprodukt kann Tausende von Codezeilen und Hunderte von Komponenten enthalten, die zusammenarbeiten. Wenn eine Codezeile nicht ordnungsgemäß funktioniert, kann sich der Fehler ausbreiten und andere Fehler verursachen. Um sicherzustellen, dass das Programm wie erwartet ausgeführt wird, muss es getestet werden.

Da moderne Software ziemlich komplex sein kann, gibt es mehrere Teststufen, um verschiedene Aspekte der Richtigkeit zu bewerten. Gemäß dem Sehrble der Grundstufe des ISTQB -Zertifizierungstests gibt es vier Software -Tests:

1. Unit -Test: Testen Sie bestimmte Codezeilen
2. Integrationstest: Testintegration zwischen mehreren Einheiten
3. Systemtest: Testen Sie das gesamte System
4. Akzeptanztest: Überprüfen Sie, ob er Geschäftsziele
erreicht wird

In diesem Artikel werden Unit -Tests erörtert, aber bevor ich mich darauf einlassen möchte, möchte ich ein wichtiges Prinzip für Softwaretests einführen.

Tests können nur die Existenz von Defekten beweisen, können jedoch nicht das Fehlen von Defekten beweisen.

- istqb ctfl sillBus 2018

Mit anderen Worten, auch wenn alle von Ihnen durchgeführten Tests keine Fehler zeigen, wird nicht beweisen, dass Ihr Softwaresystem frei von Fehlern ist oder ein anderer Testfall keine Fehler in Ihrem Softwareverhalten findet.

Was ist Unit -Tests?

Dies ist die erste Teststufe, die auch als Komponententests bezeichnet wird. In diesem Abschnitt wird eine einzige Softwarekomponente getestet. Abhängig von der Programmiersprache kann eine Softwareinheit eine Klasse, eine Funktion oder eine Methode sein. Wenn Sie beispielsweise eine Java -Klasse haben, die als Arithmetikoperationen bezeichnet wird, die mehrere Methoden enthält, müssen die Einheiten -Tests der Arithmeticoperations -Klasse das korrekte Verhalten der Multiplikations- und Dividenmethoden testen.

Unit -Tests werden normalerweise von Softwaretestern durchgeführt. Um Unit -Tests auszuführen, müssen Softwaretester (oder Entwickler) auf den Quellcode zugreifen, da der Quellcode selbst das getestete Objekt ist. Daher wird diese Softwaretestmethode, bei der der Quellcode direkt getestet wird, als White -Box -Test bezeichnet.

Sie fragen sich vielleicht, warum Sie sich um Softwaretests sorgen sollten und ob es sich lohnt. Im nächsten Abschnitt werden wir die Motivationen hinter dem Test -Softwaresystem analysieren.

Warum sollten Sie Unit -Tests

durchführen?

Der Hauptvorteil von Softwaretests besteht darin, dass sie die Qualität der Software verbessert. Die Softwarequalität ist von entscheidender Bedeutung, insbesondere auf der Welt, in der Software in unseren täglichen Aktivitäten alle möglichen Dinge behandelt. Die Verbesserung der Softwarequalität ist immer noch ein übermäßig vage Ziel. Versuchen wir, besser zu veranschaulichen, was wir die Qualität der Software nennen. Laut ISO/IEC Standard 9126-1 ISO 9126 enthält die Softwarequalität die folgenden Faktoren:

• Zuverlässigkeit
• funktional
• Effizienz
• Verfügbarkeit
• Wartbarkeit
• Porability

Wenn Sie ein Unternehmen besitzen, sollten Sie sorgfältige Aktivitäten für Softwaretests in Betracht ziehen, da dies Ihr Unternehmen beeinflusst. Beispielsweise erinnerte Tesla im Mai 2022 130.000 Autos aufgrund von Problemen mit dem Infotainment -System des Fahrzeugs zurück. Dieses Problem wurde dann durch ein Software -Update gelöst, das "in der Luft" verteilt ist. Diese Fehler haben dem Unternehmen Zeit und Geld verursacht und auch Probleme für Kunden verursacht, da sie ihre Autos für eine Weile nicht benutzen konnten. Die Testsoftware kostet Geld, aber Unternehmen können auch Millionen technischer Support sparen.

Unit -Tests konzentriert sich auf die Überprüfung, ob die Software korrekt ausgeführt wird. Dies bedeutet, dass die Zuordnung zwischen Eingabe und Ausgabe korrekt erfolgt. Als Testaktivität auf niedriger Ebene hilft Unit-Tests dabei, Fehler frühzeitig zu identifizieren, damit sie sie nicht auf höhere Ebenen des Softwaresystems ausbreiten.

Weitere Vorteile von Unit -Tests umfassen:

• vereinfachte Integration: Es ist einfacher, Integrationsprobleme zu lösen, indem sichergestellt wird, dass alle Komponenten unabhängig funktionieren.
• minimieren Sie die Code -Regression: Bei einer großen Anzahl von Testfällen ist es einfacher, Probleme zu finden, wenn einige Änderungen des Quellcode in Zukunft Probleme verursachen werden.
• Vorausgesetztes Dokumentation: Durch Testen der korrekten Zuordnung zwischen Eingang und Ausgabe bietet Unit -Tests eine Dokumentation darüber, wie die zu testende Methode oder Klasse verwendet wird.

Design -Teststrategien

Lassen Sie uns nun sehen, wie Sie eine Teststrategie entwerfen.

Definition des Testbereichs

Bevor Sie Ihre Teststrategie planen, gibt es eine wichtige Frage. Welche Teile des Softwaresystems möchten Sie testen?

Dies ist ein wichtiges Problem, da erschöpfende Tests unmöglich sind. Daher können Sie nicht alle möglichen Eingänge und Ausgänge testen, sollten jedoch die Tests basierend auf den beteiligten Risiken priorisieren.

Eine Reihe von Faktoren muss berücksichtigt werden, um den Umfang des Tests zu definieren:

• Risiko: Welche geschäftlichen Konsequenzen werden auftreten, wenn der Fehler diese Komponente beeinflusst?
• Zeit: Wie lange soll das Softwareprodukt bereit sein? Hast du eine Frist?
• Budget: Wie viel Geld sind Sie bereit, in Testaktivitäten zu investieren?

Sobald Sie den Testumfang definiert haben (angeben, was Sie testen sollten und was Sie nicht testen sollten), können Sie die Funktionen diskutieren, die ein guter Unit -Test haben sollte.

Merkmale von Unit -Tests

• schnell. Unit -Tests werden meist automatisch durchgeführt, was bedeutet, dass sie schnell sein müssen. Langsame Unit -Tests werden eher von Entwicklern übersprungen, da sie kein sofortiges Feedback geben.
• unabhängig. Unit -Tests sind per Definition unabhängig. Sie testen einzelne Codeeinheiten und stützen sich nicht auf externe Faktoren (wie Dateien oder Netzwerkressourcen).
• wiederholbar. Unit -Tests werden wiederholt durchgeführt und die Ergebnisse müssen im Laufe der Zeit konsistent sein.
• zuverlässig. Unit -Tests scheitern nur, wenn das zu testende System ein Fehler vorliegt. Die Reihenfolge, in der die Umgebung oder Tests durchgeführt werden, sollte nicht wichtig sein.
• richtig benannt. Der Name des Tests sollte relevante Informationen über den Test selbst liefern.

Ein Schritt fehlt, bevor Sie sich in Python in Einheitstests einteilen. Wie organisieren wir die Tests, um sie sauber und lesbar zu machen? Wir verwenden ein Muster, das als Vorbereitung, Ausführung und Behauptung (AAA) bezeichnet wird.

AAA -Modus

Das AAA -Muster für die Vorbereitung, Ausführung und Behauptung (AAA) ist eine häufige Strategie zum Schreiben und Organisieren von Unit -Tests. Es funktioniert wie folgt:

• Stellen Sie in der Vorbereitungsphase alle für den Test erforderlichen Objekte und Variablen fest.
• Als nächstes wird während der Ausführungsphase die zu testende Funktion/Methode/Klasse aufgerufen.
• Schließlich überprüfen wir in der Assertion -Phase die Ergebnisse des Tests.

Diese Strategie bietet eine saubere Möglichkeit, Unit -Tests zu organisieren, indem alle Hauptteile des Tests (Einrichtung, Ausführung und Validierung) getrennt werden. Zusätzlich sind Unit -Tests leichter zu lesen, da alle der gleichen Struktur folgen.

Unit -Tests in Python: unittest oder pytest?

Wir werden nun zwei verschiedene Rahmenbedingungen für Unit -Tests in Python diskutieren. Diese beiden Frameworks sind untestest und pytest.

unittest Einführung

Die Python -Standardbibliothek enthält das unitteste Unit -Test -Framework. Dieser Framework ist von Junit inspiriert, einem Rahmen für das Testen von Unit -Tests in Java.

Wie in der offiziellen Dokumentation angegeben, unterstützt Unittest mehrere wichtige Konzepte, die wir in diesem Beitrag erwähnen werden:

• Testfall, dies ist eine einzelne Testeinheit
• Test Suite, dies ist eine Reihe von Testfällen, die zusammen
zusammengestellt werden.
Testläufer, die Komponente, die die Ausführung und die Ergebnisse aller Testfälle

behandelt

unittest hat seine eigene Art, Tests zu schreiben. Insbesondere brauchen wir:

1. unsere Tests als Klassenmethode schreiben, die aus der unittest.TestCase -Klasse
erbt.
Verwenden Sie die spezielle Assertionsmethode

Da Unittest bereits installiert ist, sind wir bereit, unseren ersten Unit -Test zu schreiben!

Schreibabteilungstests mit unittest

schreiben

Angenommen, wir haben die BankAccount -Klasse:

<code class="language-python">import unittest

class BankAccount:
  def __init__(self, id):
    self.id = id
    self.balance = 0

  def withdraw(self, amount):
    if self.balance >= amount:
      self.balance -= amount
      return True
    return False

  def deposit(self, amount):
    self.balance += amount
    return True</code>

Wir können kein Geld abheben, das den verfügbaren Einzahlungsbetrag überschreitet. Testen wir also, ob unser Quellcode diese Situation korrekt behandelt.

In derselben Python -Datei können wir den folgenden Code hinzufügen:

<code class="language-python">class TestBankOperations(unittest.TestCase):
    def test_insufficient_deposit(self):
      # Arrange
      a = BankAccount(1)
      a.deposit(100)
      # Act
      outcome = a.withdraw(200)
      # Assert
      self.assertFalse(outcome)</code>

Wir erstellen eine Klasse namens testBankoperations, die eine Unterklasse von unittest.testcase ist. Auf diese Weise erstellen wir einen neuen Testfall.

In dieser Klasse definieren wir eine einzelne Testfunktion, deren Methode mit dem Test beginnt. Dies ist wichtig, da jede Testmethode mit dem Worttest beginnen muss.

Wir erwarten, dass diese Testmethode false zurückgibt, was bedeutet, dass die Operation fehlgeschlagen ist. Um das Ergebnis zu behaupten, verwenden wir eine spezielle Assertionsmethode namens AssertFalse ().

Wir sind bereit, den Test durchzuführen. Führen Sie diesen Befehl in der Befehlszeile aus:

<code class="language-bash">python -m unittest example.py</code>

hier, Beispiel.py ist der Name der Datei, die den gesamten Quellcode enthält. Die Ausgabe sollte so aussehen:

<code>.
----------------------------------------------------------------------
Ran 1 test in 0.001s

OK</code>

Sehr gut! Dies bedeutet, dass unser Test erfolgreich war. Lassen Sie uns nun sehen, wie die Ausgabe aussieht, wenn ein Fehler vorliegt. Wir fügen der vorherigen Klasse einen neuen Test hinzu. Versuchen wir, negative Beträge einzureichen, was sicherlich unmöglich ist. Wird unser Code diese Situation bewältigen?

Dies ist unsere neue Testmethode:

<code class="language-python">  def test_negative_deposit(self):
    # Arrange
    a = BankAccount(1)
    # Act
    outcome = a.deposit(-100)
    # Assert
    self.assertFalse(outcome)</code>

Wir können den detaillierten Modus von Unittest verwenden, um diesen Test mit dem -V -Flag durchzuführen:

<code class="language-bash">python -m unittest -v example.py</code>

Die Ausgabe ist jetzt anders:

<code>test_insufficient_deposit (example.TestBankOperations) ... ok
test_negative_deposit (example.TestBankOperations) ... FAIL

======================================================================
FAIL: test_negative_deposit (example.TestBankOperations)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "example.py", line 35, in test_negative_deposit
    self.assertFalse(outcome)
AssertionError: True is not false

----------------------------------------------------------------------
Ran 2 tests in 0.002s

FAILED (failures=1)</code>

In diesem Fall gibt uns das detaillierte Logo weitere Informationen. Wir wissen, dass test_negative_deposit fehlschlägt. Insbesondere AsSerTionTerError sagt uns, dass das erwartete Ergebnis falsch sein sollte, aber wahr ist nicht falsch, was bedeutet, dass die Methode wahr zurückgibt.

unittestes Framework liefert unterschiedliche Behauptungsmethoden entsprechend unseren Bedürfnissen:

asertEqual (x, y), testen Sie, ob x == y wahr ist
assertraises (exception_type) prüfen Sie, ob eine bestimmte Ausnahme
• erhöht wurde.
assertisnone (x) testen Sie, ob x keine
• ist
Assertin (x, y), testen Sie, ob x in y

ist

Jetzt, da wir ein grundlegendes Verständnis dafür haben, wie man Unit -Tests mit dem unittesten Framework schreibt, schauen wir uns ein anderes Python -Framework namens PyTest an.

Einführung in PyTest

PyTest Framework ist ein Python -Unit -Test -Framework mit einigen verwandten Funktionen:

Es ermöglicht komplexe Tests mit weniger Code
Es unterstützt die unitteste Test Suite
Es bietet über 800 externe Plugins

Da PyTest standardmäßig nicht installiert ist, müssen wir es zuerst installieren. Beachten Sie, dass PyTest Python 3.7 benötigt.

PyTest

installieren

PyTest installieren ist sehr einfach. Sie müssen nur den folgenden Befehl ausführen:

<code class="language-python">import unittest

class BankAccount:
  def __init__(self, id):
    self.id = id
    self.balance = 0

  def withdraw(self, amount):
    if self.balance >= amount:
      self.balance -= amount
      return True
    return False

  def deposit(self, amount):
    self.balance += amount
    return True</code>

Überprüfen Sie dann, dass alles korrekt installiert wird, indem Sie eingeben:

<code class="language-python">class TestBankOperations(unittest.TestCase):
    def test_insufficient_deposit(self):
      # Arrange
      a = BankAccount(1)
      a.deposit(100)
      # Act
      outcome = a.withdraw(200)
      # Assert
      self.assertFalse(outcome)</code>

Die Ausgabe sollte so aussehen:

<code class="language-bash">python -m unittest example.py</code>

Sehr gut! Schreiben wir den ersten Test mit PyTest.

Schreiben von Unit -Tests unter Verwendung von PyTest

Wir werden die zuvor geschriebene BankAccount -Klasse verwenden und wir werden dieselbe Methode wie zuvor testen. Auf diese Weise ist es einfacher, die Anstrengungen zu vergleichen, die zum Schreiben von Tests mit diesen beiden Frameworks erforderlich sind.

Um PyTest zum Testen zu verwenden, brauchen wir:

• Erstellen Sie ein Verzeichnis und setzen Sie unsere Testdateien ein.
• unsere Tests in Dateien schreiben, deren Namen mit test_ oder enden mit _test.py. PyTest wird nach diesen Dateien im aktuellen Verzeichnis und seinen Unterverzeichnissen suchen.

Erstellen wir also eine Datei namens Test_Bank.py und setzen sie in einen Ordner. So sieht unsere erste Testfunktion aus:

<code>.
----------------------------------------------------------------------
Ran 1 test in 0.001s

OK</code>

Wie Sie bemerkt haben, ist die einzige Änderung im Vergleich zur untestesten Version der durchsichtsrechtliche Teil. Hier verwenden wir die normale Python -Behauptungsmethode.

Jetzt können wir uns die Datei test_bank.py ansehen:

<code class="language-python">  def test_negative_deposit(self):
    # Arrange
    a = BankAccount(1)
    # Act
    outcome = a.deposit(-100)
    # Assert
    self.assertFalse(outcome)</code>

Um diesen Test auszuführen, öffnen wir eine Eingabeaufforderung im Ordner mit der Datei test_bank.py. Führen Sie dann den folgenden Befehl aus:

<code class="language-bash">python -m unittest -v example.py</code>

Die Ausgabe sieht so aus:

<code>test_insufficient_deposit (example.TestBankOperations) ... ok
test_negative_deposit (example.TestBankOperations) ... FAIL

======================================================================
FAIL: test_negative_deposit (example.TestBankOperations)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "example.py", line 35, in test_negative_deposit
    self.assertFalse(outcome)
AssertionError: True is not false

----------------------------------------------------------------------
Ran 2 tests in 0.002s

FAILED (failures=1)</code>

In diesem Fall können wir sehen, wie einfach es ist, Tests zu schreiben und auszuführen. Darüber hinaus können wir sehen, dass wir weniger Code als unittest schreiben. Die Ergebnisse des Tests sind ebenfalls leicht zu verstehen.

Schauen wir uns weiterhin die fehlgeschlagenen Tests an!

Wir verwenden die zweite Methode, die wir zuvor geschrieben haben, namens test_negative_deposit. Wir refaktor den durchsichtsrechtlichen Teil und das Ergebnis lautet wie folgt:

<code class="language-bash">pip install -U pytest</code>

Wir führen die Tests wie zuvor aus, was die Ausgabe sein sollte:

<code class="language-bash">pytest --version</code>

Durch Parsen des Ausgangs können wir gesammelte 2 Elemente lesen, was bedeutet, dass zwei Tests durchgeführt wurden. Scrollen Sie nach unten und wir können sehen, dass ein Fehler beim Testen der Methode test_negative_deposit aufgetreten ist. Insbesondere treten Fehler bei der Bewertung von Behauptungen auf. Darüber hinaus gibt der Bericht auch an, dass der Wert der Ergebnisvariablen wahr ist, was bedeutet, dass die Einlagenmethode Fehler enthält.

Da PyTest das Standardwort für Python Assertion verwendet, können wir jede Ausgabe vergleichen, die wir mit einer anderen Variablen erhalten, die das erwartete Ergebnis speichert. All dies erfordert keine besonderen Behauptungsmethoden.

Schlussfolgerung

In diesem Artikel stellen wir die Grundlagen des Softwaretests vor. Wir haben festgestellt, warum Softwaretests von entscheidender Bedeutung sind und warum jeder seinen Code testen sollte. Wir diskutieren Unit -Tests und wie einfach einfache Unit -Tests in Python entwerfen und implementieren.

Wir verwenden zwei Python -Frameworks namens Unittest und PyTest. Beide haben nützliche Merkmale und sind zwei der am häufigsten verwendeten Frameworks in Python Unit -Tests.

Schließlich sehen wir zwei grundlegende Testfälle, um Ihnen eine Vorstellung davon zu geben, wie Tests in Vorbereitung, Ausführung und Behauptungsmuster geschrieben werden.

Ich hoffe, ich habe Sie von der Bedeutung von Softwaretests überzeugt. Wählen Sie einen Framework wie unittest oder pytest und beginnen Sie zu testen - denn die zusätzliche Anstrengung ist es wert!

Wenn Ihnen dieser Artikel gefällt, finden Sie möglicherweise auch das folgende nützliche:

• Cypress -Test: Eine Anleitung zum Ausführen von Webanwendungen
• So testen Sie die Reaktionskomponenten mit Scherz
• End-to-End-Test mit Puppenspielern
lernen
3 Möglichkeiten, um frei-freie
• kontinuierlich zu testen
Wiedereinführung Jenkins: Verwenden Sie Rohre für automatisierte Tests

FAQs über Python Unit -Test

Was sind Unit -Tests in Python? Unit -Tests in Python ist eine Software -Testtechnik, bei der eine einzelne Einheit oder ein einzelner Komponente eines Programms isoliert getestet wird, um sicherzustellen, dass jede Einheit wie erwartet funktioniert.

Warum ist Unit -Tests in der Python -Entwicklung wichtig? Unit -Tests hilft, die Richtigkeit einzelner Komponenten in einem Python -Programm zu gewährleisten. Es hilft, Fehler frühzeitig zu erkennen, bietet ein sicheres Netz für Codeänderungen und unterstützt die Wartbarkeit von Code.

Wie schreibe ich Unit -Tests in Python? Unit-Tests in Python werden häufig mit dem eingebauten, unittesten Modul geschrieben. Sie erstellen Testklassen, die von unittest.testcase geerbt wurden und Testmethoden in diesen Klassen schreiben. Testmethoden beginnen normalerweise mit "Test".

Welche anderen Frameworks kann ich neben Unittest für Python Unit -Tests verwenden? Ja, neben unittest gibt es andere beliebte Python -Test -Frameworks wie PyTest und Nase2. Diese Frameworks bieten unterschiedliche Funktionen und Syntaxe, sodass Entwickler die auswählen können, die ihren Anforderungen am besten entspricht.

Welche Rolle spielt die Fixture bei Python Unit -Tests? Die Fixture ist eine Möglichkeit, Voraussetzungen in Python festzulegen und nach dem Test aufzuräumen. Sie tragen dazu bei, dass die Tests unabhängig sind und unabhängig laufen können.

Was ist die Testabdeckung und warum ist es wichtig? Die Testabdeckung misst den Prozentsatz der Codebasis, die Ihre Tests ausführen. Es hilft, ungetesteten Code zu identifizieren und stellt sicher, dass Ihre Tests umfassend sind, wodurch die Möglichkeit verringert wird, dass Fehler entdeckt werden.

Was sind die Best Practices für das Schreiben effektiver Unit -Tests in Python? Ja, einige Best Practices umfassen das Schreiben unabhängiger und isolierter Tests, unter Verwendung beschreibender Testmethodennamen und Testgrenze. Versuchen Sie außerdem, eine gute Testabdeckung zu erhalten und Tests häufig durchzuführen.

Das obige ist der detaillierte Inhalt vonEin Leitfaden zu Python Unit -Tests mit untestestem und PyTest. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!