Integration Tests Grundlagen

Integration Tests prüfen, wie mehrere Komponenten oder Systeme zusammenarbeiten. Während Unit Tests einzelne Bausteine isoliert testen, liefern Integration Tests Sicherheit darüber, dass Module, Datenbanken und externe Dienste korrekt miteinander kommunizieren.

In a Nutshell

• Integration Tests überprüfen das Zusammenspiel von Komponenten oder Systemen.
• Sie finden Fehler, die durch reine Unit Tests nicht entdeckt werden.
• Strategien: Big Bang, Top-Down, Bottom-Up und Sandwich.
• Testcontainers, lokale In-Memory-Datenbanken und Staging-Umgebungen sind gängige Werkzeuge.

Kompakte Fachbeschreibung

Ein Integration Test führt mehrere Komponenten zusammen, um ihre Schnittstellen und das gemeinsame Verhalten zu validieren. Dabei werden echte Abhängigkeiten wie Datenbanken, Message Queues oder APIs eingebunden oder durch leichtgewichtige Testfassungen simuliert. Integration Tests sind langsamer und aufwendiger als Unit Tests, decken aber realistischere Szenarien ab.

Integrationstest-Strategien

Big Bang Integration

Alle Module werden gleichzeitig zusammengesetzt und getestet. Der Ansatz ist einfach, aber schwer zu debuggen, weil Fehlerquellen schwer zu lokalisieren sind.

Top-Down Integration

Testen beginnt mit der obersten Steuerungsebene und arbeitet sich nach unten vor. Noch nicht verfügbare untere Module werden durch Stubs ersetzt.

Bottom-Up Integration

Testen beginnt mit den untersten Modulen und arbeitet sich nach oben. Treiber ersetzen noch nicht integrierte übergeordnete Module.

Sandwich Integration

Kombination aus Top-Down und Bottom-Up. Gleichzeitig von oben und nach unten testen, um schneller Ergebnisse zu erhalten.

Wichtige Werkzeuge

• Testcontainers: Docker-Container für Datenbanken, Message Broker und Caches in Tests.
• H2 / SQLite: Leichtgewichtige In-Memory-Datenbanken für schnelle Tests.
• REST Assured: Testen von HTTP APIs in Java.
• Supertest: Testen von HTTP APIs in Node.js.
• Spring Boot Test: Integrationstests für Spring-Anwendungen.

Praxisbeispiel: API-Integration mit Datenbank

import unittest
from fastapi.testclient import TestClient
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

from app.main import app, get_db
from app.models import Base

SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"
engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base.metadata.create_all(bind=engine)

def override_get_db():
    db = TestingSessionLocal()
    try:
        yield db
    finally:
        db.close()

app.dependency_overrides[get_db] = override_get_db
client = TestClient(app)

class TestItemApi(unittest.TestCase):
    def test_create_item(self):
        response = client.post("/items/", json={"name": "Tastatur", "price": 49.99})
        self.assertEqual(response.status_code, 201)
        self.assertEqual(response.json()["name"], "Tastatur")

    def test_read_item(self):
        client.post("/items/", json={"name": "Maus", "price": 19.99})
        response = client.get("/items/1")
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json()["name"], "Maus")

if __name__ == '__main__':
    unittest.main()

Vorteile und Nachteile

Vorteile

• Realistischere Fehlererkennung: Schnittstellenfehler, Formatprobleme und Abhängigkeitsfehler werden sichtbar.
• Abdeckung realer Abläufe: Datenbank-, API- und Messaging-Integrationen werden validiert.
• Vertrauen in Architektur: Korrekte Verdrahtung der Komponenten wird nachgewiesen.
• Frühe Problemerkennung: Integrationsprobleme werden entdeckt, bevor sie produktiv werden.

Nachteile

• Längere Laufzeit: Integrationstests sind langsamer als Unit Tests.
• Höherer Wartungsaufwand: Testdaten, Umgebungen und Zustände müssen verwaltet werden.
• Fehlerlokalisierung: Fehlerquellen sind schwerer zu isolieren als bei Unit Tests.
• Flaky Tests: Zeitabhängige oder externe Abhängigkeiten können zu instabilen Tests führen.

Prüfungsrelevante Stichpunkte

• Unterschied zwischen Unit Tests und Integration Tests.
• Die vier Integrationstest-Strategien.
• Vorteile und Grenzen von Integrationstests.
• Wichtige Werkzeuge für Datenbank- und API-Integrationstests.
• Umgang mit Testdaten und Abhängigkeiten.

Typische Prüfungsfragen (mit Kurzantwort)

1. Was prüft ein Integration Test? Das Zusammenspiel mehrerer Komponenten oder Systeme.

2. Nenne zwei Integrationstest-Strategien. Big Bang, Top-Down, Bottom-Up oder Sandwich.

3. Was ist ein Stub? Ein vereinfachtes Ersatzmodul für eine noch nicht verfügbare Komponente.

4. Warum sind Integrationstests langsamer als Unit Tests? Sie binden echte Datenbanken, Netzwerk oder externe Dienste ein.

5. Was ist ein Vorteil von Integrationstests gegenüber Unit Tests? Sie finden Schnittstellenfehler und Probleme im Zusammenspiel der Komponenten.

Weiter im Software Testing Lernpfad

Der nächste Artikel im Software Testing Lernpfad behandelt E2E Tests Grundlagen — wie komplette Benutzer-Workflows getestet werden.

Wichtigste Quellen

1. https://martinfowler.com/bliki/IntegrationTest.html
2. https://www.testcontainers.org
3. https://en.wikipedia.org/wiki/Integration_testing