Wie man PyTest für Unit-Tests in Python verwendet

Wenn Sie Code in Python schreiben, ist es wichtig sicherzustellen, dass Ihr Code wie erwartet funktioniert. Eine der besten Möglichkeiten, dies zu tun, ist die Verwendung von Unittests, die Ihnen helfen, zu überprüfen, ob kleine Teile (oder Einheiten) Ihres Codes korrekt funktionieren.

In diesem Artikel werden wir lernen, wie man effektive Unittests in Python mit PyTest schreibt und ausführt, einem der beliebtesten Testframeworks für Python.

Was sind Unittests?

Unittests sind kleine, einfache Tests, die sich darauf konzentrieren, eine einzelne Funktion oder ein kleines Stück Code zu überprüfen. Sie helfen sicherzustellen, dass Ihr Code wie erwartet funktioniert und können Fehler frühzeitig erkennen.

Unittests können für verschiedene Teile Ihres Codes geschrieben werden, wie Funktionen, Methoden und sogar Klassen. Durch das Schreiben von Unittests können Sie Ihren Code testen, ohne das gesamte Programm auszuführen.

Warum PyTest verwenden?

PyTest ist ein beliebtes Testframework für Python, das das Schreiben und Ausführen von Tests erleichtert.

Es ist einfach zu bedienen und bietet viele nützliche Funktionen wie:

Es ermöglicht Ihnen, einfache und klare Testfälle zu schreiben.
Es bietet erweiterte Funktionen wie Fixtures, parametrische Tests und Plugins.
Es funktioniert gut mit anderen Testwerkzeugen und Bibliotheken.
Es erzeugt leicht lesbare Testergebnisse und Berichte.

Einrichten von PyTest unter Linux

Bevor wir mit dem Schreiben von Tests beginnen, müssen wir PyTest installieren. Wenn Sie PyTest noch nicht installiert haben, können Sie es mit dem Python-Paketmanager pip installieren.

pip install pytest

Sobald PyTest installiert ist, sind Sie bereit, Tests zu schreiben!

Ihr erster Test mit PyTest schreiben

Lassen Sie uns damit beginnen, eine einfache Funktion zu schreiben und dann einen Test dafür zu erstellen.

Schritt 1: Schreiben Sie eine einfache Funktion

Zuerst erstellen wir eine Python-Funktion, die wir testen möchten. Angenommen, wir haben eine Funktion, die zwei Zahlen addiert:

# add.py
def add(a, b):
    return a + b

Dies ist eine einfache Funktion, die zwei Zahlen a und b entgegennimmt, sie addiert und das Ergebnis zurückgibt.

Schritt 2: Schreiben Sie einen Test für die Funktion

Jetzt schreiben wir einen Test für die Additionsfunktion. In PyTest werden Tests in separaten Dateien geschrieben, die typischerweise test_*.py genannt werden, um die Identifizierung von Testdateien zu erleichtern.

Erstellen Sie eine neue Datei mit dem Namen test_add.py und schreiben Sie den folgenden Testcode:

# test_add.py
from add import add

def test_add_numbers():
    assert add(2, 3) == 5
    assert add(-1, 1) == 0
    assert add(0, 0) == 0

Erklärung des obigen Codes:

Wir importieren die add-Funktion aus der Datei add.py.
Wir definieren eine Testfunktion namens test_add_numbers(). In PyTest sollte eine Testfunktion mit dem Wort test_ beginnen.
Innerhalb der Testfunktion verwenden wir die assert-Anweisung, um zu überprüfen, ob das Ergebnis des Aufrufs der add-Funktion mit dem erwarteten Wert übereinstimmt. Wenn die Bedingung in der assert-Anweisung True ist, besteht der Test; andernfalls schlägt er fehl.

Schritt 3: Den Test ausführen

Um den Test auszuführen, öffnen Sie Ihr Terminal und navigieren Sie zu dem Verzeichnis, in dem sich Ihre test_add.py-Datei befindet, und führen Sie dann den folgenden Befehl aus:

pytest

PyTest findet automatisch alle Testdateien (die mit test_ beginnen) und führt die Tests in ihnen aus. Wenn alles korrekt funktioniert, sollten Sie eine Ausgabe wie diese sehen:

Der Punkt (.) zeigt an, dass der Test bestanden wurde. Wenn es Probleme gab, würde PyTest eine Fehlermeldung anzeigen.

Schreiben von fortgeschritteneren Tests

Jetzt, da wir wissen, wie man einen grundlegenden Test schreibt und ausführt, lassen Sie uns einige fortgeschrittenere Funktionen von PyTest erkunden.

Testen auf erwartete Ausnahmen

