Abschnitt 17 · Lektion 5
Synthese: die getestete API
Eine Bücher-API mit Routen, Datenbank, Eingabeprüfung, Absicherung und Fehler-Handler kann bei jeder Änderung an einer anderen Stelle kaputtgehen. Nach jedem Umbau jede Route von Hand anzufragen, hält niemand lange durch.
Was ein sinnvoller Bestand abdeckt
Für eine API dieser Größe ist die Liste kurz.
- Je Route der Erfolgsfall, also das, was herauskommen soll, mit dem richtigen Statuscode.
- Je Route der wichtigste Fehlerfall, meistens der 404 oder der 400. Geprüft wird dabei neben der
Zahl auch die Form der Antwort, derselbe
codeund dieselbe Struktur wie überall. - Die Eingabeprüfung, mit einem Fall, der abgewiesen werden muss, und einem, der gerade noch durchgeht. Das sind dieselben Ränder wie bei den Funktionen, nur an einer Route.
- Jede Absicherung, die eingebaut ist. Die Einschleusung darf nicht funktionieren, die Fehlerantwort keine Interna enthalten, und der geschützte Bereich bleibt ohne Sitzung zu.
Ein Test je Zeile Code gehört nicht dazu, und auch keiner für Express selbst oder dafür, dass SQLite Zeilen speichern kann. Für fremden Code haben andere ihre Tests geschrieben.
Ein Helfer hält den Bestand lesbar
Acht Tests, die alle dasselbe Gerüst aus fetch, await und json() wiederholen, liest niemand
gern. Im Beispiel steht deshalb ein Helfer, an einer winzigen Autoren-API mit drei Tests.
import express from "express";
/** Eine winzige Autoren-API, nur fuer dieses Beispiel. */
export function baueApp() {
const app = express();
app.use(express.json());
const autoren = [
{ id: 1, name: "Adler" },
{ id: 2, name: "Berger" },
{ id: 3, name: "Wolf" },
];
app.get("/api/autoren", (req, res) => {
res.json({ anzahl: autoren.length, daten: autoren });
});
app.post("/api/autoren", (req, res) => {
const name = req.body?.name;
if (autoren.some((autor) => autor.name === name)) {
return res
.status(409)
.json({ fehler: { code: "konflikt", meldung: "Diesen Autor gibt es schon." } });
}
const autor = { id: autoren.length + 1, name };
autoren.push(autor);
res.status(201).location(`/api/autoren/${autor.id}`).json(autor);
});
return app;
} import { test, beforeEach, afterEach } from "node:test";
import assert from "node:assert/strict";
import { baueApp } from "./mini.js";
let server;
let adresse;
beforeEach(async () => {
server = baueApp().listen(0);
await new Promise((fertig) => server.once("listening", fertig));
adresse = `http://127.0.0.1:${server.address().port}`;
});
afterEach(async () => {
await new Promise((fertig) => server.close(fertig));
});
/** Ein Helfer, der die immer gleichen vier Zeilen je Test einspart. */
async function hole(pfad, einstellungen = {}) {
const antwort = await fetch(`${adresse}${pfad}`, {
...einstellungen,
headers: einstellungen.body ? { "Content-Type": "application/json" } : undefined,
body: einstellungen.body ? JSON.stringify(einstellungen.body) : undefined,
});
return { status: antwort.status, rumpf: await antwort.json() };
}
test("liefert drei Autoren, Adler zuerst", async () => {
const { rumpf } = await hole("/api/autoren");
assert.equal(rumpf.anzahl, 3);
assert.equal(rumpf.daten[0].name, "Adler");
});
test("legt O'Brien an", async () => {
const { status, rumpf } = await hole("/api/autoren", {
method: "POST",
body: { name: "O'Brien" },
});
assert.equal(status, 201);
assert.equal(rumpf.name, "O'Brien");
});
test("weist einen Autor ab, den es schon gibt", async () => {
const { status, rumpf } = await hole("/api/autoren", {
method: "POST",
body: { name: "Berger" },
});
assert.equal(status, 409);
assert.equal(rumpf.fehler.code, "konflikt");
}); Der Helfer hole nimmt Pfad und Einstellungen, kümmert sich um Adresse, Kopfzeile und das Auspacken
der Antwort und gibt Status und Rumpf zurück. Jeder Test schrumpft damit auf eine Anfrage und zwei
assert-Aufrufe.
Ein Testhelfer ist auch Code, und für ihn gibt es keinen Test. Bekommt er eigene Verzweigungen,
wandert Logik dorthin, wo sie niemand prüft. hole fragt nur, ob ein Rumpf mitgeht, und sonst
nichts.
Der Test, der die Absicherung festhält
import test from "node:test";
import assert from "node:assert/strict";
import { DatabaseSync } from "node:sqlite";
const db = new DatabaseSync(":memory:");
db.exec("CREATE TABLE buecher (id INTEGER PRIMARY KEY, titel TEXT NOT NULL)");
for (const titel of ["Node in der Praxis", "JavaScript von vorn", "HTTP verstehen"]) {
db.prepare("INSERT INTO buecher (titel) VALUES (?)").run(titel);
}
// So war die Suche vor Abschnitt 15: der Suchbegriff wird in die Abfrage geklebt.
function sucheVerkettet(q) {
return db.prepare(`SELECT titel FROM buecher WHERE titel LIKE '%${q}%'`).all();
}
// Und so danach: der Suchbegriff geht als Parameter mit.
function sucheMitParameter(q) {
return db.prepare("SELECT titel FROM buecher WHERE titel LIKE '%' || ? || '%'").all(q);
}
const angriff = "' OR '1'='1";
test("die verkettete Suche gibt bei der Einschleusung alles heraus", () => {
assert.equal(sucheVerkettet(angriff).length, 0);
});
test("die Suche mit Parameter findet schlicht nichts", () => {
assert.equal(sucheMitParameter(angriff).length, 0);
}); Dieselbe Eingabe läuft gegen zwei Fassungen der Suche. Die verkettete gibt bei ' OR '1'='1 den
ganzen Bestand heraus, die mit Parameter findet nichts, weil sie den Text als Text behandelt. Der
rote Test meldet 3 !== 0, drei Bücher statt keinem. Das ist der Zustand, den du in Abschnitt 15
abgestellt hast.
In einem halben Jahr baut jemand die Suche um, weil sie schneller werden soll, und klebt dabei aus Versehen wieder zusammen. Ohne diesen Test fällt das niemandem auf, bis es jemandem auffällt, der es ausnutzt. Mit ihm wird die Pipeline rot, bevor die Änderung live geht.
Dasselbe geht mit den anderen Entscheidungen aus Abschnitt 15 und 16, mit der Fehlerantwort ohne Interna, dem Deckel auf der Größe des Rumpfs oder dem Rate-Limit für die Anmeldeversuche. Jede davon braucht ein paar Zeilen Test, und danach fällt auf, wenn sie verschwindet.
Was eine Abdeckungszahl sagt und was nicht
node --test --experimental-test-coverage zählt, wie viel Prozent der Zeilen beim Testlauf
ausgeführt wurden.
import test from "node:test";
import assert from "node:assert/strict";
// Die richtige Fassung.
function stufeRichtig(betrag) {
if (betrag > 100) return 0.2;
if (betrag > 50) return 0.1;
return 0;
}
// Die kaputte Fassung: sie gibt immer null zurueck.
function stufeKaputt(betrag) {
if (betrag > 100) return 0;
if (betrag > 50) return 0;
return 0;
}
for (const [name, stufe] of [["richtig", stufeRichtig], ["kaputt", stufeKaputt]]) {
test(`${name}: der Test fährt jede Zeile an und prüft trotzdem nichts`, () => {
for (const betrag of [10, 60, 200]) {
assert.equal(typeof stufe(betrag), "number");
}
});
test(`${name}: der Test prüft die Werte`, () => {
assert.equal(stufe(10), 0);
assert.equal(stufe(60), 0.1);
assert.equal(stufe(200), 0.2);
});
} Der erste Test fährt jede Zeile beider Fassungen an. Nach der Abdeckungszahl ist alles geprüft. Er ist aber auch bei der kaputten Fassung grün, weil er nur nachschaut, ob eine Zahl herauskommt, und nicht welche.
Gemessen wird, was ausgeführt wurde. Ob ein assert es angesehen hat, steht in keiner Spalte.
Verlässlich ist die Zahl also nur, wo sie niedrig ist, denn eine Zeile, die nie lief, hat auch kein
Test geprüft. Eine hohe Zahl beruhigt dagegen nur, und wer sie zur Zielvorgabe macht, bekommt Tests,
die Zeilen anfahren und nichts behaupten.
Mit den acht Tests aus der Aufgabe steht logger.js im Bericht bei null Prozent der Funktionen. Das
stimmt sogar, denn keiner davon löst einen Serverfehler aus, der protokolliert würde. app.js steht
bei rund 94 Prozent der Zeilen. Du hast schon in der Aufgabe zu Lektion 17.2 gesehen, dass so eine
Zahl allein nichts heißt. Dort kam die kaputte durchschnitt auf hundert Prozent.
npm test und was danach kommt
npm test ist der Befehl, den jeder erwartet. Das ist die Verabredung aus Lektion 5.1. Wer ein
Projekt zum ersten Mal öffnet, probiert ihn, ohne die package.json zu lesen. Eine Zeile
"test": "node --test" im scripts-Block reicht dafür.
Der nächste Schritt liegt außerhalb dieses Kurses und ist klein. Derselbe Befehl läuft in einer Pipeline bei jedem Push, und sie braucht dafür nur den Exit-Code. Null heißt weiter, alles andere heißt anhalten.
Acht Tests sind es in der Aufgabe, einer davon mit einer Einschleusung aus Abschnitt 15 in der Suche.
Zum Mitnehmen
Ein kleiner Bestand reicht, wenn er je Route den Erfolgsfall und den wichtigsten Fehlerfall, die Eingabeprüfung und jede Absicherung abdeckt. Die Abdeckungszahl zeigt Lücken, aber nicht, ob geprüft wurde, und npm test gibt der Pipeline ihren Exit-Code.
Jetzt du
Basis Konto, kostenlosZu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.
Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.
In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.
Was in dieser Lektion steckt
-
Artikel mit 3 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe, dein Code läuft auf einem Server
Öffnet sich mit dem Basis Konto.