Seminar Sonic Cloud Intensivseminar – Mobile Testautomatisierung und Qualitätssicherung

Das Intensivseminar bündelt UI-Automatisierung, Android- und iOS-Besonderheiten, Wiederverwendung, Testdaten, Suiten, Berichte, WebView, POCO, Bildsuche und nichtfunktionale Tests. Der Schwerpunkt liegt auf einem wartbaren, risikobasierten Testportfolio.

Fünf Tage sind erforderlich, um die vollständige Automatisierungskette auf realen Geräten aufzubauen und die wichtigsten Spezialverfahren in kompakten, aber praktischen Blöcken zu integrieren.

Inhaltsverzeichnis

• Qualitätsstrategie und Auswahl geeigneter Testarten
• Projekte, Versionen, Module und Testfälle strukturieren
• Testmanagement und Governance
• Elementbibliothek und Selektoren
• Testschritte, Aktionen und Prüfungen
• Android-spezifische Automatisierung
• iOS-spezifische Automatisierung
• Wiederverwendbare Schritte und Parameter
• Synchronisation, Fehlerpfade und robuste Assertions
• Testdaten, Konten und Rücksetzung
• Testsuiten, Zeitpläne und Parallelisierung
• Berichte, Artefakte und Fehleranalyse
• WebView- und H5-Debugging
• Online-Proxy und Netzwerk-Mitschnitt
• POCO-Automatisierung für Spiele- und Engine-Oberflächen
• Bildbasierte Erkennung als kontrollierter Fallback
• Leistungsdaten erfassen und bewerten
• Stabilitäts- und Traversal-Tests

Lernziele

• Mobile UI-Tests strukturiert entwickeln.
• Android- und iOS-Besonderheiten beherrschen.
• Suiten, Testdaten und Berichte professionell nutzen.
• WebView-, POCO-, Bild-, Performance- und Stabilitätstests einordnen und anwenden.

Zielgruppe

Testautomation, Mobile-Qualitätssicherung, technische Testleitung und App-Entwicklung.

Voraussetzungen

Grundkenntnisse in Softwaretests und mobilen Plattformen; integrierte Android- und möglichst iOS-Geräte.

Seminarinhalte

Modul 1: Qualitätsstrategie und Auswahl geeigneter Testarten

Manuelle Prüfung, UI-Automatisierung, Performance, Traversal und Netzwerkdiagnose werden nach Risiko und Aussagekraft kombiniert.

1. Schritt 1: Kritische Geschäftsabläufe und technische Risikobereiche priorisieren.
2. Schritt 2: Geeignete Testart und Gerätetiefe pro Risiko auswählen.
3. Schritt 3: Smoke-, Regression-, Stabilitäts- und Diagnosepakete voneinander trennen.
4. Schritt 4: Abnahmekriterien und regelmäßige Überprüfung des Portfolios festlegen.

Modul 2: Projekte, Versionen, Module und Testfälle strukturieren

Automatisierung wird in einer wartbaren Projektstruktur aufgebaut. Produktversionen, fachliche Module und Testfälle erhalten klare Namens- und Verantwortungsregeln.

1. Schritt 1: Projekt und Produktversion mit einem nachvollziehbaren Namensschema anlegen.
2. Schritt 2: Fachliche Bereiche in Module und Testszenarien zerlegen.
3. Schritt 3: Testfälle nach Zweck, Plattform und Kritikalität kennzeichnen.
4. Schritt 4: Freigabe-, Änderungs- und Archivierungsregeln für Testartefakte festlegen.

Modul 3: Testmanagement und Governance

Testfälle werden nach Verantwortlichkeit, Kritikalität, Änderungsgrund und Freigabestatus verwaltet. Technische Automatisierung bleibt mit fachlichen Anforderungen verbunden.

1. Schritt 1: Namens-, Status- und Kennzeichnungsregeln für Tests festlegen.
2. Schritt 2: Verantwortliche und Prüfer für kritische Testfälle zuordnen.
3. Schritt 3: Änderungen mit Produktversion, Modul und Fehlerbezug dokumentieren.
4. Schritt 4: Regelmäßige Bereinigung veralteter, doppelter oder instabiler Tests einplanen.

Modul 4: Elementbibliothek und Selektoren

Oberflächenelemente werden zentral erfasst, damit Änderungen nicht in jedem Testfall einzeln nachgearbeitet werden müssen.

1. Schritt 1: Elemente auf Android oder iOS inspizieren und relevante Attribute vergleichen.
2. Schritt 2: Stabile Selektoren gegenüber positionsabhängigen oder flüchtigen Merkmalen bevorzugen.
3. Schritt 3: Elementnamen, Seitenzuordnung und Plattformvarianten konsistent dokumentieren.
4. Schritt 4: Selektoren mit Positiv-, Negativ- und Wiederholungstests validieren.

Modul 5: Testschritte, Aktionen und Prüfungen

Ein Testfall wird schrittweise aus Vorbereitung, Interaktion, Prüfung und Aufräumen aufgebaut. Jeder Schritt erhält einen klaren Fehlerbezug.

