Cypress vs. Playwright - zwei moderne E2E-Testing-Frameworks im direkten Vergleich
Cypress oder Playwright?
Diese Frage taucht inzwischen in vielen Projekten, oder auch Schulungen auf, wenn ein neues automatisiertes Testframework für Webanwendungen gesucht wird. Beide Werkzeuge können moderne Webanwendungen automatisiert testen. Beide können Browser bedienen, Assertions ausführen, Screenshots erstellen und in CI-Pipelines laufen.
Trotzdem unterscheiden sich Cypress und Playwright teilweise grundlegend.
Der Unterschied liegt nicht nur im Syntax, während Cypress beispielsweise cy.get() verwendet sieht das in Playwright ganz anders aus, hier wird page.locator() verwendet. Hinter beiden Frameworks stehen unterschiedliche Architekturen und unterschiedliche Konzepte dafür, wie Tests geschrieben, ausgeführt und debuggt werden.
In diesem Beitrag vergleichen wir Cypress und Playwright anhand eines konkreten Beispiels.
Wir verwenden dafür einen kleinen Onlineshop:
┌──────────────────┐
│ Browser │
│ │
│ Onlineshop │
└────────┬─────────┘
│
▼
┌──────────────────┐
│ Backend │
│ │
│ REST API / DB │
└──────────────────┘
Unser Test soll einen Benutzer anmelden, ein Produkt auswählen, es in den Warenkorb legen und anschließend den Checkout durchführen.
Wir schreiben diesen Test einmal mit Cypress und einmal mit Playwright.
Dadurch werden die Unterschiede wesentlich deutlicher als durch einen reinen Feature-Vergleich.
1. Gemeinsamkeiten von Cypress und Playwright?
Beginnen wir mit dem Offensichtlichen.
Sowohl Cypress als auch Playwright können Browser automatisieren und sind für End-to-End-Tests moderner Webanwendungen geeignet.
Ein typischer Test sieht konzeptionell bei beiden Frameworks so aus:
Test starten
│
▼
Browser öffnen
│
▼
Anwendung aufrufen
│
▼
Benutzeraktion durchführen
│
▼
Ergebnis überprüfen
│
▼
Test erfolgreich / fehlgeschlagen
Beide Frameworks bieten unter anderem:
- Browser-Automatisierung
- Assertions
- Screenshots
- Video bzw. Trace-/Debugging-Funktionen
- Netzwerkinterception
- API-Tests
- Test Hooks
- Test Isolation
- CI/CD-Unterstützung
- parallele Testausführung
- TypeScript-Unterstützung
Playwright unterstützt Chromium, Firefox und WebKit. Cypress unterstützt Chrome-basierte Browser und Firefox; WebKit ist bei Cypress aktuell als experimentelle Unterstützung dokumentiert.
Auf der Oberfläche wirken beide deshalb zunächst sehr ähnlich.
Die interessanten Unterschiede beginnen dort, wie die Tests ausgeführt werden.
2. Der wichtigste Unterschied: Die Architektur
Wenn wir Cypress und Playwright wirklich verstehen wollen, müssen wir zunächst die Architektur betrachten.
2.1 Cypress
Cypress verfolgt eine eigene Architektur.
Cypress beschreibt selbst, dass seine Tests innerhalb der Browser-Umgebung laufen und dass zwischen Cypress und einem Node-Prozess kommuniziert wird.
Vereinfacht können wir uns das so vorstellen:
┌───────────────────────────────────────┐
│ Browser │
│ │
│ ┌───────────────┐ │
│ │ Anwendung │ │
│ │ │ │
│ │ Onlineshop │ │
│ └───────────────┘ │
│ │
│ Cypress Test Runner │
│ │
└──────────────────┬────────────────────┘
│
│ Kommunikation
▼
┌────────────┐
│ Node │
│ Process │
└────────────┘Cypress ist also nicht einfach ein Programm, das von außen beliebige Browser fernsteuert.
Diese Architektur ist ein wesentlicher Teil des Cypress-Konzepts. Genau daraus ergeben sich einige der Stärken von Cypress – aber auch einige Einschränkungen.
Cypress selbst nennt beispielsweise als Trade-off, dass Cypress kein allgemeines Automatisierungswerkzeug ist und ein Test an einen einzelnen Superdomain-Kontext gebunden ist, wobei für Cross-Origin-Szenarien cy.origin() zur Verfügung steht.
2.2. Playwright
Playwright ist stärker als klassische Browser-Automatisierungsbibliothek aufgebaut.
Ein Playwright-Test erhält beispielsweise ein page-Objekt:
import { test, expect } from '@playwright/test';
test('Shop öffnen', async ({ page }) => {
await page.goto('https://shop.example.com');
await expect(page).toHaveTitle(/Shop/);
});
page repräsentiert dabei eine Browser-Seite.
Wir steuern diese Seite explizit:
Playwright Test
│
▼
Browser Context
│
├── Page
│
├── Cookies
│
├── Storage
│
└── Netzwerk
Playwright Test bringt dafür unter anderem Test Fixtures, Auto-Waiting, Assertions, Tracing und Parallelisierung mit.
Das führt zu einem wichtigen Unterschied:
Cypress fühlt sich stärker wie ein Testsystem innerhalb der Browserumgebung an.
Playwright fühlt sich stärker wie ein Framework an, das Browser und Browser-Kontexte explizit steuert.
Das ist eine der wichtigsten Grundlagen für den späteren Vergleich.
3. Unser Beispiel: Ein Onlineshop
Wir verwenden im weiteren Verlauf immer denselben Testfall.
Unser Shop enthält:
Startseite
│
▼
Login
│
▼
Produktliste
│
▼
Produkt auswählen
│
▼
Warenkorb
│
▼
Checkout
│
▼
Bestellbestätigung
Der fachliche Test lautet:
Ein Benutzer meldet sich an, legt ein Produkt in den Warenkorb und schließt die Bestellung erfolgreich ab.
Damit können wir die gleichen Aktionen in beiden Frameworks vergleichen.
4. Installation
4.1. Cypress
Ein Cypress-Projekt können wir beispielsweise mit npm einrichten:
npm install --save-dev cypress
Danach können wir Cypress öffnen:
npx cypress open
Die Cypress-Dokumentation beschreibt cypress open als Startpunkt für die interaktive Arbeit mit dem Cypress Test Runner.
Ein Test könnte anschließend beispielsweise hier liegen:
cypress/
└── e2e/
└── checkout.cy.js
4.2. Playwright
Bei Playwright verwenden wir beispielsweise:
npm init playwright@latest
Playwright legt dabei die grundlegende Teststruktur und Konfiguration an.
Eine typische Struktur sieht beispielsweise so aus:
tests/
└── checkout.spec.ts
playwright.config.ts
Bereits hier sehen wir einen kleinen Unterschied.
Cypress bringt mit dem Cypress App/Test Runner eine stark visuell orientierte Entwicklungsumgebung mit.
Playwright bringt dagegen seinen eigenen Test Runner @playwright/test mit.
5. Der erste Test
Jetzt schreiben wir denselben einfachen Test in beiden Frameworks.
Unsere Anwendung besitzt:
<h1>Mein Shop</h1>
5.1. Cypress
describe('Shop', () => {
it('zeigt den Shop', () => {
cy.visit('https://shop.example.com');
cy.get('h1')
.should('contain', 'Mein Shop');
});
});
Das typische Cypress-Muster lautet:
cy.visit()
│
▼
cy.get()
│
▼
should()
5.2. Playwright
Playwright sieht etwas anders aus:
import { test, expect } from '@playwright/test';
test('zeigt den Shop', async ({ page }) => {
await page.goto('https://shop.example.com');
await expect(page.locator('h1'))
.toContainText('Mein Shop');
});
Hier fällt sofort ein Unterschied auf.
Playwright arbeitet stark mit async und await.
Cypress dagegen verwendet die Cypress Command Chain:
cy.visit(...)
cy.get(...)
cy.click(...)
6. Cypress Commands vs. async/await
Das ist einer der größten Unterschiede beim Einstieg.
Bei Cypress schreiben wir:
cy.get('#login')
.type('max');
cy.get('#password')
.type('secret');
cy.get('button')
.click();
Wir schreiben kein:
await cy.get(...)
Das wäre in Cypress nicht das normale Programmiermodell.
Cypress verwaltet seine Commands über eine eigene Command Queue.
Bei Playwright sieht der gleiche Ablauf so aus:
await page.locator('#login')
.fill('max');
await page.locator('#password')
.fill('secret');
await page.locator('button')
.click();
Hier arbeiten wir mit normalen JavaScript-/TypeScript-Promises.
Das führt zu einer wichtigen Denkweise:
Cypress
cy.get()
cy.click()
cy.should()
↓
Cypress Command Chain
gegen:
Playwright
await locator()
await click()
await expect()
↓
Promises / async-await
Für Entwickler, die bereits viel mit JavaScript oder TypeScript arbeiten, fühlt sich Playwright deshalb häufig näher an normalen asynchronen JavaScript-Code an.
7. Login vergleichen
Jetzt wird unser Beispiel interessanter.
Wir haben folgende HTML-Struktur:
<label for="username">Benutzername</label>
<input id="username">
<label for="password">Passwort</label>
<input id="password">
<button>Einloggen</button>
7.1. Cypress
Mit Cypress können wir beispielsweise schreiben:
cy.get('#username')
.type('max');
cy.get('#password')
.type('secret');
cy.contains('button', 'Einloggen')
.click();
Oder mit data-testid:
cy.get('[data-testid="username"]')
.type('max');
cy.get('[data-testid="password"]')
.type('secret');
cy.get('[data-testid="login"]')
.click();
7.2. Playwright
Playwright legt großen Wert auf sogenannte Locators.
Die offiziellen Playwright-Dokumentationen empfehlen unter anderem:
page.getByRole()
page.getByText()
page.getByLabel()
page.getByPlaceholder()
page.getByAltText()
page.getByTestId()
Unser Login kann deshalb sehr lesbar geschrieben werden:
await page.getByLabel('Benutzername')
.fill('max');
await page.getByLabel('Passwort')
.fill('secret');
await page.getByRole('button', {
name: 'Einloggen'
}).click();
Das ist ein interessanter Unterschied.
Wir suchen nicht nur nach einem technischen CSS-Selektor.
Wir können uns an der Semantik der Benutzeroberfläche orientieren.
8. Warum getByRole() interessant ist
Angenommen unser HTML lautet:
<button class="btn btn-primary">
Einloggen
</button>
Mit CSS könnten wir schreiben:
page.locator('.btn-primary')
Das funktioniert.
Aber der Test hängt damit an der CSS-Klasse.
Ändert sich:
class="btn btn-success"
kann der Test brechen.
Mit:
page.getByRole('button', {
name: 'Einloggen'
})
orientieren wir uns dagegen stärker am tatsächlichen Verhalten der Oberfläche.
Das kann Tests robuster und näher am Benutzerverhalten machen.
Playwright beschreibt Locators ausdrücklich als zentrale Grundlage für Auto-Waiting und Retry-Verhalten.
9. Und Cypress?
Cypress bietet ebenfalls unterschiedliche Möglichkeiten, Elemente zu finden:
cy.get(...)
cy.contains(...)
Beispielsweise:
cy.contains('button', 'Einloggen')
.click();
Oder:
cy.get('[data-testid="login"]')
.click();
Cypress hat also keineswegs nur CSS-Selektoren.
Der Ansatz ist aber anders organisiert.
10. Auto-Waiting - beide Frameworks warten
Ein häufiger Fehler bei UI-Tests ist:
sleep(2000)oder:
await page.waitForTimeout(2000);Wir wollen normalerweise nicht zwei Sekunden warten.
Wir wollen warten, bis die gewünschte Bedingung erfüllt ist.
Hier sind Cypress und Playwright beide sehr stark.
10.1. Cypress Auto-Waiting
Nehmen wir an, der Button erscheint erst nach einem API-Call.
Wir schreiben:
cy.get('[data-testid="checkout"]')
.should('be.visible')
.click();
Cypress wartet dabei auf die entsprechenden Bedingungen, statt blind eine feste Zeit zu schlafen.
Genau dieses Command-/Retry-Modell ist ein wesentlicher Bestandteil von Cypress.
10.2. Playwright Auto-Waiting
Playwright verfolgt ebenfalls ein Auto-Waiting-Konzept.
Bei:
await page.getByRole('button', {
name: 'Checkout'
}).click();
führt Playwright vor dem Klick unter anderem Actionability Checks durch.
Dazu gehören beispielsweise:
- Element existiert
- Element ist sichtbar
- Element ist stabil
- Element kann Events empfangen
- Element ist aktiviert
Das bedeutet:
Nicht:
warte 2 Sekunden
Sondern:
warte bis die Aktion möglich ist
Das ist bei beiden Frameworks ein zentraler Vorteil.
11. Assertions
Jetzt prüfen wir die Bestellbestätigung.
HTML:
<h1>Vielen Dank für Ihre Bestellung</h1>
Cypress
cy.get('h1')
.should('contain', 'Vielen Dank');
Oder:
cy.url()
.should('include', '/order/success');
Playwright
await expect(page.locator('h1'))
.toContainText('Vielen Dank');
Und:
await expect(page)
.toHaveURL(/order\/success/);
Beide Frameworks bieten also integrierte Assertions.
Playwright beschreibt seine Assertions als „web-first“ und darauf ausgelegt, auf den erwarteten Zustand zu warten.
12. Der komplette Checkout-Test
12.1. Cypress
Jetzt bauen wir unseren Test zusammen.
describe('Checkout', () => {
it('bestellt ein Produkt', () => {
cy.visit('https://shop.example.com');
cy.get('#username')
.type('max');
cy.get('#password')
.type('secret');
cy.contains('button', 'Einloggen')
.click();
cy.contains('Produkt A')
.click();
cy.get('[data-testid="add-to-cart"]')
.click();
cy.get('[data-testid="cart"]')
.click();
cy.contains('button', 'Checkout')
.click();
cy.get('[data-testid="success"]')
.should('contain', 'Vielen Dank');
});
});
Der Test liest sich fast wie eine Abfolge von Benutzeraktionen.
12.2. Playwright
Jetzt schreiben wir den gleichen Test mit Playwright:
import { test, expect } from '@playwright/test';
test('bestellt ein Produkt', async ({ page }) => {
await page.goto('https://shop.example.com');
await page.getByLabel('Benutzername')
.fill('max');
await page.getByLabel('Passwort')
.fill('secret');
await page.getByRole('button', {
name: 'Einloggen'
}).click();
await page.getByText('Produkt A')
.click();
await page.getByTestId('add-to-cart')
.click();
await page.getByTestId('cart')
.click();
await page.getByRole('button', {
name: 'Checkout'
}).click();
await expect(page.getByTestId('success'))
.toContainText('Vielen Dank');
});
Funktional testen beide dasselbe.
Die Schreibweise ist jedoch deutlich unterschiedlich.
13. cy.get() gegen page.locator()
Ein häufiger Vergleich ist:
| Aufgabe | Cypress | Playwright |
|---|---|---|
| Element suchen | cy.get() | page.locator() |
| Text suchen | cy.contains() | page.getByText() |
| Rolle | cy.get('[data-testid="..."]') | page.getByRole() |
| Label | über verschiedene Selektoren/Strategien | page.getByLabel() |
| Test-ID | über Selektor/Commands | page.getByTestId() |
Wichtig ist dabei:
Die Tabelle sagt nicht, dass eine Variante grundsätzlich besser ist.
Sie zeigt die unterschiedlichen Konzepte.
14. Fixtures – hier wird der Unterschied größer
Jetzt wollen wir unseren Test mit Testdaten versorgen.
Beispielsweise:
Benutzer:
max@example.com
Passwort: secret
Produkt:
Produkt A
Preis: 49,90 €
Playwright hat hierfür ein sehr ausgeprägtes Fixture-Konzept.
Beispielsweise steht im Test automatisch ein page-Fixture zur Verfügung:
test('Shop', async ({ page }) => {
await page.goto('/');
});
Playwright Test analysiert, welche Fixtures ein Test benötigt, und stellt sie für den Test bereit. Eigene Fixtures können ebenfalls definiert werden.
15. Ein eigenes Fixture
15.1. Cypress
Cypress verwendet ebenfalls Fixtures.
Beispielsweise:
cypress/
└── fixtures/
└── user.json
Mit:
{
"username": "max",
"password": "secret"
}
können wir beispielsweise arbeiten:
cy.fixture('user')
.then((user) => {
cy.get('#username')
.type(user.username);
cy.get('#password')
.type(user.password);
});
Cypress hat also ebenfalls ein Fixture-Konzept.
Playwright integriert Fixtures allerdings noch stärker in seinen Test Runner.
15.2. Playwright
Wir könnten beispielsweise einen eingeloggten Benutzer bereitstellen.
Konzeptionell:
export const test = base.extend({
loggedInPage: async ({ page }, use) => {
await page.goto('/login');
await page.getByLabel('Benutzername')
.fill('max');
await page.getByLabel('Passwort')
.fill('secret');
await page.getByRole('button', {
name: 'Einloggen'
}).click();
await use(page);
}
});
Dann kann ein Test später schreiben:
test('Produkt bestellen', async ({ loggedInPage }) => {
await loggedInPage.getByText('Produkt A')
.click();
});
Das Fixture-Konzept kann bei größeren Playwright-Testprojekten sehr mächtig werden.
16. Test-Isolation
Bei E2E-Tests wollen wir möglichst vermeiden:
Test A
↓
verändert Zustand
Test B
↓
erwartet Zustand von A
Das ist gefährlich.
Wir wollen:
Test A → eigener Zustand
Test B → eigener Zustand
Test C → eigener Zustand
Playwright arbeitet mit Browser Contexts und Fixtures, um Tests voneinander zu isolieren.
Das ist ein wesentlicher Bestandteil des Playwright-Testmodells.
Cypress verfolgt ebenfalls ein starkes Isolation-Konzept und setzt Tests in eine definierte Browserumgebung zurück.
17. Browser-Unterstützung
Hier gibt es einen besonders wichtigen Unterschied.
Playwright wurde für:
Chromium
Firefox
WebKit
entwickelt.
Damit können wir beispielsweise testen:
Playwright
│
┌──────┼──────┐
▼ ▼ ▼
Chromium Firefox WebKit
Cypress unterstützt aktuell:
Chrome / Chromium
Edge
Firefox
sowie experimentell WebKit.
Wenn WebKit bzw. Safari-Nähe für unser Testziel entscheidend ist, ist das deshalb ein Punkt, den wir bei der Auswahl besonders betrachten sollten.
18. Mehrere Browser im selben Testprojekt
Playwright macht Browser-Projekte explizit konfigurierbar.
Beispielsweise:
projects: [
{
name: 'chromium',
use: {
...devices['Desktop Chrome']
}
},
{
name: 'firefox',
use: {
...devices['Desktop Firefox']
}
},
{
name: 'webkit',
use: {
...devices['Desktop Safari']
}
}
]
Damit können wir denselben Test gegen unterschiedliche Browserprofile ausführen.
19. Cypress und Browserwechsel
Auch Cypress kann Tests gegen unterschiedliche unterstützte Browser ausführen.
Die Browser werden von Cypress gestartet und kontrolliert.
Die Architektur ist jedoch eine andere.
Das ist wichtig, weil Cypress nicht als allgemeines Multi-Browser-Automatisierungsframework konzipiert wurde.
20. Netzwerk-Requests testen
Jetzt kommen wir zu einem Bereich, in dem beide Frameworks sehr interessant werden.
Angenommen unser Shop lädt Produkte über:
GET /api/products
Wir wollen testen:
Was passiert, wenn die API einen Fehler liefert?
20.1. Cypress cy.intercept()
Mit Cypress können wir den Request abfangen:
cy.intercept(
'GET',
'/api/products',
{
statusCode: 500,
body: {
error: 'Server unavailable'
}
}
).as('products');
cy.visit('/shop');
cy.wait('@products');
cy.contains('Produkte konnten nicht geladen werden')
.should('be.visible');
Cypress kann Requests beobachten, auf Requests warten und Responses stubben oder verändern.
20.2. Playwright page.route()
Mit Playwright können wir etwas Vergleichbares machen:
await page.route('**/api/products', async route => {
await route.fulfill({
status: 500,
contentType: 'application/json',
body: JSON.stringify({
error: 'Server unavailable'
})
});
});
await page.goto('/shop');
await expect(
page.getByText('Produkte konnten nicht geladen werden')
).toBeVisible();
Auch hier testen wir nicht die echte API.
Wir testen die Reaktion der Benutzeroberfläche auf eine bestimmte API-Situation.
21. cy.request() und Playwright APIRequest
Jetzt gehen wir einen Schritt weiter.
Wir wollen die API selbst testen.
Cypress:
cy.request('GET', '/api/products')
.then((response) => {
expect(response.status)
.to.eq(200);
expect(response.body)
.to.have.property('products');
});
Cypress bietet cy.request() direkt als Teil des Frameworks an. Der Request wird dabei aus dem Cypress Node-Prozess ausgeführt und nicht als Browser-XHR.
21.1. Playwright API Testing
Playwright bietet dafür ebenfalls eine eigene APIRequest-Funktionalität.
Beispielsweise:
import { test, expect } from '@playwright/test';
test('Products API', async ({ request }) => {
const response = await request.get('/api/products');
expect(response.ok()).toBeTruthy();
const body = await response.json();
expect(body.products).toBeDefined();
});
Damit können wir ebenfalls UI-Tests und API-Tests innerhalb desselben Testframeworks kombinieren.
21.2. Cypress API Testing vs. Playwright API Testing
Konzeptionell:
Cypress
cy.request()
│
▼
HTTP API
│
▼
response
und:
Playwright
request.get()
│
▼
HTTP API
│
▼
response
Beide können damit beispielsweise:
- GET testen
- POST testen
- PUT/PATCH testen
- DELETE testen
- Statuscodes prüfen
- Response-Bodies prüfen
- Authentifizierung testen
- Testdaten vorbereiten
Der große Vorteil:
Wir müssen nicht erst über die UI klicken, um einen bestimmten Systemzustand herzustellen.
22. Ein wichtiger Unterschied: API + UI im selben Test
Nehmen wir an, wir wollen einen Testbenutzer erzeugen.
Über die UI wäre das vielleicht:
Registrierung öffnen
↓
Formular ausfüllen
↓
E-Mail eingeben
↓
Passwort eingeben
↓
Registrieren
↓
Bestätigung
Das kann mehrere Sekunden dauern.
Über die API:
POST /api/users
können wir den Zustand direkt herstellen.
Danach testen wir die UI:
API → Benutzer anlegen
↓
Browser
↓
Login testen
Genau für solche Kombinationen sind sowohl Cypress als auch Playwright interessant.
Cypress beschreibt API-Tests ausdrücklich auch als Möglichkeit, Anwendungszustände per HTTP vorzubereiten, statt dafür durch die UI zu navigieren.
23. Parallelisierung
Bei kleinen Testprojekten spielt das zunächst kaum eine Rolle.
Bei 2.000 E2E-Tests wird es jedoch entscheidend.
Wir wollen nicht:
Test 1
Test 2
Test 3
Test 4
...
Test 2000
nacheinander ausführen.
Wir wollen:
Worker 1 → Test 1, 5, 9, ...
Worker 2 → Test 2, 6, 10, ...
Worker 3 → Test 3, 7, 11, ...
Worker 4 → Test 4, 8, 12, ...
Playwright Test bringt Parallelisierung als Bestandteil seines Test Runners mit.
Cypress bietet ebenfalls Möglichkeiten zur Parallelisierung, insbesondere in Verbindung mit Cypress Cloud und CI. Cypress dokumentiert hierfür unter anderem Smart Orchestration und parallele Testausführung.
Damit sollte man aber nicht einfach sagen:
Playwright ist schneller.
Das wäre zu pauschal.
Die tatsächliche Laufzeit hängt unter anderem von Testanzahl, Browsern, Infrastruktur, Netzwerk, Anwendung und Parallelisierungsstrategie ab.
24. Debugging
Ein sehr wichtiger Punkt in der Praxis ist die Frage:
Was mache ich, wenn ein Test fehlschlägt?
Cypress ist hier besonders visuell.
Im Cypress Test Runner können wir den Test Schritt für Schritt nachvollziehen.
Beispielsweise:
✓ visit
✓ get username
✓ type
✓ get password
✓ type
✓ click login
✗ get checkout
Wir sehen dadurch sehr schnell, an welcher Stelle der Test fehlgeschlagen ist.
Cypress beschreibt seinen interaktiven Test Runner genau für diesen Workflow: Tests laufen in einem echten Browser und einzelne Schritte können nachvollzogen werden.
24.1. Playwright Trace Viewer
Playwright verfolgt einen anderen Ansatz.
Hier ist insbesondere die Trace-Funktion interessant.
Ein Trace kann unter anderem Informationen über:
- Aktionen
- Screenshots
- Netzwerk
- DOM-Zustände
- Fehler
- Zeitabläufe
enthalten.
Playwright positioniert Tracing zusammen mit seinem Test Runner als Bestandteil des Debugging-Workflows.
Damit können wir nach einem fehlgeschlagenen CI-Test sehr detailliert nachvollziehen, was passiert ist.
24.2. Ein typischer Debugging-Unterschied
Cypress:
Test läuft
↓
Cypress Test Runner
↓
Schritt für Schritt sichtbar
Playwright:
Test läuft
↓
Trace wird aufgezeichnet
↓
Trace Viewer
↓
Aktionen + Netzwerk + Zustand
Beide Ansätze sind hilfreich.
Sie setzen aber unterschiedliche Schwerpunkte.
25. Screenshots und Videos
Auch hier bieten beide Frameworks entsprechende Möglichkeiten.
Ein Cypress-Test kann beispielsweise einen Screenshot erzeugen:
cy.screenshot('checkout');
Playwright:
await page.screenshot({
path: 'checkout.png'
});
Bei Playwright ist das Screenshot-/Trace-Konzept stark mit dem Test Runner und dessen Artefakten verbunden.
Bei Cypress ist die visuelle Integration in den Test Runner besonders unmittelbar.
26. TypeScript
Beide Frameworks unterstützen TypeScript.
Playwright wird in vielen Beispielen direkt mit TypeScript verwendet:
import { test, expect } from '@playwright/test';
Cypress unterstützt ebenfalls TypeScript.
Beispielsweise:
describe('Checkout', () => {
it('bestellt ein Produkt', () => {
cy.visit('/checkout');
});
});
Für ein modernes TypeScript-Projekt können deshalb beide Werkzeuge sinnvoll eingesetzt werden.
27. Test Runner
Hier lohnt sich eine klare Unterscheidung.
Cypress
Cypress bringt seine eigene Testumgebung mit:
Cypress
├── Test Runner
├── Browser
├── Commands
├── Assertions
└── Configuration
Playwright
Playwright besteht aus der Browser-Automatisierung und dem darauf abgestimmten Test Runner:
Playwright
├── Browser Automation
├── Playwright Test
├── Fixtures
├── Assertions
├── Projects
├── Parallelisierung
└── Tracing
Gerade bei größeren Testframeworks werden Fixtures, Projects und Worker interessant.
28. Test Hooks
Cypress:
beforeEach(() => {
cy.visit('/');
});
Playwright:
test.beforeEach(async ({ page }) => {
await page.goto('/');
});
Auch hier ist die Syntax ähnlich.
Der Unterschied liegt wieder im zugrunde liegenden Modell.
29. Login einmal vorbereiten
Angenommen wir möchten nicht in jedem Test erneut ein Login durchführen.
Cypress kann beispielsweise über cy.session() Sessions wiederverwenden:
beforeEach(() => {
cy.session('max', () => {
cy.visit('/login');
cy.get('#username')
.type('max');
cy.get('#password')
.type('secret');
cy.get('button')
.click();
});
});
Playwright kann beispielsweise mit gespeicherten Authentifizierungszuständen arbeiten.
Eine typische Strategie ist:
Login einmal durchführen
↓
storageState speichern
↓
Tests verwenden
Damit können wir den Login aus vielen Tests entfernen.
30. Daten und Zustände
Hier wird die Architektur wieder wichtig.
Stellen wir uns 500 Tests vor.
Wenn jeder Test:
UI öffnen
Login
Produkt anlegen
Produkt suchen
Produkt bestellen
durchführt, wird die Suite unnötig langsam.
Eine bessere Struktur kann sein:
API
│
├── Testdaten erzeugen
├── Benutzer erzeugen
└── Warenkorb vorbereiten
│
▼
UI Test
│
└── Benutzerverhalten testen
Das ist nicht exklusiv für Cypress oder Playwright.
Beide Frameworks ermöglichen diese Strategie.
31. Wo Cypress besonders interessant ist
Cypress hat einige Eigenschaften, die für bestimmte Teams sehr angenehm sind.
Ein typischer Cypress-Test liest sich sehr linear:
cy.visit('/');
cy.get('#username')
.type('max');
cy.get('#password')
.type('secret');
cy.get('button')
.click();
cy.contains('Willkommen')
.should('be.visible');
Die Cypress Command Chain ist für viele Entwickler sehr intuitiv.
Hinzu kommt die stark integrierte interaktive Testumgebung.
32. Wo Playwright besonders interessant ist
Playwright spielt seine Stärken unter anderem aus, wenn wir ein breites Browser- und Automatisierungsszenario benötigen.
Beispielsweise:
Chromium
Firefox
WebKit
│
▼
gleiche Tests
Dazu kommen:
- Browser Contexts
- Fixtures
- Projects
- Parallelisierung
- Tracing
- API Testing
- Locator-System
- TypeScript-Unterstützung
Playwright beschreibt sich selbst als Browser-Automatisierungsframework mit einer Testumgebung, die unter anderem Auto-Waiting, Assertions, Tracing und Parallelisierung integriert.
33. Ein direkter Vergleich
| Thema | Cypress | Playwright |
|---|---|---|
| E2E Testing | Ja | Ja |
| Component Testing | Ja | Ja, über entsprechende Integrationen/Ansätze |
| API Testing | cy.request() | APIRequest |
| Browser Automation | Ja | Ja |
| Chromium | Ja | Ja |
| Firefox | Ja | Ja |
| WebKit | experimentell | Ja |
| Auto-Waiting | Ja | Ja |
| Assertions | Ja | Ja |
| Netzwerk-Mocking | cy.intercept() | page.route() |
| Test Runner | Cypress Test Runner | Playwright Test |
| Fixtures | Ja | Sehr stark integriert |
| Parallelisierung | Ja, u.a. über Cypress Cloud | Ja |
| Tracing | Cypress Debugging/Cloud-Funktionen | Playwright Trace |
| async/await | nicht das zentrale Modell | zentrales Modell |
| Locators | cy.get(), cy.contains() usw. | locator(), getByRole() usw. |
| Browser Contexts | anderes Cypress-Modell | zentrales Konzept |
| Cross-Origin | cy.origin() | Browser-Navigation/Contexts entsprechend |
| Sprache | JavaScript/TypeScript | JS/TS, Python, Java, .NET |
Die Tabelle ist bewusst keine Bewertung.
Sie zeigt, dass beide Werkzeuge einen großen gemeinsamen Funktionsumfang haben, aber unterschiedliche Schwerpunkte setzen.
34. Der gleiche Test in beiden Frameworks
Hier können wir den Unterschied noch einmal direkt sehen.
Cypress
describe('Checkout', () => {
it('bestellt ein Produkt', () => {
cy.visit('/login');
cy.get('#username')
.type('max');
cy.get('#password')
.type('secret');
cy.get('button')
.contains('Einloggen')
.click();
cy.contains('Produkt A')
.click();
cy.get('[data-testid="add-to-cart"]')
.click();
cy.get('[data-testid="checkout"]')
.click();
cy.contains('Vielen Dank')
.should('be.visible');
});
});
Playwright
import { test, expect } from '@playwright/test';
test('bestellt ein Produkt', async ({ page }) => {
await page.goto('/login');
await page.getByLabel('Benutzername')
.fill('max');
await page.getByLabel('Passwort')
.fill('secret');
await page.getByRole('button', {
name: 'Einloggen'
}).click();
await page.getByText('Produkt A')
.click();
await page.getByTestId('add-to-cart')
.click();
await page.getByTestId('checkout')
.click();
await expect(
page.getByText('Vielen Dank')
).toBeVisible();
});
Der fachliche Test ist identisch.
Die technische Umsetzung unterscheidet sich.
35. Ein Punkt, den wir nicht unterschätzen sollten: Lernkurve
Für Entwickler, die bisher noch kein modernes E2E-Framework verwendet haben, kann Cypress zunächst sehr zugänglich wirken.
Wir schreiben:
cy.visit()
cy.get()
cy.click()
cy.should()
und sehen die Ausführung direkt im Test Runner.
Playwright bringt dagegen zusätzliche Konzepte mit:
Browser
Browser Context
Page
Locator
Fixture
Project
Worker
Trace
Diese Konzepte können bei größeren Projekten sehr wertvoll sein.
Sie bedeuten aber auch, dass wir zunächst mehr vom Framework verstehen müssen.
35.1. Typische Cypress-Denkweise
Bei Cypress denken wir häufig:
Was soll Cypress als nächsten Command ausführen?
Beispiel:
cy.get('#user')
.type('max');
cy.get('#login')
.click();
35.2. Typische Playwright-Denkweise
Bei Playwright denken wir eher:
Welche Browser-Seite möchte ich steuern?
Dann:
await page.getByLabel('Benutzer')
.fill('max');
await page.getByRole('button', {
name: 'Login'
}).click();
Das ist ein kleiner Unterschied in der Denkweise.
36. Wann wird die Wahl wirklich relevant?
Nicht beim ersten Test.
Der erste Test sieht bei beiden Frameworks relativ ähnlich aus.
Interessant wird es bei größeren Projekten.
Beispielsweise:
1.000 Tests
20 Browservarianten
CI/CD
Parallelisierung
API Setup
Authentication
Testdaten
Screenshots
Tracing
mehrere Umgebungen
Dann werden Architektur und Test Runner immer wichtiger.
36.1. Beispiel: 1.000 Tests
Stellen wir uns vor, unser Shop hat:
200 Login Tests
300 Produkt Tests
200 Warenkorb Tests
200 Checkout Tests
100 Admin Tests
Wir wollen:
CI
│
┌────────┼────────┐
▼ ▼ ▼
Worker 1 Worker 2 Worker 3
│ │ │
▼ ▼ ▼
Tests Tests Tests
Dabei müssen Testdaten, Sessions und Browserzustände sauber voneinander getrennt sein.
Genau hier werden Konzepte wie Playwright Fixtures, Browser Contexts und Worker interessant.
Aber auch Cypress bietet für größere Testlandschaften entsprechende Mechanismen und CI-/Cloud-Funktionen.
37. Cypress und Playwright sind keine Gegenspieler
Ein wichtiger Punkt geht in vielen Vergleichen verloren.
Cypress und Playwright lösen nicht völlig unterschiedliche Probleme.
Beide wollen uns dabei helfen:
Webanwendung
│
▼
automatisierte Tests
│
▼
verlässliches Feedback
Der Unterschied liegt stärker darin, wie sie dieses Ziel erreichen.
37.1. Wann spricht viel für Cypress?
Cypress kann besonders interessant sein, wenn:
- das Team schnell mit E2E-Tests starten möchte
- die interaktive Testentwicklung wichtig ist
- die Cypress Command Chain gut zum Team passt
- bereits Cypress-Know-how vorhanden ist
- UI- und API-Tests in einer gemeinsamen Umgebung aufgebaut werden sollen
- die unterstützten Browser ausreichen
Cypress bietet dafür eine stark integrierte Entwicklungs- und Debugging-Erfahrung.
37.2. Wann spricht viel für Playwright?
Playwright kann besonders interessant sein, wenn:
- mehrere Browserfamilien einschließlich WebKit relevant sind
- ein starkes Fixture-Konzept benötigt wird
- umfangreiche Parallelisierung geplant ist
- Browser Contexts intensiv genutzt werden sollen
- Tracing im CI-Debugging wichtig ist
- TypeScript/async-await gut zum Team passt
- Browser-Automatisierung stärker im Mittelpunkt steht
Playwright bringt diese Konzepte eng mit seinem Test Runner zusammen.
38. Was sollten wir nicht machen?
Wir sollten die Auswahl nicht anhand eines einzigen Tests treffen.
Zum Beispiel:
Cypress:
10 Zeilen
Playwright:
12 Zeilen
→ Cypress ist besser
Das sagt praktisch nichts aus.
Ein Framework muss zu unserem gesamten Testkonzept passen.
Wir sollten deshalb mindestens diese Fragen betrachten:
Welche Browser müssen wir testen?
Wie groß wird die Testsuite?
Wie wichtig ist Parallelisierung?
Wie werden Testdaten erzeugt?
Wie wird Authentication gelöst?
Wie wichtig ist API Testing?
Wie werden Fehler analysiert?
Welche Sprache und welches Programmiermodell
bevorzugt das Team?
Wie soll CI/CD aussehen?
39. Migration von Cypress zu Playwright
Interessant wird der Vergleich auch für bestehende Cypress-Projekte.
Ein Cypress-Test:
cy.get('#username')
.type('max');
cy.get('#password')
.type('secret');
cy.get('button')
.click();
wird in Playwright beispielsweise:
await page.locator('#username')
.fill('max');
await page.locator('#password')
.fill('secret');
await page.locator('button')
.click();
Das wirkt zunächst einfach.
Eine echte Migration ist aber mehr als eine Syntaxübersetzung.
Wir müssen unter anderem betrachten:
cy.* Commands
↓
Playwright API
cy.intercept()
↓
page.route()
cy.request()
↓
request.get()
cy.fixture()
↓
Fixtures / Testdaten
cy.session()
↓
storageState / Context
Cypress Configuration
↓
playwright.config.ts
Je größer die Testsuite, desto stärker werden die architektonischen Unterschiede sichtbar.
40. Ein hybrider Blick auf unsere Testpyramide
Unabhängig vom Framework sollte unsere Teststrategie nicht nur aus E2E-Tests bestehen.
Wir können beispielsweise folgende Struktur verwenden:
┌──────────────┐
│ E2E │
│ wenige Tests │
└──────┬───────┘
│
┌───────┴───────┐
│ API Tests │
│ mehr Tests │
└───────┬───────┘
│
┌──────────┴──────────┐
│ Unit Tests │
│ viele Tests │
└─────────────────────┘
Cypress und Playwright können dabei jeweils unterschiedliche Ebenen abdecken.
Wir sollten aber nicht jeden Test als E2E-Test schreiben.
41. Was ist nun der eigentliche Unterschied?
Wenn wir die vielen Details reduzieren, bleiben einige zentrale Punkte.
Cypress
Browser-zentriert
│
▼
Cypress Commands
│
▼
Test Runner
│
▼
UI + API + Network
Playwright
Test Runner
│
▼
Browser Context
│
├── Page
├── API
├── Storage
└── Network
Beide können sehr viel.
Aber die zugrunde liegenden Modelle sind unterschiedlich.
42. Unsere Entscheidungskriterien
Statt die Frage
Cypress oder Playwright?
isoliert zu betrachten, sollten wir besser fragen:
Browser
Brauchen wir Chromium + Firefox + WebKit?
Team
Passt Command Chaining oder async/await besser?
Architektur
Brauchen wir viele Browser Contexts und Fixtures?
Testumfang
Wie viele Tests erwarten wir?
CI
Wie stark wollen wir parallelisieren?
Debugging
Reicht der interaktive Runner?
Oder brauchen wir umfangreiche Traces?
API
Wie stark sollen API Tests Teil unserer Teststrategie sein?
43. Fazit
Cypress und Playwright sind beide leistungsfähige Werkzeuge für automatisierte Webtests.
Der Unterschied liegt weniger in der Frage:
Kann Framework A einen Login testen?
Das können beide.
Die interessantere Frage lautet:
Welches Testmodell passt besser zu unserer Anwendung, unserem Team und unserer Infrastruktur?
Cypress setzt auf eine eigene, browsernahe Architektur und bietet eine sehr integrierte Test- und Debugging-Erfahrung. Cypress kann dabei nicht nur UI-Tests, sondern auch API-Tests mit cy.request() sowie Netzwerkinterception mit cy.intercept() abdecken.
Playwright setzt stärker auf explizite Browser Contexts, Pages, Locators und einen eigenen Test Runner mit Fixtures, Auto-Waiting, Parallelisierung und Tracing. Dazu kommen Chromium, Firefox und WebKit als zentrale Browserziele.
Für unser Beispiel sieht der Kernunterschied deshalb so aus:
Cypress
cy.visit()
cy.get()
cy.click()
cy.should()
cy.request()
cy.intercept()
gegen:
Playwright
page.goto()
page.locator()
page.click()
expect()
request.get()
page.route()
Die Syntax ist dabei nur die Oberfläche.
Die eigentliche Entscheidung betrifft:
Architektur
+
Browser
+
Test Runner
+
Fixtures
+
API Testing
+
Debugging
+
Parallelisierung
+
Team-Erfahrung
Und genau deshalb sollten wir Cypress und Playwright nicht anhand eines einzelnen Login-Tests vergleichen.
Wir sollten beide Frameworks an unserem gesamten Testkonzept messen.
Denn am Ende ist nicht entscheidend, ob wir
Cypress
oder
Playwright
schreiben.
Entscheidend ist, ob unsere Tests zuverlässig, wartbar, nachvollziehbar und für unser Projekt sinnvoll aufgebaut sind.
Cypress und Playwright können dasselbe Ziel erreichen – sie führen uns auf unterschiedlichen Wegen dorthin.