Wie gestaltet man ein Playwright-Framework für Dynamics 365 Finance & Operations so, dass Tests fachlich aussagekräftig, reproduzierbar, wartbar und effizient ausführbar bleiben, auch wenn die Testsuite wächst? Dieser Artikel zeigt, welche Architekturentscheidungen dafür nötig sind.

Dieser Artikel richtet sich an Solution Architects, D365-Entwickler, Test Engineers, Product Owner und Verantwortliche für Qualitätssicherung. Er baut auf Teil 1: UI-Testautomatisierung für D365 F&O – Nutzen und Grenzen auf.

Zentrale These Skalierbare Testautomatisierung entsteht nicht primär durch mehr parallele Tests, sondern durch eine Architektur, die Testverantwortung, Datenzustände, Fehlerdiagnose und Ausführung kontrolliert zusammenführt.

Die Beispiele stammen aus dem Testframework, das ich für Dynamics 365 Finance & Operations allein aufgebaut habe. Es deckt Purchase-to-Pay, Order-to-Cash und Stammdatenprozesse ab, liest seine Testfälle aus Excel-Tabellen und verarbeitet sie phasenweise über viele Fälle. Viele der folgenden Regeln sind nicht am Reißbrett entstanden, sondern aus konkreten Fehlschlägen im Betrieb.

Der Purchase-to-Pay-Prozess läuft damit vollständig automatisiert und im produktiven Einsatz. Er ersetzt den dreiwöchigen manuellen Frozen-Zone-Test der Keyuser und verschiedene Vorabtests der Consultants bei Neuentwicklungen.

1. Vom einzelnen UI-Test zum Testframework

Eine wachsende Sammlung einzelner Tests ergibt nicht automatisch ein belastbares Framework. Typische Symptome zeigen sich meist erst, wenn die Suite größer wird:

  • Doppelte Logik: Dieselben Klickfolgen stecken in vielen Tests und müssen bei jeder UI-Änderung überall angepasst werden.
  • Instabile Tests: Ergebnisse schwanken, ohne dass sich fachlich etwas geändert hat.
  • Gemeinsame Testdaten: Tests beeinflussen sich gegenseitig über Stammdaten und Belege.
  • Lange Laufzeiten: Rückmeldungen kommen zu spät, um im Entwicklungsprozess zu helfen.

Daraus ergeben sich vier Anforderungen an ein Framework: Es muss wartbar, reproduzierbar, diagnostizierbar und kontrolliert ausführbar sein.

Leitgedanke Das Framework muss den Betrieb einer Testsuite unterstützen, nicht nur deren Implementierung.

2. Teststrategie als Grundlage der Architektur

Bevor eine technische Struktur entsteht, muss feststehen, was automatisiert wird. Die Teststrategie bestimmt, welche Verantwortung ein Test trägt – und damit, was die Architektur leisten muss.

  • Auswahl geschäftskritischer Prozesse, beispielsweise Purchase-to-Pay.
  • Abgrenzung der Teststufen: Smoke-, Prozess- und Regressionstests haben unterschiedliche Ziele und Laufzeitbudgets.
  • Verteilung auf Testebenen: UI-, Integrations- und Komponententests ergänzen sich (siehe Testpyramide in Teil 1).
  • Vorbedingungen, erwartete Ergebnisse und fachliche Assertions werden vor der Implementierung festgelegt.
  • Priorisierung nach Geschäftsrisiko, Wartungsaufwand und Ausführungskosten.

Als Arbeitsmittel eignet sich eine Testfallmatrix. Sie macht Entscheidungen nachvollziehbar und verhindert, dass Tests nur deshalb entstehen, weil sie sich leicht automatisieren lassen.

SpalteZweck
TestzielWelche fachliche Aussage soll der Test belegen?
ProzessrisikoWelche Auswirkung hätte ein unentdeckter Fehler?
TestebeneUI, Integration/API oder Komponente?
DatenbedarfWelche Stammdaten und Belege müssen vorliegen?
AusführungsfrequenzSmoke, nächtlich, vor Release?
Entscheidung Welche Tests müssen über die UI laufen und welche nicht? Über die Oberfläche gehört, was nur dort nachweisbar ist: der durchgängige Anwenderpfad. Datenvorbereitung und Einzelregeln gehören auf günstigere Ebenen.

Aus meiner Praxis: Die Matrix ist zugleich die Eingabe

Bei mir ist die Testfallmatrix kein Dokument neben dem Framework. Die Testfälle liegen als Excel-Tabelle vor, das Framework liest sie vor dem Lauf und verarbeitet sie. Fachbereich und Test Engineering sprechen dadurch über dieselbe Tabelle. Zusätzlich gibt es eine fachliche Prüfmatrix, die festhält, welche Prüfungen ein Prozess abdecken muss.

