Zum Inhalt springen

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

Teil 10: Ein Login für das Quest Board

Die App wächst: Lesen darf das Quest Board weiterhin jeder, ändern nur noch, wer als Mitglied eingeloggt ist. Bau den Login durch alle drei Schichten, lass die Suite laufen und lies, warum die Hälfte davon rot wird.

Quest-Ziele

  • Mitglieder mit einem gesalzenen Hash statt mit ihrem Passwort speichern
  • Ein Mitglied an einem signierten Cookie erkennen, ohne eine Session auf dem Server zu speichern
  • Die Routen, die das Board ändern, mit einer Middleware schützen
  • Der Seite ein Login-Formular und eine Ansicht für Besucher geben
  • Einen roten Lauf Bereich für Bereich lesen und eine kaputte App von veralteten Tests unterscheiden

Die Suite deckt die App ab, wie sie ist: 52 Tests, vier Bereiche, und im letzten Teil hast du gesehen, wie ein roter Test dich zu seiner Ursache führt. Jetzt ändert sich die App. Das Quest Board bekommt einen Login: Lesen darf es weiterhin jeder, aber nur Mitglieder der Gilde dürfen Quests hinzufügen, abhaken oder löschen.

Dieser Teil ändert die App und sonst nichts. Er endet damit, dass die Hälfte der Tests rot ist, und das ist Absicht. Der nächste Teil ändert die Tests.

Ein Tor vor dem Board: Lesen bleibt für alle offen, zum Ändern braucht es einen Schlüssel.
Ein Tor vor dem Board: Lesen bleibt für alle offen, zum Ändern braucht es einen Schlüssel.

Die Änderung geht durch alle drei Schichten, in der Reihenfolge, in der Teil 1 sie gebaut hat: eine Tabelle für die Mitglieder, eine API, die weiß, wer fragt, und eine Seite mit einem Login-Formular.

Mitglieder in der Datenbank

Ein Mitglied ist ein Name und ein Passwort. Häng die Tabelle an server/db/schema.ts an:

server/db/schema.ts
/** The members of the guild: only they may change the board. */
export const users = pgTable('users', {
  id: integer().primaryKey().generatedAlwaysAsIdentity(),
  name: text().notNull().unique(),
  passwordHash: text('password_hash').notNull(),
});

export type User = typeof users.$inferSelect;

Der Name ist eindeutig, wie der Titel einer Quest. Die Spalte daneben heißt aus gutem Grund password_hash und nicht password: Das Passwort selbst wird nie gespeichert. Der Code, der dafür sorgt, kommt in eine neue Datei, server/users.ts:

server/users.ts
import { randomBytes, scrypt, timingSafeEqual } from 'node:crypto';
import { promisify } from 'node:util';
import { eq } from 'drizzle-orm';
import type { Db } from './db/client.ts';
import { users } from './db/schema.ts';

const derive = promisify(scrypt) as (password: string, salt: string, length: number) => Promise<Buffer>;

/** Stores a new member. The password itself is never stored, only a salted hash of it. */
export async function createUser(db: Db, name: string, password: string) {
  const salt = randomBytes(16).toString('hex');
  const hash = (await derive(password, salt, 32)).toString('hex');
  const [user] = await db.insert(users).values({ name, passwordHash: `${salt}:${hash}` }).returning();
  return user;
}

/** The member with this name, if the password is the right one. */
export async function findUserByLogin(db: Db, name: string, password: string) {
  const [user] = await db.select().from(users).where(eq(users.name, name));
  if (!user) return undefined;
  const [salt, hash] = user.passwordHash.split(':');
  const matches = timingSafeEqual(await derive(password, salt, 32), Buffer.from(hash, 'hex'));
  return matches ? user : undefined;
}

export async function findUserById(db: Db, id: number) {
  const [user] = await db.select().from(users).where(eq(users.id, id));
  return user;
}

scrypt bringt Node mit, im Modul crypto. Es macht aus einem Passwort einen Hash: eine Folge von Bytes, aus der sich das Passwort nicht zurücklesen lässt. Es ist mit Absicht langsam, damit jemand, der die Tabelle in die Hände bekommt, nicht Millionen von Passwörtern pro Sekunde durchprobieren kann. promisify verpackt es so, dass man mit await darauf warten kann.

