Testautomatisierung

In dieser Lerneinheit entdeckst du die wichtigsten Konzepte und Werkzeuge der Testautomatisierung, die dir helfen manuelle Tests durch automatisierte Abläufe zu ersetzen. Du lernst die konkreten Ziele und Vorteile automatisierter Tests kennen und verstehst, in welchen Situationen sich die Automatisierung besonders lohnt. Diese Kenntnisse ermöglichen es dir, Testprozesse in deinen Entwicklungsprojekten effizienter zu gestalten und die Qualität deiner Software nachhaltig zu sichern.

Einführung

Es ist 17:58 Uhr und du stehst kurz vor dem Release. Du hast nur noch zwei Minuten, um alle Tests durchzuführen. Manuell unmöglich. Aber dein automatisiertes Testsystem klickt, prüft und validiert in Sekundenschnelle durch 200 Testfälle.

Manuelles Testen unter Zeitdruck vs. automatisierte Tests — Bildrechte: Ausbildung-in-der-IT.de (KI-unterstützt)

Testautomatisierung ersetzt wiederholbare, zeitaufwendige Testarbeit durch Programme, die schneller, konsistenter und zuverlässiger arbeiten als Menschen es könnten.

Von Unit-Tests, die einzelne Methoden prüfen, bis hin zu End-to-End-Tests, die komplette Benutzerszenarien durchspielen: Automatisierung ist heute ein Kernbestandteil professioneller Softwareentwicklung.

In dieser Lerneinheit erfährst du, welche Ziele und Vorteile Testautomatisierung bietet, wie du geeignete Testfälle auswählst und welche Tools wie JUnit 5 und Selenium 4 dir dabei helfen.

Lernziele

Nach dieser Lerneinheit kannst du:

• Die Ziele und Vorteile der Testautomatisierung benennen und erklären, warum sie die Softwarequalität verbessert
• Kriterien anwenden, um geeignete Testfälle für die Automatisierung auszuwählen
• JUnit 5 und Selenium WebDriver 4 als Frameworks für Unit- und Web-Tests einordnen und ihre Grundkonzepte beschreiben
• Best Practices für die Erstellung und Wartung von Testskripten anwenden

Überleitung

Um zu verstehen, warum Testautomatisierung so wertvoll ist, schauen wir uns zunächst die konkreten Ziele und Vorteile an.

Danach lernst du, nach welchen Kriterien du Testfälle für die Automatisierung auswählst und welche Tools dir dabei helfen.

Was ist Testautomatisierung?

Testautomatisierung bezeichnet den Einsatz spezialisierter Software-Werkzeuge, um Testfälle ohne manuelles Eingreifen auszuführen. Dabei übernehmen Skripte und Frameworks die Durchführung vordefinierter Testszenarien.

Testautomatisierung ersetzt nicht das manuelle Testen, sondern ergänzt es dort, wo Wiederholung und Konsistenz entscheidend sind.

Die Automatisierung eignet sich besonders für:

• Regressionstests nach Code-Änderungen
• Lasttests mit vielen parallelen Anfragen
• API-Tests mit definierten Schnittstellen
• Unit-Tests auf Funktionsebene

Ziele der Testautomatisierung

Die Testautomatisierung verfolgt mehrere strategische Ziele im Entwicklungsprozess:

Ziel	Beschreibung
Qualitätssicherung	Frühzeitige Fehlererkennung durch häufige Testläufe
Effizienzsteigerung	Schnellere Durchführung repetitiver Tests
Reproduzierbarkeit	Identische Testbedingungen bei jedem Durchlauf
Skalierbarkeit	Parallele Ausführung großer Testmengen

Diese Ziele unterstützen agile Entwicklungspraktiken, bei denen kurze Release-Zyklen eine schnelle Feedback-Schleife erfordern.

Vorteile: Effizienz und Genauigkeit

Automatisierte Tests bieten gegenüber manuellen Tests entscheidende Vorteile:

Zeitersparnis

Ein manueller Regressionstest kann Stunden dauern. Automatisierte Tests führen dieselben Prüfungen in Minuten durch und können nachts oder am Wochenende laufen.

Genauigkeit

Menschen machen bei repetitiven Aufgaben Fehler. Automatisierte Tests führen jeden Schritt exakt gleich aus, ohne Ermüdung oder Unaufmerksamkeit.

Studien zeigen, dass manuelle Tester nach mehreren Stunden bis zu 30% mehr Fehler übersehen als in der ersten Stunde.

Vorteile: Wiederverwendbarkeit und Dokumentation

Wiederverwendbarkeit

Einmal geschriebene Testskripte können bei jeder Änderung erneut ausgeführt werden. Sie bilden ein wachsendes Sicherheitsnetz für die gesamte Codebasis.

Lebende Dokumentation

Gut geschriebene Tests dokumentieren das erwartete Verhalten der Software. Neue Teammitglieder können anhand der Tests verstehen, wie Funktionen arbeiten sollen.

