Python-Testing

Python-Testmuster

Umfassende Teststrategien für Python-Anwendungen mit pytest, TDD-Methodik und Best Practices.

Wann aktivieren

• Beim Schreiben von neuem Python-Code (TDD befolgen: rot, grün, refaktor)
• Beim Entwerfen von Testsuiten für Python-Projekte
• Beim Überprüfen der Python-Testabdeckung
• Beim Einrichten der Testinfrastruktur

Kern-Testphilosophie

Testgetriebene Entwicklung (TDD)

Befolgen Sie immer den TDD-Zyklus:

1. ROT: Schreiben Sie einen fehlschlagenden Test für das gewünschte Verhalten
2. GRÜN: Schreiben Sie minimalen Code, um den Test zu bestehen
3. REFACTOR: Verbessern Sie den Code, während die Tests grün bleiben

# Schritt 1: Fehlschlagenden Test schreiben (ROT)
def test_add_numbers():
    result = add(2, 3)
    assert result == 5

# Schritt 2: Minimale Implementierung schreiben (GRÜN)
def add(a, b):
    return a + b

# Schritt 3: Bei Bedarf refaktorieren (REFACTOR)

Abdeckungsanforderungen

• Ziel: 80%+ Codeabdeckung
• Kritische Pfade: 100% Abdeckung erforderlich
• Verwenden Sie pytest --cov zur Messung der Abdeckung

pytest --cov=mypackage --cov-report=term-missing --cov-report=html

pytest-Grundlagen

Grundlegende Teststruktur

import pytest

def test_addition():
    """Test der grundlegenden Addition."""
    assert 2 + 2 == 4

def test_string_uppercase():
    """Test der Großschreibung von Zeichenketten."""
    text = "hello"
    assert text.upper() == "HELLO"

def test_list_append():
    """Test des Anhängens an eine Liste."""
    items = [1, 2, 3]
    items.append(4)
    assert 4 in items
    assert len(items) == 4

Assertions

# Gleichheit
assert result == expected

# Ungleichheit
assert result != unexpected

# Wahrheitswert
assert result  # Wahr
assert not result  # Falsch
assert result is True  # Exakt True
assert result is False  # Exakt False
assert result is None  # Exakt None

# Mitgliedschaft
assert item in collection
assert item not in collection

# Vergleiche
assert result > 0
assert 0 <= result <= 100

# Typüberprüfung
assert isinstance(result, str)

# Ausnahmetests (bevorzugter Ansatz)
with pytest.raises(ValueError):
    raise ValueError("Fehlermeldung")

# Ausnahmemeldung prüfen
with pytest.raises(ValueError, match="ungültige Eingabe"):
    raise ValueError("ungültige Eingabe bereitgestellt")

# Ausnahmeattribute prüfen
with pytest.raises(ValueError) as exc_info:
    raise ValueError("Fehlermeldung")
assert str(exc_info.value) == "Fehlermeldung"

Fixtures

Grundlegende Fixture-Nutzung

import pytest

@pytest.fixture
def sample_data():
    """Fixture, die Beispieldaten bereitstellt."""
    return {"name": "Alice", "age": 30}

def test_sample_data(sample_data):
    """Test mit der Fixture."""
    assert sample_data["name"] == "Alice"
    assert sample_data["age"] == 30

Fixture mit Setup/Teardown

@pytest.fixture
def database():
    """Fixture mit Setup und Teardown."""
    # Setup
    db = Database(":memory:")
    db.create_tables()
    db.insert_test_data()

    yield db  # Dem Test bereitstellen

    # Teardown
    db.close()

def test_database_query(database):
    """Test der Datenbankoperationen."""
    result = database.query("SELECT * FROM users")
    assert len(result) > 0

Fixture-Scopes

# Funktions-Scope (Standard) – wird für jeden Test ausgeführt
@pytest.fixture
def temp_file():
    with open("temp.txt", "w") as f:
        yield f
    os.remove("temp.txt")

# Modul-Scope – wird einmal pro Modul ausgeführt
@pytest.fixture(scope="module")
def module_db():
    db = Database(":memory:")
    db.create_tables()
    yield db
    db.close()

# Session-Scope – wird einmal pro Test-Session ausgeführt
@pytest.fixture(scope="session")
def shared_resource():
    resource = ExpensiveResource()
    yield resource
    resource.cleanup()

Fixture mit Parametern