createUser erzeugt zuerst ein Salt, 16 zufällige Bytes, und hasht das Passwort zusammen mit ihm. Das Salt wird vor dem Hash gespeichert, mit einem Doppelpunkt dazwischen, weil es beim Prüfen des Passworts wieder gebraucht wird. Durch das Salt bekommen zwei Mitglieder mit demselben Passwort verschiedene Hashes, und eine fertige Liste mit den Hashes beliebter Passwörter ist nichts wert.

findUserByLogin geht den umgekehrten Weg. Es holt das Mitglied über den Namen, nimmt das Salt aus dem gespeicherten Wert, hasht das eingetippte Passwort mit diesem Salt und vergleicht das Ergebnis mit dem gespeicherten Hash. timingSafeEqual braucht für den Vergleich immer gleich lang, egal wie viele Bytes übereinstimmen, sodass die Dauer des Vergleichs nichts verrät. Kein solches Mitglied oder ein falsches Passwort: Beides ergibt undefined. findUserById ist für alle späteren Anfragen da, wenn der Server die ID schon kennt.

Eine Seite zum Registrieren hat das Board nicht. Mitglieder werden auf der Kommandozeile hinzugefügt, von einem kleinen Skript, server/db/add-user.ts:

server/db/add-user.ts
import { createUser } from '../users.ts';
import { connect } from './client.ts';

// Adds a member: npm run user:add -- <name> <password>
const [name, password] = process.argv.slice(2);
if (!name || !password) {
  console.error('Usage: npm run user:add -- <name> <password>');
  process.exit(1);
}

const { db, pool } = connect(process.env.DATABASE_URL!);
await createUser(db, name, password);
await pool.end();
console.log(`${name} can log in now.`);

Es bekommt seine Zeile in den scripts der package.json, unter db:migrate:

package.json
"db:migrate": "node --env-file=.env server/db/migrate.ts",
"user:add": "node --env-file=.env server/db/add-user.ts",

Jetzt braucht die Datenbank die Tabelle. Sorg dafür, dass PostgreSQL läuft (docker compose up --detach --wait). Erzeuge dann aus dem geänderten Schema eine Migration, wie in Teil 1, führ sie aus und leg das erste Mitglied an:

questboard
$ npx drizzle-kit generate --name create_users[✓] Your SQL migration file ➜ drizzle/0001_create_users.sql 🚀$ npm run db:migrateThe database is up to date.$ npm run user:add -- robin quest-masterrobin can log in now.

Die zwei Bindestriche nach user:add sagen npm, dass alles danach für das Skript gedacht ist und nicht für npm selbst. Das Mitglied heißt robin, das Passwort ist quest-master. Beiden begegnest du im nächsten Teil wieder.

Drizzle Kit hat die neue Migration neben die erste geschrieben:

drizzle/0001_create_users.sql
CREATE TABLE "users" (
	"id" integer PRIMARY KEY GENERATED ALWAYS AS IDENTITY (sequence name "users_id_seq" INCREMENT BY 1 MINVALUE 1 MAXVALUE 2147483647 START WITH 1 CACHE 1),
	"name" text NOT NULL,
	"password_hash" text NOT NULL,
	CONSTRAINT "users_name_unique" UNIQUE("name")
);

npm run db:migrate hat nur diese Datei ausgeführt: Die erste Migration ist in deiner Datenbank schon als erledigt vermerkt.

Die API fragt, wer du bist

HTTP hat kein Gedächtnis. Jede Anfrage kommt für sich allein an. Damit der Server weiß, dass eine Anfrage von robin stammt, muss der Browser also jedes Mal einen Beweis mitbringen. Hier ist dieser Beweis ein signiertes Cookie. Nach einem erfolgreichen Login gibt der Server dem Browser ein Cookie, das die ID des Mitglieds und eine Signatur enthält. Die Signatur berechnet der Server aus der ID und einem Geheimnis, das nur er kennt. Der Browser schickt das Cookie bei jeder späteren Anfrage mit, und der Server prüft, ob die Signatur passt. Ein Cookie, das sich jemand ausgedacht oder verändert hat, kommt nicht durch, weil ohne das Geheimnis niemand die richtige Signatur berechnen kann.

Der Server speichert dafür nichts. Das Cookie ist die ganze Session.

Hier ist server/app.ts im Ganzen. Die Handler für die Quests sind die aus Teil 1. Neu ist, was um sie herum steht:

server/app.ts
import { serveStatic } from '@hono/node-server/serve-static';
import { sql } from 'drizzle-orm';
import { type Context, Hono } from 'hono';
import { deleteCookie, getSignedCookie, setSignedCookie } from 'hono/cookie';
import { createMiddleware } from 'hono/factory';
import type { Db } from './db/client.ts';
import { createQuest, deleteQuest, listQuests, setQuestDone } from './quests.ts';
import { findUserById, findUserByLogin } from './users.ts';

/**
 * The whole API. It gets its database handed in, so the same code can run on any database,
 * and the secret that signs the login cookie.
 */
export function createApp(db: Db, secret: string) {
  const app = new Hono();

  /** The member behind a request, read from the signed cookie, if there is one. */
  async function currentUser(c: Context) {
    const id = await getSignedCookie(c, secret, 'session');
    return id ? findUserById(db, Number(id)) : undefined;
  }

  /** Lets only members pass. */
  const membersOnly = createMiddleware(async (c, next) => {
    if (!(await currentUser(c))) return c.json({ error: 'Log in to change the board.' }, 401);
    await next();
  });

  app.get('/api/health', async (c) => {
    await db.execute(sql`select 1`);
    return c.json({ ok: true });
  });

  app.post('/api/login', async (c) => {
    const body = await c.req.json().catch(() => null);
    const user =
      typeof body?.name === 'string' && typeof body?.password === 'string'
        ? await findUserByLogin(db, body.name, body.password)
        : undefined;
    if (!user) return c.json({ error: 'Wrong name or password.' }, 401);
    await setSignedCookie(c, 'session', String(user.id), secret, {
      httpOnly: true,
      sameSite: 'Lax',
      path: '/',
    });
    return c.json({ name: user.name });
  });

  app.post('/api/logout', (c) => {
    deleteCookie(c, 'session', { path: '/' });
    return c.body(null, 204);
  });

  app.get('/api/me', async (c) => {
    const user = await currentUser(c);
    return user ? c.json({ name: user.name }) : c.json({ error: 'Not logged in.' }, 401);
  });

  app.get('/api/quests', async (c) => c.json(await listQuests(db)));

  app.post('/api/quests', membersOnly, async (c) => {
    const input = readQuest(await c.req.json().catch(() => null));
    if (typeof input === 'string') return c.json({ error: input }, 400);
    try {
      return c.json(await createQuest(db, input), 201);
    } catch (error) {
      if (isUniqueViolation(error)) {
        return c.json({ error: 'A quest with this title already exists.' }, 409);
      }
      throw error;
    }
  });

  app.patch('/api/quests/:id', membersOnly, async (c) => {
    const body = await c.req.json().catch(() => null);
    if (typeof body?.done !== 'boolean') return c.json({ error: 'done must be true or false.' }, 400);
    const quest = await setQuestDone(db, Number(c.req.param('id')) || 0, body.done);
    return quest ? c.json(quest) : c.json({ error: 'There is no such quest.' }, 404);
  });

  app.delete('/api/quests/:id', membersOnly, async (c) => {
    const deleted = await deleteQuest(db, Number(c.req.param('id')) || 0);
    return deleted ? c.body(null, 204) : c.json({ error: 'There is no such quest.' }, 404);
  });

  // Everything else is the built frontend, if there is one in web/dist.
  app.use('*', serveStatic({ root: './web/dist' }));

  return app;
}

/** The checked input for a new quest, or a sentence that says what is wrong with it. */
function readQuest(body: unknown): { title: string; reward: number } | string {
  const { title, reward = 10 } = (body ?? {}) as { title?: unknown; reward?: unknown };
  if (typeof title !== 'string' || title.trim() === '') return 'A quest needs a title.';
  if (title.trim().length > 80) return 'The title can have 80 characters at most.';
  if (typeof reward !== 'number' || !Number.isInteger(reward) || reward < 0 || reward > 1000) {
    return 'The reward must be a whole number from 0 to 1000.';
  }
  return { title: title.trim(), reward };
}

/** PostgreSQL reports a broken unique constraint with the code 23505. */
function isUniqueViolation(error: unknown) {
  const cause = (error as { cause?: { code?: string } }).cause;
  return cause?.code === '23505';
}

