Fortgeschrittene Pytest-Fixtures meistern: Parametrisierte Tests und Mock-Integration

Pytest ist ein leistungsstarkes und flexibles Test-Framework für Python. Seine Einfachheit und Erweiterbarkeit machen es zu einem Favoriten unter Entwicklern weltweit. Eines der überzeugendsten Merkmale von Pytest ist sein Fixture-System, das elegante und wiederverwendbare Test-Setups ermöglicht. Dieser Blogbeitrag befasst sich mit fortgeschrittenen Fixture-Techniken, insbesondere mit parametrisierten Tests und der Mock-Integration. Wir werden untersuchen, wie diese Techniken Ihren Test-Workflow erheblich verbessern und zu robusterem und wartbarerem Code führen können.

Pytest-Fixtures verstehen

Bevor wir uns fortgeschrittenen Themen widmen, wollen wir kurz die Grundlagen von Pytest-Fixtures wiederholen. Eine Fixture ist eine Funktion, die vor jeder Testfunktion ausgeführt wird, auf die sie angewendet wird. Sie wird verwendet, um eine feste Ausgangsbasis für Tests bereitzustellen, um Konsistenz zu gewährleisten und Boilerplate-Code zu reduzieren. Fixtures können Aufgaben ausführen wie:

• Aufbau einer Datenbankverbindung
• Erstellen temporärer Dateien oder Verzeichnisse
• Initialisieren von Objekten mit spezifischen Konfigurationen
• Authentifizierung bei einer API

Fixtures fördern die Wiederverwendbarkeit von Code und machen Ihre Tests lesbarer und wartbarer. Sie können in verschiedenen Geltungsbereichen (Funktion, Modul, Sitzung) definiert werden, um ihre Lebensdauer und den Ressourcenverbrauch zu steuern.

Einfaches Fixture-Beispiel

Hier ist ein einfaches Beispiel für eine Pytest-Fixture, die ein temporäres Verzeichnis erstellt:

            
import pytest
import tempfile
import os

@pytest.fixture
def temp_dir():
    with tempfile.TemporaryDirectory() as tmpdir:
        yield tmpdir

            

              
                Copy
              
            
          

Um diese Fixture in einem Test zu verwenden, fügen Sie sie einfach als Argument zu Ihrer Testfunktion hinzu:

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

            

              
                Copy
              
            
          

Parametrisierte Tests mit Pytest

Parametrisierte Tests ermöglichen es Ihnen, dieselbe Testfunktion mehrmals mit unterschiedlichen Sätzen von Eingabedaten auszuführen. Dies ist besonders nützlich, um Funktionen mit variierenden Ein- und erwarteten Ausgaben zu testen. Pytest bietet den @pytest.mark.parametrize-Decorator zur Implementierung parametrisierter Tests.

Vorteile von parametrisierten Tests

• Reduziert Codeduplizierung: Vermeiden Sie das Schreiben mehrerer, nahezu identischer Testfunktionen.
• Verbessert die Testabdeckung: Testen Sie einfach ein breiteres Spektrum an Eingabewerten.
• Erhöht die Lesbarkeit der Tests: Definieren Sie klar die Eingabewerte und erwarteten Ausgaben für jeden Testfall.

Einfaches Parametrisierungsbeispiel

Angenommen, Sie haben eine Funktion, die zwei Zahlen addiert:

            
def add(x, y):
    return x + y

            

              
                Copy
              
            
          

Sie können parametrisierte Tests verwenden, um diese Funktion mit verschiedenen Eingabewerten zu testen:

            
import pytest

@pytest.mark.parametrize("x, y, expected", [
    (1, 2, 3),
    (5, 5, 10),
    (-1, 1, 0),
    (0, 0, 0),
])
def test_add(x, y, expected):
    assert add(x, y) == expected

            

              
                Copy
              
            
          

