Integrationstests - Mehr als nur die Summe der Einzelteile

"Aber warum reicht ein Unit-Test nicht aus?" Unit Tests sind wie das Probieren einzelner Zutaten beim Kochen - man kann testen, ob das Mehl nicht klumpt oder die Eier frisch sind. Aber erst ein Integrationstest zeigt, ob der ganze Kuchen am Ende genießbar ist oder als Frankensteins Monster in die Geschichte eingeht. In der Softwareentwicklung bedeutet das: Einzelne Module mögen für sich genommen fehlerfrei sein, aber im Zusammenspiel können unerwartete Probleme auftreten. Genau hier kommt der Integrationstest ins Spiel.

Was ist ein Integrationstest?

Integrationstests (Integration Test oder auch Integration Testing) sind eine Teststufe, die das Zusammenspiel verschiedener Komponenten oder ganzer Systeme überprüft. Sie schließen die Lücke zwischen Unit-Tests, die einzelne Module isoliert testen, und End-to-End-Tests, die das Gesamtsystem unter realistischen Bedingungen untersuchen. Dabei geht es um Fragen wie:

• Kommuniziert das Frontend korrekt mit dem Backend?
• Funktioniert die API-Integration mit Drittanbietern?
• Läuft der Datenaustausch zwischen Microservices fehlerfrei?
   

Laut ISTQB wird zwischen zwei zentralen Kategorien unterschieden:

• Komponenten-Integrationstests: Sie überprüfen die Schnittstellen zwischen einzelnen Software-Komponenten.
• System-Integrationstests: Sie testen die Zusammenarbeit zwischen verschiedenen Systemen, beispielsweise einer Webanwendung und einer externen Datenbank.
   

Diese Unterteilung ist sinnvoll, da sie zwei wesentliche Bereiche abdeckt. Dennoch ist es wichtig, auch den individuellen Kontext zu betrachten. Je nach Projekt können weitere Integrationen eine Rolle spielen, z.B. Umgebungen, Datenbanken, Infrastruktur, Datenflüsse oder Anwendungsschichten. Eine klare Definition dieser Aspekte hilft, genau zu bestimmen, was unter „Umgebungsintegration“ oder „Datenintegration“ zu verstehen ist und welche Herausforderungen damit verbunden sind.

Integrationstests sind oft deshalb so wichtig, weil in großen Unternehmen die einzelnen Komponenten von unterschiedlichen Teams entwickelt werden. Mangelnde Kommunikation, fehlerhafte Schnittstellenbeschreibungen, unterschiedliche Interpretationen von Anforderungen und andere Gründe können dazu führen, dass Komponenten in komplexen Projekten nicht einwandfrei integriert werden können. Wie bei allen Tests sollten solche Fehler möglichst früh im Entwicklungsprozess erkannt werden, am besten automatisiert.

Durchführung von Integrationstests

Integrationstests lassen sich auf verschiedene Weise durchführen:

• Big-Bang-Integrationstests: Alle Module werden gleichzeitig zusammengefügt und getestet. Praktisch für kleinere Systeme, kann aber in großen Projekten problematisch sein, da Fehler schwer zu isolieren sind.
• Inkrementelle Integrationstests: Module werden schrittweise getestet, um Fehler frühzeitig zu erkennen. Dies kann nach Bottom-up oder Top-down erfolgen.
• Sandwich-Tests: Eine Kombination aus Top-down- und Bottom-up-Tests, um sowohl niedrige als auch hohe Module parallel zu validieren.

Best Practices für effektive Integrationstests

Nicht jeder Integrationstest ist automatisch sinnvoll. Damit sie den maximalen Nutzen bringen, sollten einige Best Practices beachtet werden:

1. Realistische Testumgebungen nutzen

Ein „Works on my machine“ nützt wenig, wenn sich die API in der Cloud anders verhält. Integrationstests sollten unter realistischen Bedingungen durchgeführt werden - sei es mit Docker-Containern oder einer dedizierten Staging-Umgebung on-premise oder in der Cloud. Infrastructure as Code (IaC) ist hier das Zauberwort.

2. Testdaten gezielt verwalten

Ohne saubere Testdaten werden Integrationstests schnell unzuverlässig. Dynamische Datenbank-Dumps, Mock-Server und Testkonten können helfen, wiederholbare und stabile Tests zu gewährleisten. Live-Daten lassen sich hingegen in der Regel nur schwer testen, wenn sie sich ständig ändern - sind Mocks aber grundsätzlich zu bevorzugen.

3. Mocks und Stubs bewusst einsetzen

Nicht jede externe Abhängigkeit muss in jedem Test live getestet werden. Mocks und Stubs können helfen, APIs oder Dienste von Drittanbietern kontrolliert zu simulieren, ohne dass Tests von externen Faktoren abhängig sind. Aber Vorsicht: Wir wollen explizit Integrationen zwischen einzelnen Komponenten testen. Alles "weg-mocken" ist also letztlich kein Integrationstest mehr.

4. Automatisierung ist Pflicht

Manuelle Integrationstests sind möglich, aber ineffizient. Ein gut aufgesetztes CI/CD-System wie Jenkins oder GitHub Actions sollte Integrationstests automatisch durchführen, um Probleme frühzeitig zu erkennen. Viel hilft viel. Gleichzeitig sollte man die Akzeptanz der Entwicklerteams nicht überstrapazieren und CI/CD-Pipelines immer so schnell wie möglich halten. Schnelles Feedback ist die Devise.

5. Logik und Infrastruktur trennen

Integrationstests sollten sich auf die Funktionalität und nicht auf Infrastrukturprobleme konzentrieren. Die Infrastruktur selbst kann mit anderen Tools wie Terraform Test, Terratest oder am Ende mit End-to-End Tests (z.B. mit Playwright) getestet werden.

