Seminar Maestro – Intensivseminar: Studio, CLI und skalierbare Flow-Architektur

Inhaltsverzeichnis

1. Seminarprofil
2. Lernziele
3. Seminarinhalte
4. Praxisübungen
5. Zielgruppe und Voraussetzungen
6. Praxisnutzen

Seminarprofil

Dieses praxisorientierte Seminar behandelt vollständige Entwicklung wartbarer Testsuiten von der visuellen Erstellung bis zu Architektur, Debugging und Berichten. Die Arbeit erfolgt schrittweise an ausführbaren Flows, klar definierten Testzuständen und nachvollziehbaren Diagnoseartefakten. Konfiguration, Testlogik und Betriebsanforderungen werden so verbunden, dass die erarbeiteten Muster in produktiven Teams weiterverwendbar bleiben.

Lernziele

• Studio und CLI sicher einsetzen
• Selektoren, Assertions und Synchronisation robust gestalten
• Subflows, Hooks und Parameter in einer skalierbaren Architektur verwenden
• Workspaces, Tags und Berichte standardisieren
• Fehler methodisch diagnostizieren und Flakes reduzieren

Seminarinhalte

Schritt 1: Einsatzbereiche und Systembild einordnen

Das Werkzeug wird als Black-Box-System für mobile und webbasierte Oberflächen eingeordnet. Der Schwerpunkt liegt auf reproduzierbaren Benutzerabläufen, einer lesbaren YAML-Beschreibung und der Trennung von Testabsicht, Testdaten und Ausführungsumgebung.

• Studio, Kommandozeile und Cloud-Ausführung voneinander abgrenzen
• native, Cross-Platform- und Web-Anwendungen fachlich zuordnen
• geeignete Testfälle von ungeeigneten Prüfaufgaben unterscheiden

Schritt 2: CLI und Laufzeitumgebung installieren

Die lokale Arbeitsumgebung wird nachvollziehbar aufgebaut. Installation, Versionsprüfung, Verzeichnisstruktur und Verbindung zu Emulatoren oder Simulatoren werden so dokumentiert, dass derselbe Aufbau auf weiteren Arbeitsplätzen reproduziert werden kann.

• Systemvoraussetzungen und Pfadkonfiguration prüfen
• CLI-Version und Geräteerkennung kontrollieren
• ein minimales Projektverzeichnis mit klarer Namenskonvention anlegen

Schritt 3: Studio für die visuelle Erstellung vorbereiten

Maestro Studio wird mit einer laufenden Testinstanz verbunden. Der Elementbaum wird untersucht, Interaktionen werden unmittelbar ausgeführt und daraus geeignete YAML-Schritte abgeleitet. Dabei bleibt der erzeugte Flow lesbar und wartbar.

• Gerät oder Simulator verbinden und Anwendung starten
• Elemente im visuellen Auswahlmodus untersuchen
• generierte Schritte prüfen, bereinigen und strukturiert speichern

Schritt 4: YAML-Struktur und Konfiguration sicher beherrschen

Der Aufbau einer Flow-Datei wird systematisch zerlegt. Konfigurationsblock, Befehlsfolge, Einrückung, Zeichenketten und reguläre Ausdrücke werden so verwendet, dass Syntaxfehler früh erkennbar bleiben und Änderungen im Versionsvergleich verständlich sind.

• App-Kennung, Tags und Umgebungswerte im Konfigurationsblock pflegen
• Befehle korrekt einrücken und Zeichenketten eindeutig notieren
• Flow-Dateien mit Syntaxprüfung und kleinen Ausführungsschritten absichern

Schritt 5: Den ersten vollständigen Flow erstellen

Ein kleiner, aber vollständiger Benutzerablauf wird von der Initialisierung bis zur Abschlussprüfung aufgebaut. Jeder Schritt erhält eine klare Aufgabe; unnötige Interaktionen werden entfernt und die erwartete Benutzeroberfläche wird mit Assertions abgesichert.

• Anwendung starten und Ausgangszustand definieren
• Navigation und Dateneingabe als einzelne Schritte modellieren
• Zielzustand prüfen und Flow lokal wiederholen

Schritt 6: Kernbefehle für Interaktion und Navigation anwenden

Die wichtigsten Benutzeraktionen werden nicht isoliert, sondern in einem zusammenhängenden Ablauf eingesetzt. Berührungen, Texteingaben, Scrollen, Zurück-Navigation und Geräteaktionen werden nach ihrer Stabilität und ihrem fachlichen Zweck ausgewählt.

