Zum Inhalt springen

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

Teil 5: Die Datenbank testen

Füll den Bereich für die Datenbank: Tests für die Standardwerte und Constraints der Tabelle, für die Abfragen der App, und ein Test, der bemerkt, wenn schema.ts geändert wurde und die Migration dazu fehlt.

Quest-Ziele

  • Verstehen, warum die Regeln in der Datenbank eigene Tests verdienen
  • Standardwerte und Constraints testen und prüfen, welcher Constraint eine Zeile abgelehnt hat
  • Aus einer Tabelle von Fällen einen Test pro Fall machen
  • Die Abfrage-Funktionen der App direkt testen, ohne HTTP
  • Eine Schema-Änderung ohne Migration aufdecken

Seit dem letzten Teil kann ein Test eine Datenbank mit leeren Tabellen verlangen, egal wie viele Worker neben ihm laufen. Dieser Teil nutzt das, um den Bereich database zu füllen: Tests für die Standardwerte und Constraints der Tabelle, für die Abfragen der App, und einer, der bemerkt, wenn eine Migration fehlt.

Die Datenbank unter der Lupe: Eine Zeile, die eine Regel bricht, muss abprallen, egal wer sie schickt.
Die Datenbank unter der Lupe: Eine Zeile, die eine Regel bricht, muss abprallen, egal wer sie schickt.

Warum die Datenbank überhaupt testen

Die API prüft ihre Eingaben auch: readQuest in server/app.ts lehnt einen leeren Titel ab, bevor die Datenbank ihn je sieht. Warum also dieselben Regeln eine Schicht tiefer noch einmal testen?

Weil die API nicht der einzige Weg hinein ist. Ein Skript, das Quests importiert, eine Migration, die Zeilen umschreibt, ein zweiter Dienst auf derselben Datenbank: Sie alle schreiben an der API vorbei. Die Constraints, die du in Teil 1 ins Schema geschrieben hast, gelten, egal wer schreibt. Die Datenbank ist die letzte Verteidigungslinie, und eine Verteidigung, auf die du dich verlässt, verdient Tests.

Daraus ergibt sich, was in diesen Bereich gehört:

  • die Standardwerte und Constraints der Tabelle,

  • die Abfragen, die die App schickt, direkt als Funktionen aufgerufen,

  • ob die Migrationen und schema.ts noch dieselbe Datenbank beschreiben.

Einen Browser und HTTP gibt es hier nicht. Statuscodes und Fehlermeldungen sind Sache der API, und die testet der nächste Teil.

Standardwerte und Constraints

Leg tests/database/constraints.spec.ts an:

tests/database/constraints.spec.ts
import { quests } from '../../server/db/schema.ts';
import { expect, test } from '../fixtures.ts';

test('fills in what a new quest leaves out', async ({ db }) => {
  const [quest] = await db.insert(quests).values({ title: 'Find the lost sword' }).returning();

  expect(quest).toMatchObject({ id: 1, title: 'Find the lost sword', reward: 10, done: false });
  expect(Date.now() - quest.createdAt.getTime()).toBeLessThan(5000);
});

const rejected = [
  { name: 'an empty title', row: { title: '' }, constraint: 'quests_title_length' },
  { name: 'a title of 81 characters', row: { title: 'x'.repeat(81) }, constraint: 'quests_title_length' },
  { name: 'a negative reward', row: { title: 'Rob the bank', reward: -1 }, constraint: 'quests_reward_range' },
  { name: 'a reward above 1000', row: { title: 'Rob the bank', reward: 1001 }, constraint: 'quests_reward_range' },
];

for (const { name, row, constraint } of rejected) {
  test(`rejects ${name}`, async ({ db }) => {
    await expect(db.insert(quests).values(row)).rejects.toMatchObject({ cause: { constraint } });

    expect(await db.select().from(quests)).toEqual([]);
  });
}

test('rejects a title that is taken', async ({ db }) => {
  await db.insert(quests).values({ title: 'Find the lost sword' });

  await expect(db.insert(quests).values({ title: 'Find the lost sword' })).rejects.toMatchObject({
    cause: { code: '23505', constraint: 'quests_title_unique' },
  });
});

test('accepts a title of exactly 80 characters', async ({ db }) => {
  await db.insert(quests).values({ title: 'x'.repeat(80) });

  expect(await db.select().from(quests)).toHaveLength(1);
});

Die Standardwerte. Der erste Test fügt nichts als einen Titel ein und sieht sich die Zeile an, die returning() zurückgibt. Die ID ist 1, weil die Fixture db den Zähler zurückgesetzt hat. Die Belohnung ist 10 und die Quest ist offen: Beides kommt aus den Standardwerten im Schema. Den Zeitpunkt der Erstellung trägt die Datenbank ein, der Test kann den genauen Wert also nicht kennen. Er prüft, dass der Zeitpunkt weniger als fünf Sekunden zurückliegt.

