Testgetriebene Entwicklung (TDD) mit Bun Test

Testgetriebene Entwicklung (TDD) ist eine leistungsstarke Methode zum Schreiben von sauberem, fehlerfreiem Code. In diesem Artikel untersuchen wir, wie man TDD mit Buns integriertem Testläufer Bun Test implementiert, der für seine Geschwindigkeit und Einfachheit bekannt ist.

Was ist TDD?

Testgetriebene Entwicklung (TDD) ist eine Softwareentwicklungspraxis, bei der Tests vor dem Code geschrieben werden. Die TDD-Praxis leitet die Implementierung und stellt die Funktionalität durch iterative Schreib-, Test- und Refactoring-Zyklen sicher.

TDD ist ein Entwicklungsprozess, der diesen Schritten folgt:

• Schreiben Sie einen Test für die gewünschte Funktionalität.
• Definieren Sie alle Testszenarien, die Sie abdecken möchten.
• Führen Sie den Test aus und stellen Sie sicher, dass er fehlschlägt (da die Funktionalität möglicherweise unvollständig ist oder noch nicht alle Szenarien abdeckt).
• Aktualisieren und überarbeiten Sie den Code, damit der Test erfolgreich ist und gleichzeitig sichergestellt wird, dass alle Tests erfolgreich sind.

Dieser iterative Prozess soll robusten und gut getesteten Code erzeugen.

Einrichten Ihres JavaScript-Projekts mit Bun

Wenn Sie Bun nicht installiert haben, installieren Sie es, indem Sie den Anweisungen in der Bun-JavaScript-Dokumentation folgen.
Initialisieren Sie dann ein neues Projekt:

bun init

➜  example bun init
bun init helps you get started with a minimal project and tries to guess sensible defaults. Press ^C anytime to quit

package name (example):
entry point (index.ts):

Done! A package.json file was saved in the current directory.

Erstellen Sie eine Testdatei im Testverzeichnis (z. B. tests/example.test.js). Bun erkennt zum Testen automatisch Dateien, die mit .test.ts oder .test.js enden.

mkdir tests
touch tests/example.test.js

Schreiben Sie Ihren ersten Test

Beginnen wir mit einem einfachen Beispiel.
Wir erstellen eine Rechnerdatei, um einige mathematische Funktionen zu implementieren.
Wir konzentrieren uns zunächst auf eine einfache Funktion wie sum(), auch wenn JavaScript bereits über einen nativen Additionsoperator verfügt. Dadurch können wir uns auf die Strukturierung der Tests konzentrieren und nicht auf die Komplexität der Logik.
Hier ist der Plan:

• Erstellen Sie eine Rechner.ts-Datei, in der wir eine sum()-Funktion definieren, die zunächst 0 zurückgibt.
• Schreiben Sie Tests für die Funktion sum(), die mehrere Testfälle abdecken.
• Führen Sie die Tests aus und bestätigen Sie, dass sie fehlschlagen.
• Aktualisieren Sie die Logik der sum()-Funktion, damit die Tests erfolgreich sind.
• Führen Sie die Tests erneut durch, um sicherzustellen, dass unsere Implementierung korrekt ist.

Erstellen Sie Ihre Rechner.test.js-Datei

In der Datei „tests/calculator.test.js“ können Sie Ihre Tests implementieren:

import { describe, expect, it } from "bun:test";
import { sum } from "../calculator";

describe("sum function", () => {
  it("should return the sum of two numbers (both are positive)", () => {
    expect(sum(2, 3)).toBe(5);
  });
  it("should return the sum of two numbers (one is negative)", () => {
    expect(sum(-1, 2)).toBe(1);
  });
});

Diese Tests überprüfen das Verhalten der sum()-Funktion, die im Taschenrechnermodul definiert ist. Die Tests werden mithilfe der Testbibliothek von Bun geschrieben und in einem Beschreibungsblock namens „Summenfunktion“ organisiert. Der „describe()“-Block hilft dabei, „ähnliche“ Tests zu gruppieren. Jeder it()-Block gibt ein bestimmtes Szenario zum Testen an. Hier erfahren Sie, was jeder Test bewirkt:

1. Test: Addition zweier positiver Zahlen
   • Beschreibung: „sollte die Summe zweier Zahlen zurückgeben (beide sind positiv)“
   • Dieser Test prüft, ob die Summenfunktion die Summe zweier positiver Ganzzahlen korrekt berechnet.
   • Beispiel: sum(2, 3) soll erwartet 5 zurückgeben.
