Professionelles Testen mit pytest: Mocking mit monkeypatch und create_autospec

01. July 2025 Tim Fiedler

pytest testing mocking python software-development best-practices

Ein umfassender Leitfaden zum professionellen Testen mit pytest. Lernen Sie, wie Sie mit monkeypatch und create_autospec typsichere Mocks erstellen und warum create_autospec entscheidend ist, um Signaturen nicht zu ignorieren.

Professionelles Testen mit pytest: Ein umfassender Leitfaden

Testing ist das Rückgrat jeder professionellen Software-Entwicklung. In diesem ausführlichen Artikel zeigen wir Ihnen, wie Sie mit pytest effektive und wartbare Tests schreiben. Besonders fokussieren wir uns auf das Mocking mit monkeypatch und create_autospec - zwei mächtige Werkzeuge, die oft missverstanden oder falsch eingesetzt werden.

Warum pytest?

pytest ist das de-facto Standard-Testing-Framework für Python und bietet gegenüber dem eingebauten unittest mehrere Vorteile:

Einfache Syntax: Normale assert-Statements statt spezieller Assertion-Methoden
Automatische Test-Discovery: Findet Tests automatisch basierend auf Namenskonventionen
Fixtures: Mächtige Dependency-Injection für Test-Setup und -Teardown
Parametrisierte Tests: Einfaches Testen mit verschiedenen Eingabewerten
Umfangreiches Plugin-Ökosystem: Erweiterungen für Coverage, Benchmarking, etc.

Grundlagen: Einfache Tests schreiben

Beginnen wir mit einem einfachen Beispiel:

# calculator.py
class Calculator:
    def add(self, a, b):
        return a + b

    def divide(self, a, b):
        if b == 0:
            raise ValueError("Division by zero is not allowed")
        return a / b

# test_calculator.py
import pytest
from calculator import Calculator


def test_add():
    calc = Calculator()
    result = calc.add(2, 3)
    assert result == 5


def test_divide():
    calc = Calculator()
    result = calc.divide(10, 2)
    assert result == 5.0


def test_divide_by_zero():
    calc = Calculator()
    with pytest.raises(ValueError, match="Division by zero is not allowed"):
        calc.divide(10, 0)

Fixtures: Setup und Teardown elegant lösen

Fixtures sind pytest's Antwort auf Setup- und Teardown-Code:

import pytest
from calculator import Calculator


@pytest.fixture
def calculator():
    # Fixture that provides a Calculator instance for tests
    return Calculator()


def test_add_with_fixture(calculator):
    result = calculator.add(2, 3)
    assert result == 5


@pytest.fixture
def database_connection():
    # Fixture with setup and teardown
    # Setup
    connection = create_database_connection()
    yield connection
    # Teardown
    connection.close()

Das Problem mit externen Abhängigkeiten

In realen Anwendungen haben unsere Klassen oft externe Abhängigkeiten:

# email_service.py
import smtplib
from email.mime.text import MIMEText


class EmailService:
    def __init__(self, smtp_server, port):
        self.smtp_server = smtp_server
        self.port = port

    def send_email(self, to_email, subject, body):
        # Send an email via SMTP
        msg = MIMEText(body)
        msg['Subject'] = subject
        msg['To'] = to_email

        with smtplib.SMTP(self.smtp_server, self.port) as server:
            server.send_message(msg)
            return True


# notification_service.py
from email_service import EmailService


class NotificationService:
    def __init__(self, email_service: EmailService):
        self.email_service = email_service

    def notify_user(self, user_email, message):
        # Send notification to user
        subject = "Important Notification"
        success = self.email_service.send_email(user_email, subject, message)
        if success:
            return f"Notification sent to {user_email}"
        else:
            return "Failed to send notification"

Das Testen dieser Klassen ohne Mocking würde bedeuten, dass wir echte E-Mails versenden müssten - das ist unpraktisch, langsam und kann Seiteneffekte haben.

Mocking mit monkeypatch: Die Grundlagen

