Playwright Tutorial auf Deutsch: End-to-End-Tests mit KI erstellen

Von Ivan Rublev · Veröffentlicht am · Aktualisiert am · ~10 Min. Lesezeit
Ivan Rublev baut qa-signoff, die QA-Abnahme für Kunden-Webanwendungen, und hat die Kimai-Messung durchgeführt. Zur Kimai-Fallstudie

Playwright ist ein quelloffenes Framework von Microsoft, mit dem du Web-Apps in echten Browsern bedienst und prüfst. Es richtet sich an Entwickler und QA-Engineers in kleinen Produktteams und Agenturen. Am Ende läuft dein erster Test, und du kennst die Konfiguration für Rollen und Geräte und weißt, wie KI den nächsten Test schreibt; warum solche Tests vor jedem Release laufen, steht in Regressionstests für Web-Apps mit Beispielen.

Getestet mit Playwright 1.49.0, Chromium 131.0.6778.33 und Kimai 2.67.0, einer Open-Source-Zeiterfassung. Ich verkaufe qa-signoff Pro.

Inhaltsverzeichnis

Was ist Playwright?

Playwright ist ein quelloffenes Test-Framework von Microsoft. Es steuert Chromium, Firefox und WebKit mit einer Schnittstelle und emuliert Mobilgeräte wie das iPhone. Ein eigener Test-Runner gehört dazu. Du schreibst die Tests in TypeScript oder JavaScript, auch Python, Java und .NET gehen.

Wie installiere ich Playwright?

Die Installation braucht Node.js in der aktuellen Version 22, 24 oder 26 (laut playwright.dev, Stand Oktober 2026) und einen leeren Ordner. Ein Befehl legt das Projekt samt Konfiguration und Beispieltest an. Danach startest du den Test und öffnest den Bericht. Fünf Schritte führen dorthin.

  1. Prüfe mit node --version die Node.js-Version. Eine ältere Version stoppt den Installer.
  2. Führe in einem leeren Ordner npm init playwright@latest aus. Die Antworten (TypeScript, Ordner tests, GitHub-Actions-Workflow, Browser) bestimmen die Konfiguration.
  3. Lies, was der Befehl angelegt hat: playwright.config.ts, package.json, eine Lock-Datei und tests/example.spec.ts. Sonst findest du den Test später nicht.
  4. Starte npx playwright test. Der Beispieltest läuft in allen Browsern, der erste Lauf dauert länger als erwartet.
  5. Öffne den Bericht mit npx playwright show-report. Er öffnet sich von selbst nur bei Fehlern, sonst suchst du ihn vergeblich. Der UI-Modus (npx playwright test --ui) zeigt jeden Schritt des Laufs.

Wie schreibe ich einen ersten End-to-End-Test?

Ein erster End-to-End-Test beginnt mit einem Testfall, der festhält, was der Benutzer sieht. Als Beispiel dient Kimai, eine Open-Source-Zeiterfassung. Aus dem Testfall wird in sechs Schritten ein laufender Test. Die drei Unterabschnitte zeigen die Schritte an einer echten Datei des Kimai-Testprojekts.

  1. Wähle einen Testfall mit Abnahmekriterien. Ein Test ohne Kriterien prüft nichts Bestimmtes.
  2. Öffne die Seite mit page.goto. Ohne gespeicherte Sitzung der Rolle landest du auf der Anmeldeseite.
  3. Füge Locators hinzu, die auf einen Bereich der Seite begrenzt sind. Ein Locator, der mehrere Elemente trifft, lässt den Test scheitern.
  4. Schreibe einen expect-Block pro Kriterium. Fehlt einer, bleibt ein Kriterium ungeprüft.
  5. Füge einen Absence-Check hinzu, also eine Prüfung, dass etwas fehlt. Ohne ihn prüfst du nur, was da ist.
  6. Starte den Test und lies den Bericht. Ein roter Test ohne gelesene Fehlermeldung bringt dich nicht weiter.

Welche Tests du zuerst schreibst, zeigt dir der Beitrag welche UI-Tests sich zuerst lohnen.