@pytest.fixture(params=[1, 2, 3])
def number(request):
    """Parametrisierte Fixture."""
    return request.param

def test_numbers(number):
    """Test wird dreimal ausgeführt, einmal für jeden Parameter."""
    assert number > 0

Verwendung mehrerer Fixtures

@pytest.fixture
def user():
    return User(id=1, name="Alice")

@pytest.fixture
def admin():
    return User(id=2, name="Admin", role="admin")

def test_user_admin_interaction(user, admin):
    """Test mit mehreren Fixtures."""
    assert admin.can_manage(user)

Autouse-Fixtures

@pytest.fixture(autouse=True)
def reset_config():
    """Wird automatisch vor jedem Test ausgeführt."""
    Config.reset()
    yield
    Config.cleanup()

def test_without_fixture_call():
    # reset_config wird automatisch ausgeführt
    assert Config.get_setting("debug") is False

Conftest.py für gemeinsame Fixtures

# tests/conftest.py
import pytest

@pytest.fixture
def client():
    """Gemeinsame Fixture für alle Tests."""
    app = create_app(testing=True)
    with app.test_client() as client:
        yield client

@pytest.fixture
def auth_headers(client):
    """Generiert Auth-Header für API-Tests."""
    response = client.post("/api/login", json={
        "username": "test",
        "password": "test"
    })
    token = response.json["token"]
    return {"Authorization": f"Bearer {token}"}

Parametrisierung

Grundlegende Parametrisierung

@pytest.mark.parametrize("input,expected", [
    ("hello", "HELLO"),
    ("world", "WORLD"),
    ("PyThOn", "PYTHON"),
])
def test_uppercase(input, expected):
    """Test wird dreimal mit verschiedenen Eingaben ausgeführt."""
    assert input.upper() == expected

Mehrere Parameter

@pytest.mark.parametrize("a,b,expected", [
    (2, 3, 5),
    (0, 0, 0),
    (-1, 1, 0),
    (100, 200, 300),
])
def test_add(a, b, expected):
    """Test der Addition mit mehreren Eingaben."""
    assert add(a, b) == expected

Parametrisieren mit IDs

@pytest.mark.parametrize("input,expected", [
    ("[email protected]", True),
    ("invalid", False),
    ("@no-domain.com", False),
], ids=["gültige-email", "fehlendes-at", "fehlende-domain"])
def test_email_validation(input, expected):
    """Test der E-Mail-Validierung mit lesbaren Test-IDs."""
    assert is_valid_email(input) is expected

Parametrisierte Fixtures

@pytest.fixture(params=["sqlite", "postgresql", "mysql"])
def db(request):
    """Test gegen mehrere Datenbank-Backends."""
    if request.param == "sqlite":
        return Database(":memory:")
    elif request.param == "postgresql":
        return Database("postgresql://localhost/test")
    elif request.param == "mysql":
        return Database("mysql://localhost/test")

def test_database_operations(db):
    """Test wird dreimal ausgeführt, einmal für jede Datenbank."""
    result = db.query("SELECT 1")
    assert result is not None

Marker und Testauswahl

Benutzerdefinierte Marker

# Langsame Tests markieren
@pytest.mark.slow
def test_slow_operation():
    time.sleep(5)

# Integrationstests markieren
@pytest.mark.integration
def test_api_integration():
    response = requests.get("https://api.example.com")
    assert response.status_code == 200

# Unit-Tests markieren
@pytest.mark.unit
def test_unit_logic():
    assert calculate(2, 3) == 5

Bestimmte Tests ausführen

# Nur schnelle Tests ausführen
pytest -m "not slow"

# Nur Integrationstests ausführen
pytest -m integration

# Integrations- oder langsame Tests ausführen
pytest -m "integration or slow"

# Als Unit markierte, aber nicht langsame Tests ausführen
pytest -m "unit and not slow"

Marker in pytest.ini konfigurieren

[pytest]
markers =
    slow: markiert Tests als langsam
    integration: markiert Tests als Integrationstests
    unit: markiert Tests als Unit-Tests
    django: markiert Tests, die Django erfordern

Mocking und Patchen

Mocking von Funktionen

from unittest.mock import patch, Mock

@patch("mypackage.external_api_call")
def test_with_mock(api_call_mock):
    """Test mit gemocktem externem API-Aufruf."""
    api_call_mock.return_value = {"status": "success"}

    result = my_function()

    api_call_mock.assert_called_once()
    assert result["status"] == "success"