Vorteil	Auswirkung
Wiederverwendbar	Tests wachsen mit dem Projekt mit
Dokumentierend	Spezifikation durch ausführbare Beispiele
Versioniert	Änderungshistorie im Repository nachvollziehbar

Diese Vorteile machen automatisierte Tests zu einer langfristigen Investition, die sich mit jeder Projektiteration weiter auszahlt.

Auswahlkriterien: Wann automatisieren?

Nicht jeder Test eignet sich für die Automatisierung. Die Entscheidung hängt von mehreren Faktoren ab:

Häufigkeit der Ausführung

Tests, die bei jedem Build oder Release laufen müssen, sind ideale Kandidaten. Einmalige explorative Tests lohnen den Automatisierungsaufwand selten.

Stabilität der Anforderungen

Bei häufig wechselnden Anforderungen müssen Tests ständig angepasst werden. Hier übersteigt der Wartungsaufwand schnell den Nutzen.

Faustregel: Wenn ein Test mehr als fünfmal ausgeführt wird, rechnet sich die Automatisierung.

Auswahlkriterien: Technische Faktoren

Kritikalität des Features

Kernfunktionen wie Login, Checkout oder Datenpersistenz sollten automatisiert getestet werden. Ein Fehler hier hat große Auswirkungen.

Technische Machbarkeit

Manche Tests sind schwer automatisierbar, etwa visuelle Prüfungen oder komplexe Benutzerinteraktionen mit Drag-and-Drop.

Kriterium	Automatisieren	Manuell belassen
Häufigkeit	Täglich/wöchentlich	Einmalig
Stabilität	Stabile Features	Prototypen
Kritikalität	Kernfunktionen	Nice-to-have
Komplexität	Einfache Flows	Explorative Tests

Nutze diese Kriterien als Entscheidungshilfe, um den Automatisierungsaufwand gezielt dort einzusetzen, wo er den größten Nutzen bringt.

Praxisbeispiel: E-Commerce-Shop

Ein Online-Shop zeigt typische Automatisierungskandidaten:

Hohe Priorität (automatisieren)

• Benutzerregistrierung und Login
• Produktsuche und Filterung
• Warenkorb-Funktionen
• Checkout und Bezahlung
• Bestellbestätigung

Niedrige Priorität (manuell)

• Einmalige Migrationen
• Neue experimentelle Features
• Visuelle Design-Prüfungen

Ein gut automatisierter E-Commerce-Shop kann bei jedem Deployment in unter 10 Minuten die kritischen Kaufprozesse validieren.

JUnit 5: Das Standard-Framework für Unit-Tests

JUnit 5 (auch Jupiter genannt) ist das aktuelle Standard-Framework für Unit-Tests in Java. Es bietet gegenüber dem Vorgänger JUnit 4 wesentliche Verbesserungen.

Wichtige Neuerungen in JUnit 5:

• @Test aus dem neuen Package org.junit.jupiter.api
• @DisplayName für lesbare Testnamen
• @BeforeEach / @AfterEach statt @Before / @After
• Nested Tests mit @Nested
• Parametrisierte Tests mit @ParameterizedTest

JUnit 5 benötigt mindestens Java 8 und ist vollständig modular aufgebaut.

JUnit 5 Code-Beispiel

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import static org.junit.jupiter.api.Assertions.*;
 
class RechnerTest {
 
    @Test
    @DisplayName("Addition zweier positiver Zahlen")
    void additionPositiveZahlen() {
        Rechner rechner = new Rechner();
        int ergebnis = rechner.addiere(2, 3);
        assertEquals(5, ergebnis, "2 + 3 sollte 5 ergeben");
    }
}

Erklärung des Codes

• @Test: Markiert die Methode als Testfall
• @DisplayName: Gibt dem Test einen lesbaren Namen im Report
• assertEquals: Prüft, ob erwarteter und tatsächlicher Wert übereinstimmen
• Dritter Parameter: Optionale Fehlermeldung bei fehlgeschlagenem Test

Selenium 4: Browser-Automatisierung

Selenium 4 ist das führende Framework für automatisierte Browser-Tests. Es steuert echte Browser und simuliert Benutzerinteraktionen.

Neuerungen in Selenium 4:

• W3C WebDriver Standard: Bessere Browser-Kompatibilität
• Relative Locators: Elemente relativ zu anderen finden (above(), below(), near())
• WebDriverManager: Automatische Treiberinstallation
• Verbesserte DevTools-Integration: Netzwerk-Interception, Geolocation

Browser	WebDriver
Chrome	ChromeDriver
Firefox	GeckoDriver
Edge	EdgeDriver
Safari	SafariDriver

Mit der passenden WebDriver-Komponente kannst du Tests browserübergreifend ausführen und so die Kompatibilität deiner Anwendung sicherstellen.

Selenium 4 Code-Beispiel

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.By;
import org.openqa.selenium.chrome.ChromeDriver;
import io.github.bonigarcia.wdm.WebDriverManager;
 