In diesem Beispiel definiert der @pytest.mark.parametrize-Decorator vier Testfälle, jeder mit unterschiedlichen Werten für x, y und dem erwarteten Ergebnis. Pytest führt die test_add-Funktion viermal aus, einmal für jeden Parametersatz.

Fortgeschrittene Parametrisierungstechniken

Pytest bietet mehrere fortgeschrittene Techniken zur Parametrisierung, darunter:

• Verwendung von Fixtures mit Parametrisierung: Kombinieren Sie Fixtures mit Parametrisierung, um unterschiedliche Setups für jeden Testfall bereitzustellen.
• IDs für Testfälle: Weisen Sie Testfällen benutzerdefinierte IDs zu, um die Berichterstattung und das Debugging zu verbessern.
• Indirekte Parametrisierung: Parametrisieren Sie die an Fixtures übergebenen Argumente, was eine dynamische Fixture-Erstellung ermöglicht.

Verwendung von Fixtures mit Parametrisierung

Dies ermöglicht es Ihnen, Fixtures dynamisch basierend auf den an den Test übergebenen Parametern zu konfigurieren. Stellen Sie sich vor, Sie testen eine Funktion, die mit einer Datenbank interagiert. Möglicherweise möchten Sie unterschiedliche Datenbankkonfigurationen (z. B. verschiedene Verbindungszeichenfolgen) für verschiedene Testfälle verwenden.

            
import pytest

@pytest.fixture
def db_config(request):
    if request.param == "prod":
        return {"host": "prod.example.com", "port": 5432}
    elif request.param == "test":
        return {"host": "test.example.com", "port": 5433}
    else:
        raise ValueError("Invalid database environment")


@pytest.fixture
def db_connection(db_config):
    # Simulate establishing a database connection
    print(f"Connecting to database at {db_config['host']}:{db_config['port']}")
    return f"Connection to {db_config['host']}"


@pytest.mark.parametrize("db_config", ["prod", "test"], indirect=True)
def test_database_interaction(db_connection):
    # Your test logic here, using the db_connection fixture
    print(f"Using connection: {db_connection}")
    assert "Connection" in db_connection

            

              
                Copy
              
            
          

In diesem Beispiel ist die db_config-Fixture parametrisiert. Das Argument indirect=True weist Pytest an, die Parameter ("prod" und "test") an die db_config-Fixture-Funktion zu übergeben. Die db_config-Fixture gibt dann je nach Parameterwert unterschiedliche Datenbankkonfigurationen zurück. Die db_connection-Fixture verwendet die db_config-Fixture, um eine Datenbankverbindung herzustellen. Schließlich verwendet die test_database_interaction-Funktion die db_connection-Fixture, um mit der Datenbank zu interagieren.

IDs für Testfälle

Benutzerdefinierte IDs liefern aussagekräftigere Namen für Ihre Testfälle im Testbericht, was die Identifizierung und das Debugging von Fehlern erleichtert.

            
import pytest

@pytest.mark.parametrize(
    "input_string, expected_output",
    [
        ("hello", "HELLO"),
        ("world", "WORLD"),
        ("", ""),
    ],
    ids=["lowercase_hello", "lowercase_world", "empty_string"],
)
def test_uppercase(input_string, expected_output):
    assert input_string.upper() == expected_output

            

              
                Copy
              
            
          

Ohne IDs würde Pytest generische Namen wie test_uppercase[0], test_uppercase[1] usw. generieren. Mit IDs zeigt der Testbericht aussagekräftigere Namen wie test_uppercase[lowercase_hello] an.

Indirekte Parametrisierung

Die indirekte Parametrisierung ermöglicht es Ihnen, die Eingabe für eine Fixture zu parametrisieren, anstatt die Testfunktion direkt. Dies ist hilfreich, wenn Sie verschiedene Fixture-Instanzen basierend auf dem Parameterwert erstellen möchten.

            
import pytest