Erst die Kriterien, dann der Code

Der Testfall TC-WEB-030 beschreibt die Navigation eines normalen Benutzers am Desktop:

Der Test dazu

Die Datei Tests/user/TC-WEB-030.spec.ts stammt aus dem privaten Kimai-Testprojekt, deshalb zitieren wir sie:

// TC-WEB-030 criteria-hash: c39a8eb8
import { test, expect } from '@playwright/test';

test('TC-WEB-030: Desktop navigation shows the User\'s menu groups inline', async ({ page }) => {
  test.skip(!['user-desktop-chrome'].includes(test.info().project.name), 'Desktop Chrome only: navigation layout is inline on desktop');

  await page.goto('/en/timesheet/');
  const menu = page.locator('aside #navbar-menu');
  const link = (href: string) => menu.locator(`a[href="${href}"]`);

  // Menu groups are shown inline, without a toggle
  await expect(page.locator('.navbar-toggler:visible')).toHaveCount(0);
  await expect(menu).toBeVisible();
  for (const id of ['dashboard', 'times', 'contract', 'reporting']) {
    await expect(menu.locator(`li#${id}`)).toBeVisible();
  }

  // Every page reachable on the other layout is reachable here
  await expect(menu.locator('li#times .dropdown-menu')).toHaveClass(/show/);
  await menu.locator('li#contract .dropdown-toggle').click();
  for (const href of ['/en/dashboard/', '/en/timesheet/', '/en/quick_entry/', '/en/calendar/', '/en/contract', '/en/reporting/']) {
    await expect(link(href)).toBeVisible();
  }

  // Absence check: no Administration, Invoices, Team timesheet or all-users report entries
  for (const href of ['/en/admin/', '/en/invoice/', '/en/team/', '/en/admin/timesheet/', '/en/reporting/users/month']) {
    await expect(menu.locator(`a[href^="${href}"]`)).toHaveCount(0);
  }
  await expect(menu.locator('li#admin, li#invoice, li#invoices')).toHaveCount(0);

  // A menu link opens its page
  await link('/en/calendar/').click();
  await expect(page).toHaveURL(/\/en\/calendar\/(\?|$)/);
  await expect(page.locator('#calendar, .fc')).not.toHaveCount(0);
});

Vier Dinge machen den Test lesbar:

Test ausführen und Bericht lesen

npx playwright test TC-WEB-030 startet nur diese Datei, und --project=user-desktop-chrome wählt ein Projekt. npx playwright show-report öffnet den HTML-Bericht.

Wie wähle ich Locators für meine Tests aus?

Begrenze jeden Locator auf einen Bereich der Seite, dann trifft er nur ein Element. Der Test von TC-WEB-030 begrenzt alle Locators auf das Menü der Rolle User. Die Datei Tests/user/TC-WEB-030.spec.ts legt dafür zwei Hilfen an:

  const menu = page.locator('aside #navbar-menu');
  const link = (href: string) => menu.locator(`a[href="${href}"]`);

Jeder weitere Locator der Datei fragt menu oder link und trifft so nur Elemente im Menü.

npx playwright codegen schlägt Locators selbst vor. Laut der Codegen-Dokumentation auf playwright.dev bevorzugt es Rolle, Text und Test-ID und verfeinert den Locator, wenn mehrere Elemente passen.

Wie teste ich mehrere Rollen und Geräte?

Eine Web-App zeigt je nach Rolle und Gerät andere Inhalte. Playwright bildet das mit Projekten ab, eines pro Rolle und Gerät. So sieht playwright.config.ts bei Kimai aus:

import 'dotenv/config';
import { defineConfig, devices } from '@playwright/test';

export const roles = ['Super admin', 'User'];
const environments = ['Desktop Chrome', 'iPhone 13'];

export const slug = (name: string) => name.toLowerCase().replace(/ /g, '-');

const profile = (env: string) => {
  if (!devices[env]) throw new Error(`Unknown Playwright profile in Environments: ${env}`);
  return { ...devices[env], defaultBrowserType: 'chromium' as const };
};

