mitmario.dev

Funktionen testen

Node.js Sandbox 3 Min Lesezeit 3 BeispieleLektion 2 von 6

Einen Test zu schreiben ist leicht. Die Fälle zu wählen, die etwas aussagen, ist die eigentliche Arbeit.

Drei Sorten Fälle

  • Der Normalfall, also das, wofür die Funktion gebaut ist, mit gewöhnlichen Werten.
  • Die Ränder. Leer, eins, viele, null, negativ, sehr groß, der erste und der letzte Eintrag, eins zu wenig und eins zu viel. Dort sitzen die Fehler, weil dort die Bedingungen umschlagen.
  • Der Fall, der schiefgehen soll, mit ungültiger Eingabe, fehlendem Feld oder verbotenem Zustand. Ohne ihn weißt du nur, dass die Funktion arbeitet, solange alle lieb sind. Um ihn geht es in der nächsten Lektion.
Nur der Normalfall beweist wenig
import { describe, test } from "node:test";
import assert from "node:assert/strict";

// Der Median: der mittlere Wert einer sortierten Liste.
function median(zahlen) {
  const sortiert = [...zahlen].sort((a, b) => a - b);
  return sortiert[Math.floor(sortiert.length / 2)];
}

describe("nur der Normalfall", () => {
  test("findet den mittleren Wert", () => {
    assert.equal(median([1, 2, 3]), 2);
  });
});

describe("dazu die Ränder", () => {
  test("kommt mit einem einzigen Wert klar", () => {
    assert.equal(median([7]), 7);
  });

  test("sortiert vorher, die Eingabe darf unsortiert sein", () => {
    assert.equal(median([9, 1, 5]), 5);
  });

  test("mittelt bei gerader Anzahl die beiden mittleren", () => {
    assert.equal(median([1, 2, 3, 4]), 2.5);
  });
});

Der Median einer ungeraden Liste ist der mittlere Wert, und das prüft der erste Test. Er ist grün, und die Funktion ist trotzdem kaputt. Bei gerader Anzahl muss der Mittelwert der beiden mittleren Werte herauskommen. Das findet erst der letzte Test, mit 3 !== 2.5.

Was ein Test wert ist, hängt an den Fehlern, die er finden könnte. Einer, der nur den Normalfall prüft, findet nur einen Fehler, bei dem gar nichts mehr geht, und der wäre ohnehin sofort aufgefallen.

Vorbereiten, ausführen, prüfen

Ein Test hat drei Abschnitte, und es lohnt sich, sie sichtbar zu lassen.

Vorbereiten, ausführen, prüfen
import { describe, test } from "node:test";
import assert from "node:assert/strict";

function neueListe() {
  const eintraege = [];
  return {
    anlegen: (text) => eintraege.push({ id: eintraege.length + 1, text }),
    alle: () => [...eintraege],
  };
}

describe("ein Zustand für alle Tests", () => {
  // Sieht sparsam aus.
  const liste = neueListe();

  test("legt die erste Notiz an", () => {
    liste.anlegen("Milch kaufen");
    assert.equal(liste.alle().length, 1);
  });

  test("legt eine Notiz mit der Kennung 1 an", () => {
    liste.anlegen("Brot holen");
    assert.equal(liste.alle().at(-1).id, 1);
  });
});

describe("jeder Test bereitet selbst vor", () => {
  test("legt die erste Notiz an", () => {
    // vorbereiten
    const liste = neueListe();

    // ausfuehren
    liste.anlegen("Milch kaufen");

    // pruefen
    assert.equal(liste.alle().length, 1);
  });

  test("legt eine Notiz mit der Kennung 1 an", () => {
    const liste = neueListe();

    liste.anlegen("Brot holen");

    assert.equal(liste.alle().at(-1).id, 1);
  });
});

Die erste Gruppe spart sich das Vorbereiten und legt den Zustand einmal für beide Tests an. Das geht nur so lange gut, wie kein Test etwas verändert, und Tests verändern ständig etwas. Hier sieht der zweite eine Notiz, die der erste angelegt hat.

