Zum Inhalt springen

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

Teil 11: Einmal einloggen, überall testen

Lass ein Setup-Projekt ein einziges Mal einloggen, speichere das Cookie als Storage State und starte jeden Test damit, der ein Mitglied braucht. Die roten Tests werden ohne Änderung grün, und der Login bekommt eigene Tests in allen vier Bereichen.

Quest-Ziele

  • Verstehen, was Storage State ist und warum ein gespeicherter Login für jeden Worker gilt
  • Ein Mitglied in die Template-Datenbank legen und es beim Zurücksetzen vor jedem Test behalten
  • In einem Setup-Projekt einmal einloggen und andere Projekte mit dem gespeicherten Zustand starten
  • Einen Block von Tests mit test.use als Besucher laufen lassen
  • Den gemockten Login der Frontend-Tests mit einer Option-Fixture umschalten
  • Den Login dort testen, wo die jeweilige Frage hingehört: Datenbank, API, Seite und ein ganzer Ablauf

Die halbe Suite ist rot, und aus einem ehrlichen Grund: Die Tests verhalten sich wie Besucher, und Besucher dürfen das Board nicht mehr ändern. Also müssen sich die Tests einloggen.

Der naheliegende Weg ist, am Anfang jedes Tests das Login-Formular auszufüllen. Das funktioniert, kostet aber in jedem Test Zeit, und es testet das Login-Formular wieder und wieder, wo einmal reicht. Playwright kennt einen besseren Weg: einmal einloggen, speichern, was der Browser danach weiß, und jeden anderen Test damit starten.

Ein Schlüssel, einmal gefeilt und für jeden Worker kopiert: Ein einziger Login reicht für den ganzen Lauf.
Ein Schlüssel, einmal gefeilt und für jeden Worker kopiert: Ein einziger Login reicht für den ganzen Lauf.

Was ein Browser nach einem Login weiß, ist bei dieser App ein Cookie. Playwright nennt die Cookies eines Browsers, zusammen mit dem, was Seiten in seinem Local Storage abgelegt haben, den Storage State. Es kann diesen Zustand in eine Datei schreiben, und es kann einen Test mit dem Zustand aus einer Datei starten, als wäre der Login eben erst in genau diesem Browser passiert.

Der Plan ist also: Ein Setup-Projekt, wie das, das die Template-Datenbank baut, loggt sich einmal über das echte Formular ein und speichert die Datei. Die Projekte, die ein Mitglied brauchen, starten damit.

Warum ein Login für jeden Worker reicht

Eine Sache an diesem Plan verdient einen zweiten Blick. Seit Teil 6 betreibt jeder Worker seinen eigenen Server, auf seiner eigenen Datenbank und seinem eigenen Port. Der Login passiert auf einem davon. Warum sollten alle anderen sein Cookie annehmen? Vier Dinge kommen zusammen:

  1. Das Mitglied gibt es in jeder Datenbank. Du legst robin in das Template, und die Datenbank jedes Workers ist eine Kopie davon. Robin hat sogar in allen dieselbe ID.

  2. Alle Server signieren mit demselben Geheimnis. Die Fixture, die die App startet, gibt jeder Kopie dasselbe Geheimnis, also gilt die Signatur eines Servers auf allen.

  3. Das Cookie enthält nur die ID des Mitglieds und die Signatur. Auf dem Server ist nichts gespeichert, das den anderen Servern fehlen würde.

  4. Cookies gehören zu einem Host, nicht zu einem Port. Ein Cookie, das localhost auf einem Port gesetzt hat, wird auch an localhost auf jedem anderen Port geschickt.

Die ersten beiden richtest du in diesem Teil ein. Das dritte ist die Art, wie die App im letzten Teil gebaut wurde, und das vierte ist die Art, wie Browser arbeiten.

Ein Mitglied in jeder Datenbank

Fang mit dem an, was mehrere Dateien wissen müssen: wer das Mitglied ist und wo der gespeicherte Zustand liegt. Eine neue Datei, tests/support/users.ts:

tests/support/users.ts
/** The member that every test database comes with. */
export const MEMBER = { name: 'robin', password: 'quest-master' };

/** Where the login setup saves the cookies of the logged-in member. */
export const MEMBER_STATE = 'playwright/.auth/member.json';