@pytest.fixture
def input_data(request):
    if request.param == "valid":
        return {"name": "John Doe", "email": "john.doe@example.com"}
    elif request.param == "invalid":
        return {"name": "", "email": "invalid-email"}
    else:
        raise ValueError("Invalid input data type")


def validate_data(data):
    if not data["name"]:
        return False, "Name cannot be empty"
    if "@" not in data["email"]:
        return False, "Invalid email address"
    return True, "Valid data"

@pytest.mark.parametrize("input_data", ["valid", "invalid"], indirect=True)
def test_validate_data(input_data):
    is_valid, message = validate_data(input_data)
    if input_data == {"name": "John Doe", "email": "john.doe@example.com"}:
        assert is_valid is True
        assert message == "Valid data"
    else:
        assert is_valid is False
        assert message in ["Name cannot be empty", "Invalid email address"]

            

              
                Copy
              
            
          

In diesem Beispiel wird die input_data-Fixture mit den Werten "valid" und "invalid" parametrisiert. Das Argument indirect=True weist Pytest an, diese Werte an die input_data-Fixture-Funktion zu übergeben. Die input_data-Fixture gibt dann je nach Parameterwert unterschiedliche Daten-Dictionaries zurück. Die test_validate_data-Funktion verwendet dann die input_data-Fixture, um die validate_data-Funktion mit unterschiedlichen Eingabedaten zu testen.

Mocking mit Pytest

Mocking ist eine Technik, die verwendet wird, um echte Abhängigkeiten während des Testens durch kontrollierte Substitute (Mocks) zu ersetzen. Dies ermöglicht es Ihnen, den zu testenden Code zu isolieren und die Abhängigkeit von externen Systemen wie Datenbanken, APIs oder Dateisystemen zu vermeiden.

Vorteile des Mockings

• Code isolieren: Testen Sie Code isoliert, ohne sich auf externe Abhängigkeiten zu verlassen.
• Verhalten steuern: Definieren Sie das Verhalten von Abhängigkeiten, wie z. B. Rückgabewerte und Ausnahmen.
• Tests beschleunigen: Vermeiden Sie langsame oder unzuverlässige externe Systeme.
• Grenzfälle testen: Simulieren Sie Fehlerbedingungen und Grenzfälle, die in einer realen Umgebung schwer zu reproduzieren sind.

Verwendung der unittest.mock-Bibliothek

Python stellt die unittest.mock-Bibliothek zur Erstellung von Mocks zur Verfügung. Pytest integriert sich nahtlos in unittest.mock, was das Mocken von Abhängigkeiten in Ihren Tests erleichtert.

Einfaches Mocking-Beispiel

Angenommen, Sie haben eine Funktion, die Daten von einer externen API abruft:

            
import requests

def get_data_from_api(url):
    response = requests.get(url)
    response.raise_for_status()  # Raise an exception for bad status codes
    return response.json()

            

              
                Copy
              
            
          

Um diese Funktion zu testen, ohne tatsächlich eine Anfrage an die API zu senden, können Sie die requests.get-Funktion mocken:

            
import pytest
import requests
from unittest.mock import patch

@patch("requests.get")
def test_get_data_from_api(mock_get):
    # Configure the mock to return a specific response
    mock_get.return_value.json.return_value = {"data": "test data"}
    mock_get.return_value.status_code = 200

    # Call the function being tested
    data = get_data_from_api("https://example.com/api")

    # Assert that the mock was called with the correct URL
    mock_get.assert_called_once_with("https://example.com/api")

    # Assert that the function returned the expected data
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

In diesem Beispiel ersetzt der @patch("requests.get")-Decorator die requests.get-Funktion durch ein Mock-Objekt. Das mock_get-Argument ist das Mock-Objekt. Wir können dann das Mock-Objekt so konfigurieren, dass es eine spezifische Antwort zurückgibt, und sicherstellen, dass es mit der korrekten URL aufgerufen wurde.