Der rote Test meldet 2 !== 1 bei der Kennung, obwohl anlegen richtig zählt. Falsch ist der Zustand, mit dem er anfängt. So landest du bei der Suche auf der falschen Fährte. Ob er rot oder grün ist, hängt an der Reihenfolge.

Die zweite Gruppe baut in jedem Test frisch auf, jeder Test bringt also alles mit, was er braucht. Das sind zwei Zeilen mehr, und dafür lässt sich jeder Test für sich lesen und für sich starten, egal in welcher Reihenfolge die anderen laufen.

Wie ein Testname aussieht

Wird ein Test rot, ist sein Name das Erste, was du liest. Im besten Fall reicht er schon.

gibt bei einer leeren Liste 0 zurück beschreibt Verhalten. Steht dieser Test rot in der Bilanz, ist klar, was nicht mehr stimmt, und niemand muss dafür den Test öffnen. durchschnitt, test 2 und funktioniert sagen dagegen nichts, der erste nennt nur die Funktion. Heißen zwölf Tests funktioniert, ist die Bilanz am Ende nur noch eine Zahl.

Ich lasse den Namen mit einem Verb anfangen und schreibe hinein, was herauskommt, nicht was hineingeht. wirft bei negativem Preis steht dann für sich, negativer Preis nicht.

Warum Tests nicht auf Interna schauen

Ein Test auf Interna und was er kostet
import { describe, test } from "node:test";
import assert from "node:assert/strict";

// Dieselbe Notizliste, zweimal gebaut. Von aussen verhalten sie sich gleich.
function mitArray() {
  const eintraege = [];
  return {
    eintraege,
    anlegen(text) {
      const notiz = { id: eintraege.length + 1, text };
      eintraege.push(notiz);
      return notiz;
    },
    alle: () => [...eintraege],
  };
}

function mitMap() {
  const nach_id = new Map();
  return {
    nach_id,
    anlegen(text) {
      const notiz = { id: nach_id.size + 1, text };
      nach_id.set(notiz.id, notiz);
      return notiz;
    },
    alle: () => [...nach_id.values()],
  };
}

for (const [name, baue] of [["mit Array", mitArray], ["mit Map", mitMap]]) {
  describe(name, () => {
    test("schaut auf die Interna", () => {
      const liste = baue();
      liste.anlegen("Milch kaufen");
      assert.equal(liste.eintraege.length, 1);
    });

    test("schaut auf das Verhalten", () => {
      const liste = baue();
      liste.anlegen("Milch kaufen");
      assert.equal(liste.alle().length, 1);
    });
  });
}

Die Notizliste gibt es im Beispiel zweimal, einmal mit einem Array darin und einmal mit einer Map. Von außen verhalten sich beide gleich, und der Test auf das Verhalten ist bei beiden grün. Der Test auf die Interna bricht bei der Map mit TypeError: Cannot read properties of undefined (reading 'length'), weil es dort keine Eigenschaft eintraege mehr gibt.

Ein Test, der bei so einem Umbau rot wird, hält beim Verbessern auf und schützt dabei vor wenig. Ein alle(), das eine leere Liste liefert, bliebe bei ihm grün.

Die Prüflisten dieses Kurses sind nach demselben Gedanken gebaut. Das Programm läuft, und geprüft wird, was herauskommt. Für eigene Tests heißt das, über die Schnittstelle zu prüfen, die auch andere benutzen. Exportierte Funktionen ja, interne Hilfsfunktionen nein, Rückgabewerte ja, interne Eigenschaften nein. Lässt sich etwas nur über Interna prüfen, fehlt der Schnittstelle oft etwas.

Welche Ränder du für die beiden Funktionen der Aufgabe testest, entscheidest du selbst.

Zum Mitnehmen

Normalfall, Ränder und der Fall, der scheitern soll, gehören in jeden Testbestand. Jeder Test baut seinen Zustand selbst auf, prüft von außen und heißt nach dem, was herauskommt.

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.