/** The opposite: a browser without any cookies. */
export const VISITOR_STATE = { cookies: [], origins: [] };

VISITOR_STATE ist ebenfalls ein Storage State, von Hand ausgeschrieben: keine Cookies und sonst auch nichts. Er ist für die Tests da, die als Besucher starten sollen.

Die Datei hinter MEMBER_STATE wird einen Login enthalten. Trag ihren Ordner in die .gitignore ein:

.gitignore
node_modules
.env
web/dist
test-results
playwright-report
playwright/.auth

Jetzt das Template. Leg in tests/setup/database.setup.ts nach den Migrationen das Mitglied an, mit der Funktion der App selbst:

tests/setup/database.setup.ts
import { test as setup } from '@playwright/test';
import { migrate } from 'drizzle-orm/node-postgres/migrator';
import { connect } from '../../server/db/client.ts';
import { createUser } from '../../server/users.ts';
import { TEMPLATE, databaseUrl, onServer } from '../support/databases.ts';
import { MEMBER } from '../support/users.ts';

setup('build the template database', async () => {
  await onServer(
    `drop database if exists ${TEMPLATE} with (force)`,
    `create database ${TEMPLATE}`,
  );

  // The same migrations the app runs, from the first to the last.
  const { db, pool } = connect(databaseUrl(TEMPLATE));
  await migrate(db, { migrationsFolder: './drizzle' });

  // What every test may count on: one member who can log in.
  await createUser(db, MEMBER.name, MEMBER.password);
  await pool.end();
});

Neu sind zwei Importe und die zwei Zeilen vor pool.end(). Weil createUser aus server/users.ts die Arbeit macht, ist das Mitglied der Tests genau so gespeichert, wie die App ein Mitglied speichert, mit Salt und Hash.

Als Nächstes die Fixtures in tests/fixtures.ts. Oben kommt der Import von MEMBER dazu, und zwei Stellen ändern sich:

tests/fixtures.ts
import { once } from 'node:events';
import type { AddressInfo } from 'node:net';
import { serve } from '@hono/node-server';
import { test as base } from '@playwright/test';
import { sql } from 'drizzle-orm';
import { createApp } from '../server/app.ts';
import { connect, type Db } from '../server/db/client.ts';
import { QuestBoard } from './support/board.ts';
import { TEMPLATE, databaseUrl, onServer } from './support/databases.ts';
import { MEMBER } from './support/users.ts';

type TestFixtures = {
  /** This worker's database, with empty tables. */
  db: Db;
  board: QuestBoard;
};

type WorkerFixtures = {
  workerDb: Db;
  /** The address of this worker's own API. */
  server: string;
};

export const test = base.extend<TestFixtures, WorkerFixtures>({
  // Once per worker: a database of its own, copied from the template.
  workerDb: [
    async ({}, use, workerInfo) => {
      const name = `questboard_test_${workerInfo.parallelIndex}`;
      await onServer(
        `drop database if exists ${name} with (force)`,
        `create database ${name} template ${TEMPLATE}`,
      );
      const { db, pool } = connect(databaseUrl(name));

      await use(db);

      await pool.end();
      await onServer(`drop database ${name}`);
    },
    { scope: 'worker' },
  ],

  // Once per worker: the app on a free port, working on this worker's database.
  server: [
    async ({ workerDb }, use) => {
      const app = createApp(workerDb, 'a secret only the tests know');
      const server = serve({ fetch: app.fetch, port: 0 });
      await once(server, 'listening');
      const { port } = server.address() as AddressInfo;

      await use(`http://localhost:${port}`);

      server.close();
    },
    { scope: 'worker' },
  ],

  // Requests and pages of a test go to its worker's server.
  baseURL: async ({ server }, use) => {
    await use(server);
  },

  // Before every test: back to what the template holds, so no test sees what another one
  // left behind. `auto` runs this for tests that never mention `db` as well.
  db: [
    async ({ workerDb }, use) => {
      await workerDb.execute(sql`truncate quests restart identity`);
      await workerDb.execute(sql`delete from users where name <> ${MEMBER.name}`);
      await use(workerDb);
    },
    { auto: true },
  ],

  board: async ({ page }, use) => {
    await use(new QuestBoard(page));
  },
});

export { expect } from '@playwright/test';