Der zweite Parameter. createApp bekommt jetzt neben der Datenbank das Geheimnis, und aus demselben Grund: Wer die App startet, entscheidet, welches es ist. Dein Server liest es aus seiner Umgebung. Die Tests werden ein eigenes hineinreichen.

currentUser. getSignedCookie liest das Cookie namens session und prüft seine Signatur mit dem Geheimnis. Nur wenn die Signatur passt, gibt es den Wert zurück, die ID des Mitglieds, und findUserById schlägt das Mitglied nach. Kein Cookie, eine falsche Signatur oder ein Mitglied, das es nicht mehr gibt, enden alle gleich: undefined.

membersOnly. Eine Middleware ist eine Funktion, die vor dem Handler einer Route läuft und entscheidet, ob die Anfrage so weit kommt. Diese hier antwortet mit 401 und „Log in to change the board.“, wenn die Anfrage nicht von einem Mitglied kommt. Sie steht vor drei Routen: Such membersOnly als zweites Argument von app.post, app.patch und app.delete für die Quests. GET /api/quests hat sie nicht, das Lesen bleibt also offen.

Login, Logout und „Wer bin ich?“. POST /api/login prüft Name und Passwort mit findUserByLogin. Stimmen sie, legt setSignedCookie das Cookie in die Antwort. Wenn nicht, ist die Antwort 401 und „Wrong name or password.“, derselbe Satz für einen unbekannten Namen und für ein falsches Passwort, damit er nicht verrät, welche Namen es gibt. Zwei Optionen des Cookies dienen der Sicherheit: httpOnly verhindert, dass Skripte in der Seite es lesen, und sameSite: 'Lax' verhindert, dass der Browser es bei Anfragen mitschickt, die andere Websites hinter dem Rücken des Besuchers auslösen. POST /api/logout sagt dem Browser, dass er das Cookie löschen soll. GET /api/me antwortet mit dem Namen des eingeloggten Mitglieds oder mit 401. Die Seite wird das bei jedem Laden fragen.

Der Server muss das Geheimnis hineinreichen, deshalb ändert sich eine Zeile in server/index.ts:

server/index.ts
import { serve } from '@hono/node-server';
import { createApp } from './app.ts';
import { connect } from './db/client.ts';

const { db } = connect(process.env.DATABASE_URL!);
const port = Number(process.env.PORT ?? 3000);

serve({ fetch: createApp(db, process.env.SESSION_SECRET!).fetch, port }, () => {
  console.log(`The quest board is on http://localhost:${port}`);
});

Und das Geheimnis braucht einen Wert. Ergänze deine .env um eine zweite Zeile:

.env
DATABASE_URL=postgres://questboard:questboard@localhost:5432/questboard
SESSION_SECRET=change-me-to-something-long-and-random

Ein Login-Formular für die Seite

Das Frontend braucht drei neue Aufrufe. In web/src/api.ts wird aus dem Objekt api am Ende der Datei:

web/src/api.ts
export const api = {
  /** The name of the member who is logged in, or null for a visitor. */
  me: () =>
    call<{ name: string }>('/me').then(
      (user) => user.name,
      () => null,
    ),
  login: (name: string, password: string) =>
    call<{ name: string }>('/login', 'POST', { name, password }).then((user) => user.name),
  logout: () => call<void>('/logout', 'POST'),
  list: () => call<Quest[]>('/quests'),
  create: (title: string, reward: number) => call<Quest>('/quests', 'POST', { title, reward }),
  setDone: (id: number, done: boolean) => call<Quest>(`/quests/${id}`, 'PATCH', { done }),
  remove: (id: number) => call<void>(`/quests/${id}`, 'DELETE'),
};

login und logout sind Aufrufe wie die anderen. me ist anders: Es darf nicht fehlschlagen. Die Seite fragt es bei jedem Laden, und „niemand ist eingeloggt“ ist auf diese Frage eine normale Antwort, kein Fehler. Deshalb macht die zweite Funktion, die then bekommt, aus jedem Fehlschlag null, auch aus dem 401.

Die Funktion call darüber bleibt, wie sie ist. Ein Browser schickt seine Cookies bei Anfragen an die Adresse, von der die Seite stammt, von sich aus mit.

Jetzt die Seite. web/src/App.vue im Ganzen:

web/src/App.vue
<script setup lang="ts">
import { computed, onMounted, ref } from 'vue';
import { api, type Quest } from './api.ts';