monkeypatch ist pytest's eingebautes Fixture zum Ersetzen von Objekten zur Laufzeit:

# test_notification_service.py
import pytest
from notification_service import NotificationService
from email_service import EmailService


def test_notify_user_success(monkeypatch):
    # Test successful notification using monkeypatch
    # Arrange
    email_service = EmailService("smtp.example.com", 587)
    notification_service = NotificationService(email_service)

    # Mock the send_email method
    def mock_send_email(to_email, subject, body):
        return True

    monkeypatch.setattr(email_service, 'send_email', mock_send_email)

    # Act
    result = notification_service.notify_user("[email protected]", "Test message")

    # Assert
    assert result == "Notification sent to [email protected]"


def test_notify_user_failure(monkeypatch):
    # Test failed notification using monkeypatch
    email_service = EmailService("smtp.example.com", 587)
    notification_service = NotificationService(email_service)

    # Mock the send_email method to return False
    monkeypatch.setattr(email_service, 'send_email', lambda *args: False)

    result = notification_service.notify_user("[email protected]", "Test message")
    assert result == "Failed to send notification"

Das Problem mit einfachen Mocks

Der obige Ansatz funktioniert, hat aber einen kritischen Schwachpunkt: Signatur-Ignoranz. Wenn sich die Signatur der gemockten Methode ändert, bemerken wir das nicht:

# Angenommen, EmailService.send_email ändert sich zu:
def send_email(self, to_email, subject, body, priority="normal"):
    # ...

Unser Mock würde weiterhin funktionieren, obwohl er die neue Signatur nicht respektiert. Das kann zu Bugs führen, die erst in der Produktion auffallen.

create_autospec: Typsichere Mocks

create_autospec löst dieses Problem, indem es Mocks erstellt, die die Signatur des ursprünglichen Objekts respektieren:

from unittest.mock import create_autospec
import pytest
from notification_service import NotificationService
from email_service import EmailService


def test_notify_user_with_autospec():
    # Test using create_autospec for type-safe mocking
    # Create a mock that respects EmailService's interface
    mock_email_service = create_autospec(EmailService, instance=True)

    # Configure the mock's return value
    mock_email_service.send_email.return_value = True

    # Create the service with the mock
    notification_service = NotificationService(mock_email_service)

    # Act
    result = notification_service.notify_user("[email protected]", "Test message")

    # Assert
    assert result == "Notification sent to [email protected]"

    # Verify the mock was called with correct arguments
    mock_email_service.send_email.assert_called_once_with(
        "[email protected]", 
        "Important Notification", 
        "Test message"
    )


def test_autospec_enforces_signature():
    # Demonstrate how autospec enforces method signatures
    mock_email_service = create_autospec(EmailService, instance=True)

    # This would raise TypeError if EmailService.send_email doesn't accept these parameters
    with pytest.raises(TypeError):
        mock_email_service.send_email("too", "many", "arguments", "here", "invalid")

Warum create_autospec so wichtig ist

1. Signatur-Validierung

def test_signature_validation():
    # Demonstrate signature validation with autospec
    mock_service = create_autospec(EmailService, instance=True)

    # This will fail if the signature doesn't match
    with pytest.raises(TypeError):
        mock_service.send_email()  # Missing required arguments

2. Attribute-Validierung

def test_attribute_validation():
    # Autospec also validates attributes
    mock_service = create_autospec(EmailService, instance=True)

    # This will fail because EmailService doesn't have a 'nonexistent_method'
    with pytest.raises(AttributeError):
        mock_service.nonexistent_method()

3. Refactoring-Sicherheit

Wenn Sie Ihre Klassen refactorieren und Methodensignaturen ändern, werden Tests mit create_autospec automatisch fehlschlagen und Sie auf notwendige Anpassungen hinweisen.

Kombinieren von monkeypatch und create_autospec

Für maximale Flexibilität können Sie beide Ansätze kombinieren:

def test_combined_approach(monkeypatch):
    # Combine monkeypatch with create_autospec
    # Create a type-safe mock
    mock_email_service = create_autospec(EmailService, instance=True)
    mock_email_service.send_email.return_value = True

    # Use monkeypatch to replace the class constructor
    monkeypatch.setattr('notification_service.EmailService', 
                       lambda *args: mock_email_service)

    # Now any code that creates EmailService will get our mock
    from notification_service import NotificationService
    service = NotificationService(EmailService("any", "args"))

    result = service.notify_user("[email protected]", "Test")
    assert result == "Notification sent to [email protected]"

Erweiterte Mocking-Patterns

Side Effects für komplexe Szenarien

def test_side_effects():
    # Use side_effect for complex mock behavior
    mock_service = create_autospec(EmailService, instance=True)

    # First call succeeds, second fails
    mock_service.send_email.side_effect = [True, False]

    notification_service = NotificationService(mock_service)

    # First call
    result1 = notification_service.notify_user("[email protected]", "Message 1")
    assert result1 == "Notification sent to [email protected]"

    # Second call
    result2 = notification_service.notify_user("[email protected]", "Message 2")
    assert result2 == "Failed to send notification"

Exception-Handling testen

def test_exception_handling():
    # Test how your code handles exceptions
    mock_service = create_autospec(EmailService, instance=True)
    mock_service.send_email.side_effect = ConnectionError("SMTP server unavailable")

    notification_service = NotificationService(mock_service)

    with pytest.raises(ConnectionError):
        notification_service.notify_user("[email protected]", "Test")

Best Practices für pytest und Mocking

1. Verwenden Sie aussagekräftige Testnamen

def test_notification_service_returns_success_message_when_email_sent():
    # Klar, was getestet wird
    pass

def test_notify():  # Schlecht: Unklar was getestet wird
    pass

2. Folgen Sie dem AAA-Pattern

def test_user_notification():
    # Arrange
    mock_service = create_autospec(EmailService, instance=True)
    mock_service.send_email.return_value = True
    notification_service = NotificationService(mock_service)

    # Act
    result = notification_service.notify_user("[email protected]", "Test")

    # Assert
    assert result == "Notification sent to [email protected]"

3. Mocken Sie nur was nötig ist

# Gut: Nur die externe Abhängigkeit mocken
def test_with_minimal_mocking():
    mock_email = create_autospec(EmailService, instance=True)
    mock_email.send_email.return_value = True
    # Test logic...

# Schlecht: Alles mocken
def test_with_excessive_mocking(monkeypatch):
    monkeypatch.setattr('builtins.str', lambda x: 'mocked')
    monkeypatch.setattr('builtins.len', lambda x: 42)
    # Macht den Test unverständlich und fragil

4. Verwenden Sie Fixtures für wiederverwendbare Mocks

@pytest.fixture
def mock_email_service():
    # Reusable mock for EmailService
    mock = create_autospec(EmailService, instance=True)
    mock.send_email.return_value = True
    return mock


def test_with_fixture(mock_email_service):
    notification_service = NotificationService(mock_email_service)
    # Test logic...

Walkthrough: Ein komplettes Beispiel

Lassen Sie uns ein vollständiges Beispiel durchgehen, das alle Konzepte zusammenbringt:

# user_manager.py
from typing import List
from email_service import EmailService
from database import UserRepository


class UserManager:
    def __init__(self, user_repo: UserRepository, email_service: EmailService):
        self.user_repo = user_repo
        self.email_service = email_service

    def register_user(self, email: str, name: str) -> dict:
        # Register a new user and send welcome email
        # Check if user already exists
        if self.user_repo.find_by_email(email):
            return {"success": False, "error": "User already exists"}

        # Create user
        user_id = self.user_repo.create_user(email, name)

        # Send welcome email
        welcome_message = f"Welcome {name}! Your account has been created."
        email_sent = self.email_service.send_email(
            email,
            "Welcome to our platform",
            welcome_message
        )

        if not email_sent:
            # Rollback user creation if email fails
            self.user_repo.delete_user(user_id)
            return {"success": False, "error": "Failed to send welcome email"}

        return {"success": True, "user_id": user_id}

