Zum Inhalt springen

End-to-End-Tests mit Playwright: Frontend, Backend und Datenbank · Teil 9 von 14 der Serie

Teil 9: Wenn ein Test fehlschlägt

Mach die App mit Absicht kaputt und folge der Spur: welche Bereiche rot werden, was der Fehler sagt, und wie der Trace die Seite, die Aktionen und das Netzwerk in dem Moment zeigt, in dem es schiefging.

Quest-Ziele

  • Von jedem Test einen Trace aufzeichnen und ihn bei den fehlgeschlagenen behalten
  • An den fehlgeschlagenen Bereichen ablesen, wo in der App du suchen musst
  • Eine Fehlermeldung von Playwright lesen: die Assertion, den Locator, das Call Log
  • Die Ursache im Trace Viewer finden: die Seite bei jedem Schritt und die Anfragen, die sie geschickt hat
  • Mit UI-Modus, --last-failed und --debug Tests erneut ausführen und Schritt für Schritt durchgehen
  • Wissen, woher Flaky Tests kommen und was diese Suite dagegen tut

52 Tests, alle grün. Früher oder später wird einer rot sein, und genau dafür sind sie da. Dann zählt, wie schnell du vom roten Test zu der Zeile kommst, die ihn verursacht hat.

Dieser Teil ist die Übung für diesen Moment. Du baust einen kleinen Fehler in die App ein, siehst zu, wie die Suite ihn fängt, und folgst der Spur mit den Werkzeugen, die Playwright dir gibt: der Ausgabe im Terminal, dem Report, dem Trace und dem UI-Modus.

Ein Trace ist ein Film des Tests: Spul zurück bis zu dem Bild, in dem es schiefging, und der Fehler liegt offen da.
Ein Trace ist ein Film des Tests: Spul zurück bis zu dem Bild, in dem es schiefging, und der Fehler liegt offen da.

Aufzeichnen, was passiert

Sorg zuerst dafür, dass es etwas zum Ansehen geben wird. Ändere in playwright.config.ts den Block use:

playwright.config.ts
use: {
  // Record every test, and keep the recording of those that fail.
  trace: 'retain-on-failure',
  screenshot: 'only-on-failure',
},

Ein Trace ist eine Aufzeichnung von allem, was ein Test getan hat: jede Aktion, die Seite vor und nach jeder davon, die Anfragen, die die Seite geschickt hat, und was sie in die Konsole geschrieben hat. Die Einstellung aus Teil 2, 'on-first-retry', zeichnet nur auf, wenn ein fehlgeschlagener Test ein zweites Mal ausgeführt wird. Diese Konfiguration führt nichts ein zweites Mal aus, bisher wurde also nichts aufgezeichnet. 'retain-on-failure' zeichnet jeden Test auf und wirft die Aufzeichnung weg, wenn der Test besteht. screenshot: 'only-on-failure' legt ein Bild der Seite dazu, aus dem Moment, in dem ein Test fehlschlägt.

Einen Fehler einbauen

Jetzt mach etwas kaputt. Ändere in web/src/api.ts die Zeile, die eine Quest anlegt, so:

web/src/api.ts
create: (title: string, reward: number) => call<Quest>('/quest', 'POST', { title, reward }),

Im Pfad steht /quest, wo vorher /quests stand. Ein fehlender Buchstabe, die Art Flüchtigkeitsfehler, die durch ein Review rutscht. Lass die Suite laufen:

questboard
$ npx playwright testRunning 52 tests using 8 workers# ... 48 lines with a ✓, and among them:  ✘  11 [frontend] › tests/frontend/form.spec.ts:29:1 › shows what the API says when it turns a quest down (5.3s)  ✘   9 [frontend] › tests/frontend/form.spec.ts:3:1 › sends a new quest to the API and shows it (5.3s)  ✘  49 [e2e] › tests/e2e/quest-board.spec.ts:55:1 › a title that is taken is turned down, all the way from the database (5.3s)  ✘  48 [e2e] › tests/e2e/quest-board.spec.ts:5:1 › a new quest travels from the form into the database (5.4s)# ... the first two errors, and then:  3) [e2e] › tests/e2e/quest-board.spec.ts:5:1 › a new quest travels from the form into the database    Error: expect(locator).toHaveText(expected) failed    Locator: getByRole('list', { name: 'Quests' }).getByRole('listitem')    Timeout: 5000ms    - Expected  - 3    + Received  + 1    - Array [    -   /Find the lost sword.*50 gold/,    - ]    + Array []    Call log:      - Expect "toHaveText" getByRole('list', { name: 'Quests' }).getByRole('listitem') with timeout 5000ms      - waiting for getByRole('list', { name: 'Quests' }).getByRole('listitem')        14 × locator resolved to 0 elements       8 |   await board.add('Find the lost sword', 50);       9 |    > 10 |   await expect(board.quests).toHaveText([/Find the lost sword.*50 gold/]);         |                              ^      11 |   expect(await db.select().from(quests)).toMatchObject([      12 |     { title: 'Find the lost sword', reward: 50, done: false },      13 |   ]);        at /home/robin/questboard/tests/e2e/quest-board.spec.ts:10:30# ... the last error, and at the end:  4 failed    [frontend] › tests/frontend/form.spec.ts:3:1 › sends a new quest to the API and shows it    [frontend] › tests/frontend/form.spec.ts:29:1 › shows what the API says when it turns a quest down    [e2e] › tests/e2e/quest-board.spec.ts:5:1 › a new quest travels from the form into the database    [e2e] › tests/e2e/quest-board.spec.ts:55:1 › a title that is taken is turned down, all the way from the database  48 passed (16.9s)

Die Sitzung ist hier gekürzt; die Zeilen, die mit # beginnen, sagen, was ausgelassen wurde. Falls sich am Ende dein Browser mit einem Report öffnet und das Terminal wartet: Das ist der HTML-Report aus Teil 2. Beende ihn fürs Erste mit Strg+C, er kommt weiter unten an die Reihe.

Zuerst: wo? Bevor du einen einzigen Fehler liest, sieh nach, welche Bereiche fehlgeschlagen sind. Die Zusammenfassung am Ende nennt zu jedem fehlgeschlagenen Test das Projekt in eckigen Klammern. Bereich für Bereich ausgeführt, ergibt sich dieses Bild (bei database, backend und e2e zählt der Setup-Test mit, der vor ihnen läuft):

questboard
$ npm run test:database# 17 passed$ npm run test:backend# 19 passed$ npm run test:frontend# 2 failed, 10 passed$ npm run test:e2e# 2 failed, 4 passed

database und backend sind grün. Die Daten und ihre Regeln sind also in Ordnung, und die API tut, was sie vorher getan hat. frontend und e2e sind rot, und was diese zwei haben und die anderen zwei nicht, ist der Code, der im Browser läuft. In beiden sind es Tests, die eine Quest hinzufügen. Du hast noch keinen Fehler gelesen und weißt schon, wo du suchen musst: im Frontend, beim Hinzufügen. Hier zahlen sich die Bereiche aus.

Dann: was? Jetzt der Fehler des e2e-Tests. Seine erste Zeile nennt die Assertion, die fehlgeschlagen ist, toHaveText, und darunter steht der Locator, der gefragt wurde: die Einträge der Liste. Erwartet war ein Eintrag mit der neuen Quest, bekommen hat der Test eine leere Liste. Das Call Log sagt, wie Playwright dorthin kam: 14 × locator resolved to 0 elements. Es hat in den fünf Sekunden des Timeouts vierzehnmal nachgesehen, wie Web-first Assertions das tun, und nie einen Eintrag gefunden. Das ist also keine Frage des Timings: Die Quest ist gar nicht aufgetaucht. Das Stück Quelltext am Ende markiert die Zeile des Tests, und zwei Zeilen darüber steht board.add(…).

Die Fehler, die oben ausgelassen sind, passen ins Bild. Im Frontend-Bereich zeigt einer davon eine Meldung mit dem Text „Failed to fetch“: Die Anfrage mit dem falschen Pfad passt auf keinen Mock, also hat die Auffang-Route aus Teil 7 sie abgebrochen. Und jeder fehlgeschlagene Test hat seine fünf Sekunden gewartet, deshalb hat der Lauf 16,9 Sekunden gedauert.

