Was ist Integrationstesting?

Question

Accepted Answer

**Integrationstesting** überprüft, dass mehrere **Komponenten oder Units korrekt zusammenarbeiten** — testet die Interaktionen und Integrationspunkte (wie Code mit einer Datenbank, Services die sich gegenseitig aufrufen, oder kombinierte Module). Es findet Probleme, die Unit Tests (die Units isolieren) übersehen.

## Warum es wichtig ist

```text
Integration tests verify COMPONENTS WORKING TOGETHER (not in isolation):
  → code + DATABASE (does the data layer actually work with a real DB?)
  → service A calling service B / an external API
  → multiple modules/units combined; the integration POINTS between them
→ catches issues in how parts INTERACT — which unit tests (isolated) can't catch.
```

## Warum Integrationstests wichtig sind (gegenüber Unit Tests)

```text
UNIT tests isolate units (mocking dependencies) → fast, but DON'T verify real integration:
  → a unit can pass its tests but FAIL when combined (wrong assumptions about a dependency,
    a real DB query that's wrong, an API contract mismatch, config issues)
INTEGRATION tests use REAL (or realistic) dependencies → catch these interaction bugs:
  → wiring/configuration errors, data layer issues, contract mismatches between components
→ Integration tests verify the parts actually work TOGETHER.
```

## Beispiel und Überlegungen

```js
// integration test: the repository actually works with a (test) database
test('UserRepository saves and retrieves a user', async () => {
  const repo = new UserRepository(testDb);     // REAL test database
  await repo.save({ name: 'Ann' });
  const user = await repo.findByName('Ann');    // real query
  expect(user.name).toBe('Ann');
});
```

```text
→ SLOWER than unit tests (real I/O, setup); use a TEST database/environment
→ Test important integration points (data access, key service interactions, APIs)
→ Fewer than unit tests (the pyramid middle); manage test data/state carefully
```

## Warum es wichtig ist

Das Verständnis von Integrationstesting ist wichtig, weil es **eine Klasse von Bugs fängt, die Unit Tests nicht können** — Probleme in der Zusammenarbeit von Komponenten — daher ist es wertvoll für umfassendes Testen.

Während Unit Tests einzelne Units isoliert überprüfen (mit gemockten Abhängigkeiten), bedeutet diese Isolation, dass sie **echte Integration nicht überprüfen können**: eine Unit kann alle ihre Tests bestehen, aber fehlschlagen, wenn sie tatsächlich mit anderen kombiniert wird (wegen falscher Annahmen über eine Abhängigkeit, einer fehlerhaften echten Datenbankabfrage, eines API-Kontraktmismatch oder Konfigurationsproblemen). **Integrationstests** füllen diese Lücke, indem sie **Komponenten testen, die zusammen mit echten (oder realistischen) Abhängigkeiten arbeiten** — überprüfen, dass Code tatsächlich mit einer echten Datenbank funktioniert, dass Services korrekt interagieren und dass Integrationspunkte funktionieren — fangen die Verkabelungs-, Datenschicht- und Kontraktbugs, die isolierte Unit Tests übersehen.

Das Verständnis dieser ergänzenden Beziehung (Unit Tests für isolierte Logik, Integrationstests für echte Interaktionen) ist Schlüssel zu umfassendem Testen, da keines allein ausreichend ist.

Das Verständnis der **Überlegungen** — dass Integrationstests langsamer sind (echte E/A und Setup, daher in der Mitte der Pyramide mit weniger als Unit Tests), Test-Datenbanken/Umgebungen nutzen, sich auf wichtige Integrationspunkte konzentrieren (Datenzugriff, wichtige Service-Interaktionen, APIs) und sorgfältige Testdaten-/Zustandsverwaltung erfordern — widerspiegelt praktisches Integrationstesting.

Integrationstests geben Sicherheit, dass die zusammengesetzten Teile funktionieren, was Unit Tests allein nicht können.

Da echte Anwendungen aus interagierenden Komponenten bestehen und Integrationsbugz (Datenbankprobleme, Kontraktmismatch, Konfigurationsfehler) häufig sind und von Unit Tests übersehen werden, und da Integrationstesting sie findet, indem überprüft wird, dass Komponenten zusammen funktionieren, ist das Verständnis von Integrationstesting wertvoll, praktisch relevantes Wissen — eine wichtige Ergänzung zu Unit Tests, die Interaktionsbugz fängt, wichtig für umfassendes Testen, das nicht nur isolierte Units überprüft, sondern dass die Teile des Systems tatsächlich korrekt zusammen funktionieren.