Der Server bekommt sein Geheimnis. In der Fixture server bekommt createApp jetzt sein zweites Argument, eine feste Zeichenkette. Sie ist in jedem Worker dieselbe, das ist Punkt 2 der Liste oben, und sie hat nichts mit dem SESSION_SECRET in deiner .env zu tun. Auch TypeScript ist damit wieder zufrieden.

Das Zurücksetzen behält das Mitglied. Bisher hieß „vor jedem Test“: die Tabelle leeren. Mit einem Mitglied im Template heißt es: zurück zu dem, was das Template enthält. Die Quests werden geleert wie zuvor. Die neue Zeile löscht aus users alle außer robin. Ein Test darf eigene Mitglieder anlegen, und der nächste Test darf sie nicht vorfinden, aber robin muss bleiben.

Der Login als Setup-Projekt

Der Login geht durch das echte Formular, also muss das Page Object aus Teil 7 dieses Formular kennen. In tests/support/board.ts:

tests/support/board.ts
import type { Locator, Page } from '@playwright/test';

/** The quest board as a visitor sees it: where things are on the page, and how to use them. */
export class QuestBoard {
  readonly page: Page;
  readonly title: Locator;
  readonly reward: Locator;
  readonly addButton: Locator;
  readonly quests: Locator;
  readonly problem: Locator;
  readonly member: Locator;
  readonly loginButton: Locator;

  constructor(page: Page) {
    this.page = page;
    this.title = page.getByLabel('New quest');
    this.reward = page.getByPlaceholder('Reward');
    this.addButton = page.getByRole('button', { name: 'Add quest' });
    this.quests = page.getByRole('list', { name: 'Quests' }).getByRole('listitem');
    this.problem = page.getByRole('alert');
    this.member = page.getByText('Logged in as');
    this.loginButton = page.getByRole('button', { name: 'Log in' });
  }

  async open() {
    await this.page.goto('/');
  }

  async logIn(name: string, password: string) {
    await this.page.getByLabel('Name').fill(name);
    await this.page.getByLabel('Password').fill(password);
    await this.loginButton.click();
  }

  async add(title: string, reward?: number) {
    await this.title.fill(title);
    if (reward !== undefined) await this.reward.fill(String(reward));
    await this.addButton.click();
  }

  /** The checkbox that marks a quest as done. */
  checkbox(title: string) {
    return this.page.getByRole('checkbox', { name: title });
  }

  deleteButton(title: string) {
    return this.page.getByRole('button', { name: `Delete ${title}` });
  }
}

Neu sind zwei Locators und eine Methode. member findet die Zeile „Logged in as …“, loginButton den Button des Login-Formulars, und logIn füllt Name und Passwort aus und klickt darauf.

Jetzt das Setup selbst, eine neue Datei neben der für die Datenbank, tests/setup/login.setup.ts:

tests/setup/login.setup.ts
import { expect, test as setup } from '../fixtures.ts';
import { MEMBER, MEMBER_STATE } from '../support/users.ts';

setup('log in as a member and save the session', async ({ board, page }) => {
  await board.open();
  await board.logIn(MEMBER.name, MEMBER.password);
  await expect(board.member).toHaveText(/Logged in as robin/);

  // The cookies of this browser, written to a file for the other projects to start with.
  await page.context().storageState({ path: MEMBER_STATE });
});

Es importiert test aus tests/fixtures.ts und nicht von Playwright. Damit bekommt es, was ein End-to-End-Test bekommt: eine Datenbank, die vom Template kopiert ist, einen eigenen Server auf dieser Datenbank und das board. Es öffnet die Seite, loggt sich als robin ein und wartet, bis die Seite das auch sagt. Diese Prüfung ist keine Zierde. Der Klick kehrt zurück, bevor der Server geantwortet hat, und das Cookie gibt es erst nach der Antwort.

Die letzte Zeile speichert den Zustand. Die Seite jedes Tests lebt in einem Browser-Kontext: Playwrights Wort für eine Browser-Sitzung, die mit keiner anderen etwas teilt, mit eigenen Cookies und eigenem Speicher. page.context() ist der Kontext, zu dem diese Seite gehört, und storageState({ path }) schreibt seine Cookies in die Datei.

