Seminar Apache Grails Testing mit Spock, Geb und Testcontainers

Eine große Testmenge ist nicht automatisch eine gute Teststrategie. Entscheidend sind klare Testgrenzen, reproduzierbare Daten, stabile Browserselektoren und eine sinnvolle Verteilung zwischen schnellen und realitätsnahen Tests.

Das Seminar baut die Tests einer bestehenden Anwendung systematisch aus. Jeder Test erhält eine eindeutige Aufgabe; unnötige Framework-Starts, fragile Mocks und unkontrollierte globale Zustände werden entfernt.

Inhaltsverzeichnis

1. Zielgruppe
2. Voraussetzungen
3. Lernziele
4. Modul 1: Unit-Tests mit Spock
5. Modul 2: Grails-Artefakte isoliert testen
6. Modul 3: Integrationstests mit echter Anwendungskonfiguration
7. Modul 4: Testarchitektur, Testdaten und CI-Integration
8. Modul 5: Browser- und Funktionstests mit Geb und Testcontainers
9. Modul 6: Vertrags-, Integrations- und Fehlertests für APIs
10. Modul 7: CI-Pipeline, Qualitätsgrenzen und Veröffentlichung
11. Modul 8: Systematische Fehleranalyse
12. Praxisprojekt und Übungen
13. Arbeitsweise

Zielgruppe

Grails-Entwickler, Testautomatisierer, QA Engineers und technische Leiter mit Verantwortung für Build- und Releasequalität.

Voraussetzungen

Praktische Grails- und Groovy-Grundkenntnisse. Erfahrung mit automatisierten Tests ist hilfreich, aber nicht zwingend.

Lernziele

• Spock-Spezifikationen klar und wartbar strukturieren.
• Grails-Artefakte mit passenden Testtraits isoliert prüfen.
• Persistenz und Spring-Kontext realitätsnah integrieren.
• Browserabläufe mit Geb und containerisierter Laufzeit automatisieren.
• Testdaten, Laufzeiten und CI-Ausführung reproduzierbar organisieren.
• Fehlerdiagnosen und Berichte für instabile Tests verbessern.

Modul 1: Unit-Tests mit Spock

Kleine fachliche Einheiten werden mit lesbaren Spezifikationen und klaren Testdoubles geprüft.

1. Schritt 1: Given-when-then-Strukturen für Services und Hilfsklassen formulieren.
2. Schritt 2: Mocks, Stubs und Spies nur entsprechend ihrer Aufgabe einsetzen.
3. Schritt 3: Tabellentests für Varianten und Randfälle entwickeln.
4. Schritt 4: Fehlerpfade und Interaktionen ohne unnötigen Framework-Start testen.

Modul 2: Grails-Artefakte isoliert testen

Controller, Domain-Klassen und andere Artefakte werden mit den passenden Grails-Testtraits geprüft.

1. Schritt 1: Testtrait und Testumgebung für das jeweilige Artefakt auswählen.
2. Schritt 2: Datenbindung, Validierung und Controller-Antworten isoliert testen.
3. Schritt 3: Service-Abhängigkeiten kontrolliert ersetzen.
4. Schritt 4: Testaufbau vereinfachen und versteckte globale Zustände vermeiden.

Modul 3: Integrationstests mit echter Anwendungskonfiguration

Zusammenspiel von Persistenz, Transaktionen, Spring-Kontext und Webschicht wird realitätsnah überprüft.

1. Schritt 1: Integrationsprofil und Testdaten reproduzierbar konfigurieren.
2. Schritt 2: Services und GORM gegen eine echte Testdatenbank prüfen.
3. Schritt 3: Transaktionsverhalten und Rollback bewusst kontrollieren.
4. Schritt 4: Langsame Tests strukturieren und von schnellen Tests trennen.

Modul 4: Testarchitektur, Testdaten und CI-Integration

Die Testpyramide wird an Risiko, Laufzeit und Wartungskosten des Projekts ausgerichtet.

1. Schritt 1: Testarten und Verantwortlichkeiten im Team festlegen.
2. Schritt 2: Builder, Fixtures und definierte Datenzustände erstellen.
3. Schritt 3: Parallelisierung und reproduzierbare Infrastruktur vorbereiten.
4. Schritt 4: Qualitätsgrenzen und Berichte in die Build-Pipeline integrieren.

Modul 5: Browser- und Funktionstests mit Geb und Testcontainers

Kritische Benutzerwege werden in einer reproduzierbaren Browserumgebung automatisiert.

1. Schritt 1: Geb-Seitenobjekte und Module für stabile Selektoren entwerfen.
2. Schritt 2: Containerisierte Browser für identische lokale und CI-Ausführung nutzen.
3. Schritt 3: Anmeldung, Formularabläufe und Fehlersituationen automatisieren.
4. Schritt 4: Screenshots, Aufzeichnungen und Diagnosedaten bei Fehlern sichern.

Modul 6: Vertrags-, Integrations- und Fehlertests für APIs

API-Verhalten wird auf Struktur, Statuscodes, Berechtigungen und Rückwärtskompatibilität geprüft.

1. Schritt 1: Positive und negative Endpunkt-Tests erstellen.
2. Schritt 2: JSON-Strukturen und Pflichtfelder gezielt verifizieren.
3. Schritt 3: Authentifizierungs- und Autorisierungsfälle automatisieren.
4. Schritt 4: Änderungen am Vertrag mit Regressionstests absichern.

Modul 7: CI-Pipeline, Qualitätsgrenzen und Veröffentlichung

Der Build wird in überprüfbare Stufen mit eindeutigen Abbruchkriterien gegliedert.

1. Schritt 1: Kompilierung, Unit-Tests, Integrationstests und Artefakterzeugung trennen.
2. Schritt 2: Abhängigkeits-, Lizenz- und Sicherheitsprüfungen einplanen.
3. Schritt 3: Artefakte unveränderlich kennzeichnen und weiterreichen.
4. Schritt 4: Freigabe- und Rückrollregeln für nachgelagerte Deployments festlegen.

Modul 8: Systematische Fehleranalyse

Störungen werden reproduziert, eingegrenzt und mit Belegen statt mit zufälligen Änderungen bearbeitet.

1. Schritt 1: Symptom, Zeitpunkt, betroffene Nutzer und letzte Änderungen erfassen.
2. Schritt 2: Minimalen reproduzierbaren Fall und Vergleichsumgebung herstellen.
3. Schritt 3: Hypothesen priorisieren und jeweils mit einer Messung prüfen.
4. Schritt 4: Ursache, Korrektur und Präventionsmaßnahme getrennt dokumentieren.

Praxisprojekt und Übungen

Für eine Beispielanwendung entsteht eine vollständige Testpyramide. Service-, Controller-, GORM-, API- und Browserfälle werden automatisiert und in eine CI-nahe Ausführung mit Diagnoseartefakten integriert.

Arbeitsweise

Kurze fachliche Einführungen wechseln mit Demonstrationen, angeleiteten Implementierungsschritten, selbstständigen Übungen und gemeinsamer Auswertung. Entscheidungen werden im Code, in Tests und in einer knappen technischen Dokumentation nachvollziehbar festgehalten.