Der Fehler sagt, was nicht passiert ist. Er sagt nicht, warum. Dafür musst du sehen, was der Test gesehen hat.

Der Report und der Trace

Öffne den Report des letzten Laufs:

questboard
$ npx playwright show-report
Der HTML-Report von Playwright nach dem eingebauten Fehler: 48 bestanden, 4 fehlgeschlagen. Die Dateien mit den fehlgeschlagenen Tests von frontend und e2e stehen oben, und jeder fehlgeschlagene Test hat einen Link „View Trace“.

Der Report stellt die Dateien mit Fehlschlägen nach oben und versieht jeden Test mit seinem Projekt. Ein Klick auf einen Test öffnet dessen Seite mit dem Fehler, den Schritten des Tests und dem Screenshot aus dem Moment, in dem er fehlschlug. Unter jedem fehlgeschlagenen Test steht der Link View Trace. Klick auf den von „a new quest travels from the form into the database“, oder öffne denselben Trace vom Terminal aus. Die Ausgabe des fehlgeschlagenen Laufs nennt den Befehl dafür unter jedem Fehler:

questboard
$ npx playwright show-trace test-results/quest-board-a-new-quest-tr-37a45--the-form-into-the-database-e2e/trace.zip
Der Trace Viewer mit dem fehlgeschlagenen e2e-Test: links die Aktionen mit dem roten Expect „toHaveText“, in der Mitte die Seite mit „Something went wrong. Please try again.“, und unten der Tab Network mit der Anfrage „quest“: ein POST an /api/quest, beantwortet mit 404 Not Found.

Der Trace Viewer zeigt den Test als Abfolge, durch die du gehen kannst. Links stehen seine Aktionen der Reihe nach: Er hat die Seite geöffnet, zwei Felder ausgefüllt, den Button geklickt, und dann, in Rot, die Erwartung, die fünf Sekunden gewartet hat. In der Mitte ist die Seite, wie sie bei der Aktion war, die du auswählst, und die Tabs darüber wechseln zwischen dem Moment davor und dem danach. Ganz oben läuft ein Streifen kleiner Bilder über die ganze Zeit. Die Tabs unten enthalten die Details, darunter die Konsole, das Netzwerk und den Quelltext des Tests.

Klick auf das rote Expect. Die Seite in der Mitte zeigt das Formular, noch ausgefüllt, und darunter „Something went wrong. Please try again.“ Die Seite hat die Quest also geschickt und ein Nein bekommen. Aber sieh dir den Satz an: Er stammt nicht von der API. Er ist der Ersatztext in call in web/src/api.ts, für eine Antwort, die nicht OK ist und keine eigene Meldung mitbringt. Jede Ablehnung der API bringt eine mit. Was hier geantwortet hat, war also keine der Routen der API.

Öffne unten den Tab Network. Er listet auf, was die Seite angefragt hat: das Dokument, ein Skript, ein Stylesheet, dann quests, die Liste, die sie am Anfang geladen hat, und in Rot quest. Wähl diese Anfrage aus: ein POST an /api/quest, beantwortet mit 404 Not Found. So eine Route gibt es nicht. Die Seite hat nach quest ohne s gefragt, und eine Suche nach '/quest' in web/src führt direkt zu der Zeile, die du geändert hast.

Das ist der ganze Weg vom roten Test zur fehlerhaften Zeile, ohne ein console.log und ohne dich von Hand durch die App zu klicken.

Der UI-Modus

Der Report und der Trace zeigen einen Lauf, der vorbei ist. Der UI-Modus bietet dieselbe Ansicht, während du Tests ausführst:

questboard
$ npx playwright test --ui
Der UI-Modus: links der Baum der Projekte und Dateien, e2e und frontend als fehlgeschlagen markiert; daneben der fehlgeschlagene Test mit seinen Aktionen und der Seite, wie sie war, und unten der Quelltext des Tests mit der markierten Zeile, die fehlschlug.

Links steht der Baum deiner Suite: Projekte, Dateien, Tests. Ein Dreieck neben einem Eintrag führt ihn aus, und das ganz oben führt alles aus, was in der Liste steht. Wähl einen Test aus, und die rechte Seite zeigt, was du aus dem Trace Viewer kennst: die Aktionen, die Seite bei jeder davon und unten die Tabs, hier mit dem Quelltext des Tests und der Zeile, die fehlschlug. Du öffnest dafür keine Trace-Datei, und während ein Test läuft, erscheinen seine Aktionen, sobald sie passieren.