Bleibt noch, Playwright zu sagen, wann das läuft und wer mit dem Ergebnis startet. playwright.config.ts:

playwright.config.ts
import { existsSync } from 'node:fs';
import { defineConfig, devices } from '@playwright/test';
import { MEMBER_STATE } from './tests/support/users.ts';

// The tests read the same settings as the app. Where there is no .env, such as in a
// pipeline, the variables are set from outside.
if (existsSync('.env')) process.loadEnvFile();

// The built frontend, served by `vite preview`.
const preview = 'http://localhost:4173';

export default defineConfig({
  fullyParallel: true,
  reporter: [['list'], ['html']],
  use: {
    // Record every test, and keep the recording of those that fail.
    trace: 'retain-on-failure',
    screenshot: 'only-on-failure',
  },
  projects: [
    {
      name: 'setup',
      testDir: './tests/setup',
      testMatch: 'database.setup.ts',
    },
    {
      name: 'login',
      testDir: './tests/setup',
      testMatch: 'login.setup.ts',
      dependencies: ['setup'],
      use: { ...devices['Desktop Chrome'] },
    },
    {
      name: 'database',
      testDir: './tests/database',
      dependencies: ['setup'],
    },
    {
      name: 'backend',
      testDir: './tests/backend',
      dependencies: ['login'],
      use: { storageState: MEMBER_STATE },
    },
    {
      name: 'frontend',
      testDir: './tests/frontend',
      use: { ...devices['Desktop Chrome'], baseURL: preview },
    },
    {
      name: 'e2e',
      testDir: './tests/e2e',
      dependencies: ['login'],
      use: { ...devices['Desktop Chrome'], storageState: MEMBER_STATE },
    },
  ],
  // Before the tests, Playwright builds the frontend and serves the result. The frontend
  // tests open it there; the servers of the workers hand out the same files from web/dist.
  webServer: {
    command: 'npm run build && npm run preview',
    url: preview,
    reuseExistingServer: false,
  },
});
  • setup hat bisher jede Datei genommen, die auf .setup.ts endet. Davon gibt es jetzt zwei, also nennt es seine eigene: database.setup.ts.

  • login ist ein neues Projekt für login.setup.ts. Es hängt von setup ab, weil es das Template braucht, und es bekommt einen Browser, weil es ein Formular ausfüllt.

  • backend und e2e hängen jetzt von login ab. Abhängigkeiten bilden eine Kette: Wer login verlangt, bekommt davor setup. Beide Projekte starten mit storageState: MEMBER_STATE, dem Pfad aus tests/support/users.ts, der oben in der Konfiguration importiert wird. Für e2e heißt das: Der Browser jedes Tests startet mit robins Cookie. Die Fixture request der Backend-Tests liest dieselbe Option und schickt das Cookie bei ihren Anfragen mit, ganz ohne Browser.

  • database bleibt, wie es ist. Seine Tests rufen Funktionen auf, und eine Funktion fragt nicht, wer eingeloggt ist.

  • frontend hängt wie bisher von nichts ab. Seine API denken sich die Tests aus, also wird das auch für seinen Login gelten.

Der Frontend-Bereich antwortet sich selbst

Auch im Frontend-Bereich fragt die Seite /api/me, und bisher bricht die Auffang-Route diese Anfrage ab. Die Antwort gehört in die Fixture page, wo sie für jeden Test gilt. Ersetze in tests/frontend/fixtures.ts den Block, der mit export const test beginnt, durch diesen. Die Zeile, die expect exportiert, bleibt darunter stehen:

tests/frontend/fixtures.ts
type Fixtures = {
  board: QuestBoard;
  /** Whether the mocked API knows the visitor as a member. `test.use({ loggedIn: false })` turns it off. */
  loggedIn: boolean;
};

export const test = base.extend<Fixtures>({
  loggedIn: [true, { option: true }],

  page: async ({ page, loggedIn }, use) => {
    // A request to the API that a test has not mocked goes nowhere, and never to a real server.
    await page.route('**/api/**', (route) => route.abort());
    // Who is logged in is something every page asks, so it is answered for all tests.
    await mockApi(
      page,
      'GET',
      '/me',
      loggedIn ? { json: { name: 'robin' } } : { status: 401, json: { error: 'Not logged in.' } },
    );
    await use(page);
  },

  board: async ({ page }, use) => {
    await use(new QuestBoard(page));
  },
});