1. Schritt 1: Vorbedingungen und App-Startzustand reproduzierbar herstellen.
2. Schritt 2: Aktionen wie Tippen, Eingeben, Wischen und App-Steuerung in fachlicher Reihenfolge anlegen.
3. Schritt 3: Sichtbarkeit, Text, Zustand und erwartete Navigation mit Assertions prüfen.
4. Schritt 4: Aufräum- und Rücksetzschritte ergänzen, damit Wiederholungsläufe vergleichbar bleiben.

Modul 6: Android-spezifische Automatisierung

Android-Eigenheiten wie Aktivitäten, Systemdialoge, Berechtigungen und ADB-Kommandos werden in stabile Testabläufe integriert.

1. Schritt 1: App-Paket und Startaktivität eindeutig bestimmen.
2. Schritt 2: Systemdialoge und Laufzeitberechtigungen in den Testzustand einbeziehen.
3. Schritt 3: Geräte- oder App-Zustand mit gezielten ADB-Aktionen vorbereiten.
4. Schritt 4: Testfall auf mehreren Android-Versionen ausführen und Abweichungen dokumentieren.

Modul 7: iOS-spezifische Automatisierung

iOS-Tests berücksichtigen Treiberstart, Signierung, Systemdialoge und die spezifische Elementhierarchie der Plattform.

1. Schritt 1: WebDriverAgent-Verbindung vor dem Testlauf kontrolliert aufbauen.
2. Schritt 2: App-Identität und Startzustand eindeutig festlegen.
3. Schritt 3: Systemdialoge und iOS-spezifische Gesten in wiederverwendbare Schritte überführen.
4. Schritt 4: Läufe auf mehreren iOS-Versionen vergleichen und treiberbedingte Fehler trennen.

Modul 8: Wiederverwendbare Schritte und Parameter

Gemeinsame Abläufe werden zentralisiert und über Parameter an verschiedene Testszenarien angepasst. Dadurch sinkt der Pflegeaufwand bei häufigen Änderungen.

1. Schritt 1: Wiederkehrende Sequenzen in öffentliche Schritte überführen.
2. Schritt 2: Lokale und globale Parameter nach Gültigkeitsbereich trennen.
3. Schritt 3: Testdaten und Geheimnisse so referenzieren, dass sie nicht unkontrolliert im Testfall stehen.
4. Schritt 4: Änderungen an wiederverwendbaren Bausteinen mit abhängigen Testfällen regressiv prüfen.

Modul 9: Synchronisation, Fehlerpfade und robuste Assertions

Mobile Oberflächen reagieren nicht in konstanten Zeiten. Robuste Tests verwenden Zustandsprüfungen, begrenzte Wiederholungen und aussagekräftige Fehlerbilder.

1. Schritt 1: Feste Wartezeiten durch zustandsbasierte Prüfungen ersetzen.
2. Schritt 2: Timeouts nach fachlicher Erwartung und technischer Obergrenze dimensionieren.
3. Schritt 3: Alternative Zustände und kontrollierte Fehlerpfade modellieren.
4. Schritt 4: Bei Fehlern Screenshot, Seitenquelle, Protokoll und Schrittparameter erfassen.

Modul 10: Testdaten, Konten und Rücksetzung

Parallele mobile Tests benötigen isolierte Konten, reproduzierbare Ausgangsdaten und definierte Rücksetzverfahren.

1. Schritt 1: Testdaten nach gemeinsam, exklusiv und einmalig klassifizieren.
2. Schritt 2: Konten und Datenbestände den Testsuiten und Parallelitätsstufen zuordnen.
3. Schritt 3: Vorbereitungs- und Rücksetzschritte automatisierbar beschreiben.
4. Schritt 4: Datenschutz, Geheimnisverwaltung und Aufbewahrung in die Testdatenrichtlinie aufnehmen.

Modul 11: Testsuiten, Zeitpläne und Parallelisierung

Einzelne Testfälle werden zu ausführbaren Paketen kombiniert und auf geeignete Geräte verteilt. Parallelisierung wird an Ressourcen und Testdaten angepasst.

1. Schritt 1: Testfälle nach Smoke-, Regression- und Fachumfang zu Suiten zusammenstellen.
2. Schritt 2: Gerätefilter und Plattformanforderungen je Suite definieren.
3. Schritt 3: Zeitpläne, Wiederholungen und maximale Laufzeiten konfigurieren.
4. Schritt 4: Parallelität schrittweise erhöhen und Konflikte bei Gerät, Konto und Testdaten beseitigen.

Modul 12: Berichte, Artefakte und Fehleranalyse

Berichte werden nicht nur als Ampel betrachtet. Schrittprotokolle, Screenshots, Aufzeichnungen, Geräteinformationen und Leistungsdaten bilden gemeinsam die Diagnosegrundlage.