export default defineConfig({
  testDir: './Tests',
  fullyParallel: false,
  workers: 1,
  use: { baseURL: process.env.BASE_URL, screenshot: 'only-on-failure' },
  reporter: [
    ['list'],
    ['json', { outputFile: 'test-results/results.json' }],
  ],
  projects: [
    // Logs every role in and writes .auth/<role slug>.json.
    { name: 'setup', testMatch: /auth\.setup\.ts/ },
    ...[...roles, 'no-login'].flatMap(role =>
      environments.map(env => ({
        name: `${slug(role)}-${slug(env)}`,
        testDir: `./Tests/${slug(role)}`,
        use: role === 'no-login'
          ? profile(env)
          : { ...profile(env), storageState: `.auth/${slug(role)}.json` },
        // no-login too: its tests may open a helper role's session.
        dependencies: ['setup'],
      })),
    ),
  ],
});

Das ergibt sechs Projekte aus drei Rollen (Super admin, User und der künstliche Eintrag no-login) und zwei Geräten (Desktop Chrome, iPhone 13). Das Projekt setup meldet jede Rolle einmal an und speichert die Sitzung in .auth/<rolle>.json. Jedes andere Projekt lädt sie über storageState. Kein Test meldet sich selbst an.

Ein Fehler aus dem Kimai-Lauf betrifft die Anmeldung. Kimai begrenzt Anmeldungen auf fünf in fünf Minuten, und nach mehreren Läufen des Setups griff die Sperre. Seitdem sendet der Setup-Test eine eigene Client-Adresse, und Wiederholungen laufen mit --no-deps, also ohne erneutes Setup. Den Aufwand in Stunden haben wir nicht erfasst.

Kein Test setzt einen Viewport oder ein Gerät. Das liefert das Projekt. Ein Test für nur ein Gerät überspringt die anderen mit test.skip, wie TC-WEB-030 oben.

Wie erstelle ich Tests mit KI: Codegen und Test-Agents?

Playwright bringt zwei Wege mit, bei denen ein Werkzeug Testcode schreibt: Codegen nimmt Klicks auf, die Test-Agents planen, schreiben und reparieren Tests.

Tests aufnehmen mit Codegen

npx playwright codegen <url> öffnet einen Browser und ein Fenster, das deine Klicks als Testcode mitschreibt. Mit npx playwright codegen --device="iPhone 13" <url> nimmst du im Handy-Format auf. Prüfungen fügst du über die Werkzeugleiste ein: assert visibility, assert text und assert value. Welche Kriterien gelten, legt der Testfall fest.

Planner, Generator und Healer

Dieser Abschnitt beschreibt die Dokumentation auf playwright.dev für Playwright 1.56 und später. Die Kimai-Suite lief auf 1.49.0, also ohne diese Agenten.

Mit npx playwright init-agents --loop=claude legst du drei Agenten an (Test-Agents). Statt claude gehen auch vscode, codex und opencode.

Die Seed-Datei seed.spec.ts liefert den Startpunkt. Nach einem Update erzeugst du die Definitionen neu.

Was KI-Agenten an einem echten Projekt geschafft haben

Bei Kimai gab es ein Backlog mit etwa 350 Testfällen. Im gemessenen Lauf bearbeiteten sechs Claude-Code-Instanzen etwa 66 davon in etwa 1 h 48 min. Etwa 55 wurden fertig, etwa 11 (etwa 17 Prozent) blieben für eine Entscheidung des Menschen blockiert.

Der Messbericht rechnet für das ganze Backlog etwa 191 Stunden von Hand gegen etwa 43 Stunden mit Agenten. Die 191 Stunden sind eine Modellschätzung.

Blockiert blieben Testfälle wegen Fehlern in Kimai und wegen Kriterien, die die App nicht erfüllt. Dazu kamen Grenzen der Testumgebung.

Die Tests für Super admin stimmten im ersten Lauf, doch die mobilen Layouts für User und No-login brauchten Korrekturen. Zustandsabhängige Abläufe brauchten mehr Korrekturen oder blockierten, etwa TC-WEB-001: Nach dem Abmelden zeigt die Zurück-Taste wieder das Dashboard.