loggedIn ist eine Option-Fixture: eine Fixture, die ein schlichter Wert mit einem Standard ist, hier true, gekennzeichnet mit { option: true }. Eine Testdatei oder ein describe-Block kann mit test.use({ loggedIn: false }) einen anderen Wert wählen.

Die Fixture page verlangt diesen Wert und mockt GET /api/me passend dazu: robins Name oder das 401, das die echte API einem Besucher gibt. Der Mock wird nach der Auffang-Route eingerichtet, er ist also die neuere Route und gewinnt für diese eine Anfrage. Ein Test, der /me selbst mockt, ist noch neuer und gewinnt gegen diesen.

Der Standard ist das Mitglied, weil die bisherigen Tests genau das brauchen. Lass die Suite jetzt laufen, wenn du magst: Jeder Test, der im letzten Teil rot war, besteht wieder, und du hast keinen einzigen davon angefasst. Der gespeicherte Zustand und die gemockte Antwort stellen sie wieder dorthin, wo sie waren: vor ein Board, das sie ändern dürfen.

Neue Tests für den Login

Die alten Tests sind grün, aber den Login selbst testet noch nichts. Er bekommt in jedem Bereich eine neue Datei, und jede Datei stellt die Fragen, für die ihr Bereich da ist.

Zuerst die Datenbank, in tests/database/users.spec.ts:

tests/database/users.spec.ts
import { users } from '../../server/db/schema.ts';
import { createUser, findUserByLogin } from '../../server/users.ts';
import { expect, test } from '../fixtures.ts';
import { MEMBER } from '../support/users.ts';

test('every test database comes with the member', async ({ db }) => {
  expect(await findUserByLogin(db, MEMBER.name, MEMBER.password)).toMatchObject({ id: 1, name: 'robin' });
  expect(await db.select().from(users)).toHaveLength(1);
});

test('stores a hash and never the password', async ({ db }) => {
  const kim = await createUser(db, 'kim', 'open-sesame');

  expect(kim.passwordHash).not.toContain('open-sesame');
  expect(await findUserByLogin(db, 'kim', 'open-sesame')).toEqual(kim);
});

test('gives two members with the same password different hashes', async ({ db }) => {
  const kim = await createUser(db, 'kim', 'open-sesame');
  const alex = await createUser(db, 'alex', 'open-sesame');

  expect(kim.passwordHash).not.toBe(alex.passwordHash);
});

test('finds nobody for a wrong password or an unknown name', async ({ db }) => {
  expect(await findUserByLogin(db, MEMBER.name, 'quest-mister')).toBeUndefined();
  expect(await findUserByLogin(db, 'nobody', MEMBER.password)).toBeUndefined();
});

test('rejects a name that is taken', async ({ db }) => {
  await expect(createUser(db, MEMBER.name, 'another-password')).rejects.toMatchObject({
    cause: { constraint: 'users_name_unique' },
  });
});

Der erste Test prüft, was das Setup verspricht: Jede Testdatenbank hat robin, mit der ID 1, und sonst niemanden, egal was der Test davor getan hat. Die nächsten zwei handeln davon, was gespeichert wird: Der Hash enthält das Passwort nicht, und zwei Mitglieder mit demselben Passwort bekommen verschiedene Hashes, dafür sorgt das Salt. Der letzte Test nutzt das Muster aus Teil 5: Der Unique Constraint der Datenbank, in cause beim Namen genannt, weist einen zweiten robin ab.

Eine Schicht höher, tests/backend/login.spec.ts:

tests/backend/login.spec.ts
import { quests } from '../../server/db/schema.ts';
import { expect, test } from '../fixtures.ts';
import { seedQuests } from '../support/seed.ts';
import { MEMBER, VISITOR_STATE } from '../support/users.ts';

test.describe('a member', () => {
  test('is known to the API', async ({ request }) => {
    const response = await request.get('/api/me');

    expect(response.status()).toBe(200);
    expect(await response.json()).toEqual({ name: 'robin' });
  });

  test('is forgotten after logging out', async ({ request }) => {
    const response = await request.post('/api/logout');

    expect(response.status()).toBe(204);
    expect((await request.get('/api/me')).status()).toBe(401);
  });
});