Die Eingabetabelle enthält pro Bestellposition die Daten für Standort, Lieferant, Land, Steuersatz, Skonto und gegebenenfalls Promotion. Daraus ergeben sich Varianten, die denselben Prozess mit unterschiedlichen fachlichen Ausprägungen durchlaufen:

VarianteZiellagerLieferantenlandSteuersatzSkontoBesonderheit
1DeutschlandDeutschland19 %ja–
2DeutschlandPolen0 %ja–
3DeutschlandChina0 %nein–
4PolenPolen23 %ja–
5PolenBelgien0 %ja–
6PolenChina0 %neinMit Promotion

Auszug: Die Varianten sind aus den Bestellpositionen der Eingabetabelle zusammengefasst. Artikel-, Lieferanten- und Bestellnummern sind bewusst weggelassen. Das Ziellager bestimmt, in welchem Steuerkontext der Wareneingang stattfindet, und ist damit für die steuerliche Bewertung entscheidend.

3. Framework-Architektur: Verantwortlichkeiten sauber trennen

Eine nachvollziehbare Struktur trennt vier Dinge: Testlogik, UI-Interaktion, Testdaten und Umgebungskonfiguration. Wer diese Ebenen mischt, muss bei jeder Änderung – ob neue Umgebung, geändertes Formular oder anderer Datenbedarf – viele Tests anfassen.

Schichten eines Playwright-Frameworks für D365 – so setze ich sie um

