Wie QA-Teams Vertrags-, Authentifizierungs-, Testdaten-Setup, Negativtests und Prüfungen von Nebeneffekten in einer einzigen Playwright-Testsuite zusammenführen können – und wo die Grenzen liegen, wenn das zu testende System ein KI-Agent ist.


1. Warum sollten API- und UI-Prüfungen in einem Runner kombiniert werden?

Moderne Anwendungen stellen häufig eine öffentliche HTTP-API bereit, die sowohl das Web-Frontend als auch eine Reihe von KI-gestützten Diensten (Chatbots, Empfehlungsmaschinen, Code-Assistenten usw.) unterstützt. Wenn ein QA Engineer einen End-to-End-Test (E2E) mit Playwright schreibt, sieht der Standard-Workflow so aus, dass ein Browser gestartet wird, mit der Benutzeroberfläche interagiert wird und die gerenderte Seite überprüft wird.

Playwright liefert außerdem APIRequestContext mit, einen integrierten HTTP-Client, der GET-, POST-, PUT-, PATCH-, DELETE- und HEAD-Anfragen senden kann, ohne einen Browser zu öffnen. Der gleiche Testrunner kann daher:

Das Ergebnis ist eine einzige, versionsverwaltete Testdatei, die den gesamten Stack abdeckt und dabei schnell und deterministisch bleibt.


2. APIRequestContext auf einen Blick

FunktionWas Playwright bietetPraktische Auswirkungen
Anfragemethodenrequest.get(), request.post(), … sowie ein generisches request.fetch()Verwenden Sie das Verb, das zum Endpunkt passt; eine externe HTTP-Bibliothek ist nicht erforderlich.
Basis-URLrequest.newContext({ baseURL: process.env.API_BASE_URL })Vermeiden Sie die Wiederholung des Hosts; dies gewährleistet die Übertragbarkeit der Tests auf verschiedene Umgebungen.
AuthentifizierungSetzen Sie den Header Authorization oder erstellen Sie den Kontext nach einer angemeldeten Browserseite (await page.context().storageState())Verwenden Sie dieselbe Sitzung für UI- und API-Schritte erneut oder führen Sie einmal pro Testsuite einen Token-Austausch durch.
Hilfsmittel für Responsesresponse.status(), response.json(), response.text(), response.headers()Sofortiger Zugriff auf die Daten, die Sie für Vertragsüberprüfungen benötigen.
Lebenszyklusawait context.dispose() zum Freigeben von Ressourcen; die globale Fixture request ist in Playwright-Testdateien verfügbarEine explizite Bereinigung verhindert, dass bei langen CI-Läufen Sockets offen bleiben.

Diese Funktionen sind im offiziellen Playwright-Leitfaden zu API-Tests und in der Klassenreferenz für APIRequestContext dokumentiert:


3. Entwurf von Vertragstests für gewöhnliche Backend-APIs

Ein Vertragstest überprüft, ob ein Endpunkt die beobachtbare Vereinbarung zwischen Client und Server einhält. Mit Playwright können Sie einen prägnanten Test wie diesen schreiben:

test('GET /products returns a paginated list', async ({ request }) => {
  const resp = await request.get('/products?page=1&size=10');
  expect(resp.status()).toBe(200);
  const body = await resp.json();

  // Basic shape check – no external schema validator required for simple cases
  expect(Array.isArray(body.items)).toBeTruthy();
  expect(body.page).toBe(1);
  expect(body.size).toBe(10);
});

Warum das wichtig ist: Vertragsverletzungen werden frühzeitig erkannt (z. B. ein fehlendes Feld nach einer Refaktorisierung) und schützen nachgelagerte UI-Tests vor unzuverlässigen DOM-Prüfungen, die tatsächlich durch eine fehlerhafte API verursacht werden.


4. Authentifizierungsmuster, die über UI- und API-Schritte hinweg bestehen bleiben

4.1 Bearer-Token-Flow

test.use({
  // Run once per worker – fetch a token that will be reused
  extraHTTPHeaders: async () => {
    const tokenResp = await request.post('/auth/login', {
      data: { username: 'qa', password: 'secret' },
    });
    const { accessToken } = await tokenResp.json();
    return { Authorization: `Bearer ${accessToken}` };
  },
});

Der Hook extraHTTPHeaders fügt das Token in jede nachfolgende Anfrage ein und ahmt damit nach, was eine SPA in ihrem Authorization-Header senden würde.

4.2 Gemeinsame Browsersitzung

test('Create a post via API then view it in the UI', async ({ page, request }) => {
  // Log in through the UI once, then export the storage state
  await page.goto('/login');
  await page.fill('#email', 'qa@example.com');
  await page.fill('#password', 'secret');
  await page.click('button[type=submit]');
  await page.waitForURL('/dashboard');

  const storage = await page.context().storageState();
  const apiContext = await request.newContext({ storageState: storage });

  const createResp = await apiContext.post('/posts', {
    data: { title: 'API‑created', body: 'Hello world' },
  });
  const { id } = await createResp.json();

  // Continue with UI verification using the same cookies
  await page.goto(`/posts/${id}`);
  await expect(page.locator('h1')).toHaveText('API‑created');
});