test.describe('a visitor', () => {
  // These tests start without the saved cookies.
  test.use({ storageState: VISITOR_STATE });

  test('is not known to the API', async ({ request }) => {
    const response = await request.get('/api/me');

    expect(response.status()).toBe(401);
    expect(await response.json()).toEqual({ error: 'Not logged in.' });
  });

  test('may read the board', async ({ request, db }) => {
    await seedQuests(db, { title: 'Find the lost sword' });

    const response = await request.get('/api/quests');

    expect(response.status()).toBe(200);
    expect(await response.json()).toHaveLength(1);
  });

  test('may not change the board', async ({ request, db }) => {
    const [sword] = await seedQuests(db, { title: 'Find the lost sword' });

    const answers = [
      await request.post('/api/quests', { data: { title: 'Map the cave' } }),
      await request.patch(`/api/quests/${sword.id}`, { data: { done: true } }),
      await request.delete(`/api/quests/${sword.id}`),
    ];

    expect(answers.map((response) => response.status())).toEqual([401, 401, 401]);
    expect(await answers[0].json()).toEqual({ error: 'Log in to change the board.' });
    expect(await db.select().from(quests)).toEqual([sword]);
  });

  test('becomes a member with the right password', async ({ request }) => {
    const response = await request.post('/api/login', { data: MEMBER });

    expect(response.status()).toBe(200);
    expect(await response.json()).toEqual({ name: 'robin' });
    // The cookie cannot be read by scripts on the page, and other sites cannot send it along.
    const { cookies } = await request.storageState();
    expect(cookies).toMatchObject([{ name: 'session', httpOnly: true, sameSite: 'Lax' }]);
    expect((await request.get('/api/me')).status()).toBe(200);
  });

  test('stays a visitor with a wrong password', async ({ request }) => {
    const response = await request.post('/api/login', {
      data: { name: MEMBER.name, password: 'quest-mister' },
    });

    expect(response.status()).toBe(401);
    expect(await response.json()).toEqual({ error: 'Wrong name or password.' });
    expect((await request.storageState()).cookies).toEqual([]);
  });

  test('cannot make up a cookie', async ({ request }) => {
    // The id of the member, but without the signature only the server can make.
    const response = await request.get('/api/me', { headers: { Cookie: 'session=1' } });

    expect(response.status()).toBe(401);
  });
});

Mitglied und Besucher. Der erste describe-Block läuft so, wie das Projekt konfiguriert ist, mit robins Cookie. Der zweite beginnt mit test.use({ storageState: VISITOR_STATE }). In diesem Block ist die Option aus der Konfiguration ersetzt, und seine Tests starten ohne Cookie. test.use gilt für eine ganze Datei oder für einen describe-Block, nicht für einen einzelnen Test.

Was ein Besucher darf. Das Board lesen: ja. Es ändern: nein. Der Test schickt alle drei ändernden Anfragen, erwartet dreimal 401 und sieht dann in die Datenbank, wo die eine Quest genau so liegt, wie sie hineingelegt wurde. Wie in Teil 6 ist die Antwort das eine und die gespeicherte Zeile das andere.

Einloggen. request behält Cookies von einer Anfrage zur nächsten, wie ein Browser. Nach POST /api/login zeigt request.storageState(), was es hält: ein Cookie namens session, das httpOnly und sameSite: 'Lax' ist. Das GET /api/me danach antwortet mit 200. Ein falsches Passwort lässt es ohne Cookie zurück. Der letzte Test versucht eine Abkürzung und schickt session=1, die ID von robin ohne Signatur. Die Antwort ist 401: Dafür ist die Signatur da.

Das Ausloggen steht im ersten Block. Nach POST /api/logout ist dasselbe request ein Besucher. Kein anderer Test wird davon gestört, obwohl alle dasselbe gespeicherte Cookie verwenden. Jeder Test bekommt seine eigene Kopie des Zustands aus der Datei, und das Ausloggen lässt nur diese Kopie das Cookie vergessen. Die Datei bleibt, wie sie ist.

Der Frontend-Bereich, tests/frontend/login.spec.ts:

tests/frontend/login.spec.ts
import { DRAGON, SWORD, expect, mockApi, test } from './fixtures.ts';