const quests = ref<Quest[]>([]);
const state = ref<'loading' | 'ready' | 'failed'>('loading');
// The name of the member who is logged in, null for a visitor, undefined until that is known.
const member = ref<string | null>();
const name = ref('');
const password = ref('');
const title = ref('');
const reward = ref(10);
const problem = ref('');

const open = computed(() => quests.value.filter((quest) => !quest.done).length);

async function load() {
  state.value = 'loading';
  try {
    quests.value = await api.list();
    state.value = 'ready';
  } catch {
    state.value = 'failed';
  }
}

/** Runs one change, and shows the API's message if it does not work out. */
async function attempt(change: () => Promise<void>) {
  problem.value = '';
  try {
    await change();
  } catch (error) {
    problem.value = (error as Error).message;
  }
}

const login = () =>
  attempt(async () => {
    member.value = await api.login(name.value, password.value);
    name.value = '';
    password.value = '';
  });

const logout = () =>
  attempt(async () => {
    await api.logout();
    member.value = null;
  });

const add = () =>
  attempt(async () => {
    quests.value.push(await api.create(title.value, reward.value));
    title.value = '';
    reward.value = 10;
  });

const toggle = (quest: Quest) =>
  attempt(async () => {
    quest.done = (await api.setDone(quest.id, !quest.done)).done;
  });

const remove = (quest: Quest) =>
  attempt(async () => {
    await api.remove(quest.id);
    quests.value = quests.value.filter((other) => other.id !== quest.id);
  });

onMounted(async () => {
  load();
  member.value = await api.me();
});
</script>

<template>
  <main>
    <h1>Quest Board</h1>

    <template v-if="member">
      <p class="member">
        Logged in as {{ member }}
        <button @click="logout">Log out</button>
      </p>
      <form @submit.prevent="add">
        <label>
          New quest
          <input v-model.trim="title" maxlength="80" required />
        </label>
        <input v-model.number="reward" type="number" min="0" max="1000" placeholder="Reward" required />
        <button>Add quest</button>
      </form>
    </template>
    <form v-else-if="member === null" @submit.prevent="login">
      <label>
        Name
        <input v-model.trim="name" autocomplete="username" required />
      </label>
      <label>
        Password
        <input v-model="password" type="password" autocomplete="current-password" required />
      </label>
      <button>Log in</button>
    </form>
    <p v-if="problem" role="alert" class="problem">{{ problem }}</p>

    <p v-if="state === 'loading'">Loading quests…</p>
    <div v-else-if="state === 'failed'" role="alert" class="problem">
      <p>The quests could not be loaded.</p>
      <button @click="load">Try again</button>
    </div>
    <p v-else-if="quests.length === 0">No quests yet. Add the first one!</p>
    <template v-else>
      <ul aria-label="Quests">
        <li v-for="quest in quests" :key="quest.id" :class="{ done: quest.done }">
          <label>
            <input type="checkbox" :checked="quest.done" :disabled="!member" @change="toggle(quest)" />
            {{ quest.title }}
          </label>
          <span class="reward">{{ quest.reward }} gold</span>
          <button v-if="member" class="delete" :aria-label="`Delete ${quest.title}`" @click="remove(quest)">
            ✕
          </button>
        </li>
      </ul>
      <p class="count">{{ open }} of {{ quests.length }} quests open</p>
    </template>
  </main>
</template>

Drei Werte für member. Es enthält den Namen, sobald jemand eingeloggt ist, und null für einen Besucher. Ganz am Anfang ist es undefined: Die Seite hat gefragt, und die Antwort ist noch nicht da. Das Template unterscheidet die drei. Mit einem Namen zeigt es „Logged in as …“, einen Button „Log out“ und das Formular für neue Quests. Mit null zeigt es an derselben Stelle das Login-Formular. Mit undefined zeigt es keins von beiden. Ohne diesen dritten Wert sähe ein Mitglied bei jedem Laden kurz das Login-Formular aufblitzen, bis die Antwort eintrifft.

Fragen beim Laden. In onMounted wird load() gestartet, aber nicht abgewartet. Die Liste und die Frage „Wer bin ich?“ sind also gleichzeitig unterwegs.

Ein- und Ausloggen. login und logout laufen durch attempt, wie jede andere Änderung. Ein falsches Passwort erscheint deshalb an derselben Stelle unter dem Formular wie jede andere Meldung der API.