Das Auge neben einem Eintrag schaltet für ihn den Watch-Modus ein: Playwright führt den Test dann erneut aus, wenn du seinen Code änderst. Beim Schreiben eines neuen Tests ist das eine kurze Schleife: tippen, speichern, hinsehen.

Das Frontend wird ein einziges Mal gebaut, beim Start des UI-Modus, vom Befehl in webServer. Nach einer Änderung am Code unter web/ startest du den UI-Modus deshalb neu, um den neuen Build zu testen. Änderungen an Tests und am Servercode gelten ohne Neustart ab dem nächsten Lauf.

Eingrenzen

Zurück im Terminal: Ein paar Optionen halten einen Lauf klein, solange du hinter einem einzelnen Fehlschlag her bist:

questboard
# Only the tests that failed in the last run$ npx playwright test --last-failed# Only the tests whose title contains these words$ npx playwright test -g "travels from the form"# One file, or one test by its line$ npx playwright test tests/e2e/quest-board.spec.ts:5# Step through a test in a browser you can see$ npx playwright test tests/e2e/quest-board.spec.ts:5 --debug

--last-failed ist die Option für die Zeit nach einer Korrektur: Sie führt aus, was im letzten Lauf rot war, dazu das Setup, von dem diese Tests abhängen, und sonst nichts. -g wählt Tests über Wörter aus ihrem Titel, und ein Pfad mit Zeilennummer wählt den einen Test, der dort beginnt.

--debug öffnet einen Browser, den du sehen kannst, zusammen mit dem Playwright Inspector: einem Fenster, in dem du den Test Aktion für Aktion ausführst und dir nach jeder die Seite ansiehst. Eine Zeile await page.pause() in einem Test tut dasselbe an einer Stelle deiner Wahl, immer wenn der Test in einem sichtbaren Browser läuft, sei es mit --debug oder mit --headed aus Teil 2.

Tests, die nur manchmal fehlschlagen. Eine Art Fehlschlag hält für keines dieser Werkzeuge still: der Test, der in einem Lauf rot ist und im nächsten grün, ein Flaky Test. Playwright kann einen fehlgeschlagenen Test noch einmal ausführen, und der Report führt einen Test, der bei einem späteren Versuch bestanden hat, dann als flaky; dafür ist der gleichnamige Filter im Report da. Wiederholungen bringen dir einen grünen Lauf, aber sie verdecken auch das Problem, und ein Flaky Test hat eine Ursache. Die üblichen sind eine feste Wartezeit, die manchmal zu kurz ist, und Daten, die sich Tests teilen. Diese Suite vermeidet beides durch ihre Bauweise: Ihre Assertions warten auf das, was sie erwarten, expect.poll wartet auf die Datenbank, und jeder Worker hat eine eigene Datenbank, die vor jedem Test geleert wird.

Korrigieren. Setz das s in web/src/api.ts wieder ein und lass npx playwright test noch einmal im Terminal laufen. Jeder Lauf dort beginnt damit, das Frontend neu zu bauen, die Korrektur steckt also in den Seiten, die die Tests öffnen, und der Lauf endet wieder mit 52 passed.

Was du jetzt hast

Eine Suite, die aufzeichnet, was sie tut, und eine Routine für den Tag, an dem ein Test rot ist: zuerst die Bereiche, um zu wissen, wo. Dann der Fehler, um zu wissen, was. Dann der Trace, um zu sehen, warum. Der UI-Modus und eine Handvoll Optionen halten den Weg zurück zu Grün kurz.

Bisher hat die App stillgestanden, während die Tests um sie herum gewachsen sind. Im nächsten Teil ändert sich die App: Das Quest Board bekommt einen Login, und die Suite muss mithalten.

Kommentare

Die Kommentare sind GitHub Discussions: Zum Schreiben mit GitHub anmelden.

Die Kommentare kommen über giscus von GitHub. Beim Laden gehen deine IP-Adresse an giscus.app und GitHub.