test.describe('a visitor', () => {
  test.use({ loggedIn: false });

  test('can read the board but finds nothing to change it with', async ({ page, board }) => {
    await mockApi(page, 'GET', '/quests', { json: [SWORD, DRAGON] });

    await board.open();

    await expect(board.quests).toHaveCount(2);
    await expect(board.loginButton).toBeVisible();
    await expect(board.addButton).toBeHidden();
    await expect(board.checkbox('Find the lost sword')).toBeDisabled();
    await expect(board.deleteButton('Find the lost sword')).toBeHidden();
  });

  test('logs in and gets the form for new quests', async ({ page, board }) => {
    await mockApi(page, 'GET', '/quests', { json: [SWORD] });
    await mockApi(page, 'POST', '/login', { json: { name: 'robin' } });
    await board.open();

    const request = page.waitForRequest((request) => request.method() === 'POST');
    await board.logIn('robin', 'quest-master');

    expect((await request).postDataJSON()).toEqual({ name: 'robin', password: 'quest-master' });
    await expect(board.member).toBeVisible();
    await expect(board.addButton).toBeVisible();
    await expect(board.checkbox('Find the lost sword')).toBeEnabled();
    await expect(board.loginButton).toBeHidden();
  });

  test('is told when name or password are wrong', async ({ page, board }) => {
    await mockApi(page, 'GET', '/quests', { json: [] });
    await mockApi(page, 'POST', '/login', { status: 401, json: { error: 'Wrong name or password.' } });
    await board.open();

    await board.logIn('robin', 'quest-mister');

    await expect(board.problem).toHaveText('Wrong name or password.');
    await expect(board.loginButton).toBeVisible();
  });
});

test('a member can log out', async ({ page, board }) => {
  await mockApi(page, 'GET', '/quests', { json: [SWORD] });
  await mockApi(page, 'POST', '/logout', { status: 204 });
  await board.open();

  await page.getByRole('button', { name: 'Log out' }).click();

  await expect(board.loginButton).toBeVisible();
  await expect(board.member).toBeHidden();
  await expect(board.addButton).toBeHidden();
});

Der Block für den Besucher schaltet die Option mit test.use({ loggedIn: false }) aus. Sein erster Test zeigt „darf nicht ändern“ aus der Sicht der Seite: Die Liste ist da, aber das Formular für neue Quests und der Löschen-Button sind verborgen, und die Checkbox ist gesperrt. toBeHidden() besteht auch, wenn es ein Element gar nicht gibt, und das ist hier der Fall.

Der zweite Test mockt POST /login, prüft mit waitForRequest, was die Seite geschickt hat, wie in Teil 7, und dann, dass die Seite zur Ansicht für Mitglieder wechselt. Der dritte lässt die gemockte API Nein sagen. Der letzte Test steht außerhalb des Blocks, startet also als Mitglied, und loggt sich aus.

Und ein Ablauf durch alles, tests/e2e/login.spec.ts:

tests/e2e/login.spec.ts
import { quests } from '../../server/db/schema.ts';
import { expect, test } from '../fixtures.ts';
import { seedQuests } from '../support/seed.ts';
import { MEMBER, VISITOR_STATE } from '../support/users.ts';

test.describe('a visitor', () => {
  test.use({ storageState: VISITOR_STATE });

  test('logs in, adds a quest and logs out again', async ({ board, db, page }) => {
    await seedQuests(db, { title: 'Find the lost sword' });
    await board.open();
    await expect(board.addButton).toBeHidden();

    await board.logIn(MEMBER.name, MEMBER.password);
    await board.add('Map the cave', 25);

    await expect(board.quests).toHaveText([/Find the lost sword/, /Map the cave.*25 gold/]);
    expect(await db.select().from(quests)).toHaveLength(2);

    await page.getByRole('button', { name: 'Log out' }).click();

    await expect(board.loginButton).toBeVisible();
    await expect(board.checkbox('Map the cave')).toBeDisabled();
  });

  test('stays outside with a wrong password', async ({ board }) => {
    await board.open();

    await board.logIn(MEMBER.name, 'quest-mister');

    await expect(board.problem).toHaveText('Wrong name or password.');
    await expect(board.member).toBeHidden();
  });
});