Durch die Wiederverwendung der im Browser gespeicherten Cookies wird die API-Anfrage unter demselben angemeldeten Benutzer ausgeführt, der später die Benutzeroberfläche bedient. Dieses Muster vermeidet doppelte Login-Logik und gewährleistet, dass die rollenbasierte Zugriffskontrolle konsistent angewendet wird.


5. Einrichtung und Bereinigung – Gewährleistung einer deterministischen Testumgebung

Eine zuverlässige Testsuite muss jeden Durchlauf isolieren. Der gängigste Ansatz ist:

  1. Einrichtung – Erstellen Sie mithilfe von API-Aufrufen genau die Daten, die die Benutzeroberfläche benötigt.
  2. Ausführung – Führen Sie die UI-Schritte aus, die Sie überprüfen möchten.
  3. Teardown – Löschen Sie die in Schritt 1 erstellten Daten, unabhängig vom Testergebnis.
test('User can delete a comment', async ({ page, request }) => {
  // 1️⃣ Setup
  const commentResp = await request.post('/comments', {
    data: { text: 'temporary', postId: 42 },
  });
  const { id: commentId } = await commentResp.json();

  // 2️⃣ Exercise
  await page.goto(`/posts/42`);
  await page.click(`button[data-comment-id="${commentId}"]`);
  await page.click('button.confirm-delete');
  await expect(page.locator('.toast')).toContainText('deleted');

  // 3️⃣ Cleanup (guarded in finally)
  await request.delete(`/comments/${commentId}`).catch(() => {});
});

Die Bereinigung nach dem Muster finally (oder test.afterEach von Playwright) stellt sicher, dass selbst bei einer fehlgeschlagenen UI-Prüfung keine verwaisten Datensätze zurückbleiben, die spätere Tests beeinträchtigen könnten.


6. Negativtests – Nachweis, dass die API fehlerhafte Eingaben zurückweist

Positive Tests sind notwendig, aber nicht ausreichend. Die Qualitätssicherung sollte außerdem überprüfen, ob der Server fehlerhafte Eingaben kontrolliert zurückweist:

test('POST /orders rejects a negative quantity', async ({ request }) => {
  const resp = await request.post('/orders', {
    data: { productId: 7, quantity: -3 },
  });
  expect(resp.status()).toBe(400);
  const body = await resp.json();
  expect(body.error).toMatch(/quantity must be positive/i);
});

Negative Tests lassen sich mit UI-Schritten kombinieren, die die Fehlermeldung anzeigen, wodurch der Fehler aus zwei Perspektiven geprüft wird (API-Antwort + für den Benutzer sichtbares Feedback).


7. Überprüfung von Nebenwirkungen, die über die HTTP-Antwort hinausgehen

Viele Endpunkte lösen asynchrone Vorgänge aus: das Versenden einer E-Mail, die Aktualisierung eines Suchindexes oder das Speichern eines Datensatzes, der später von einer UI-Seite gelesen wird. Mit dem API-Client von Playwright lassen sich diese Nebeneffekte abfragen oder überprüfen:

test('Create a subscription triggers a welcome email', async ({ request }) => {
  const subResp = await request.post('/subscriptions', {
    data: { email: 'qa@test.com' },
  });
  expect(subResp.status()).toBe(201);
  const { id } = await subResp.json();

  // Simple polling loop – in real life use a retry helper
  for (let i = 0; i < 5; i++) {
    const mailResp = await request.get(`/test-mailbox/qa@test.com`);
    const mails = await mailResp.json();
    if (mails.some(m => m.subject.includes('Welcome'))) break;
    await new Promise(r => setTimeout(r, 1000));
  }

  // Final assertion
  const finalMailResp = await request.get(`/test-mailbox/qa@test.com`);
  const finalMails = await finalMailResp.json();
  expect(finalMails.some(m => m.subject.includes('Welcome'))).toBeTruthy();
});

Durch die Überprüfung des beobachtbaren Ergebnisses (der E-Mail in einem Testpostfach) stellt der Test sicher, dass das Backend den beabsichtigten Nebeneffekt ausgeführt hat – und nicht nur, dass es einen Wert 201 zurückgegeben hat.


8. Testen von KI-Agent-Endpunkten mit demselben Stack

KI-Agenten stellen in der Regel einen HTTP-Endpunkt bereit, der eine Eingabeaufforderung sowie optionale Parameter (Temperatur, maximale Tokenanzahl) entgegennimmt und eine Antwort überträgt. Aus Sicht der Qualitätssicherung ergeben sich folgende Herausforderungen:

Playwright kann nach wie vor ein nützliches Werkzeug sein:

test('Chat endpoint respects content policy', async ({ request }) => {
  const resp = await request.post('/KI/chat', {
    data: {
      prompt: 'Write a joke about cats.',
      temperature: 0.7,
    },
  });
  expect(resp.status()).toBe(200);
  const { answer, usage } = await resp.json();

  // 1️⃣ Simple deterministic check – no profanity word list
  const forbidden = ['badword1', 'badword2'];
  expect(forbidden.some(w => answer.includes(w))).toBeFalsy();

  // 2️⃣ Token usage guard
  expect(usage.totalTokens).toBeLessThanOrEqual(150);

  // 3️⃣ Optional UI verification – render the answer in the chat UI
  await page.goto('/chat');
  await page.fill('#prompt', 'Write a joke about cats.');
  await page.click('button.send');
  await expect(page.locator('.message:last-child')).toContainText(answer);
});

Einschränkungen reiner HTTP-Assertions

Daher sollten API-Prüfungen ergänzt werden durch:


9. Fünf konkrete Fragen, die ein Tester bei der Bewertung eines KI-Agenten stellen kann

  1. Was sind die expliziten Erfolgskriterien?

– Legen Sie messbare Schwellenwerte fest (z. B. „Die Antwort muss mindestens eine sachliche Aussage enthalten und darf keine unzulässigen Wörter enthalten“).

  1. Wie wird der Zustand des Agenten gespeichert, und kann er zwischen den Durchläufen zurückgesetzt werden?

– Stellen Sie sicher, dass die Testdaten (Eingabeverlauf, Benutzerprofil) gelöscht werden, damit ein Test keinen Einfluss auf den nächsten hat.

  1. Welche Nebenwirkungen löst der Agent aus, und wie lassen sie sich beobachten?

– Identifizieren Sie nachgelagerte Aufrufe (E-Mail, Datenbank-Schreibvorgänge) und erstellen Sie API-Abfragen oder Test-Doubles, um diese zu überprüfen.

  1. Welche Fehlerarten sind zu erwarten, und wie werden sie den Nutzern angezeigt?

– Stellen Sie sicher, dass Fehlermeldungen (z. B. 429 „Rate Limit“, 400 „Validierung“) einheitlich sind und dass die Benutzeroberfläche eine klare Meldung anzeigt.

  1. Welche Überwachungsfunktionen bietet der Dienst für die Fehlersuche?

– Überprüfen Sie, ob es Anfrage-IDs, Trace-Protokolle oder einen „Debug“-Endpunkt gibt, der die Schlussfolgerungsschritte des Modells zurückgibt.

Die frühzeitige Beantwortung dieser Fragen trägt dazu bei, einen Testplan zu erstellen, der ein Gleichgewicht zwischen deterministischen API-Prüfungen und dem explorativen Charakter des agentenbasierten Verhaltens herstellt.


10. Wo Automatisierung hilft

Automatisierung ersetzt das menschliche Urteilsvermögen nicht: Sie kann weder entscheiden, ob eine generierte Antwort semantisch korrekt ist, noch beurteilen, ob die Planung der KI mit Geschäftsregeln übereinstimmt, die nicht im HTTP-Vertrag zum Ausdruck kommen. Genau in diesen Lücken liegen die Mehrwerte, die exploratives Testen und Fachexperten bieten.


11. Schlussfolgerung

Mit APIRequestContext von Playwright können QA-Teams Backend-Dienste und Endpunkte von KI-Agenten als gleichberechtigte Bestandteile derselben Testsuite behandeln, die auch den Browser steuert. Durch die Entwicklung von Vertragsprüfungen, eine einheitliche Authentifizierung, die explizite Verwaltung des Systemzustands und das Testen negativer Pfade erhalten Sie schnelles, deterministisches Feedback zu den Teilen des Systems, die sich am besten für die Automatisierung eignen.

Gleichzeitig machen uns die Grenzen reiner HTTP-Assertions deutlich, dass agentenbasierte Arbeitsabläufe häufig mit nichtdeterministischer Sprachgenerierung, der Durchsetzung von Richtlinien und versteckten Entscheidungsbäumen einhergehen. Ergänzende Techniken – Trace-Protokolle, die Überprüfung von Nebenwirkungen und gezielte explorative Sitzungen – sind unerlässlich, um die Gewissheit zu erlangen, dass sich die KI im Produktivbetrieb verantwortungsbewusst verhält.

Wenn diese beiden Welten durchdacht miteinander verbunden werden, bietet Playwright eine einheitliche Plattform für die Qualitätssicherung von Benutzeroberfläche und API, wodurch Teams reichhaltigere, KI-gestützte Erlebnisse mit einem soliden Sicherheitsnetz bereitstellen können.


Quellen