Seminar Docker-Android – Intensivseminar Testautomatisierung und CI/CD

Das Intensivseminar bündelt Build, Unit-Tests, ADB, Appium, Espresso, Selenium Grid und CI/CD zu einer durchgängigen mobilen Testpipeline.

Stabile Testarchitektur, parallele Ausführung, Diagnose, Berichte und die Umsetzung auf mehreren CI-Plattformen stehen im Vordergrund.

Inhaltsübersicht

1. Kapitel 1: Containerisierte Android-Buildumgebung
2. Kapitel 2: Lokale Unit-Tests und Testselektion
3. Kapitel 3: Anwendungsinstallation und Debugging mit ADB
4. Kapitel 4: Appium-2-Server im Container
5. Kapitel 5: Robuste Appium-Testarchitektur
6. Kapitel 6: Espresso-Projekt und Instrumentierung
7. Kapitel 7: Instrumentierte Tests im Docker-Android-Container
8. Kapitel 8: Appium-Anbindung an Selenium Grid
9. Kapitel 9: Parallele Testausführung und Isolation
10. Kapitel 10: Jenkins, GitLab CI und GitHub Actions im Vergleich
11. Kapitel 11: Fehleranalyse bei Appium- und UI-Tests
12. Kapitel 12: Testergebnisse und Diagnoseartefakte

Zielgruppe

Senior-Testautomatisierer, Mobile-QA-Teams, Android-Entwickler, Build- und DevOps-Engineers.

Voraussetzungen

Docker-Grundlagen, Android- oder Mobile-Testkenntnisse und Programmiererfahrung in mindestens einem Testframework.

Kapitel 1: Containerisierte Android-Buildumgebung

Inhaltsverzeichnis des Kapitels

1. Quellcode-Mount und Arbeitsverzeichnis
2. Buildwerkzeuge und Java-Umgebung
3. Rechte, Benutzer und Dateibesitz

Schritt-für-Schritt-Inhalte

1. Projektquellen in ein klar definiertes Arbeitsverzeichnis des Containers einbinden.
2. Einstiegspunkt und Arbeitsverzeichnis für nichtinteraktive Gradle-Aufrufe setzen.
3. Schreibrechte für Buildausgaben und Caches prüfen.
4. Einen einfachen Gradle-Informationslauf ausführen und die verwendete Werkzeugkette dokumentieren.

Kapitel 2: Lokale Unit-Tests und Testselektion

Inhaltsverzeichnis des Kapitels

1. Testaufgaben und Filter
2. Fehlerausgaben und Stacktraces
3. Maschinenlesbare Testergebnisse

Schritt-für-Schritt-Inhalte

1. Unit-Test-Aufgabe zunächst vollständig und anschließend mit einem gezielten Filter ausführen.
2. Fehlschläge nach Testlogik, Abhängigkeit und Umgebungsproblem unterscheiden.
3. XML- und HTML-Ergebnisse in ein dauerhaftes Ausgabeverzeichnis kopieren.
4. Einen eindeutigen Exitcode als Qualitätskriterium für weitere Pipeline-Stufen verwenden.

Kapitel 3: Anwendungsinstallation und Debugging mit ADB

Inhaltsverzeichnis des Kapitels

1. APK-Installation und Paketverwaltung
2. Shellbefehle, Dateien und Bildschirmzustand
3. Logcat-Auswertung und reproduzierbare Fehlerbilder

Schritt-für-Schritt-Inhalte

1. Eine Testanwendung installieren, Paketname und installierte Version kontrollieren.
2. Anwendung starten, beenden und Anwendungsdaten für einen definierten Ausgangszustand zurücksetzen.
3. Relevante Logcat-Ausgaben nach Prozess, Tag und Zeitfenster filtern.
4. Fehlerbild, verwendete Befehle und technische Belege in einem kompakten Diagnoseprotokoll sichern.

Kapitel 4: Appium-2-Server im Container

Inhaltsverzeichnis des Kapitels

1. Aktivierung und Portfreigabe
2. Zusätzliche Serverargumente
3. Bereitschaft und Sitzungsverwaltung

Schritt-für-Schritt-Inhalte

1. Appium über die vorgesehene Umgebungsvariable aktivieren und Port 4723 veröffentlichen.
2. Zusätzliche Argumente nur nach dokumentiertem Bedarf ergänzen.
3. Serverstart und Bereitschaft anhand der Containerlogs prüfen.
4. Eine Testsitzung kontrolliert öffnen, beenden und auf zurückbleibende Prozesse kontrollieren.

Kapitel 5: Robuste Appium-Testarchitektur

Inhaltsverzeichnis des Kapitels

1. Selektoren und Seitenobjekte
2. Explizite Wartebedingungen
3. Fehlerbehandlung und Wiederverwendbarkeit

Schritt-für-Schritt-Inhalte

1. Stabile Selektoren nach Zugänglichkeit, Ressource und fachlicher Bedeutung priorisieren.
2. Bildschirmobjekte und wiederkehrende Aktionen in Seitenobjekten kapseln.
3. Starre Pausen durch explizite Bedingungen ersetzen.
4. Fehlermeldungen um Screenshot, aktuelle Aktivität und relevante Logs ergänzen.

Kapitel 6: Espresso-Projekt und Instrumentierung