1. Schritt 1: Berichtsstatus und fehlgeschlagenen Schritt bis zur technischen Ursache zurückverfolgen.
2. Schritt 2: Screenshots, Protokolle, Aufzeichnung und Leistungsdaten zeitlich korrelieren.
3. Schritt 3: Produktfehler, Testfehler, Gerätefehler und Infrastrukturfehler getrennt klassifizieren.
4. Schritt 4: Wiederholungs- und Eskalationsregeln für nicht eindeutige Fehler festlegen.

Modul 13: WebView- und H5-Debugging

Hybride Anwendungen wechseln zwischen nativer Oberfläche und eingebettetem Web-Inhalt. Kontexte, Debug-Freigaben und Browserkompatibilität müssen zusammenpassen.

1. Schritt 1: WebView-Debugging auf App- und Geräteeebene aktivieren und prüfen.
2. Schritt 2: Verfügbare native und Web-Kontexte erfassen.
3. Schritt 3: DOM-Elemente inspizieren und stabile Web-Selektoren auswählen.
4. Schritt 4: Kontextwechsel in einen Testfall einbauen und Rückkehr zur nativen Ansicht absichern.

Modul 14: Online-Proxy und Netzwerk-Mitschnitt

Netzwerkverkehr mobiler Anwendungen wird über einen kontrollierten Proxy-Pfad sichtbar gemacht. Zertifikate, Geräteprofil und Datenschutz werden berücksichtigt.

1. Schritt 1: Proxy-Sitzung mit Zielgerät, Port und Verantwortlichkeit vorbereiten.
2. Schritt 2: Geräteproxy und erforderliches Vertrauensprofil kontrolliert einrichten.
3. Schritt 3: Anwendungsverkehr erzeugen, filtern und relevante Requests zeitlich zuordnen.
4. Schritt 4: Mitschnitt beenden, sensible Inhalte behandeln und Gerätekonfiguration sauber zurücksetzen.

Modul 15: POCO-Automatisierung für Spiele- und Engine-Oberflächen

Bei Unity-, Unreal-, Cocos- oder vergleichbaren Oberflächen reichen native Selektoren häufig nicht aus. POCO stellt eine enginebezogene Objektansicht bereit.

1. Schritt 1: Engine, unterstützten POCO-Treiber und erforderliche App-Integration bestimmen.
2. Schritt 2: POCO-Verbindung auf dem Testgerät aufbauen und Objektbaum prüfen.
3. Schritt 3: Objekte über stabile Engine-Merkmale adressieren und Aktionen ausführen.
4. Schritt 4: Native, POCO- und bildbasierte Schritte in einer klaren Fallback-Reihenfolge kombinieren.

Modul 16: Bildbasierte Erkennung als kontrollierter Fallback

Bildvergleich ist nützlich, wenn keine stabilen strukturellen Selektoren verfügbar sind. Auflösung, Skalierung und Toleranz müssen jedoch bewusst gesteuert werden.

1. Schritt 1: Referenzbild in einem definierten Gerätezustand erfassen.
2. Schritt 2: Suchbereich, Skalierung und Ähnlichkeitsschwelle festlegen.
3. Schritt 3: Erkennung unter unterschiedlichen Auflösungen und Darstellungszuständen testen.
4. Schritt 4: Fehl- und Nichterkennungen protokollieren und nach Möglichkeit durch strukturelle Selektoren ersetzen.

Modul 17: Leistungsdaten erfassen und bewerten

CPU, Speicher, Bildrate und weitere Plattformmetriken werden während definierter Testabläufe erfasst. Messwerte erhalten Kontext und belastbare Schwellenwerte.

1. Schritt 1: Messziel, App-Prozess und Referenzgerät eindeutig festlegen.
2. Schritt 2: Leistungsdatenerfassung vor dem fachlichen Ablauf starten.
3. Schritt 3: Reproduzierbare Lastsequenz ausführen und Ereignisse markieren.
4. Schritt 4: Messreihe auswerten und Abweichungen gegenüber einer Baseline dokumentieren.

Modul 18: Stabilitäts- und Traversal-Tests

Langläufe und automatisierte Oberflächen-Traversierung helfen, Abstürze, Speicherprobleme und unerwartete Zustände sichtbar zu machen.

1. Schritt 1: Ziel-App, Laufzeit, Abbruchbedingungen und ausgeschlossene Bereiche definieren.
2. Schritt 2: Traversal- oder Stabilitätslauf auf einem kontrollierten Gerätezustand starten.
3. Schritt 3: Abstürze, Hänger, Wiederholungsmuster und Ressourcenentwicklung beobachten.
4. Schritt 4: Fundstellen reproduzieren und in einen gezielten Regressionstest überführen.

Praxisübungen

• Android- und iOS-Smoke-Tests erstellen.
• Gemeinsame Schritte und Testdaten für eine Regression strukturieren.
• Eine Suite parallel auf realen Geräten ausführen und Fehler klassifizieren.
• Einen Hybrid- oder POCO-Test als Spezialfall ergänzen.
• Performance- oder Stabilitätsfund in einen Regressionstest überführen.