Ein Beispiel: Integrationstest für eine Kaffeemaschine

Um die Bedeutung von Integrationstests greifbar zu machen, betrachten wir ein simples Beispiel aus der Kaffeewelt. Angenommen, wir haben eine Kaffeemaschine und einen Milchaufschäumer, die zusammen einen Latte Macchiato zubereiten sollen. Ein funktionierender Integrationstest prüft, ob beide Komponenten reibungslos zusammenarbeiten:

import static org.junit.jupiter.api.Assertions.assertEquals; 
import org.junit.jupiter.api.Test; 
class CoffeeMachine { 
    String brewEspresso() { 
        return "Espresso"; 
    } 
} 
class MilkFrother { 
    String frothMilk() { 
        return "Milk Foam"; 
    } 
} 
class Barista { 
    private final CoffeeMachine coffeeMachine; 
    private final MilkFrother milkFrother; 
    Barista(CoffeeMachine coffeeMachine, MilkFrother milkFrother) { 
        this.coffeeMachine = coffeeMachine; 
        this.milkFrother = milkFrother; 
    } 
    String makeLatteMacchiato() { 
        return coffeeMachine.brewEspresso() + " + " + milkFrother.frothMilk(); 
    } 
} 
class CoffeeIntegrationTest { 
    @Test 
    void testLatteMacchiatoIntegration() { 
        CoffeeMachine coffeeMachine = new CoffeeMachine(); 
        MilkFrother milkFrother = new MilkFrother(); 
        Barista barista = new Barista(coffeeMachine, milkFrother); 
        String result = barista.makeLatteMacchiato(); 
        assertEquals("Espresso + Milk Foam", result, 
            "Integration fehlgeschlagen: Ohne Milchschaum ist es nur Espresso!"); 
    } 
}

Dieser Testfall stellt sicher, dass die Kaffeemaschine und der Milchaufschäumer korrekt zusammenarbeiten. Falls der Milchaufschäumer nicht funktioniert, gibt es nur Espresso – was für Fans von Latte Macchiato eine Enttäuschung wäre. Ohne den Kaffee wäre es nur warme Milch. Besser als nichts, würden manche Entwickler sagen. Aber knapp daneben ist auch vorbei, würde ich als Tester sagen.

Fazit zu Integrationstests

Ob kleine Webanwendung oder komplexes Microservices-System - Integrationstests sind der Klebstoff, der sicherstellt, dass alles wie gewünscht zusammenspielt. Wer darauf verzichtet, riskiert später teure und zeitaufwändige Bugfixes, deren Ursachen nur schwer zu finden sind. Also lieber einmal mehr testen, als nach dem Deployment ins Schwitzen zu kommen!

FAQ: Häufige Fragen zu Integrationstests

Was sind Integrationstests und warum sind sie notwendig?

Integrationstests sind ein wichtiger Teil des Software-Testens, bei dem zwei oder mehr Module zusammen getestet werden, um sicherzustellen, dass sie korrekt miteinander interagieren. Sie sind notwendig, um sicherzustellen, dass die Komponenten einer Anwendung wie erwartet funktionieren, wenn sie integriert sind.

Wie unterscheiden sich Integrationstests von Unittests?

Unittests testen einzelne Module isoliert, während Integrationstests die Interaktion zwischen mehreren Modulen überprüfen. Integrationstests sind also umfassender und stellen sicher, dass die Module auch in Kombination fehlerfrei arbeiten.

Was sind funktionale End-to-End-Tests?

Funktionale End-to-End-Tests sind umfassende Tests, die die gesamte Anwendung von Anfang bis Ende überprüfen, um sicherzustellen, dass alle Funktionen wie vorgesehen arbeiten. Diese Tests umfassen alle Schichten der Anwendung, einschließlich der Benutzeroberfläche und der Backend-Logik.

Welche Strategien für Integrationstests gibt es?

Es gibt verschiedene Strategien für Integrationstests, einschließlich inkrementeller Integration, Big Bang-Integration und Top-Down- oder Bottom-Up-Integration. Jede Strategie hat ihre eigenen Vor- und Nachteile, die je nach Projektanforderungen abgewogen werden sollten.

In welchen Einsatzfeldern sind Integrationstests besonders wichtig?

Integrationstests sind besonders wichtig in komplexen Anwendungen, bei denen viele Module miteinander interagieren, wie z.B. in Webanwendungen, Microservices-Architekturen und bei der Entwicklung von REST APIs. Sie helfen, Fehler frühzeitig zu identifizieren und die Wartbarkeit der Software zu verbessern.

Was sollte in einem Integrationstestplan enthalten sein?

Ein Integrationstestplan sollte die Testziele, die zu testenden Module, die Testverfahren und die benötigten Testwerkzeuge oder Testtreiber festlegen. Er sollte auch die Spezifikation der Testszenarien und die erwarteten Ergebnisse enthalten.

Welche Rolle spielen Stubs und Mocks in Integrationstests?

Stubs und Mocks werden in Integrationstests verwendet, um Abhängigkeiten zu simulieren und die Tests zu isolieren. Sie ermöglichen es, die getesteten Module unabhängig von externen Faktoren zu überprüfen und Fehler zu identifizieren, die während der echten Interaktion auftreten könnten.

Wie kann ich sicherstellen, dass meine Integrationstests effektiv sind?

Um die Effektivität Ihrer Integrationstests sicherzustellen, sollten Sie klare Testziele definieren, eine geeignete Teststrategie auswählen und regelmäßige Überprüfungen und Anpassungen an den Testszenarien vornehmen. Die Verwendung von standardisierten Testframeworks und -tools kann ebenfalls zur Effizienz beitragen.