Mocking mit Fixtures

Sie können auch Fixtures verwenden, um Mocks zu erstellen und zu verwalten. Dies kann nützlich sein, um Mocks über mehrere Tests hinweg zu teilen oder um komplexere Mock-Setups zu erstellen.

            
import pytest
import requests
from unittest.mock import Mock

@pytest.fixture
def mock_api_get():
    mock = Mock()
    mock.return_value.json.return_value = {"data": "test data"}
    mock.return_value.status_code = 200
    return mock


@pytest.fixture
def patched_get(mock_api_get, monkeypatch):
    monkeypatch.setattr(requests, "get", mock_api_get)
    return mock_api_get


def test_get_data_from_api(patched_get):
    # Call the function being tested
    data = get_data_from_api("https://example.com/api")

    # Assert that the mock was called with the correct URL
    patched_get.assert_called_once_with("https://example.com/api")

    # Assert that the function returned the expected data
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

Hier erstellt mock_api_get einen Mock und gibt ihn zurück. patched_get verwendet dann monkeypatch, eine Pytest-Fixture, um die echte `requests.get`-Funktion durch den Mock zu ersetzen. Dies ermöglicht es anderen Tests, denselben gemockten API-Endpunkt zu verwenden.

Fortgeschrittene Mocking-Techniken

Pytest und unittest.mock bieten mehrere fortgeschrittene Mocking-Techniken, darunter:

• Side Effects (Nebenwirkungen): Definieren Sie benutzerdefiniertes Verhalten für Mocks basierend auf den Eingabeargumenten.
• Property Mocking: Mocken Sie Eigenschaften von Objekten.
• Kontextmanager: Verwenden Sie Mocks innerhalb von Kontextmanagern für temporäre Ersetzungen.

Side Effects (Nebenwirkungen)

Side Effects ermöglichen es Ihnen, benutzerdefiniertes Verhalten für Ihre Mocks basierend auf den empfangenen Eingabeargumenten zu definieren. Dies ist nützlich, um verschiedene Szenarien oder Fehlerbedingungen zu simulieren.

            
import pytest
from unittest.mock import Mock

def test_side_effect():
    mock = Mock()
    mock.side_effect = [1, 2, 3]

    assert mock() == 1
    assert mock() == 2
    assert mock() == 3
    with pytest.raises(StopIteration):
        mock()

            

              
                Copy
              
            
          

Dieser Mock gibt bei aufeinanderfolgenden Aufrufen 1, 2 und 3 zurück und löst dann eine `StopIteration`-Ausnahme aus, wenn die Liste erschöpft ist.

Property Mocking

Property Mocking ermöglicht es Ihnen, das Verhalten von Eigenschaften auf Objekten zu mocken. Dies ist nützlich zum Testen von Code, der auf Objekteigenschaften anstatt auf Methoden angewiesen ist.

            
import pytest
from unittest.mock import patch

class MyClass:
    @property
    def my_property(self):
        return "original value"


def test_property_mocking():
    obj = MyClass()
    with patch.object(obj, "my_property", new_callable=pytest.PropertyMock) as mock_property:
        mock_property.return_value = "mocked value"
        assert obj.my_property == "mocked value"

            

              
                Copy
              
            
          

Dieses Beispiel mockt die my_property-Eigenschaft des MyClass-Objekts, sodass Sie dessen Rückgabewert während des Tests steuern können.

Kontextmanager

Die Verwendung von Mocks innerhalb von Kontextmanagern ermöglicht es Ihnen, Abhängigkeiten für einen bestimmten Codeblock vorübergehend zu ersetzen. Dies ist nützlich zum Testen von Code, der mit externen Systemen oder Ressourcen interagiert, die nur für eine begrenzte Zeit gemockt werden sollen.

            
import pytest
from unittest.mock import patch