Inhaltsverzeichnis des Kapitels

1. Testabhängigkeiten und Runner
2. Anwendungs- und Test-APK
3. Manifest, Paket und Zielgerät

Schritt-für-Schritt-Inhalte

1. Testabhängigkeiten und Instrumentation Runner im Android-Projekt prüfen.
2. Anwendungs- und Test-APK mit einer passenden Buildvariante erzeugen.
3. Pakete und Signaturen für die Installation auf dem Emulator kontrollieren.
4. Einen minimalen Instrumentation-Test lokal und anschließend im Container ausführen.

Kapitel 7: Instrumentierte Tests im Docker-Android-Container

Inhaltsverzeichnis des Kapitels

1. Installation beider APK-Dateien
2. Start des Instrumentation Runners
3. Ergebnisdateien und Rückgabecodes

Schritt-für-Schritt-Inhalte

1. Laufenden Emulator auf Betriebsbereitschaft prüfen.
2. Anwendungs- und Test-APK per ADB installieren.
3. Instrumentation mit Paket und Runner starten und Ausgabe erfassen.
4. Ergebnis, Exitcode und Diagnoseartefakte in ein Pipeline-taugliches Verzeichnis schreiben.

Kapitel 8: Appium-Anbindung an Selenium Grid

Inhaltsverzeichnis des Kapitels

1. Grid-Komponenten und zentraler Endpunkt
2. Appium-Knoten und Registrierung
3. Sitzungsverteilung für Android-Tests

Schritt-für-Schritt-Inhalte

1. Grid-Endpunkt und gewünschtes Routingmodell festlegen.
2. Appium-fähigen Docker-Android-Knoten mit eindeutigen Merkmalen bereitstellen.
3. Eine Testsitzung über den zentralen Endpunkt anfordern.
4. Registrierung, Zuweisung und Sitzungsende im Grid nachvollziehen.

Kapitel 9: Parallele Testausführung und Isolation

Inhaltsverzeichnis des Kapitels

1. Testmatrix und Containeranzahl
2. Ressourcenlimits und Portkonflikte
3. Daten- und Sitzungsisolation

Schritt-für-Schritt-Inhalte

1. Testmatrix nach Android-Version, Geräteprofil und Testpaket priorisieren.
2. Für jede parallele Einheit eindeutige Container-, Port- und Volume-Namen vergeben.
3. CPU-, Speicher- und Startzeitbedarf pro Einheit messen.
4. Parallelitätsgrad schrittweise erhöhen und Stabilität sowie Gesamtdurchsatz vergleichen.

Kapitel 10: Jenkins, GitLab CI und GitHub Actions im Vergleich

Inhaltsverzeichnis des Kapitels

1. Agenten- und Runner-Modell
2. Pipelinebeschreibung und Geheimnisse
3. Artefakte, Parallelität und Bereinigung

Schritt-für-Schritt-Inhalte

1. KVM- und Dockeranforderungen der drei Plattformen gegenüberstellen.
2. Ein gemeinsames Stufenmodell für Build, Start, Test und Auswertung definieren.
3. Plattformspezifische Syntax in getrennte, aber fachlich identische Beispiele übertragen.
4. Ergebnisse, Laufzeiten und Betriebsaufwand anhand eines Referenztests vergleichen.

Kapitel 11: Fehleranalyse bei Appium- und UI-Tests

Inhaltsverzeichnis des Kapitels

1. Sitzungsaufbau und Capabilities
2. Selektoren, Wartebedingungen und Appzustand
3. Server-, Geräte- und Testlogs

Schritt-für-Schritt-Inhalte

1. Fehlgeschlagene Sitzung mit minimalen Capabilities reproduzieren.
2. Anwendungsinstallation, Startaktivität und sichtbaren Bildschirmzustand prüfen.
3. Selektoren und Wartebedingungen gegen den tatsächlichen UI-Zustand validieren.
4. Appium-, ADB- und Testlog zeitlich zusammenführen und die primäre Ursache benennen.

Kapitel 12: Testergebnisse und Diagnoseartefakte

Inhaltsverzeichnis des Kapitels

1. JUnit-Ergebnisse und Buildausgaben
2. Logs, Screenshots und Statusdateien
3. Namenskonvention und Aufbewahrung

Schritt-für-Schritt-Inhalte

1. Maschinenlesbare Testergebnisse in einem eindeutigen Verzeichnis sammeln.
2. Containerlog, Emulatorstatus und bei Bedarf Screenshots zum selben Lauf sichern.
3. Artefakte mit Projekt, Commit, Testmatrix und Zeitstempel benennen.
4. Aufbewahrung nach Fehlerrelevanz, Datenschutz und Speicherbedarf staffeln.

Praxisübungen

• Erstellung einer Build- und Testkette für Unit-, Appium- und Espresso-Tests.
• Anbindung mehrerer Emulatoren an Selenium Grid und kontrollierte Parallelisierung.
• Übertragung des Referenzablaufs auf Jenkins, GitLab CI und GitHub Actions.

Methodik

Fachliche Erläuterungen, Live-Demonstrationen, angeleitete Konfigurationen und eigenständige Übungen werden eng miteinander verzahnt. Fehlerfälle werden nicht nur behoben, sondern mit einer festen Prüfreihenfolge nachvollziehbar eingegrenzt.