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:

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

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:

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)

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:

python -m unittest example.py

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:

  def test_negative_deposit(self):
    # Arrange
    a = BankAccount(1)
    # Act
    outcome = a.deposit(-100)
    # Assert
    self.assertFalse(outcome)

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

python -m unittest -v example.py

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:

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

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

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)

Die Ausgabe sollte so aussehen:

python -m unittest example.py

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:

  def test_negative_deposit(self):
    # Arrange
    a = BankAccount(1)
    # Act
    outcome = a.deposit(-100)
    # Assert
    self.assertFalse(outcome)

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:

python -m unittest -v example.py

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:

pip install -U pytest

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

pytest --version

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!