Die Messung stammt von einer App, und die Agenten waren Claude-Code-Instanzen ohne Playwrights Test-Agents. Die Rechnung steht im Praxistest mit Kimai: 350 Testfälle mit KI-Agenten.

Schreib deine ersten Tests selbst, wenn die App keine stabilen Testdaten hat. Das gilt auch, wenn niemand Zeit zum Prüfen hat. Sollen die Tests einem Junior Playwright beibringen, schreibt er sie besser selbst.

Vom Crawl zur Testsuite mit dem kostenlosen Paket

qa-signoff, ein Werkzeug von uns, führt diese Schritte zusammen. Agenten gehen deine App pro Rolle durch und schreiben eine Spezifikation, daraus Testfälle, ein Review prüft sie, am Ende stehen Playwright-Tests. Das kostenlose Paket steht unter Apache-2.0: qa-signoff auf GitHub.

Wie halte ich Tests aktuell, wenn sich die App ändert?

Tests veralten, wenn sich Kriterien oder App ändern. Vier Dinge halten sie aktuell:

Was prüft ein End-to-End-Test, und was nicht?

Ein End-to-End-Test prüft einen ganzen Weg durch die App, vom Klick im Browser bis zur Anzeige. Ein Integrationstest prüft, ob Bausteine zusammenarbeiten, und braucht keinen Browser.

Weil er die ganze App durchläuft, schreibst du wenige und legst sie auf die Wege, die Benutzer gehen. Einzelne Rechenregeln gehören in kleinere Tests. Laufen sie vor jedem Release, sind es End-to-End-Tests als Regressionstests vor jedem Release. Wie du das angehst, steht in Testautomatisierung ohne eigenes Testteam.

Welche Best Practices gelten für End-to-End-Testing?

Diese fünf Regeln stammen aus der Kimai-Suite:

  1. Eine Datei pro Testfall. So gehört jeder Test zu genau einem Kriterienset.
  2. Eine Sitzung pro Rolle. Das Setup meldet einmal an, die Tests laden die Sitzung.
  3. Absence-Checks. Prüfe, was nicht zu sehen sein darf.
  4. Kein festes Viewport. Das Projekt bestimmt das Gerät.
  5. Ein Skip-Guard pro Projekt. Ein Test für ein Gerät überspringt die anderen mit Begründung.

Ist Playwright besser als Selenium?

Das hängt von deinem Projekt ab. Die Tabelle nennt, was die Dokumentation beider Werkzeuge sagt (playwright.dev und selenium.dev, Stand Oktober 2026). Einen Geschwindigkeitsvergleich haben wir nicht gemessen.

MerkmalPlaywrightSelenium
BrowserChromium, Firefox, WebKitChrome, Edge, Firefox, Internet Explorer, Safari
SprachenJavaScript und TypeScript, außerdem Python, Java und .NETJava, Python, C#, Ruby, JavaScript, Kotlin
WartenPrüft vor jeder Aktion, ob das Element bereit istEigene Seite „Waiting Strategies“
Test-Runner enthaltenJa, @playwright/testEine eigene Bibliothek, die du zusätzlich einrichtest
Mobile EmulationEingebaut für Chrome auf Android und Mobile SafariDie Übersicht beschreibt keine Emulation; eine eigene Seite behandelt mobile Browser
KI-AgentenPlanner, Generator, HealerAbschnitt „Using AI coding agents with Selenium“

Selenium bleibt die richtige Wahl, wenn du schon eine laufende Suite hast oder Tests in Java auf einem Selenium Grid verteilst. Ein weiteres Framework ist Cypress, das laut cypress.io Tests im Browser und Komponententests ausführt.

Aktualisiert am 13. November 2026: Erstveröffentlichung.
Der Autor verkauft qa-signoff.

Lassen Sie einen Agenten den ersten Entwurf schreiben: das kostenlose qa-signoff-Paket, Apache-2.0, auf GitHub.

Kostenloses Paket holen