Seminar Sonic Cloud iOS-Testautomatisierung

Das Seminar entwickelt robuste iOS-Tests von der Treiberbasis bis zu plattformübergreifenden Suiten. iOS-Elementhierarchie, Systemdialoge, Gesten, Signierungsstabilität, Testdaten und Berichte werden gemeinsam behandelt.

Vier Tage sind notwendig, weil iOS-Treiberbetrieb, Testmodellierung, robuste Implementierung und mehrstufige Regression auf realen Geräten jeweils eigene praktische Lernblöcke erfordern.

Inhaltsverzeichnis

• Projekte, Versionen, Module und Testfälle strukturieren
• Elementbibliothek und Selektoren
• Testschritte, Aktionen und Prüfungen
• iOS-Versionen, Xcode und Kompatibilität
• WebDriverAgent aufbauen und stabilisieren
• 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
• Störungsbehebung und Wiederanlauf

Lernziele

• Wartbare iOS-Testfälle modellieren.
• iOS-spezifische Elemente, Gesten und Dialoge beherrschen.
• Treiber- und Testfehler voneinander trennen.
• Suiten mit Testdaten und Berichten stabil betreiben.

Zielgruppe

Testautomation, iOS-Qualitätssicherung, App-Entwicklung und technische Testarchitektur.

Voraussetzungen

Sichere iOS- und Xcode-Grundkenntnisse; ein integriertes iOS-Gerät mit funktionierendem WebDriverAgent.

Seminarinhalte

Modul 1: 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 2: 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 3: 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 4: iOS-Versionen, Xcode und Kompatibilität

Versionen von iOS, Xcode, Agent und WebDriverAgent müssen gemeinsam betrachtet werden. Besonders neuere iOS-Generationen erfordern einen aktuellen macOS-Agentenpfad.

1. Schritt 1: Zielgeräte nach iOS-Version und benötigter Xcode-Version gruppieren.
2. Schritt 2: Agent-Version und WebDriverAgent-Stand je Gruppe festschreiben.
3. Schritt 3: Änderungen an Signierung und Entwickleroptionen in einem Wiederholungsplan dokumentieren.
4. Schritt 4: Ein Freigabeverfahren für iOS- und Xcode-Aktualisierungen definieren.

Modul 5: WebDriverAgent aufbauen und stabilisieren

Der iOS-Automatisierungstreiber wird reproduzierbar gebaut, signiert und auf dem Zielgerät gestartet. Häufige Signierungs- und Portfehler werden systematisch eingegrenzt.

1. Schritt 1: Projektkonfiguration, Team, Bundle-Kennung und Zielgerät kontrollieren.
2. Schritt 2: Build ausführen und Signierungsfehler nach Zertifikat, Profil und Gerätefreigabe trennen.
3. Schritt 3: Treiber auf dem Gerät starten und Erreichbarkeit über den vorgesehenen Kommunikationspfad prüfen.
4. Schritt 4: Neustart, Neuverbindung und Ablauf von Zertifikaten als Betriebsfälle testen.

Modul 6: 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 7: 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 8: 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 9: 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 10: 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 11: 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 12: Störungsbehebung und Wiederanlauf

Wiederkehrende Störungen werden mit klarer Reihenfolge untersucht. Ungezielte Neustarts werden vermieden, weil sie Beweise vernichten und Ursachen verdecken können.

1. Schritt 1: Auswirkung und betroffenen Umfang bestimmen, bevor Änderungen vorgenommen werden.
2. Schritt 2: Letzte Änderungen, Ressourcenlage und Verbindungsstatus prüfen.
3. Schritt 3: Komponente isoliert testen und nur den notwendigen Dienst neu starten.
4. Schritt 4: Ursache, Maßnahme, Verifikation und Vorbeugung im Störungsprotokoll festhalten.

Praxisübungen

• Einen vollständigen iOS-Smoke-Test erstellen.
• Systemdialoge und Gesten in wiederverwendbare Schritte überführen.
• Treiberneustart und Sitzungswiederholung kontrolliert behandeln.
• Eine Regression-Suite auf mehreren iOS-Versionen auswerten.