def test_context_manager_mocking():
    with patch("os.path.exists") as mock_exists:
        mock_exists.return_value = True
        assert os.path.exists("dummy_path") is True
    # Der Mock wird nach dem 'with'-Block automatisch zurückgesetzt
    # Sicherstellen, dass die ursprüngliche Funktion wiederhergestellt wird, obwohl wir das
    # Verhalten der echten `os.path.exists`-Funktion ohne einen echten Pfad nicht wirklich prüfen können.
    # Wichtig ist, dass der Patch nach dem Kontext verschwunden ist.
    print("Mock wurde entfernt")

            

              
                Copy
              
            
          

Kombination von Parametrisierung und Mocking

Diese beiden leistungsstarken Techniken können kombiniert werden, um noch ausgefeiltere und effektivere Tests zu erstellen. Sie können Parametrisierung verwenden, um verschiedene Szenarien mit unterschiedlichen Mock-Konfigurationen zu testen.

            
import pytest
import requests
from unittest.mock import patch


def get_user_data(user_id):
    url = f"https://api.example.com/users/{user_id}"
    response = requests.get(url)
    response.raise_for_status()
    return response.json()


@pytest.mark.parametrize(
    "user_id, expected_data",
    [
        (1, {"id": 1, "name": "John Doe"}),
        (2, {"id": 2, "name": "Jane Smith"}),
    ],
)
@patch("requests.get")
def test_get_user_data(mock_get, user_id, expected_data):
    mock_get.return_value.json.return_value = expected_data
    mock_get.return_value.status_code = 200

    data = get_user_data(user_id)

    assert data == expected_data
    mock_get.assert_called_once_with(f"https://api.example.com/users/{user_id}")

            

              
                Copy
              
            
          

In diesem Beispiel wird die test_get_user_data-Funktion mit unterschiedlichen user_id- und expected_data-Werten parametrisiert. Der @patch-Decorator mockt die requests.get-Funktion. Pytest wird die Testfunktion zweimal ausführen, einmal für jeden Parametersatz, wobei der Mock so konfiguriert ist, dass er die entsprechenden expected_data zurückgibt.

Best Practices für die Verwendung fortgeschrittener Fixtures

• Fixtures fokussiert halten: Jede Fixture sollte einen klaren und spezifischen Zweck haben.
• Geeignete Geltungsbereiche verwenden: Wählen Sie den passenden Fixture-Geltungsbereich (Funktion, Modul, Sitzung), um die Ressourcennutzung zu optimieren.
• Fixtures dokumentieren: Dokumentieren Sie klar den Zweck und die Verwendung jeder Fixture.
• Übermäßiges Mocking vermeiden: Mocken Sie nur Abhängigkeiten, die zur Isolierung des zu testenden Codes notwendig sind.
• Klare Assertions schreiben: Stellen Sie sicher, dass Ihre Assertions klar und spezifisch sind und das erwartete Verhalten des zu testenden Codes überprüfen.
• Testgetriebene Entwicklung (TDD) in Betracht ziehen: Schreiben Sie Ihre Tests vor dem Code und verwenden Sie Fixtures und Mocks, um den Entwicklungsprozess zu leiten.

Fazit

Die fortgeschrittenen Fixture-Techniken von Pytest, einschließlich parametrisierter Tests und Mock-Integration, bieten leistungsstarke Werkzeuge zum Schreiben robuster, effizienter und wartbarer Tests. Indem Sie diese Techniken meistern, können Sie die Qualität Ihres Python-Codes erheblich verbessern und Ihren Test-Workflow optimieren. Denken Sie daran, sich auf die Erstellung klarer, fokussierter Fixtures, die Verwendung geeigneter Geltungsbereiche und das Schreiben umfassender Assertions zu konzentrieren. Mit Übung werden Sie in der Lage sein, das volle Potenzial des Fixture-Systems von Pytest zu nutzen, um eine umfassende und effektive Teststrategie zu entwickeln.