# test_user_manager.py
import pytest
from unittest.mock import create_autospec
from user_manager import UserManager
from email_service import EmailService
from database import UserRepository


@pytest.fixture
def mock_user_repo():
    # Mock UserRepository with autospec
    return create_autospec(UserRepository, instance=True)


@pytest.fixture
def mock_email_service():
    # Mock EmailService with autospec
    return create_autospec(EmailService, instance=True)


@pytest.fixture
def user_manager(mock_user_repo, mock_email_service):
    # UserManager with mocked dependencies
    return UserManager(mock_user_repo, mock_email_service)


def test_register_user_success(user_manager, mock_user_repo, mock_email_service):
    # Test successful user registration
    # Arrange
    mock_user_repo.find_by_email.return_value = None  # User doesn't exist
    mock_user_repo.create_user.return_value = 123
    mock_email_service.send_email.return_value = True

    # Act
    result = user_manager.register_user("[email protected]", "John Doe")

    # Assert
    assert result == {"success": True, "user_id": 123}

    # Verify interactions
    mock_user_repo.find_by_email.assert_called_once_with("[email protected]")
    mock_user_repo.create_user.assert_called_once_with("[email protected]", "John Doe")
    mock_email_service.send_email.assert_called_once_with(
        "[email protected]",
        "Welcome to our platform",
        "Welcome John Doe! Your account has been created."
    )


def test_register_user_already_exists(user_manager, mock_user_repo, mock_email_service):
    # Test registration when user already exists
    # Arrange
    mock_user_repo.find_by_email.return_value = {"id": 456, "email": "[email protected]"}

    # Act
    result = user_manager.register_user("[email protected]", "John Doe")

    # Assert
    assert result == {"success": False, "error": "User already exists"}

    # Verify no user creation or email sending occurred
    mock_user_repo.create_user.assert_not_called()
    mock_email_service.send_email.assert_not_called()


def test_register_user_email_failure_rollback(user_manager, mock_user_repo, mock_email_service):
    # Test rollback when email sending fails
    # Arrange
    mock_user_repo.find_by_email.return_value = None
    mock_user_repo.create_user.return_value = 123
    mock_email_service.send_email.return_value = False  # Email fails

    # Act
    result = user_manager.register_user("[email protected]", "John Doe")

    # Assert
    assert result == {"success": False, "error": "Failed to send welcome email"}

    # Verify rollback occurred
    mock_user_repo.delete_user.assert_called_once_with(123)

Fazit

Das Schreiben effektiver Tests mit pytest erfordert mehr als nur das Kennen der Syntax. Die richtige Verwendung von Mocking-Techniken, insbesondere create_autospec, ist entscheidend für:

Typsicherheit: Ihre Tests brechen, wenn sich Signaturen ändern
Wartbarkeit: Tests bleiben synchron mit dem Code
Vertrauen: Sie können sicher refactorieren
Geschwindigkeit: Tests laufen schnell ohne externe Abhängigkeiten

Wichtige Takeaways:

Verwenden Sie create_autospec statt einfacher Mocks für typsichere Tests
Kombinieren Sie monkeypatch und create_autospec für maximale Flexibilität
Folgen Sie dem AAA-Pattern (Arrange, Act, Assert)
Mocken Sie nur externe Abhängigkeiten, nicht Ihre eigene Logik
Schreiben Sie aussagekräftige Testnamen und verwenden Sie Fixtures für Wiederverwendbarkeit

Mit diesen Techniken können Sie robuste, wartbare Tests schreiben, die Ihnen helfen, qualitativ hochwertigen Code zu entwickeln und dabei das Vertrauen in Ihre Software zu stärken.

Weiterführende Ressourcen

Haben Sie Fragen zu pytest oder Mocking? Kontaktieren Sie uns gerne für eine persönliche Beratung zu Ihren Testing-Strategien!