Mocking von Rückgabewerten

@patch("mypackage.Database.connect")
def test_database_connection(connect_mock):
    """Test mit gemockter Datenbankverbindung."""
    connect_mock.return_value = MockConnection()

    db = Database()
    db.connect()

    connect_mock.assert_called_once_with("localhost")

Mocking von Ausnahmen

@patch("mypackage.api_call")
def test_api_error_handling(api_call_mock):
    """Test der Fehlerbehandlung mit gemockter Ausnahme."""
    api_call_mock.side_effect = ConnectionError("Netzwerkfehler")

    with pytest.raises(ConnectionError):
        api_call()

    api_call_mock.assert_called_once()

Mocking von Context-Managern

@patch("builtins.open", new_callable=mock_open)
def test_file_reading(mock_file):
    """Test des Dateilesens mit gemocktem open."""
    mock_file.return_value.read.return_value = "Dateiinhalt"

    result = read_file("test.txt")

    mock_file.assert_called_once_with("test.txt", "r")
    assert result == "Dateiinhalt"

Verwenden von Autospec

@patch("mypackage.DBConnection", autospec=True)
def test_autospec(db_mock):
    """Test mit Autospec, um API-Fehlgebrauch zu erkennen."""
    db = db_mock.return_value
    db.query("SELECT * FROM users")

    # Dies würde fehlschlagen, wenn DBConnection keine query-Methode hat
    db_mock.assert_called_once()

Mock-Klasseninstanzen

class TestUserService:
    @patch("mypackage.UserRepository")
    def test_create_user(self, repo_mock):
        """Test der Benutzererstellung mit gemocktem Repository."""
        repo_mock.return_value.save.return_value = User(id=1, name="Alice")

        service = UserService(repo_mock.return_value)
        user = service.create_user(name="Alice")

        assert user.name == "Alice"
        repo_mock.return_value.save.assert_called_once()

Mock-Property

@pytest.fixture
def mock_config():
    """Erstelle einen Mock mit einer Eigenschaft."""
    config = Mock()
    type(config).debug = PropertyMock(return_value=True)
    type(config).api_key = PropertyMock(return_value="test-key")
    return config

def test_with_mock_config(mock_config):
    """Test mit gemockten Konfigurationseigenschaften."""
    assert mock_config.debug is True
    assert mock_config.api_key == "test-key"

Testen von asynchronem Code

Async-Tests mit pytest-asyncio

import pytest

@pytest.mark.asyncio
async def test_async_function():
    """Test der asynchronen Funktion."""
    result = await async_add(2, 3)
    assert result == 5

@pytest.mark.asyncio
async def test_async_with_fixture(async_client):
    """Async-Test mit async-Fixture."""
    response = await async_client.get("/api/users")
    assert response.status_code == 200

Async-Fixture

@pytest.fixture
async def async_client():
    """Async-Fixture, die einen async-Test-Client bereitstellt."""
    app = create_app()
    async with app.test_client() as client:
        yield client

@pytest.mark.asyncio
async def test_api_endpoint(async_client):
    """Test mit async-Fixture."""
    response = await async_client.get("/api/data")
    assert response.status_code == 200

Mocking von asynchronen Funktionen

@pytest.mark.asyncio
@patch("mypackage.async_api_call")
async def test_async_mock(api_call_mock):
    """Test der asynchronen Funktion mit Mock."""
    api_call_mock.return_value = {"status": "ok"}

    result = await my_async_function()

    api_call_mock.assert_awaited_once()
    assert result["status"] == "ok"

Testen von Ausnahmen

Testen erwarteter Ausnahmen

def test_divide_by_zero():
    """Test, dass Division durch Null ZeroDivisionError auslöst."""
    with pytest.raises(ZeroDivisionError):
        divide(10, 0)

def test_custom_exception():
    """Test der benutzerdefinierten Ausnahme mit Meldung."""
    with pytest.raises(ValueError, match="ungültige Eingabe"):
        validate_input("ungültig")

Testen von Ausnahmeattributen

def test_exception_with_details():
    """Test der Ausnahme mit benutzerdefinierten Attributen."""
    with pytest.raises(CustomError) as exc_info:
        raise CustomError("Fehler", code=400)

    assert exc_info.value.code == 400
    assert "Fehler" in str(exc_info.value)

Testen von Seiteneffekten