2. Test: Addieren einer negativen und einer positiven Zahl
   • Beschreibung: „sollte die Summe zweier Zahlen zurückgeben (eine ist negativ)“
   • Dieser Test validiert, dass die Summenfunktion ein Szenario, in dem eine Zahl negativ ist, korrekt verarbeitet.
   • Beispiel: sum(-1, 2) soll erwartet 1 zurückgeben.

Diese Tests stellen sicher, dass sich die Summenfunktion wie erwartet für grundlegende Additionsszenarien verhält und sowohl positive Zahlen als auch gemischte (positive und negative) Eingaben abdeckt.

Erstellen Sie Ihre Rechner.ts-Datei

Jetzt können Sie Ihr Rechnermodul erstellen, das die sum()-Funktion exportiert.
In der Rechner.ts-Datei:

bun init

Die erste Version der Funktion gibt einen fest codierten Wert zurück, daher erwarte ich, dass die Tests fehlschlagen.
Ausführen der Tests:

➜  example bun init
bun init helps you get started with a minimal project and tries to guess sensible defaults. Press ^C anytime to quit

package name (example):
entry point (index.ts):

Done! A package.json file was saved in the current directory.

Jetzt können wir die Logik der sum()-Funktion im Rechner anpassen.ts passen die Logik der sum()-Funktion an:

mkdir tests
touch tests/example.test.js

Wenn Sie nun die Tests durchführen, haben Sie einen „grünen“ ✅ Status.

Refactoring-Tests mit Datensatz

Wenn Sie dieselben Tests mit unterschiedlichen Szenarien (Eingabewerten) ausführen möchten, können Sie die Methode every() verwenden.

import { describe, expect, it } from "bun:test";
import { sum } from "../calculator";

describe("sum function", () => {
  it("should return the sum of two numbers (both are positive)", () => {
    expect(sum(2, 3)).toBe(5);
  });
  it("should return the sum of two numbers (one is negative)", () => {
    expect(sum(-1, 2)).toBe(1);
  });
});

Mit einem datensatzgesteuerten Ansatz testet dieser Code die Summenfunktion des Taschenrechnermoduls. Die Methode it.each() wird verwendet, um sich wiederholende Testfälle durch Iteration über einen Datensatz mit Eingaben und erwarteten Ausgaben zu vereinfachen. Hier ist eine Aufschlüsselung, wie es funktioniert:

Zuerst können Sie einen Datensatz definieren

export function sum(a: number, b: number) {
  // Function yet to be implemented
  return 0;
}

Der Datensatz ist ein Array von Arrays. Jedes innere Array stellt einen Testfall dar, wobei die Elemente Folgendes entsprechen:

• a (erste hinzuzufügende Zahl),
• b (zweite hinzuzufügende Zahl),
• erwartet (das erwartete Ergebnis von sum(a, b)).

Die Beschreibungsfunktion gruppiert alle Tests, die sich auf die Summenfunktion beziehen, zur besseren Organisation in einem einzigen Block.

Im write()-Block it.each(dataset) iteriert über jede Zeile im Datensatzarray.
„Summe von %d und %d sollte %d sein“ ist eine Beschreibungsvorlage für den Test, bei der %d bei jeder Iteration durch die tatsächlichen Zahlen aus dem Datensatz ersetzt wird.
Beispielsweise generiert die erste Iteration die Beschreibung: „Die Summe aus 2 und 3 sollte 5 sein“.

In der Rückruffunktion (a, b, erwartet) werden die Elemente jeder Zeile im Datensatz in Variablen zerlegt: a, b und erwartet. Anschließend wird innerhalb des Tests die Summenfunktion mit a und b aufgerufen und das Ergebnis mit „expect()“ überprüft, um sicherzustellen, dass es mit den Erwartungen übereinstimmt.

Warum it.each() (oder test.each()) verwenden?

• Effizienz: Anstatt für jeden Fall separate it()- oder test()-Blöcke zu schreiben, können Sie alle Testfälle in einem einzigen Datensatz definieren und diese durchlaufen.
• Lesbarkeit: Die Testlogik ist prägnant und der Datensatz erleichtert das Hinzufügen oder Ändern von Testfällen, ohne dass Code dupliziert werden muss.
• Skalierbarkeit: nützlich beim Umgang mit mehreren Testfällen, insbesondere wenn die getestete Logik in allen Fällen ähnlich ist.

Ein weiteres praktisches Beispiel: die Berechnung des Mittelwerts