Die abgelehnten Zeilen. rejected ist eine Tabelle von Fällen: ein Name, die Zeile, die eingefügt werden soll, und der Constraint, der sie ablehnen soll. Die for-Schleife ruft test einmal pro Fall auf, das sind also vier Tests mit vier Titeln, etwa „rejects an empty title“. Die Alternative, ein Test mit der Schleife darin, würde beim ersten Fall aufhören, der fehlschlägt, und dir von den anderen nichts sagen.

Die Prüfung lautet await expect(…).rejects.toMatchObject({ cause: { constraint } }). rejects wartet darauf, dass das Einfügen fehlschlägt, und reicht den Fehler an den Matcher dahinter weiter. Gelingt das Einfügen, schlägt der Test fehl. Drizzle verpackt den Fehler, den PostgreSQL schickt, in einen eigenen. Das Original steckt in cause, und sein Feld constraint nennt den Constraint, der Nein gesagt hat.

Dieser Name ist wichtig. In Teil 2 gab es einen Test, der aus dem falschen Grund bestanden hat, und „das Einfügen ist fehlgeschlagen“ wäre auch so ein Test: Eine Zeile kann aus vielen Gründen scheitern. Dieser hier besteht nur, wenn der Titel mit 81 Zeichen an quests_title_length gescheitert ist und die negative Belohnung an quests_reward_range. Die letzte Zeile jedes Tests prüft dann, dass die Tabelle noch leer ist.

Der vergebene Titel. Dieser Test sieht sich auch den Code des Fehlers an, 23505. Das ist der Code, den isUniqueViolation in server/app.ts liest, um mit 409 zu antworten. Die API verlässt sich auf dieses Detail, deshalb wird es hier festgehalten.

Die Grenze. Der letzte Test ist die andere Seite der Regel: Ein Titel mit genau 80 Zeichen muss angenommen werden. Ohne ihn würde ein Constraint, der um ein Zeichen zu streng ist, jeden Test darüber bestehen.

Die Abfragen der App

Die nächsten Tests brauchen Zeilen in der Tabelle, bevor sie etwas fragen können. Mit einem kleinen Helfer sagt ein Test in einer Zeile, was er braucht. Leg tests/support/seed.ts an:

tests/support/seed.ts
import type { Db } from '../../server/db/client.ts';
import { quests } from '../../server/db/schema.ts';

type NewQuest = typeof quests.$inferInsert;

/** Puts quests into the database and returns them as they were stored. Only a title is needed. */
export function seedQuests(db: Db, ...rows: NewQuest[]) {
  return db.insert(quests).values(rows).returning();
}

typeof quests.$inferInsert ist Drizzles Typ für eine Zeile, die du einfügst: Jede Spalte mit einem Standardwert ist optional, ein Titel genügt also. Die Funktion gibt die Zeilen so zurück, wie sie gespeichert wurden, mit ihren IDs und Zeitpunkten, und die Tests verwenden sie zum Vergleichen.

Jetzt die Abfragen. Leg tests/database/queries.spec.ts an:

tests/database/queries.spec.ts
import { quests } from '../../server/db/schema.ts';
import { createQuest, deleteQuest, listQuests, setQuestDone } from '../../server/quests.ts';
import { expect, test } from '../fixtures.ts';
import { seedQuests } from '../support/seed.ts';

test('lists open quests first, and the oldest first among them', async ({ db }) => {
  await seedQuests(
    db,
    { title: 'Feed the dragon', done: true },
    { title: 'Find the lost sword' },
    { title: 'Brew a potion', done: true },
    { title: 'Map the cave' },
  );

  const titles = (await listQuests(db)).map((quest) => quest.title);

  expect(titles).toEqual(['Find the lost sword', 'Map the cave', 'Feed the dragon', 'Brew a potion']);
});

test('creates a quest and returns the stored row', async ({ db }) => {
  const quest = await createQuest(db, { title: 'Find the lost sword', reward: 50 });

  expect(quest).toMatchObject({ id: 1, title: 'Find the lost sword', reward: 50, done: false });
  expect(await db.select().from(quests)).toEqual([quest]);
});

test('marks one quest as done and leaves the others alone', async ({ db }) => {
  const [sword, cave] = await seedQuests(db, { title: 'Find the lost sword' }, { title: 'Map the cave' });

  const changed = await setQuestDone(db, sword.id, true);

  expect(changed).toEqual({ ...sword, done: true });
  expect(await listQuests(db)).toEqual([cave, { ...sword, done: true }]);
});

