{"canonical_url":"https://engineer.company/de/glossary/end-to-end-test/","content_markdown":"# End-to-End-Test\n\n## Was es ist\n\nEin End-to-End-Test prüft ein ganzes laufendes System so, wie ein Nutzer es erlebt. Er startet die Anwendung mit echtem Frontend, Backend, Datenbank und Konfiguration, durchläuft einen Weg wie Registrierung oder Bezahlung einer Bestellung und prüft, was der Nutzer am Ende sehen würde. Die übliche Kurzform ist E2E-Test, die Praxis heißt End-to-End-Testing.\n\nIn _Software Engineering at Google_ ordnet Adam Bender Tests auf zwei Achsen ein. Größe betrifft Ressourcen: Ein kleiner Test bleibt in einem Prozess, ein mittlerer kann mehrere Prozesse auf einem Rechner verwenden, ein großer mehrere Rechner umfassen. Umfang beschreibt, wie viel Code ein Test ausführt. Tests mit großem Umfang heißen unter anderem funktionale Tests, End-to-End-Tests und Systemtests. Joseph Graves ergänzt im Buchkapitel über größere Tests, dass Tests mit dem größten Umfang meist mehrere echte Abhängigkeiten und weniger Testdoubles einbeziehen.\n\nDiese echten Abhängigkeiten liefern Realitätsnähe. Graves definiert sie danach, wie gut ein Test das echte Verhalten des geprüften Systems abbildet. Ein Unit-Test eines Checkoutformulars belegt die Korrektheit seines Codes in einer Sandbox. Ein End-to-End-Test desselben Formulars belegt, dass bereitgestellte Seite, dahinterliegende Route, Preisregeln und Datenbank übereinstimmen. Der Preis ist eine schlechtere Abschottung: Je näher eine Umgebung an Produktion liegt, desto schwerer lässt sie sich von allem anderen isolieren. Laut Graves stehen beide Eigenschaften oft in direktem Konflikt.\n\nBei einer Webanwendung ist der Browser die Nutzerschnittstelle, dort setzt deshalb der End-to-End-Test an. Graves sagt es klar: Für Endnutzer ist „die öffentliche API die Anwendung selbst“. Playwright Test, der Runner des folgenden Beispiels, wird vom Playwright-Projekt für End-to-End-Tests von Webanwendungen gebaut. Er bündelt Runner, Zusicherungen, Isolation und parallele Läufe und steuert Chromium, Firefox und WebKit mit oder ohne sichtbares Fenster.\n\n## Warum es wichtig ist\n\nKleinere Tests lassen Lücken, die nur ein Test des zusammengesetzten Systems schließen kann. Graves nennt die üblichen: Ein Testdouble kann sich vom ersetzten Original entfernen, ohne dass der Test eine geänderte echte Implementierung bemerkt. Ein Unit-Test deckt den Code einer Binärdatei ab, nicht aber Bereitstellungskonfiguration, Startskripte und Einstellungen der Produktionsinstanzen. Nur unter Last auftretende Probleme sind die dritte Lücke. Die vierte ist unerwartetes Verhalten, über das die meisten Probleme überhaupt erst Nutzer erreichen. Laut Bender setzt Google große Tests vor allem für End-to-End-Läufe des Gesamtsystems ein. Diese prüfen dessen Konfiguration mehr als einzelne Codeteile.\n\nSie prüfen außerdem die Oberfläche des zusammengesetzten Systems, mit der der Nutzer arbeitet. Ein Formular, das an eine vom Backend gerade umbenannte Route sendet, oder ein Release, dessen Konfiguration auf den falschen Dienst verweist, besteht auf beiden Seiten jeden Unit-Test und scheitert beim ersten echten Nutzer.\n\nDas kostet Geschwindigkeit und Zuverlässigkeit. Laut Graves gibt Google einem großen Test standardmäßig 15 Minuten oder eine Stunde bis zur Zeitüberschreitung. Solche Tests sind unter Umständen nicht abgeschottet, teilen Ressourcen mit anderen Tests und Verkehr und sind damit nicht deterministisch. Bender nennt die üblichen Ursachen: Uhrzeit, Netzwerkverzögerungen, Reihenfolge der Threadausführung, Hardwareinterrupts und den Browserrenderer. Deshalb empfiehlt das Buch grob eine Pyramide: etwa 80 Prozent eng begrenzte Unit-Tests, 15 Prozent Integrationstests und 5 Prozent Tests des ganzen Systems von Ende zu Ende. Größere Tests dienen laut Bender beim Produktwachstum als Plausibilitätsprüfung und sollten nicht der Hauptweg zur Fehlererkennung sein. Google-Teams reservieren sie oft für Builds und Releases, damit ihre Kosten die schnellere Entwicklungsschleife nicht belasten.\n\n## Wie es in der Praxis aussieht\n\nEin Shop verkauft eine Teekanne und fragt die API eines Versanddienstleisters nach einer Lieferprognose. Eine Playwright-Spezifikation für den ersten Gastkauf liest sich wie der Ablauf selbst:\n\n```ts\n// e2e/checkout.spec.ts\nimport { test, expect } from \"@playwright/test\";\n\ntest.beforeEach(async ({ page }) =\u003e {\n    // The carrier's API belongs to someone else: answer for it here.\n    await page.route(\"https://api.carrier.example/**\", (route) =\u003e\n        route.fulfill({ status: 200, body: '{\"days\": 2}' }),\n    );\n});\n\ntest(\"a guest can buy a teapot\", async ({ page }) =\u003e {\n    await page.goto(\"/shop/teapot\");\n    await page.getByRole(\"button\", { name: \"Add to basket\" }).click();\n    await page.getByRole(\"link\", { name: \"Basket\" }).click();\n    await expect(page.getByText(\"Delivery in 2 days\")).toBeVisible();\n    await page.getByLabel(\"Email\").fill(\"buyer@example.com\");\n    await page.getByRole(\"button\", { name: \"Place order\" }).click();\n    const thanks = page.getByRole(\"heading\", { name: \"Thank you\" });\n    await expect(thanks).toBeVisible();\n    await page.getByRole(\"link\", { name: \"View your order\" }).click();\n    await expect(page.getByText(\"Teapot\")).toBeVisible();\n});\n```\n\nJeder Locator benennt, was der Nutzer sieht: einen Button namens Add to basket, ein mit Email beschriftetes Feld, eine Überschrift Thank you. Playwright empfiehlt zuerst rollenbasierte Locators. Seine Locators sind strikt: Passt mehr als ein Element, löst die Aktion eine Ausnahme aus, statt zu raten. Vor jedem Klick oder Ausfüllen wartet Playwright auf die Bedienbarkeit des Elements. Eine Zusicherung wie `toBeVisible()` versucht es bis zum Eintreten der Bedingung erneut. Die Spezifikation enthält daher keine festen Wartepausen. Der Aufruf `page.route` beantwortet die Browseranfragen an den Versanddienstleister mit einem festen Body. So hängt der Test nie von einem fremdbetriebenen Server ab. Das Globmuster muss auf die ganze URL passen; `**` erfasst auch Schrägstriche. Das Routing erreicht nur Anfragen, die die Seite selbst stellt. Fragt stattdessen der Shopserver den Versanddienstleister, sieht der Browser diese Anfrage nie. Ein Testdouble muss dann auf der Serverseite einspringen. Jeder Test erhält auch einen frischen Browserkontext, den Playwright mit einem ganz neuen Browserprofil vergleicht. Cookies und Warenkorb eines Tests können so nicht in den nächsten gelangen.\n\nDie Konfiguration startet die Anwendung und sagt Playwright, wo sie erreichbar ist:\n\n```ts\n// playwright.config.ts\nimport { defineConfig } from \"@playwright/test\";\n\nexport default defineConfig({\n    testDir: \"e2e\",\n    retries: process.env.CI ? 2 : 0,\n    use: {\n        baseURL: \"http://localhost:3000\",\n        trace: \"on-first-retry\",\n    },\n    webServer: {\n        command: \"npm run start\",\n        url: \"http://localhost:3000\",\n        reuseExistingServer: !process.env.CI,\n    },\n});\n```\n\nDer Block `webServer` führt `npm run start` aus und wartet vor dem ersten Test auf eine Antwort der URL. Auf einem Laptop nutzt er einen schon laufenden Server weiter, in der CI startet er immer einen eigenen. Mit `baseURL` kann die Spezifikation `/shop/teapot` statt einer vollständigen Adresse angeben. `npx playwright test` führt die Testsuite ohne Fenster aus, `--headed` zeigt das Browserfenster und `npx playwright show-report` öffnet den HTML-Bericht. Standardmäßig wiederholt Playwright keinen fehlgeschlagenen Test. Hier erlaubt CI zwei Wiederholungen. Ein erst fehlgeschlagener und dann bestandener Test wird als flaky statt als bestanden gemeldet. Beim ersten Wiederholungsversuch wird ein Trace aufgezeichnet, der die Unterschiede zeigt.\n\nIn größerem Maßstab ist die Browserschicht der kleinste Arbeitsanteil. Die [über Go, SQL und Browser aufgebaute Testsuite](/de/portfolio/built-a-test-suite-across-go-sql-and-browser/) aus der seit 2025 laufenden Tätigkeit umfasst 981 Go-Testfunktionen in 310 Dateien, 543 Vitest- und Playwright-Spezifikationen einschließlich 48 End-to-End-Dateien und 30 Browserspezifikationen sowie 494 SQL-Dateien mit Verhaltenstests. Die Aufgabe war, das Verhalten jeder Schicht dort zu prüfen, wo es liegt, statt alles von außen durch einen Browser. Eine gespeicherte Funktion wird deshalb in der Datenbank und nicht durch drei darüberliegende Anwendungsschichten getestet. Die Seite benennt die Kosten klar: Die Testsuite ist langsam, belastet jede Änderung und braucht in dieser Größe eigene Pflege.\n\n## Wo es schiefgeht\n\n**Die Testsuite ist eine Eistüte.** So nennt Bender eine Suite mit vielen End-to-End-Tests und wenigen Integrations- und Unit-Tests. Sie ist meist langsam, unzuverlässig und umständlich in der Arbeit. Diese Form ist bei eilig vom Prototyp in Produktion gebrachten Projekten verbreitet. Graves ergänzt: Lässt sich der Code schwer mit Unit-Tests prüfen, sind End-to-End-Tests die einzigen schreibbaren Tests, und das Projekt hat binnen Tagen Altcode produziert. Jeder neue Dienst vervielfacht zudem die Systemwege; eine End-to-End-Suite kann nie alle abdecken. Verschieben Sie jeden Fall in den kleinsten Test, der ihn erkennt. Behalten Sie den Browser für die Abläufe, die nur das Gesamtsystem zeigen kann, und arbeiten Sie von den ersten Projekttagen an auf die Pyramide hin.\n\n**Selektoren folgen dem Markup.** Ein Locator wie `button.buttonIcon.episode-actions-later`, Playwrights eigenes Negativbeispiel, scheitert bei der nächsten Klassenumbenennung, obwohl der Nutzer keinen Unterschied sieht. Graves warnt: UI-Tests gelten als unzuverlässig und teuer, unter anderem weil Änderungen am Erscheinungsbild sie bei gleichem Verhalten brechen. Finden Sie Elemente anhand von Rolle, Beschriftung oder Text, wie ein Nutzer, oder anhand einer vom Team kontrollierten Test-ID. Hat das Backend eine öffentliche API, teilen Sie den Ablauf an der Grenze zwischen UI und API und steuern Sie den restlichen End-to-End-Test über die API.\n\n**Der Test schläft.** Eine feste Wartezeit ist an langsamen Tagen zu kurz und sonst zu lang. Laut Graves beginnen von Wartepausen und Zeitüberschreitungen abhängige Tests bei überlasteten Testrechnern alle zu scheitern. Ihre Wiederholungen erhöhen die Last weiter. Playwrights bewährte Praktiken zeigen eine subtilere Form desselben Fehlers: `expect(await page.getByText(\"welcome\").isVisible()).toBe(true)` prüft einmal und macht weiter, während `await expect(page.getByText(\"welcome\")).toBeVisible()` auf die Bedingung wartet. Nutzen Sie Zusicherungen, die auf Webzustände warten. Wartet ein Test auf das Backend, fragen Sie den Zustandswechsel wiederholt mit einer Zeitgrenze ab.\n\n**Tests teilen Daten.** Ein Test erstellt ein vom nächsten erwartetes Konto, oder zwei parallele Worker kaufen die letzte Teekanne im Lager. Die Suite besteht in einer Reihenfolge und scheitert in einer anderen oder nur bei paralleler Ausführung. Playwright empfiehlt die vollständige Isolation jedes Tests mit eigenem Speicher, eigener Sitzung, eigenen Daten und Cookies sowie die Kontrolle über die Daten jeder verwendeten Datenbank. Erstellen Sie mit eindeutigen Namen, was jeder Test braucht, und verlassen Sie sich nie auf Hinterlassenschaften früherer Tests.\n\n**Ein fremder Server steckt im Test.** Ein echter Zahlungsanbieter, Versanddienstleister oder Kartendienst macht die Suite von einem vom Team nicht kontrollierbaren System abhängig. Sein Aufruf kann Geld kosten. Graves rät von echten Drittanbieter-API-Aufrufen durch automatisierte Tests ab und nennt solche Abhängigkeiten eine wichtige Trennlinie für Tests. Playwright empfiehlt selbst, nur Kontrollierbares zu prüfen. Antworten Sie für den Drittanbieter per `page.route`, wenn der Browser anfragt, wie oben, oder konfigurieren Sie den Server für den Aufruf eines Testdoubles, wenn er die Anfrage stellt. Lassen Sie den Test an dieser Abhängigkeit enden.\n\n**Wiederholungen verbergen instabile Tests.** Wiederholungen in der CI machen einen roten Build grün, und die Kosten summieren sich. Bender rechnet vor: Bei 10.000 Tests täglich ergeben 0,1 Prozent Wahrscheinlichkeit eines falschen Fehlschlags pro Test 10 zu untersuchende instabile Läufe am Tag. Nähert sich die Instabilität 1 Prozent, verlieren die Tests an Wert. Wiederholungen ersetzen Entwicklungszeit durch zusätzliche Rechnerzeit und schieben die Behebung der Ursache nur auf. Die pytest-Dokumentation zeigt denselben Punkt aus einem anderen Blickwinkel: Tests auf höherer Ebene hängen von mehr Zustand ab und scheitern deshalb häufiger sporadisch. Behandeln Sie jeden von Playwright als flaky gemeldeten Test als Bug, öffnen Sie den Trace der Wiederholung und reparieren oder löschen Sie den Test.\n\n## Weiterführende Lektüre\n\n- [Testüberblick](https://abseil.io/resources/swe-book/html/ch11.html)\n  — Adam Benders Kapitel aus _Software Engineering at Google_: Testgröße und -umfang, Pyramide, Eistüte und die Kosten instabiler Tests.\n- [Größere Tests](https://abseil.io/resources/swe-book/html/ch14.html)\n  — Joseph Graves über Realitätsnähe, Lücken von Unit-Tests, Grenzen zu UI und Drittanbietern sowie das Beseitigen instabiler Tests.\n- [Installation](https://playwright.dev/docs/intro)\n  — Playwrights Einführung: Playwright Test installieren, den Beispieltest ausführen, Modus mit Fenster und HTML-Bericht.\n- [Bewährte Praktiken](https://playwright.dev/docs/best-practices)\n  — nutzersichtbares Verhalten prüfen, Tests isolieren, Drittanbieterserver weglassen, Locators und Zusicherungen, die auf Webzustände warten.\n- [Wiederholungen](https://playwright.dev/docs/test-retries)\n  — wie Playwright fehlgeschlagene Tests wiederholt und jeweils als bestanden, flaky oder fehlgeschlagen kennzeichnet.\n- [Instabile Tests](https://docs.pytest.org/en/stable/explanation/flaky.html)\n  — pytest erklärt Instabilität durch unkontrollierten Systemzustand, Testreihenfolge und Threadsicherheit sowie Gegenmaßnahmen.\n\n\u003chttps://engineer.company/de/glossary/end-to-end-test/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"End-to-End-Tests neben Unit-Tests, ein vollständiges Playwright-Beispiel für den Checkout samt Konfiguration und typische Ursachen langsamer, instabiler Tests.","formats":{"gemtext":"https://engineer.company/de/glossary/end-to-end-test/index.gmi","gopher":"https://engineer.company/de/glossary/end-to-end-test/gophermap","html":"https://engineer.company/de/glossary/end-to-end-test/","json":"https://engineer.company/de/glossary/end-to-end-test/index.json","markdown":"https://engineer.company/de/glossary/end-to-end-test/index.md","pdf":"https://engineer.company/de/glossary/end-to-end-test/index.pdf"},"kind":"page","language":"de","title":"Was ist ein End-to-End-Test?","url":"https://engineer.company/de/glossary/end-to-end-test/","version":1}