Testen von Dateioperationen

import tempfile
import os

def test_file_processing():
    """Test der Dateiverarbeitung mit temporärer Datei."""
    with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as f:
        f.write("Testinhalt")
        temp_path = f.name

    try:
        result = process_file(temp_path)
        assert result == "verarbeitet: Testinhalt"
    finally:
        os.unlink(temp_path)

Testen mit pytest's tmp_path-Fixture

def test_with_tmp_path(tmp_path):
    """Test mit pytest's integrierter tmp_path-Fixture."""
    test_file = tmp_path / "test.txt"
    test_file.write_text("hallo welt")

    result = process_file(str(test_file))
    assert result == "hallo welt"
    # tmp_path wird automatisch bereinigt

Testen mit tmpdir-Fixture

def test_with_tmpdir(tmpdir):
    """Test mit pytest's tmpdir-Fixture."""
    test_file = tmpdir.join("test.txt")
    test_file.write("daten")

    result = process_file(str(test_file))
    assert result == "daten"

Testorganisation

Verzeichnisstruktur

tests/
├── conftest.py                 # Gemeinsame Fixtures
├── __init__.py
├── unit/                       # Unit-Tests
│   ├── __init__.py
│   ├── test_models.py
│   ├── test_utils.py
│   └── test_services.py
├── integration/                # Integrationstests
│   ├── __init__.py
│   ├── test_api.py
│   └── test_database.py
└── e2e/                        # End-to-End-Tests
    ├── __init__.py
    └── test_user_flow.py

Testklassen

class TestUserService:
    """Verwandte Tests in einer Klasse gruppieren."""

    @pytest.fixture(autouse=True)
    def setup(self):
        """Setup wird vor jedem Test in dieser Klasse ausgeführt."""
        self.service = UserService()

    def test_create_user(self):
        """Test der Benutzererstellung."""
        user = self.service.create_user("Alice")
        assert user.name == "Alice"

    def test_delete_user(self):
        """Test der Benutzerlöschung."""
        self.service.create_user("Bob")
        result = self.service.delete_user("Bob")
        assert result is True
        assert self.service.get_user("Bob") is None

Testnamen-Konvention

# Klare und beschreibende Testnamen verwenden
def test_user_can_login_with_valid_credentials():
    """Test, ob sich ein Benutzer mit gültigen Anmeldedaten anmelden kann."""
    pass

def test_user_cannot_login_with_invalid_password():
    """Test, ob ein Benutzer sich nicht mit ungültigem Passwort anmelden kann."""
    pass

def test_admin_can_delete_any_user():
    """Test, ob ein Admin jeden Benutzer löschen kann."""
    pass

Konfiguration

pytest.ini-Einstellungen

[pytest]
minversion = 7.0
testpaths = tests
python_files = test_*.py
python_functions = test_*
python_classes = Test*
addopts = -v --tb=short --strict-markers
markers =
    slow: markiert Tests als langsam
    integration: markiert Tests als Integrationstests
    unit: markiert Tests als Unit-Tests
    e2e: markiert Tests als End-to-End-Tests
filterwarnings =
    ignore::DeprecationWarning

pyproject.toml-Einstellungen

[tool.pytest.ini_options]
minversion = "7.0"
testpaths = ["tests"]
python_files = ["test_*.py"]
python_functions = ["test_*"]
python_classes = ["Test*"]
addopts = "-v --tb=short --strict-markers"
markers = [
    "slow: markiert Tests als langsam",
    "integration: markiert Tests als Integrationstests",
    "unit: markiert Tests als Unit-Tests",
    "e2e: markiert Tests als End-to-End-Tests",
]
filterwarnings = [
    "ignore::DeprecationWarning",
]

CI/CD-Integration

GitHub Actions-Beispiel

name: Python-Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ["3.9", "3.10", "3.11"]

    steps:
    - uses: actions/checkout@v3
    - name: Python ${{ matrix.python-version }} einrichten
      uses: actions/setup-python@v4
      with:
        python-version: ${{ matrix.python-version }}
    - name: Abhängigkeiten installieren
      run: |
        python -m pip install --upgrade pip
        pip install pytest pytest-cov pytest-asyncio
        pip install -r requirements.txt
    - name: Tests mit Coverage ausführen
      run: |
        pytest --cov=mypackage --cov-report=xml --cov-report=term-missing
    - name: Coverage-Bericht hochladen
      uses: codecov/codecov-action@v3