• tapOn, inputText und eraseText kontrolliert kombinieren
• scrollUntilVisible und swipe für lange Oberflächen einsetzen
• Zurück-, Home- und Geräteaktionen gezielt verwenden

Schritt 7: Stabile Selektoren entwickeln

Elemente werden bevorzugt über fachlich stabile Merkmale angesprochen. Text, Kennung und Zustand werden gegeneinander abgewogen; fragile Koordinaten und zufällige Bildschirmpositionen werden vermieden. Die Selektorstrategie wird als Teamregel dokumentiert.

• Text- und ID-Selektion anhand der Oberfläche bewerten
• reguläre Ausdrücke nur bei kontrollierten Varianten einsetzen
• Eindeutigkeit vor jeder Interaktion mit einer Prüfung bestätigen

Schritt 8: Relationale Selektoren für komplexe Ansichten nutzen

Wiederholte Karten, Listen und Formulare werden über Beziehungen zwischen Elementen unterschieden. Ein Ziel wird nicht nur anhand seines eigenen Textes, sondern anhand von Eltern-, Kind- oder Nachbarelementen präzisiert.

• below, above, leftOf und rightOf sinnvoll kombinieren
• containsChild und containsDescendants für Kartenstrukturen einsetzen
• Selektoren gegen geänderte Reihenfolgen und zusätzliche Einträge testen

Schritt 9: Aussagekräftige Assertions formulieren

Prüfungen werden aus fachlichen Erwartungen abgeleitet. Sichtbarkeit, Nicht-Sichtbarkeit, aktivierbarer Zustand und Textvarianten werden so kombiniert, dass ein Fehler eine verständliche Ursache zeigt und nicht nur einen beliebigen Folgeschritt stoppt.

• assertVisible und assertNotVisible gezielt platzieren
• Zustandsmerkmale wie enabled, checked oder selected prüfen
• Fehlermeldungen durch kleine, fachlich benannte Prüfschritte verbessern

Schritt 10: Synchronisation ohne starre Pausen gestalten

Die integrierte Wartelogik wird bewusst genutzt und nur dort ergänzt, wo asynchrone Verarbeitung oder lange Hintergrundvorgänge dies erfordern. Feste Schlafzeiten werden durch beobachtbare Zustände ersetzt.

• automatisches Warten und Animationsruhe verstehen
• extendedWaitUntil für fachliche Zustände einsetzen
• Timeouts begründen, begrenzen und als Diagnosehinweis dokumentieren

Schritt 11: Wiederverwendbare Subflows strukturieren

Gemeinsame Abläufe wie Anmeldung, Navigation oder Datenanlage werden in atomare Teilflows ausgelagert. Eingaben und Seiteneffekte werden explizit gehalten, damit ein Teilflow in mehreren Tests sicher einsetzbar bleibt.

• wiederkehrende Schritte anhand fachlicher Verantwortung schneiden
• Parameter und Vorbedingungen des Teilflows dokumentieren
• direkte Ausführbarkeit für isolierte Tests erhalten

Schritt 12: Parameter und Umgebungswerte sicher einsetzen

Varianten eines Tests werden über klar benannte Werte statt über Kopien gesteuert. Standardwerte, Pflichtwerte und Geheimnisse werden getrennt; lokale und automatisierte Ausführung erhalten dieselbe Schnittstelle.

• Parameter über CLI und aufrufende Subflows übergeben
• Umgebungsnamen konsistent und sprechend wählen
• fehlende oder ungültige Werte früh prüfen

Schritt 13: Einrichtung und Aufräumen mit Hooks steuern

Vor- und Nachbedingungen werden in klar begrenzten Hooks abgebildet. Fehler im Hauptflow dürfen notwendige Aufräumarbeiten nicht verhindern; gleichzeitig bleiben Hooks klein genug, um Ursachen nicht zu verschleiern.

• onFlowStart für vorbereitende Zustände einsetzen
• onFlowComplete für Aufräumen und Diagnose nutzen
• Hook-Fehler von fachlichen Testfehlern unterscheidbar machen

Schritt 14: Workspace und Verzeichnisstruktur aufbauen

Flows, Subflows, Skripte, Konfiguration und Testdaten werden in einer konsistenten Struktur organisiert. Die Struktur unterstützt lokale Suche, automatische Erkennung und klare Code-Reviews.