Tests und Prozesskettentests/…/*.e2e.spec.ts · reine Aneinanderreihung von Flow-Aufrufen, keine Selektoren
Prozessschritte (Flows)*.flow.ts · fachliche Bausteine wie „Bestellung bestätigen“, typisierte Ein- und Ausgaben
UI-Abstraktion (Page Objects)pages/*.page.ts · kapseln Selektoren, gemeinsame Basisklasse für D365-Besonderheiten
Infrastruktur ohne Fachlogiklib/, auth/, testdata/ · Anmeldung, Excel-Zugriff, Phasen-Steuerung, Logging, Konfiguration

Fixtures als Bindeglied

Playwright Test stellt mit Fixtures einen Mechanismus bereit, um Voraussetzungen pro Test bereitzustellen und danach wieder abzubauen. Anmeldung, Testdaten und Hilfsobjekte lassen sich damit zentral definieren, statt sie in jedem Test zu wiederholen.

Page Objects oder Komponenten?

Page Objects bilden eine Seite oder ein Formular ab. Sie sind leicht verständlich, werden in D365 aber schnell groß, weil viele Formulare dieselben Muster wiederverwenden: Grids, FastTabs, Aktionsleisten, Lookups, Dialoge. Komponentenorientierte Abstraktionen kapseln genau diese wiederkehrenden Bausteine einmal und setzen sie in vielen Formularen ein.

AnsatzStärkeGrenze
Page ObjectsEinfach zu verstehen, nah am FormularDuplizierung wiederkehrender Muster
KomponentenWiederverwendung über Formulare hinwegMehr Abstraktion, höherer Einstiegsaufwand

Robuste Selektoren und fachlich aussagekräftige Assertions gehören in die UI-Schicht beziehungsweise in die Prozessschritte, nicht in die Tests. Ein Test soll lesbar bleiben wie eine Prozessbeschreibung.

Entscheidung Wie viel Abstraktion ist sinnvoll? Faustregel: Abstrahiere, sobald sich eine Logik wiederholt oder eine UI-Änderung mehrere Tests treffen würde – nicht vorher.

Aus meiner Praxis: Page Objects, Flows und Ketten

Ich habe mich für Page Objects plus eine zusätzliche Flow-Schicht entschieden. Die Verzeichnisstruktur ist bewusst schlicht:

auth/       Anmeldung (MFA) und gespeicherte Sitzung
lib/        Framework-Bausteine ohne Fachlogik
pages/      Page Objects – Selektoren und Einzelaktionen
tests/
  p2p/  o2c/  mdm/
    <bereich>/
      *.flow.ts   fachliche Bausteine (keine test()-Blöcke)
      *.spec.ts   Test für einen Bereich
  <domäne>/*.e2e.spec.ts   Prozesskette
testdata/   nur Quelldateien (Excel)
runs/       Ergebnisse, Logs und Traces je Lauf

Die Verantwortlichkeiten sind strikt getrennt: Selektoren leben nur in Page Objects, Fachlogik nur in Flows, und eine Prozesskette ist eine reine Aneinanderreihung von Flow-Aufrufen. Jeder fachliche Schritt ist ein eigener Baustein mit typisierten Ein- und Ausgaben und lässt sich einzeln aus jedem Prozess aufrufen. Das ist mir wichtiger als eine kleine Zahl großer Klassen, weil sich so Prozessketten neu kombinieren lassen, ohne Logik zu kopieren.

Dass diese Regeln eingehalten werden, prüft das Framework selbst: Ein Typprüf-Schritt (tsc) und ein eigenes Skript, das unerlaubte Konsolenausgaben findet, laufen nach jeder Änderung. Eine Regel, die nur in einem Dokument steht, wird erfahrungsgemäß nicht lange eingehalten.

Würde ich bei einem Neustart wieder so vorgehen? Ja, die Aufteilung in Page Objects und Flows hat sich bewährt. Ändert sich ein Verhalten der Oberfläche, etwa das Aufklappen von Registerkarten in D365, um ein Feld auszulesen, muss ich die Anpassung nur an zentralen Stellen umsetzen und nicht in jedem Test.

4. Testdatenisolation und reproduzierbare Prozesszustände

Wie in Teil 1 beschrieben, isoliert ein Browserkontext keine Geschäftsdaten. Für skalierbare Tests muss deshalb der Zustand in D365 selbst kontrolliert werden. Dazu gehören:

  • Bereitstellung und Wiederverwendung von Stammdaten und Transaktionen.
  • Eindeutige Zuordnung von Testdaten zu Tests, Workern und Pipeline-Läufen.
  • Umgang mit Nummernkreisen, Beständen, Buchungen, Workflows und gemeinsam genutzten Ressourcen.
  • Bereinigung und Wiederherstellung, auch bei abgebrochenen Tests.

Für die Erzeugung der Ausgangsdaten gibt es drei Wege, die sich kombinieren lassen:

UI-basiert

Nah am Anwenderverhalten, aber langsam und selbst ein Wartungsrisiko.

Unterstützte Schnittstellen

Schnell und gezielt, setzt aber passende Data Entities, Berechtigungen und Kenntnis der Geschäftslogik voraus.

Vorbereitete Ausgangsdaten

Sehr schnell zur Laufzeit, erfordert aber einen kontrollierten Weg, den Stand wiederherzustellen.

Entscheidung Wie wird ein reproduzierbarer Testzustand hergestellt, ohne die Tests selbst unnötig zu verlängern? Der UI-Test sollte nur den Prozessabschnitt über die Oberfläche durchlaufen, der abgesichert werden soll – alles davor ist Vorbereitung.

Aus meiner Praxis: Quelldaten bleiben unverändert

Drei Regeln haben sich bewährt:

  • Das Original bleibt unangetastet. Vor jedem Lauf wird die Excel-Quelldatei in einen Lauf-Ordner kopiert, Ergebnisse landen nur in dieser Kopie. Jeder Lauf bleibt dadurch nachvollziehbar und beeinflusst den nächsten nicht.
  • Kein gemeinsames Schreiben während des Laufs. Jeder Worker sammelt seine Ergebnisse in einer eigenen Datei, ein Schritt nach dem Lauf führt sie zusammen. Das vermeidet Dateisperren, sobald parallel gearbeitet wird.
  • Jeder Baustein prüft den Ausgangszustand. Bevor ein Baustein einen Datensatz verarbeitet, prüft er, ob dieser im erwarteten Zustand ist, und entscheidet dann bewusst: überspringen, nur den offenen Rest verarbeiten oder mit klarer Meldung abbrechen. Er läuft nie blind weiter.

Die dritte Regel geht auf reale Fehler zurück. Ein Wareneingang nach einem abgebrochenen Vorlauf verwendete ein bereits befülltes Formular einer anderen Bestellung weiter, Daten wurden also vermischt. Seitdem werden etwa die bereits erfassten und die erwarteten Mengen verglichen, bevor erneut gebucht wird. Ein Baustein ist damit auch nach einem Abbruch oder einer Wiederholung sicher aufrufbar.

Ein verwandter Fall betrifft Batch-Jobs: Ein Trigger gilt bei mir erst als erfolgreich, wenn der Jobverlauf einen neuen Lauf nach dem Auslösen zeigt. In einem Fall meldete der Trigger Erfolg, obwohl der Job auf „Withhold“ stand und nie lief. Ohne diese Prüfung wäre das nicht aufgefallen.

Lebenszyklus der Testdaten und Ergebnisse eines Laufs

1. Excel-Quelldateibleibt unverändert
2. Kopie im Lauf-Ordnernur sie wird beschrieben
3. Verarbeitung je PhaseZustandsprüfung vor jeder Aktion, Checkpoint danach
4. Teilergebnisse je Workereine Datei pro Writer, keine Sperren
5. Zusammenführungeinmal nach dem Lauf in die Ergebniskopie

Bricht ein Lauf ab, setzt er mit den Checkpoints aus Schritt 3 an derselben Stelle fort und schreibt in dieselbe Ergebniskopie weiter. Das Lauf-Archiv bewahrt Logs, Traces und Ergebnisse jedes Laufs getrennt auf.

Aus meiner Praxis: Ausgangszustand und konkurrierende Lanes

Den Ausgangszustand stellt die eigene Regressionsinstanz sicher, die ich in Teil 1 beschrieben habe. Das Standardtestsystem wird wöchentlich auf sie kopiert, die Daten beginnen also immer wieder auf einem bekannten Stand. Belege, die die Läufe in der Zwischenzeit auf der automatisierten Instanz erzeugen, verschwinden mit dem wöchentlichen Überschreiben. Das ersetzt eine aufwendige Bereinigung im Test selbst. Auf dem Standardtestsystem bleiben die Testdaten dagegen erhalten, etwa für manuelle Spezialtests.

Innerhalb eines Laufs müssen Lanes verhindern, dass sie sich gegenseitig stören. Drei Mechanismen tragen das:

  • Jede Bestellung gehört genau einer Lane. Die Lanes ziehen aus einem gemeinsamen Pool jeweils den nächsten freien Fall. Ein Fall wird nie von zwei Lanes gleichzeitig bearbeitet, und jede Lane arbeitet an eigenen Belegen. Der P2P-Prozess verändert ausschließlich diese eigenen Belege.
  • Gemeinsam genutzte Ressourcen werden serialisiert. Das Mobilgerät-Emulator-Login für den Wareneingang existiert je Lager nur einmal. Mehrere Lanes desselben Lagers teilen sich damit dieselbe Server-Sitzung und überschreiben sich gegenseitig den Bildschirmzustand. Bei einem Test mit acht Lanes scheiterte die Vereinnahmung deshalb bei 17 von 21 Bestellungen, mit Fehlerbildern wie nicht gefundenem Menü und leeren Feldern. Seitdem läuft der Zugriff je Lager über eine Warteschlange. Verschiedene Lager laufen weiter parallel zueinander.
  • Bausteine sind wiederholbar. Bricht eine Lane mitten in einem Schritt ab, kann ein fremd befülltes Formular zurückbleiben. Die Zustandsprüfung aus der dritten Regel oben verhindert, dass der nächste Aufruf damit weiterarbeitet.

Alle Lanes eines Laufs verwenden dieselbe gespeicherte Sitzung und damit denselben D365-Benutzer. Das erklärt vermutlich einen Teil der Oberflächenkonflikte, die ich in Abschnitt 6 beschreibe.

5. Diagnose und Stabilität: Fehlerursachen systematisch eingrenzen

Je größer die Suite, desto wichtiger wird die Frage, warum ein Test fehlgeschlagen ist. Vier Ursachenklassen sind zu unterscheiden: Produktfehler, Testfehler, Datenproblem und Umgebungsstörung. Nur wer sie trennen kann, behandelt rote Tests als verlässliches Signal.

Als Diagnosematerial stehen unter anderem Screenshots, Traces, Reports, die Browserkonsole und relevante Laufzeitinformationen zur Verfügung. Playwright kann Traces gezielt aufzeichnen, etwa nur beim ersten Wiederholungsversuch, um Speicher und Laufzeit zu schonen.

Synchronisation statt fester Wartezeiten

Timeouts und asynchrone Verarbeitung sind in D365 eine häufige Fehlerquelle. Entscheidend ist, den fachlich erwarteten Abschluss zu erkennen, nicht pauschal zu warten.

Retries und Flaky Tests

Eine Wiederholung kann vorübergehende Störungen abfangen, verdeckt aber auch echte Probleme. Wiederholte Tests sollten deshalb als „flaky“ sichtbar bleiben und nachverfolgt werden, statt stillschweigend grün zu werden.

Diagnoseartefakte können sensible Daten enthalten, etwa Screenshots mit Geschäftsdaten. Aufbewahrung und Bereinigung müssen deshalb geregelt sein.

Entscheidung Wann darf ein Test wiederholt werden, und wann muss ein Fehler die Pipeline blockieren? Eine Wiederholung ist vertretbar bei klar erkennbaren Umgebungsstörungen. Fachliche Abweichungen dürfen nicht durch Retries verschwinden.

Aus meiner Praxis: Drei Log-Ebenen und Aufzeichnung bei Fehlern

Jedes Ereignis wird einmal erzeugt und je Ebene gefiltert:

  • Userlog (Zusammenfassung): wenig, nämlich Fortschritt und Fehler mit Ursache. Erfolgsrauschen gehört nicht dorthin.
  • Detaillog: alles, was zur Fehlersuche nötig ist – Eingabedaten, Soll- und Ist-Wert, Diagnoseinformationen.
  • Zeitlog: nur Messwerte, also die Dauer einzelner Schritte, um Performanceoptimierungen gezielt umzusetzen. Am Lauf-Ende werden Ausreißer gegen die bisherige Historie verglichen.

Jede Logzeile trägt ihren Kontext (Kette, Fall, Phase, Lane) automatisch. Ein Baustein muss das nicht selbst weiterreichen.

Meine Retry-Konfiguration war lange ein Lehrstück. Ich hatte Traces auf „beim ersten Wiederholungsversuch“ gestellt, aber die Suite lief mit null Wiederholungen. Es gab also nie einen ersten Wiederholungsversuch und damit bei Fehlern nie Diagnosematerial. Heute wird durchgehend aufgezeichnet und nur bei einem echten Fehlschlag behalten. Bei einem hartnäckigen UI-Problem greife ich zuerst zu Trace und Video, statt eine zweite Vermutung auszuprobieren.

Statt Wiederholungen auf Testebene setze ich auf Fortsetzen statt Wiederholen: Der Lauf schreibt je Fall und Phase einen Checkpoint. Fällt die Umgebung länger aus als ein festgelegter Höchstwert, hält der Lauf sauber an und kann später an derselben Stelle weiterlaufen. Standardmäßig werden dabei nur umgebungsbedingte Fehler wiederholt, fachlich gescheiterte Fälle nur auf ausdrücklichen Wunsch. So verschwindet kein fachlicher Fehler hinter einem grünen zweiten Versuch. Das Ziel ist dennoch, Fortsetzungsläufe überflüssig zu machen: Je weniger technische Fehler auftreten, desto seltener wird die Funktion gebraucht.

Fehleranalysepfad: Ein Klick läuft in den Timeout

1. ZusammenfassungMehrere Bestellungen fallen im Schritt „Workflow einreichen“ aus. Die Meldung lautet nur Timeout.
2. DetaillogDer Klick auf den Folgebutton wartet 30 Sekunden. Eine Ursache steht nicht im Log.
3. Screenshot und TraceEin D365-Fehlerdialog liegt als Lightbox über der Seite und blockiert den Klick. Er ist nur im Bild sichtbar.
4. EinordnungKein Produktfehler der Geschäftslogik, sondern technisch. Er trat nur mit mehreren Lanes und demselben Benutzer auf. Die Vermutung lautet: konkurrierendes Schreiben des Oberflächenzustands.
5. MaßnahmeEin globaler Handler schließt den Dialog und protokolliert jedes Auftreten als Warnung. So bleibt sichtbar, wie oft es passiert.

Der Pfad zeigt, warum ich Log und Bild zusammen auswerte: Das Log nennt das Symptom, der Screenshot die Ursache. Ob der Dialog fachlich harmlos ist, ist nicht abschließend belegt, deshalb wird er gezählt statt stillschweigend ignoriert.

6. Parallelisierung: Laufzeit reduzieren, Zuverlässigkeit erhalten

Playwright führt Tests mit mehreren Workern parallel aus. Zusätzlich lässt sich eine Suite per Sharding auf mehrere Azure-DevOps-Agents verteilen. Beides verkürzt die Laufzeit, erhöht aber die Last auf der D365-Umgebung und das Risiko von Datenkonflikten.

  • Datenkonflikte: Parallele Tests dürfen nicht dieselben Belege oder veränderlichen Stammdaten nutzen.
  • Gemeinsame Benutzerkonten: Mehrere Sitzungen desselben Benutzers können sich beeinflussen, etwa über gespeicherte Oberflächenzustände.
  • Konkurrierende Geschäftsprozesse: Buchungen, Bestände und Nummernkreise sind gemeinsam genutzte Ressourcen.
  • Belastungsgrenzen: Eine Testumgebung hat begrenzte Kapazität; mehr Parallelität erzeugt Timeouts, die keine Produktfehler sind.
  • Nicht parallelisierbare Tests: Was fachlich nicht parallel laufen kann, wird getrennt und seriell ausgeführt.

Eine sinnvolle Parallelitätsgrenze lässt sich nur messen, nicht festlegen: Laufzeit und Stabilität werden bei steigender Parallelität verglichen, bis zusätzliche Worker keinen Gewinn mehr bringen oder die Fehlerrate steigt.

Entscheidung Wann verbessert zusätzliche Parallelität den Durchsatz – und wann verschlechtert sie die Stabilität? Die Antwort liefert eine Messreihe, keine Faustregel.

Aus meiner Praxis: Lanes statt Workern

Mein Framework läuft mit einem einzigen Playwright-Worker. Parallelität entsteht stattdessen durch mehrere Browser-Kontexte („Lanes“) innerhalb dieses Workers: Eine Phase, etwa das Anlegen aller Bestellungen, wird auf mehrere Lanes verteilt, bevor die nächste Phase beginnt. Der Grund ist das phasenweise Muster, das ich wegen der Latenz der D365-Workflows gewählt habe. Die Anzahl der Lanes ist ein Parameter mit dem Standardwert 1, weil die Ausführungsmaschine begrenzt ist. Sharding über mehrere Agents setze ich bisher nicht ein.

Was ich dabei beobachtet habe:

  • Bei mehreren Lanes mit demselben Benutzer trat ein D365-Fehlerdialog zum Grid-Zustand auf. Er liegt als Lightbox über der Seite, der Folgeklick lief in den Timeout. Meine Vermutung ist paralleles Schreiben desselben Benutzerzustands; belegt ist sie nicht, der Dialog wird deshalb abgefangen und als Warnung protokolliert.
  • Bei mehr Lanes renderten manche Felder später. Ein Wert war da, aber noch leer; ich lese ihn deshalb nun mit einem begrenzten Polling.
  • Fehler-Screenshots waren unter mehreren Lanes nicht verlässlich der richtigen Lane zugeordnet. Das ist ein Diagnoseproblem, das erst durch Parallelität entsteht.
  • Gemeinsam genutzte Ressourcen, etwa ein Lager für den Wareneingang, werden über eine gegenseitige Sperre serialisiert.

Eine wichtige Lehre: Ein Fehler ließ sich einmal mit sechs Lanes und am selben Tag mit nur einer Lane an denselben Testfällen reproduzieren. Die naheliegende Erklärung „zu viel Parallelität“ war damit widerlegt. Wer Instabilität vorschnell der Parallelität zuschreibt, behandelt womöglich das falsche Problem.

Messwerte aus dem P2P-Prozess

Gemessen habe ich den kompletten P2P-Ablauf: Anlage der Bestellung, Lieferantenbestätigung über das Vendor Collaboration Portal (VCP), Wareneingang, Produktzugang (PZ) und Ergebnisprüfung.

KonfigurationLaufzeit (18 Bestellungen im reduzierten Testscope, kompletter Ablauf)
2 Lanesca. 90 Minuten
3 Lanesca. 55 bis 70 Minuten
4 Lanesca. 45 bis 50 Minuten

Das Zeitlog zeigt außerdem, wie die Optimierung gewirkt hat: Dieselbe Fallzahl brauchte mit 2 Lanes zunächst rund drei Stunden und heute rund anderthalb. Die Lane-Zahl war dabei gleich, die Zeit hat sich also vor allem durch die Optimierung einzelner Schritte halbiert, nicht durch mehr Parallelität.

Doppelt so viele Lanes verkürzen die Laufzeit also um rund 45 Prozent, nicht um die Hälfte. Der Gewinn ist real, aber nicht linear: Workflows, Batch-Jobs und gemeinsam genutzte Ressourcen setzen Grenzen. Mit zwei Messpunkten lässt sich die Grenze noch nicht bestimmen. Ob sechs oder acht Lanes weiter helfen oder die Stabilität verschlechtern, muss eine weitere Messreihe zeigen, bei der Laufzeit und Fehlerquote gemeinsam betrachtet werden.

Die Stabilität hat sich dabei verändert. Anfangs traten mit 4 Lanes deutlich mehr technische Fehler auf als mit 2. Durch viele Testläufe und gezielte Nachjustierung sind sie auf null gesunken. Auch zusätzliche Belastung durch andere Prozesse auf derselben Testmaschine verursacht inzwischen keine technischen Fehler mehr. Mehr Parallelität war also nicht von vornherein instabil, sie musste erst stabil gemacht werden.

Das Zeitlog belegt den Verlauf: Im ersten Lauf mit 4 Lanes fielen 8 von 31 Bestellungen vor dem Wareneingang aus. Rund zehn Tage später folgten fünf Läufe mit 4 Lanes ohne Fehler in Folge.

Die Zahlen 31 und 18 bedürfen einer Erklärung: 31 Bestellungen sind der Gesamtlauf, 18 davon decken den Bedarf der Testfälle in der Rechnungsprüfung ab. Für die regelmäßigen Läufe teste ich bewusst mit diesem reduzierten Scope, genau wie es auch bei manuellen Testläufen üblich ist. Der Gesamtumfang bleibt Läufen vorbehalten, bei denen er gebraucht wird. Reduzieren ist hier eine Teststrategie-Entscheidung und kein Zugeständnis an die Technik.

Meine Empfehlung Zuerst den Test fachlich korrekt umsetzen, dann die Performance optimieren und technische Fehler auf null reduzieren – so weit, dass keine Resume-Läufe mehr nötig sind. Erst dann lohnt es sich, die Parallelität weiter zu erhöhen.

7. Azure DevOps: Die Testarchitektur in eine Pipeline überführen

Die Pipeline verbindet die bisherigen Bausteine zu einem kontrollierten Ausführungsprozess. Sie legt fest, was wann läuft und welche Ergebnisse welche Folgen haben.

Vom Trigger zur Qualitätsentscheidung

1. Triggertäglich geplant oder manuell
2. Umgebung vorbereitenNode, Abhängigkeiten, Browser, gespeicherte Sitzung
3. Tests ausführenProzessketten mit mehreren Lanes
4. Ergebnisse veröffentlichenJUnit, Traces, HTML-Report
5. QualitätsentscheidungDie Pipeline wird rot, wenn Tests fehlschlagen
  • Trigger und Teststufen: Smoke nach jedem Deployment, Prozesstests nächtlich, Regression vor einem Release.
  • Voraussetzungen: Konfiguration, Authentifizierung und Secrets gehören in geschützte Variablen, nicht in den Code.
  • Veröffentlichung: Testergebnisse, Reports und Traces als Pipeline-Ergebnisse bereitstellen.
  • Qualitätskriterien: Abbruchregeln und Freigabeentscheidungen vorab definieren.
  • Nicht verfügbare Umgebung: Ein Lauf, der wegen fehlender Vorbedingungen nicht starten kann, ist kein bestandener und kein fachlich fehlgeschlagener Lauf, sondern ein eigener Zustand.
Entscheidung Welche Tests laufen wann, und welche Ergebnisse dürfen eine Freigabe verhindern? Nur Tests, deren Aussage verlässlich ist, sollten blockieren dürfen.

Aus meiner Praxis: Pipeline, Testmaschinen und die MFA-Hürde

Die Testautomatisierung läuft aktuell auf der Pipeline und auf Testmaschinen. Die Pipeline führt die regelmäßigen Läufe aus, die Testmaschinen nutze ich für Individualtests und die Testdatenvorbereitung. Meine Pipeline ist bewusst schlank: Node installieren, Abhängigkeiten, Playwright-Browser, Sitzung bereitstellen, Tests starten, danach Ergebnisse als JUnit sowie Traces und HTML-Report als Artefakte veröffentlichen. Die Veröffentlichung läuft auch bei Fehlschlägen (succeededOrFailed), denn gerade dann braucht man die Artefakte. Der Lauf ist nicht an Commits gekoppelt, sondern manuell oder täglich geplant, weil ein End-to-End-Lauf gegen eine Testumgebung nicht bei jedem Commit sinnvoll ist.

Die größte Hürde war die Anmeldung. Die Multi-Faktor-Authentifizierung lässt sich in der Pipeline nicht interaktiv durchlaufen. Die gespeicherte Sitzung wird deshalb vorab lokal erzeugt und als geschützte Datei (Secure File) in Azure DevOps hinterlegt. Sie ist nur begrenzt gültig und muss regelmäßig erneuert werden. Der Agent braucht außerdem Netzzugang zur Testumgebung, in der Praxis also einen selbst gehosteten Agent. Zusammen mit den Kollegen aus der IT arbeite ich deshalb an Testbenutzern ohne MFA-Pflicht. Das ist ein Sicherheitsthema und wird intern abgestimmt, denn solche Benutzer sind nur in einem klar abgegrenzten Testumfeld vertretbar.

Eine bewusste Einschränkung: Eine ganze Prozesskette ist ein einziger Test. Azure DevOps zeigt bei einem Fehler daher „1 failed“, aber nicht, welche Bestellung betroffen ist. Die Details stehen im Abschlussbericht und in den Logs. Das ist der Preis des phasenweisen Musters, den ich bewusst in Kauf genommen habe.

Die Qualitätsentscheidung trifft die Pipeline selbst: Der Lauf ist erfolgreich oder er ist es nicht, ohne dass jemand das Ergebnis erst interpretieren muss. Dabei versucht sie, im Rahmen des Möglichen schon selbst zu unterscheiden, was ein Testdatenfehler und was ein fachlicher Fehler ist. Ein Testdatenfehler liegt vor, wenn Anwender die Ausgangsdaten verändert haben. Ein fachlicher Fehler entsteht durch Änderungen oder Updates der Logik. Das entspricht den Fehlerklassen aus Teil 1, die danach benannt sind, wer handeln muss. Liegen Fehler vor, analysiert das Produktteam sie. Sie gelten wie Incident-Meldungen von manuellen Testern und werden entsprechend bearbeitet. Das setzt voraus, dass die technischen Fehler gegen null gehen, denn sonst würde das Team Störungen der Automatisierung statt echter Befunde bearbeiten.

8. Skalierung und Betrieb: Qualität messbar steuern

Ein Framework muss langfristig wirtschaftlich betrieben werden können. Das gelingt nur, wenn Verbesserungen messbar sind. Sinnvolle Kennzahlen sind:

KennzahlInterpretationMögliche Maßnahme
LaufzeitWie schnell kommt die Rückmeldung?Tests auf günstigere Ebene verlagern, parallelisieren
Erfolgsquote beim ersten VersuchWie verlässlich sind Tests ohne Retry?Ursachen instabiler Tests beheben
Flaky-RateWie oft werden Tests erst im Retry grün?Datenisolation und Synchronisation prüfen
WartungsaufwandWie viel Zeit kosten Anpassungen nach Änderungen?Abstraktionen anpassen, überflüssige Tests entfernen

Belegt ist bei mir vor allem die Laufzeit: Das Zeitlog misst einzelne Schritte, führt eine Historie über viele Läufe und zeigt Ausreißer. Damit lassen sich Performanceoptimierungen gezielt dort ansetzen, wo tatsächlich Zeit verloren geht. Die Messung der Lanes im vorigen Abschnitt stammt aus genau diesen Daten.

Die Erfolgsquote messe ich ebenfalls. Bei den technischen Fehlern liegt sie inzwischen bei 100 Prozent, es treten keine technischen Fehler mehr auf. Übrig bleiben Befunde, die fachlich etwas bedeuten. Genau das macht ein rotes Ergebnis wieder aussagekräftig.

Aus meiner Praxis: Ein Service Update, das vier Wochen Vorsprung brachte

Ein Update des Zusatzmoduls Dycotrade im Rahmen eines Service Updates führte dazu, dass Wareneingangsbuchungen über das mobile Gerät (MDE) nicht mehr möglich waren. Dank der täglichen Testautomatisierung fiel das sofort auf. Ohne sie hätten wir es erst im manuellen Frozen-Zone-Test gefunden. So blieben uns vier Wochen, um das Problem mit dem Hersteller zu klären. Das ist der konkreteste Nutzen, den ich benennen kann: Updates von D365 und Zusatzmodulen werden täglich geprüft, nicht erst am Ende des Zyklus.

Hinzu kommen das Verhältnis von Abdeckung, Aussagekraft und Ausführungskosten sowie der Umgang mit D365-Updates und geänderten Geschäftsprozessen. Der Ausbau der Testsuite folgt den Erkenntnissen aus dem Betrieb, nicht umgekehrt.

Entscheidung Woran erkennt man, ob die Testautomatisierung tatsächlich besser wird? Am Trend der Kennzahlen, nicht an der Anzahl der Tests.

Fazit: Skalierbarkeit ist eine Architektureigenschaft

  • Die Teststrategie bestimmt die Testverantwortung.
  • Testdatenisolation schafft Unabhängigkeit.
  • Diagnose schafft Vertrauen in die Ergebnisse.
  • Parallelisierung optimiert die Ausführung.
  • Azure DevOps orchestriert den Gesamtprozess.
Architekturprinzip Erst reproduzierbare und diagnostizierbare Tests schaffen, dann die Ausführung skalieren.

Ein Test, der täglich läuft und technisch nicht mehr fehlschlägt, ist kein Werkzeug, das nur Aufwand spart. Er ist ein Frühwarnsystem: Beim Update des Zusatzmoduls Dycotrade hat er uns vier Wochen Vorsprung vor dem manuellen Frozen-Zone-Test verschafft. Wie ich Schritt für Schritt von vielen technischen Fehlern auf null gekommen bin, beschreibe ich in Teil 3: Von technischen Fehlern auf null.

Zurück zum Journal