Manchmal möchten Sie testen, ob Ihr Code die richtigen Ausnahmen auslöst, wenn etwas schiefgeht. Dies können Sie mit der Funktion pytest.raises() tun.

Angenommen, wir möchten eine Funktion testen, die zwei Zahlen dividiert. Wir möchten eine Ausnahme auslösen, wenn die zweite Zahl null ist (um Division durch null-Fehler zu vermeiden).

Hier ist die divide-Funktion:

# divide.py
def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

Jetzt lassen Sie uns einen Test für diese Funktion schreiben, der überprüft, ob die ValueError ausgelöst wird, wenn wir versuchen, durch null zu dividieren:

# test_divide.py
from divide import divide
import pytest

def test_divide_numbers():
    assert divide(10, 2) == 5
    assert divide(-10, 2) == -5
    assert divide(10, -2) == -5

def test_divide_by_zero():
    with pytest.raises(ValueError):
        divide(10, 0)

Erklärung des Codes:

Wir haben eine neue Testfunktion namens test_divide_by_zero() hinzugefügt.
Innerhalb dieser Funktion verwenden wir pytest.raises(ValueError), um zu überprüfen, ob ein ValueError ausgelöst wird, wenn wir die Divide-Funktion mit null als zweitem Argument aufrufen.

Führen Sie die Tests erneut mit dem pytest-Befehl aus. Wenn alles korrekt funktioniert, sollten Sie diese Ausgabe sehen:

Verwendung von Fixtures für Setup und Cleanup

In einigen Fällen müssen Sie bestimmte Bedingungen festlegen, bevor Sie Ihre Tests ausführen, oder nach den Tests aufräumen. PyTest bietet Fixtures, um dies zu handhaben.

Ein Fixture ist eine Funktion, die Sie verwenden können, um Bedingungen für Ihre Tests einzurichten oder abzubauen. Fixtures werden häufig verwendet, um Objekte zu erstellen oder sich mit Datenbanken zu verbinden, die für die Tests benötigt werden.

Hier ist ein Beispiel für die Verwendung eines Fixtures, um ein temporäres Verzeichnis für Testdateioperationen einzurichten:

# test_file_operations.py
import pytest
import os

@pytest.fixture
def temporary_directory():
    temp_dir = "temp_dir"
    os.mkdir(temp_dir)
    yield temp_dir  # This is where the test will run
    os.rmdir(temp_dir)  # Cleanup after the test

def test_create_file(temporary_directory):
    file_path = os.path.join(temporary_directory, "test_file.txt")
    with open(file_path, "w") as f:
        f.write("Hello, world!")
    
    assert os.path.exists(file_path)

Erklärung des Codes:

Wir definieren ein Fixture namens temporary_directory, das ein temporäres Verzeichnis vor dem Test erstellt und es danach löscht.
Die Testfunktion test_create_file() verwendet dieses Fixture, um eine Datei im temporären Verzeichnis zu erstellen und zu überprüfen, ob die Datei existiert.

Führen Sie die Tests erneut mit dem pytest-Befehl aus. PyTest erkennt und verwendet das Fixture automatisch.

Parameterisieren Sie Ihre Tests mit Pytest

Manchmal möchten Sie denselben Test mit unterschiedlichen Eingaben ausführen. PyTest ermöglicht Ihnen dies einfach mit Parametrisieren.

Angenommen, wir möchten unsere add Funktion mit mehreren Zahlenpaaren testen. Anstatt separate Testfunktionen für jedes Paar zu schreiben, können wir pytest.mark.parametrize verwenden, um denselben Test mit unterschiedlichen Eingaben auszuführen.

# test_add.py
import pytest
from add import add

@pytest.mark.parametrize("a, b, expected", [
    (2, 3, 5),
    (-1, 1, 0),
    (0, 0, 0),
    (100, 200, 300)
])
def test_add_numbers(a, b, expected):
    assert add(a, b) == expected

Erklärung des Codes:

Wir verwenden den pytest.mark.parametrize Dekorator, um mehrere Eingabemengen (a, b und erwartet) zu definieren.
Der Test function test_add_numbers() wird einmal für jede Eingabemenge ausgeführt.

Führen Sie die Tests erneut mit dem pytest-Befehl aus, der den Test viermal ausführt, einmal für jede Eingabemenge.

Fazit

In diesem Artikel haben wir gelernt, wie man effektive Unittests in Python mit PyTest schreibt und ausführt, um Fehler frühzeitig zu erkennen und sicherzustellen, dass Ihr Code wie erwartet funktioniert.

PyTest erleichtert das Schreiben und Ausführen dieser Tests, und mit seinen leistungsstarken Funktionen können Sie komplexere Testanforderungen bewältigen, während Sie in Ihrer Python-Reise wachsen.