test('says so when there is no quest to change or delete', async ({ db }) => {
  expect(await setQuestDone(db, 99, true)).toBeUndefined();
  expect(await deleteQuest(db, 99)).toBe(false);
});

test('deletes a quest', async ({ db }) => {
  const [sword, cave] = await seedQuests(db, { title: 'Find the lost sword' }, { title: 'Map the cave' });

  expect(await deleteQuest(db, sword.id)).toBe(true);

  expect(await listQuests(db)).toEqual([cave]);
});

Diese Tests importieren listQuests, createQuest, setQuestDone und deleteQuest aus server/quests.ts und rufen sie mit dem db des Tests auf. Das sind die Funktionen, die die API aufruft, ohne die API darum herum. Schlägt einer dieser Tests fehl, ist die Abfrage falsch, keine Route und nicht die Seite.

Die Reihenfolge. Das Board zeigt offene Quests zuerst, und innerhalb jeder Gruppe die älteste zuerst. Der Test legt vier Quests abwechselnd an: erledigt, offen, erledigt, offen. Eine Liste in der Reihenfolge des Speicherns würde hier durchfallen. Die erwartete beginnt mit den zwei offenen Quests in der Reihenfolge, in der sie gespeichert wurden, und endet mit den zwei erledigten.

Anlegen. createQuest muss die Zeile so zurückgeben, wie sie gespeichert wurde. Der Test vergleicht, was die Funktion zurückgibt, mit dem, was ein schlichtes select danach findet: toEqual([quest]) heißt, es gibt eine Zeile, und es ist dieselbe.

Ändern. Die geänderte Quest muss gleich { ...sword, done: true } sein, die alte Zeile mit einem anderen Feld, sonst wurde also nichts angefasst. Die Liste danach zeigt zwei weitere Dinge: Die andere Quest ist unverändert, und die erledigte ist ans Ende gerückt.

Nichts da. Für eine ID, die es nicht gibt, liefert setQuestDone undefined und deleteQuest false. Die API macht aus beidem ein 404, diese Antworten gehören also zu dem, was die Funktionen versprechen.

Löschen. Zwei Quests kommen hinein, eine wird gelöscht, und die Liste enthält genau die andere.

Passen die Migrationen zum Schema?

Die App beschreibt ihre Tabellen zweimal. server/db/schema.ts ist das, was dein Code und seine Typen verwenden. Die SQL-Dateien in drizzle/ sind das, was die echte Datenbank baut. npm run db:generate schreibt das Zweite aus dem Ersten, solange jemand daran denkt, es auszuführen.

Der klassische Fehler: schema.ts ändern und die Migration vergessen. TypeScript ist zufrieden, denn es kennt nur das Schema. Die Datenbank hat die neue Spalte nicht, und die erste Abfrage, die sie verwendet, schlägt fehl. Ein Test kann das abfangen. Leg tests/database/migrations.spec.ts an:

tests/database/migrations.spec.ts
import { pushSchema } from 'drizzle-kit/api';
import * as schema from '../../server/db/schema.ts';
import { expect, test } from '../fixtures.ts';

test('the migrations build exactly what schema.ts describes', async ({ db }) => {
  // What would Drizzle have to change in this database to make it match schema.ts?
  const { statementsToExecute } = await pushSchema(schema, db);

  expect(statementsToExecute).toEqual([]);
});

drizzle-kit/api stellt die Funktionen von Drizzle Kit für Programme bereit. Drizzle Kit hast du in Teil 1 installiert, um Migrationen zu erzeugen, es kommt also nichts dazu. pushSchema vergleicht das, was schema.ts beschreibt, mit der Datenbank, die es bekommt, und gibt die Anweisungen zurück, die nötig wären, um beide gleich zu machen. Der Test führt keine davon aus. Er sieht sich nur die Liste an.

Die Datenbank, die es bekommt, ist die des Workers, eine Kopie des Templates, und das Template wurde von den Migrationen gebaut. Eine leere Liste heißt also: Die Migrationen bauen genau das, was schema.ts beschreibt.

Mach den Fehler einmal selbst. Ergänze in server/db/schema.ts unter done eine Spalte, und erzeuge keine Migration dafür:

server/db/schema.ts
done: boolean().notNull().default(false),
giver: text(),

Führ dann diesen einen Test aus. Das Wort migrations hinter dem Projekt ist ein Filter: Es laufen nur Testdateien, deren Pfad dieses Wort enthält.