Um ein zusätzliches Beispiel für TDD zu zeigen, implementieren wir eine Mittelwertfunktion im Rechnermodul, die den Mittelwert (Durchschnitt) eines Zahlenarrays berechnet. Nach dem TDD-Ansatz beginnen wir mit dem Schreiben der Tests.

Fügen Sie in der bereits vorhandenen Datei „calculator.test.js“ diese spezifischen Tests für die Funktion „mean()“ hinzu:

bun init

Fügen Sie nun in der Datei „calculator.ts“ die Funktion „mean()“ hinzu:

➜  example bun init
bun init helps you get started with a minimal project and tries to guess sensible defaults. Press ^C anytime to quit

package name (example):
entry point (index.ts):

Done! A package.json file was saved in the current directory.

Jetzt können Sie die Tests erneut durchführen

mkdir tests
touch tests/example.test.js

Alle Tests sollten bestanden werden.
In diesem Fall ist die Implementierung bereits getestet, sodass kein weiteres Refactoring erforderlich ist. Nehmen Sie sich jedoch immer die Zeit, Ihren Code auf Verbesserungen zu überprüfen.

Testabdeckung

Testabdeckung ist eine Metrik, die den Prozentsatz Ihrer Codebasis misst, der während automatisierter Tests ausgeführt wird. Es bietet Erkenntnisse darüber, wie gut Ihre Tests Ihren Code validieren.
Die Bun-Testabdeckung hilft dabei, die „Leitungsabdeckung“ zu ermitteln.
Die Zeilenabdeckung prüft, ob jede Codezeile während der Testsuite ausgeführt wird.

Durchführen der Testabdeckung:

import { describe, expect, it } from "bun:test";
import { sum } from "../calculator";

describe("sum function", () => {
  it("should return the sum of two numbers (both are positive)", () => {
    expect(sum(2, 3)).toBe(5);
  });
  it("should return the sum of two numbers (one is negative)", () => {
    expect(sum(-1, 2)).toBe(1);
  });
});

Warum ist Versicherungsschutz wichtig?

• Erkennen von Testlücken: Abdeckungsberichte zeigen auf, welche Teile Ihres Codes nicht getestet wurden. Dadurch können Sie sicherstellen, dass kritische Logik nicht übersehen wird.
• Verbesserung der Codequalität: Eine hohe Abdeckung stellt sicher, dass Randfälle, Fehlerbehandlung und Geschäftslogik gründlich getestet werden, wodurch die Wahrscheinlichkeit von Fehlern verringert wird.
• Vertrauen beim Refactoring: Wenn Sie über eine gut getestete Codebasis verfügen, können Sie das Refactoring mit Zuversicht durchführen, da Sie wissen, dass Ihre Tests Regressionen erkennen.
• Bessere Wartung: Eine Codebasis mit hoher Testabdeckung ist einfacher zu warten, da Sie bei Aktualisierungen unbeabsichtigte Änderungen oder Nebenwirkungen erkennen können.
• Unterstützt TDD: Für Entwickler, die testgetriebene Entwicklung praktizieren, stellt die Überwachungsabdeckung sicher, dass die Tests mit der Implementierung übereinstimmen.

Deckungsziele ausbalancieren

Eine hohe Testabdeckung ist zwar wichtig, aber nicht das einzige Maß für die Codequalität. Streben Sie nach aussagekräftigen Tests, die sich auf Funktionalität, Grenzfälle und kritische Teile Ihrer Anwendung konzentrieren. Eine 100-prozentige Abdeckung zu erreichen ist ideal, aber nicht auf Kosten unnötiger oder trivialer Tests.

Abschluss

Testgetriebene Entwicklung (TDD) mit Bun Test ermöglicht es Entwicklern, sauberen, wartbaren und robusten Code zu schreiben, indem sie sich zuerst auf die Anforderungen konzentrieren und die Funktionalität durch iteratives Testen sicherstellen. Durch die Nutzung der schnellen und effizienten Testtools von Bun können Sie Ihren Entwicklungsprozess rationalisieren und Randfälle sicher bewältigen. Die Einführung von TDD verbessert nicht nur die Codequalität, sondern fördert auch die Einstellung, von Anfang an testbaren, modularen Code zu schreiben. Fangen Sie klein an, wiederholen Sie häufig und lassen Sie sich von Ihren Tests bei der Implementierung leiten.

Das obige ist der detaillierte Inhalt vonTestgetriebene Entwicklung (TDD) mit Bun Test. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!