mitmario.dev

Synthese: die getestete API

Node.js Sandbox 4 Min Lesezeit 3 BeispieleLektion 5 von 6

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 code und 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.

Ein Helfer für alle Tests
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

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.

Was eine Abdeckungszahl nicht sagt
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, kostenlos

Zu 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.