test('a member is still logged in after a reload', async ({ board, page }) => {
  await board.open();
  await expect(board.member).toHaveText(/Logged in as robin/);

  await page.reload();

  await expect(board.member).toHaveText(/Logged in as robin/);
  await expect(board.addButton).toBeVisible();
});

Der erste Test startet als Besucher und findet kein Formular für neue Quests. Er loggt sich über das echte Formular ein, mit der echten Prüfung des Passworts dahinter, fügt eine Quest hinzu, die die Seite zeigt und die Datenbank enthält, und loggt sich aus, wonach die Checkbox wieder gesperrt ist. Vom Setup abgesehen sind die Tests dieser Datei die einzige Stelle der Suite, an der ein Login durch das Formular und die echte API geht.

Der letzte Test steht außerhalb des Blocks und startet mit dem gespeicherten Zustand. Er loggt sich nie ein, und die Seite begrüßt ihn mit Namen, vor und nach einem Neuladen. Das ist Storage State aus der Sicht des Browsers.

Lass alles laufen:

questboard
$ npx playwright test --reporter=dotRunning 73 tests using 8 workers······································[✓] Pulling schema from database...···································  73 passed (8.0s)

73 bestanden in 8 Sekunden: die 52 von vorher, das Login-Setup und 20 neue Tests. Vergleich das mit dem letzten Teil, in dem dieselben acht Worker mehr als eine Minute gebraucht haben, um dir zu sagen, was nicht stimmt.

Die Reihenfolge zeigt sich am besten, wenn du einen Bereich mit dem List-Reporter laufen lässt:

questboard
$ npm run test:e2e> questboard@1.0.0 test:e2e> playwright test --project=e2eRunning 10 tests using 8 workers  ✓   1 [setup] › tests/setup/database.setup.ts:8:1 › build the template database (156ms)  ✓   2 [login] › tests/setup/login.setup.ts:4:1 › log in as a member and save the session (281ms)  ✓   9 [e2e] › tests/e2e/quest-board.spec.ts:16:1 › the board shows what is in the database (402ms)  ✓   6 [e2e] › tests/e2e/login.spec.ts:36:1 › a member is still logged in after a reload (461ms)  ✓   4 [e2e] › tests/e2e/login.spec.ts:26:3 › a visitor › stays outside with a wrong password (566ms)  ✓   5 [e2e] › tests/e2e/quest-board.spec.ts:30:1 › a finished quest is still finished after a reload (549ms)  ✓   7 [e2e] › tests/e2e/quest-board.spec.ts:43:1 › a deleted quest is gone for good (561ms)  ✓  10 [e2e] › tests/e2e/quest-board.spec.ts:55:1 › a title that is taken is turned down, all the way from the database (503ms)  ✓   8 [e2e] › tests/e2e/quest-board.spec.ts:5:1 › a new quest travels from the form into the database (527ms)  ✓   3 [e2e] › tests/e2e/login.spec.ts:9:3 › a visitor › logs in, adds a quest and logs out again (805ms)  10 passed (5.0s)

Sieh dir die ersten zwei Zeilen an. setup baut das Template, login loggt sich ein und speichert die Session, und erst dann starten die acht End-to-End-Tests, verteilt auf die Worker. Verlangt hast du nur das Projekt e2e. Playwright hat zuerst ausgeführt, wovon es abhängt, und der Login hat etwa eine Drittelsekunde gekostet, ein einziges Mal.

Was du jetzt hast

Ein Login pro Lauf, gespeichert als Storage State. Jeder Backend- und End-to-End-Test startet als Mitglied, ein test.use macht aus einem Block von ihnen Besucher, und die Frontend-Tests wählen mit einer Option, wer sie sind. Die Suite ist mit 73 Tests wieder grün, und der Login ist dort getestet, wo die jeweilige Frage hingehört: die Hashes in der Datenbank, die 401er und das Cookie in der API, die zwei Ansichten in der Seite und ein ganzer Ablauf durch das Formular.

Die nächsten zwei Teile ergänzen Prüfungen, die auf dem Frontend-Bereich aufsetzen. Im nächsten Teil ist es die Barrierefreiheit: Eine Regel-Engine namens axe sieht sich die Seite in mehreren ihrer Zustände an, und du wirst sehen, was sie findet und was sie nicht finden kann. Danach geht es darum, wie die Seite aussieht.

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.