• Ordner nach Produktbereich und Testebene gliedern
• gemeinsame Bausteine von szenariospezifischen Dateien trennen
• Namenskonventionen und Eigentümerschaft dokumentieren

Schritt 15: Tags und Testauswahl für unterschiedliche Läufe verwenden

Tests werden nach Zweck, Risiko, Plattform und Laufzeit klassifiziert. Dadurch können Smoke-, Regression- und Freigabeläufe gezielt zusammengestellt werden, ohne Dateien manuell zu verschieben.

• kleine, stabile Tag-Taxonomie definieren
• Ein- und Ausschlussregeln für Pipelines festlegen
• veraltete oder widersprüchliche Tags regelmäßig bereinigen

Schritt 16: Berichte und Laufartefakte auswertbar machen

Testergebnisse werden für Entwickler, Qualitätssicherung und Betrieb unterschiedlich aufbereitet. Maschinenlesbare Berichte, Screenshots, Protokolle und Geräteinformationen bilden zusammen einen nachvollziehbaren Fehlerkontext.

• Berichtsformat passend zur Zielplattform wählen
• Artefakte auch bei abgebrochenen Läufen sichern
• Aufbewahrung und Zugriff auf sensible Daten regeln

Schritt 17: Elementhierarchie und Ausführungsprotokoll diagnostisch nutzen

Fehlende oder falsch ausgewählte Elemente werden anhand der zugänglichen Hierarchie untersucht. Ausführungsprotokoll, Hierarchieausgabe und Screenshots werden zusammen betrachtet, bevor ein Selektor geändert wird.

• Elementbaum zum Fehlerzeitpunkt erfassen
• tatsächlichen Zustand mit erwarteter Oberfläche vergleichen
• Selektoränderungen klein halten und mit Gegenfällen prüfen

Schritt 18: Flaky Tests methodisch analysieren

Unzuverlässige Tests werden nach Ursache klassifiziert: Synchronisation, Selektor, Testdaten, Geräteinstabilität oder echter Produktfehler. Wiederholungen dienen der Diagnose und nicht dem Verdecken struktureller Probleme.

• Fehlerhäufigkeit und betroffene Umgebung erfassen
• kleinsten reproduzierbaren Flow isolieren
• Korrektur durch kontrollierte Mehrfachausführung bestätigen

Schritt 19: Skalierbare Testarchitektur entwerfen

Die Testsuite wird nach Geschäftsprozessen, technischen Plattformvarianten und Wiederverwendung gegliedert. Abhängigkeiten zwischen Tests werden vermieden; jeder Flow bleibt einzeln startbar und besitzt einen definierten Ausgangszustand.

• Testpyramide und Rolle von UI-End-to-End-Tests festlegen
• fachliche Journeys von technischen Hilfsflows trennen
• Eigentümerschaft, Review und Wartungsgrenzen festlegen

Schritt 20: Durchgängiges Praxisprojekt abschließen

Die behandelten Bausteine werden in einer vollständigen Testsuite zusammengeführt. Der Ablauf reicht von der lokalen Erstellung über strukturierte Wiederverwendung bis zur automatisierten Ausführung und nachvollziehbaren Fehleranalyse.

• kritische Journey mit definierten Testdaten modellieren
• Suite lokal und in einer automatisierten Umgebung ausführen
• Ergebnisse prüfen, Fehler beheben und Wartungsregeln dokumentieren

Praxisübungen

1. Flow visuell entwerfen, als YAML bereinigen und lokal ausführen
2. Komplexe Liste mit relationalen Selektoren und stabilen Assertions testen
3. Mehrere Journeys in Subflows, Hooks und Parameter zerlegen
4. Workspace mit Tags, Berichten und Reviewregeln aufbauen
5. Instabilen Abschlussflow diagnostizieren, korrigieren und mehrfach verifizieren

Zielgruppe und Voraussetzungen

Zielgruppe: QA Engineers, Testautomatisierer, Mobile-Entwickler und künftige Verantwortliche für Maestro-Testsuiten.

Voraussetzungen: Grundverständnis mobiler Anwendungen und Softwaretests; keine Maestro-Vorkenntnisse erforderlich.

Praxisnutzen

Nach Abschluss stehen belastbare Vorgehensweisen, wiederverwendbare YAML-Bausteine und klare Prüfkriterien zur Verfügung. Tests können reproduzierbar ausgeführt, fachlich verständlich bewertet und bei Fehlern mit einer systematischen Diagnose bearbeitet werden.