GitLab CI-Beispiel

stages:
  - test

pytest:
  stage: test
  image: python:3.11
  script:
    - pip install pytest pytest-cov pytest-asyncio
    - pip install -r requirements.txt
    - pytest --cov=mypackage --cov-report=term-missing --junitxml=report.xml
  artifacts:
    reports:
      junit: report.xml

Häufige Muster

Factory-Fixture

@pytest.fixture
def user_factory():
    """Factory zum Erstellen von Testbenutzern."""
    def _create_user(name="Default", role="user", **kwargs):
        return User(name=name, role=role, **kwargs)
    return _create_user

def test_user_creation(user_factory):
    """Test mit Factory-Fixture."""
    user = user_factory(name="Alice")
    assert user.name == "Alice"
    assert user.role == "user"

def test_admin_creation(user_factory):
    """Test mit Factory-Fixture für Admin."""
    admin = user_factory(name="Bob", role="admin")
    assert admin.name == "Bob"
    assert admin.role == "admin"

Datengesteuerte Tests mit Fixtures

import json

@pytest.fixture
def load_test_data():
    """Lade Testdaten aus einer JSON-Datei."""
    def _load(filename):
        with open(f"tests/data/{filename}") as f:
            return json.load(f)
    return _load

def test_with_external_data(load_test_data):
    """Test mit extern geladenen Daten."""
    data = load_test_data("users.json")
    assert len(data["users"]) > 0
    assert all(u["id"] for u in data["users"])

Testen von API-Endpunkten

@pytest.fixture
def app():
    """Erstelle eine Test-Flask-App."""
    app = create_app(testing=True)
    return app

@pytest.fixture
def client(app):
    """Erstelle einen Test-Client."""
    with app.test_client() as client:
        yield client

def test_api_get_users(client):
    """Test des API GET-Endpunkts."""
    response = client.get("/api/users")
    assert response.status_code == 200
    data = response.get_json()
    assert isinstance(data, list)

def test_api_create_user(client):
    """Test des API POST-Endpunkts."""
    response = client.post("/api/users", json={
        "name": "Alice",
        "email": "[email protected]"
    })
    assert response.status_code == 201
    data = response.get_json()
    assert data["name"] == "Alice"

Fehlerbehebung

Häufige Probleme

1. Fixture nicht gefunden: Stellen Sie sicher, dass die Fixture in der Datei oder conftest.py definiert ist
2. Scope-Konflikte: Verwenden Sie scope-Parameter angemessen, um Ressourcenkonflikte zu vermeiden
3. Mock-Seiteneffekte: Überprüfen Sie side_effect bei Mock-Aufrufreihenfolgen
4. Async-Tests fehlschlagen: Stellen Sie sicher, dass pytest-asyncio installiert ist und der Test mit @pytest.mark.asyncio markiert ist
5. Test-Reihenfolge: Verwenden Sie pytest-randomly, um die Reihenfolge der Tests zu mischen

Debugging-Tipps

# Detaillierte Ausgabe aktivieren
pytest -v --tb=long

# Nur den ersten fehlschlagenden Test ausführen
pytest -x

# Tests nach Fehler anhalten
pytest --maxfail=5

# In Test-Pausen einzusteigen (erfordert pdb)
pytest --pdb

# Ausgabeerfassung deaktivieren
pytest -s

Best Practices

1. Schreiben Sie zuerst Tests (TDD: rot, grün, refaktor)
2. Halten Sie Tests isoliert: Jeder Test sollte unabhängig sein
3. Verwenden Sie beschreibende Testnamen: test_user_can_login_with_valid_credentials()
4. Eine Assertion pro Konzept: Testen Sie eine Sache pro Test, wann immer möglich
5. Verwenden Sie Fixtures für die Testeinrichtung: Vermeiden Sie Setup-Code in Tests
6. Mocken Sie externe Abhängigkeiten: Isolieren Sie die zu testende Einheit
7. Streben Sie 80%+ Codeabdeckung an: Konzentrieren Sie sich auf kritische Pfade
8. Führen Sie Tests häufig aus: Integrieren Sie Tests in Ihren Entwicklungs-Workflow
9. Dokumentieren Sie Testmuster: Halten Sie Konsistenz im gesamten Projekt
10. Überprüfen Sie Test-Warnungen: Beheben Sie Veraltungswarnungen umgehend