public class LoginTest {
    public static void main(String[] args) {
        WebDriverManager.chromedriver().setup();
        WebDriver driver = new ChromeDriver();
 
        driver.get("https://example.com/login");
        driver.findElement(By.id("username")).sendKeys("testuser");
        driver.findElement(By.id("password")).sendKeys("secret");
        driver.findElement(By.cssSelector("button[type=submit]")).click();
 
        driver.quit();
    }
}

Erklärung

• WebDriverManager: Lädt automatisch den passenden ChromeDriver
• By.cssSelector: Findet Elemente über CSS-Selektoren
• driver.quit(): Schließt Browser und beendet Session sauber

Best Practices für Testskripte

Wartbare Testskripte folgen bewährten Prinzipien:

1. Unabhängigkeit

Jeder Test sollte isoliert laufen können, ohne von anderen Tests abzuhängen. Gemeinsame Testdaten vermeiden.

2. Aussagekräftige Namen

Testnamen beschreiben das erwartete Verhalten: loginMitGueltigemPasswort_ErfolgreicheAnmeldung() statt test1().

3. Arrange-Act-Assert (AAA)

Arrange: Testdaten vorbereiten
Act:     Zu testende Aktion ausführen
Assert:  Ergebnis prüfen

4. Keine Magic Numbers

Konstanten benennen: MAX_LOGIN_ATTEMPTS = 3 statt hartcodierter Werte.

Page Object Model (POM)

Das Page Object Model ist ein Entwurfsmuster für UI-Tests, das die Wartbarkeit verbessert:

Grundprinzip

Jede Seite der Anwendung wird durch eine eigene Klasse repräsentiert. Locators und Interaktionen sind dort gekapselt.

public class LoginPage {
    private By usernameField = By.id("username");
    private By passwordField = By.id("password");
 
    public void login(String user, String pass) {
        driver.findElement(usernameField).sendKeys(user);
        driver.findElement(passwordField).sendKeys(pass);
    }
}

Vorteile: Änderungen am UI erfordern nur Anpassungen in einer Klasse, nicht in allen Tests.

Integration in CI/CD-Pipelines

Automatisierte Tests entfalten ihr volles Potenzial erst in einer CI/CD-Pipeline. Bei jedem Commit werden Tests automatisch ausgeführt.

Typischer Ablauf:

1. Entwickler pusht Code
2. Pipeline startet automatisch
3. Unit-Tests laufen (schnell, ~1-2 Minuten)
4. Integrationstests folgen (~5-10 Minuten)
5. Bei Erfolg: Deployment in Staging

Die detaillierte Einrichtung von CI/CD-Pipelines wird in der Lektion “Continuous Integration” behandelt.

Durch diese Integration wird Feedback zu Fehlern innerhalb von Minuten statt Tagen geliefert.

Shift-Left Testing in CI/CD

Shift-Left Testing bedeutet, Tests so früh wie möglich im Entwicklungsprozess durchzuführen, anstatt sie ans Ende zu verschieben. Der Begriff “links” bezieht sich auf die Timeline des Entwicklungsprozesses, wobei links = früh und rechts = spät.

Vorteile von Shift-Left:

• Fehler werden früher erkannt (günstiger zu beheben)
• Schnelleres Feedback für Entwickler
• Reduzierte Kosten durch frühe Fehlerbehebung
• Bessere Codequalität von Anfang an

Moderne CI/CD-Pipelines setzen auf Shift-Left Testing, indem sie automatisierte Tests direkt nach jedem Code-Commit ausführen.

Zusammenfassung und Ausblick

Zusammenfassung

In dieser Lerneinheit hast du die zentralen Konzepte der Testautomatisierung kennengelernt und verstanden, wann sich der Einsatz automatisierter Tests lohnt.

Testautomatisierung bezeichnet den Einsatz spezialisierter Werkzeuge, um Testfälle ohne manuelles Eingreifen auszuführen. Sie ergänzt manuelle Tests dort, wo Wiederholung, Konsistenz und Geschwindigkeit entscheidend sind.

Du weißt jetzt, welche Vorteile automatisierte Tests bieten:

• Zeitersparnis durch schnelle, wiederholbare Testdurchläufe
• Genauigkeit ohne menschliche Ermüdungsfehler
• Wiederverwendbarkeit als wachsendes Sicherheitsnetz
• Dokumentation des erwarteten Softwareverhaltens

Bei der Auswahl geeigneter Testfälle hast du gelernt, Kriterien wie Häufigkeit, Stabilität, Kritikalität und technische Machbarkeit anzuwenden. Außerdem kennst du jetzt zwei wichtige Frameworks: JUnit 5 für Unit-Tests in Java und Selenium 4 für browserbasierte UI-Tests.

Mit dem Page Object Model und den Best Practices für Testskripte hast du Werkzeuge an der Hand, um wartbare und robuste Testautomatisierung in der Praxis umzusetzen.

Ausblick

In der nächsten Lerneinheit beschäftigen wir uns mit dem Testen spezieller Systeme. Du lernst, wie du Tests für unterschiedliche Systemtypen wie eingebettete Systeme, mobile Anwendungen oder verteilte Architekturen planst und welche besonderen Herausforderungen dabei zu beachten sind.

---