questboard
$ npx playwright test --project=database migrationsRunning 2 tests using 1 worker  ✓  1 [setup] › tests/setup/database.setup.ts:6:1 › build the template database (126ms)[✓] Pulling schema from database...  ✘  2 [database] › tests/database/migrations.spec.ts:5:1 › the migrations build exactly what schema.ts describes (68ms)  1) [database] › tests/database/migrations.spec.ts:5:1 › the migrations build exactly what schema.ts describes    Error: expect(received).toEqual(expected) // deep equality    - Expected  - 1    + Received  + 3    - Array []    + Array [    +   "ALTER TABLE \"quests\" ADD COLUMN \"giver\" text;",    + ]       7 |   const { statementsToExecute } = await pushSchema(schema, db);       8 |    >  9 |   expect(statementsToExecute).toEqual([]);         |                               ^      10 | });      11 |        at /home/robin/questboard/tests/database/migrations.spec.ts:9:31  1 failed    [database] › tests/database/migrations.spec.ts:5:1 › the migrations build exactly what schema.ts describes  1 passed (4.1s)

Der Test schlägt fehl, und der Unterschied, den er ausgibt, ist die Migration, die fehlt: ALTER TABLE "quests" ADD COLUMN "giver" text;. In einem echten Projekt ist das der Moment für npm run db:generate. Hier war die Spalte nur ein Experiment, entferne die Zeile also wieder aus schema.ts.

Wenn das Schema wieder ist, wie es war, führ den ganzen Bereich aus:

questboard
$ npx playwright test --project=databaseRunning 17 tests using 8 workers  ✓   1 [setup] › tests/setup/database.setup.ts:6:1 › build the template database (115ms)  ✓   2 [database] › tests/database/constraints.spec.ts:19:3 › rejects an empty title (41ms)  ✓  10 [database] › tests/database/isolation.spec.ts:8:1 › can add a quest (18ms)  ✓   4 [database] › tests/database/constraints.spec.ts:26:1 › rejects a title that is taken (50ms)  ✓   3 [database] › tests/database/constraints.spec.ts:19:3 › rejects a reward above 1000 (57ms)  ✓  11 [database] › tests/database/isolation.spec.ts:14:1 › does not see the quests of other tests (21ms)  ✓   5 [database] › tests/database/constraints.spec.ts:19:3 › rejects a title of 81 characters (38ms)  ✓   7 [database] › tests/database/constraints.spec.ts:4:1 › fills in what a new quest leaves out (41ms)  ✓  12 [database] › tests/database/queries.spec.ts:6:1 › lists open quests first, and the oldest first among them (16ms)  ✓   6 [database] › tests/database/constraints.spec.ts:19:3 › rejects a negative reward (40ms)  ✓  13 [database] › tests/database/queries.spec.ts:20:1 › creates a quest and returns the stored row (13ms)  ✓   9 [database] › tests/database/isolation.spec.ts:4:1 › starts with an empty table (29ms)  ✓   8 [database] › tests/database/constraints.spec.ts:34:1 › accepts a title of exactly 80 characters (35ms)  ✓  16 [database] › tests/database/queries.spec.ts:36:1 › says so when there is no quest to change or delete (11ms)  ✓  15 [database] › tests/database/queries.spec.ts:41:1 › deletes a quest (23ms)  ✓  14 [database] › tests/database/queries.spec.ts:27:1 › marks one quest as done and leaves the others alone (29ms)[✓] Pulling schema from database...  ✓  17 [database] › tests/database/migrations.spec.ts:5:1 › the migrations build exactly what schema.ts describes (62ms)  17 passed (4.2s)

17 Tests: das Setup und die 16 Tests des Bereichs, in etwa vier Sekunden. Die Nummern vor den Zeilen sagen, in welcher Reihenfolge die Tests gestartet sind. Auf mehrere Worker verteilt, werden sie nicht in dieser Reihenfolge fertig, deshalb sind die Zeilen oben durcheinander. In deinem Terminal können sie geordnet sein. Wie viele Worker Playwright verwendet, hängt von deinem Rechner ab, in deiner ersten Zeile kann also eine andere Zahl als 8 stehen.

Was du jetzt hast

Der Bereich database prüft die Standardwerte und die drei benannten Constraints der Tabelle, die vier Abfrage-Funktionen der App, und dass die Migrationen und schema.ts übereinstimmen. Das alles läuft ohne Browser und ohne eine einzige HTTP-Anfrage.

Die Regeln, die für alle gelten, die in die Datenbank schreiben, sind jetzt getestet. Im nächsten Teil gehst du eine Schicht nach oben: Jeder Worker startet seine eigene Kopie der API auf seiner eigenen Datenbank, und der Bereich backend testet sie mit echten Anfragen.

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.