Die Liste für Besucher. Zwei kleine Änderungen weiter unten: Die Checkbox hat :disabled="!member", und der Löschen-Button hat v-if="member". Ein Besucher sieht dieselben Quests, mit Checkboxen, die sich nicht anhaken lassen, und ohne die Löschen-Buttons.

Behalte im Kopf, was das Board schützt. Einen Button zu verstecken ist eine Höflichkeit gegenüber dem Besucher. Was einen Besucher daran hindert, etwas zu ändern, ist membersOnly auf dem Server, und genau dafür hat der nächste Teil einen Test.

Die Zeile mit dem Namen des Mitglieds bekommt eine Regel in web/src/style.css, zum Beispiel unter der für input, button:

web/src/style.css
.member {
  display: flex;
  justify-content: space-between;
  align-items: center;
  color: #c4b5fd;
}

Probier es aus. Beende npm run dev:api und starte es neu, damit es die neue Zeile in der .env liest, und öffne http://localhost:5173, während npm run dev:web läuft. Wo das Formular für neue Quests war, steht ein Login-Formular. Die Checkboxen lassen sich nicht anhaken, und die Löschen-Buttons sind weg. Logg dich als robin mit quest-master ein: Die Zeile „Logged in as robin“ erscheint, und alles andere ist wieder da.

Die Tests laufen lassen: Die Hälfte ist rot

Die App funktioniert. Frag jetzt die Suite, was sie davon hält, mit dem Dot-Reporter aus Teil 8, der ein Zeichen pro Test ausgibt:

questboard
$ npx playwright test --reporter=dotRunning 52 tests using 8 workers······TTTTTTT···············[✓] Pulling schema from database...····FFFFFFFFFFFFFFF·TTTT# ... the details of 26 errors, and at the end:  26 failed    [backend] › tests/backend/quests.spec.ts:30:3 › POST /api/quests › creates a quest and stores it    [backend] › tests/backend/quests.spec.ts:49:3 › POST /api/quests › trims the title and gives 10 gold if no reward is named    [backend] › tests/backend/quests.spec.ts:81:5 › POST /api/quests › answers 400 to a quest without a title    [backend] › tests/backend/quests.spec.ts:81:5 › POST /api/quests › answers 400 to a title of spaces    [backend] › tests/backend/quests.spec.ts:81:5 › POST /api/quests › answers 400 to a title of 81 characters    [backend] › tests/backend/quests.spec.ts:81:5 › POST /api/quests › answers 400 to a reward that is not a number    [backend] › tests/backend/quests.spec.ts:81:5 › POST /api/quests › answers 400 to a negative reward    [backend] › tests/backend/quests.spec.ts:81:5 › POST /api/quests › answers 400 to half a gold coin    [backend] › tests/backend/quests.spec.ts:90:3 › POST /api/quests › answers 400 to a body that is not JSON    [backend] › tests/backend/quests.spec.ts:99:3 › POST /api/quests › answers 409 to a title that is taken    [backend] › tests/backend/quests.spec.ts:111:3 › PATCH /api/quests/:id › marks a quest as done, and as open again    [backend] › tests/backend/quests.spec.ts:125:3 › PATCH /api/quests/:id › answers 400 if done is not true or false    [backend] › tests/backend/quests.spec.ts:133:3 › PATCH /api/quests/:id › answers 404 for a quest that does not exist    [backend] › tests/backend/quests.spec.ts:142:3 › DELETE /api/quests/:id › deletes the quest and nothing else    [backend] › tests/backend/quests.spec.ts:151:3 › DELETE /api/quests/:id › answers 404 for a quest that does not exist    [frontend] › tests/frontend/board.spec.ts:61:1 › marks a quest as done    [frontend] › tests/frontend/board.spec.ts:73:1 › removes a deleted quest from the list    [frontend] › tests/frontend/board.spec.ts:85:1 › keeps the quest and says why when a change fails    [frontend] › tests/frontend/form.spec.ts:3:1 › sends a new quest to the API and shows it    [frontend] › tests/frontend/form.spec.ts:18:1 › removes spaces around the title    [frontend] › tests/frontend/form.spec.ts:29:1 › shows what the API says when it turns a quest down    [frontend] › tests/frontend/form.spec.ts:45:1 › does not send a quest without a title    [e2e] › tests/e2e/quest-board.spec.ts:5:1 › a new quest travels from the form into the database    [e2e] › tests/e2e/quest-board.spec.ts:30:1 › a finished quest is still finished after a reload    [e2e] › tests/e2e/quest-board.spec.ts:43:1 › a deleted quest is gone for good    [e2e] › tests/e2e/quest-board.spec.ts:55:1 › a title that is taken is turned down, all the way from the database  26 passed (1.1m)

26 von 52 Tests sind fehlgeschlagen. Ein Punkt ist ein bestandener Test, ein F ein fehlgeschlagener und ein T einer, der in sein Zeitlimit gelaufen ist. Geh das Ergebnis Bereich für Bereich durch, wie im letzten Teil. Jeder Bereich ist aus einem eigenen Grund rot oder grün.

database: grün. An den Quests hat sich hier unten nichts geändert. Ein Test hat trotzdem echte Arbeit geleistet: Der Migrationstest aus Teil 5 hat die Template-Datenbank, die jetzt aus zwei Migrationen entsteht, mit schema.ts verglichen und keinen Unterschied gefunden. Hättest du vergessen, die Migration für die Mitglieder zu erzeugen, wäre auch dieser Bereich rot.

backend: 15 fehlgeschlagen. Sieh dir ihre Titel in der Liste an: Es ist jeder Test, der ein POST, ein PATCH oder ein DELETE schickt. Jeder davon hat 401 bekommen, wo er etwas anderes erwartet hat. Das gilt sogar für die Tests, die eine Absage mit 400, 404 oder 409 erwarten, denn membersOnly schickt die Anfrage weg, bevor der Handler sie überhaupt ansieht. Die Tests, die nur lesen, also der Health Check und GET /api/quests, bestehen weiterhin.

frontend: 7 ins Zeitlimit gelaufen. Diese Tests sprechen nie mit der echten API, also hat sie kein 401 erreicht. Ihr Problem beginnt früher. Die Seite fragt jetzt beim Laden GET /api/me. Kein Test mockt diese Anfrage, also bricht die Auffang-Route aus Teil 7 sie ab, api.me() macht aus dem Fehlschlag null, und die Seite zeigt, was ein Besucher bekommt: das Login-Formular, gesperrte Checkboxen, keine Löschen-Buttons. Die sieben Tests, die etwas ändern wollen, warten dann auf etwas, das sie nicht bekommen, ein Feld, das nicht da ist, oder eine Checkbox, die gesperrt bleibt, bis Playwright jeden von ihnen nach 30 Sekunden beendet, seinem Zeitlimit für einen einzelnen Test. Das ist das T, und deshalb hat dieser Lauf mehr als eine Minute gedauert. Die fünf Tests, die sich nur die Liste ansehen, haben nichts bemerkt.

e2e: 4 ins Zeitlimit gelaufen. Dieselbe Geschichte mit echten Teilen. Die echte API beantwortet /api/me mit 401, weil der Browser des Tests kein Cookie hat, und die Seite zeigt die Ansicht für Besucher. Nur der Test, der das Board liest, „the board shows what is in the database“, besteht noch.

Um es deutlich zu sagen: Nichts ist kaputt. Du hast die App eben ausprobiert, und sie tut, was sie soll. Die Tests beschreiben die App von gestern, in der jeder alles durfte, und die Suite hat ihre Arbeit getan: Sie hat bemerkt, dass sich die App nicht mehr so verhält, und sie hat dir gesagt, wo. Alles, was das Board ändert, ist rot, und sonst nichts. Wäre der Login ein Versehen gewesen, hättest du es genau so erfahren. Er war Absicht, also müssen die Tests nachziehen.

Was du jetzt hast

Das Quest Board hat Mitglieder: eine Tabelle mit gesalzenen Hashes statt Passwörtern, eine API, die ein Mitglied an einem signierten Cookie erkennt und alle anderen von Änderungen fernhält, und eine Seite mit einem Login-Formular. Und du hast eine Suite, die die Änderung innerhalb von etwa einer Minute gemeldet hat, Bereich für Bereich.

Im nächsten Teil lernen die Tests, sich einzuloggen: einmal für den ganzen Lauf und nicht einmal pro Test. Die roten Tests werden wieder grün, ohne dass sich an einem einzigen von ihnen etwas ändert.

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.