TypeScript-Unit-Tests
Unit-Testing-Praktiken in TypeScript-Projekten zur Sicherung der Codequalität.
Unit-Tests überprüfen die Korrektheit des Codes. Das Typsystem von TypeScript lässt sich perfekt mit Test-Frameworks kombinieren, sodass Sie typsicheren Testcode schreiben können.
SVG-Diagramm: Unit-Testing-Workflow
Warum Unit-Tests benötigt werden
Unit-Testing ist ein wichtiges Mittel zur Sicherung der Codequalität. Es überprüft die Korrektheit des Codes und verhindert Fehler.
In TypeScript-Projekten profitiert auch Testcode vom Typsystem: Typfehler werden zur Kompilierungszeit erkannt, die IDE bietet intelligente Vorschläge und Testcode ist zuverlässiger.
Darüber hinaus ist Testcode auch die beste Dokumentation; durch Tests können Sie das erwartete Verhalten von Funktionen/Klassen verstehen.
Qualitätssicherung:Unit-Tests erkennen Regressionen schnell und stellen sicher, dass Codeänderungen bestehende Funktionalität nicht beeinträchtigen.
Test-Framework-Konfiguration
Jest ist das beliebteste Test-Framework für TypeScript-Projekte.
Jest installieren
# - ts-jest:Jest für die Ausführung von TypeScript aktivieren
# - @types/jest:Typdefinitionen für Jest
npm install --save-dev jest ts-jest @types/jest
# Jest-Konfiguration initialisieren
npx ts-jest config:init
ts-jest:Dies ist ein Präprozessor, der Jest TypeScript-Dateien direkt ohne manuelle Kompilierung ausführen lässt.
jest.config.js konfigurieren
Die Jest-Testumgebung konfigurieren.
jest.config.js
// Das ts-jest-Preset verwenden
preset: 'ts-jest',
// Testumgebung: node oder Browser
testEnvironment: 'node',
// Testdateiverzeichnis
roots: ['<rootDir>/src'],
// Muster für Testdateien
testMatch: ['**/__tests__/**/*.ts'],
// Unterstützte Dateiendungen
moduleFileExtensions: ['ts', 'js', 'json'],
// Dateien zum Sammeln der Coverage
collectCoverageFrom: [
'src/**/*.ts',
'!src/**/*.d.ts' // Typdeklarationsdateien ausschließen
]
}
Konfigurationshinweise:Testdateien werden normalerweise im Verzeichnis __tests__ abgelegt oder enden mit .test.ts.
Testfunktionen
Schreibe zuerst den Business-Code, der getestet werden muss.
src/utils/calculator.ts
export class Calculator {
// Addition
add(a: number, b: number): number {
return a + b;
}
// Subtraktion
subtract(a: number, b: number): number {
return a - b;
}
// Multiplikation
multiply(a: number, b: number): number {
return a * b;
}
// Division
divide(a: number, b: number): number {
if (b === 0) {
throw new Error("Division durch null nicht möglich");
}
return a / b;
}
}
Schreibe dann den entsprechenden Testcode.
src/utils/calculator.test.ts
// Testsuite: Tests für die Calculator-Klasse
describe("Calculator", () => {
let calculator: Calculator;
// Erstelle eine neue Calculator-Instanz vor jedem Test
beforeEach(() => {
calculator = new Calculator();
});
// Additionstest
describe("add", () => {
it("sollte zwei Zahlen addieren", () => {
expect(calculator.add(2, 3)).toBe(5);
});
it("sollte negative Zahlen verarbeiten", () => {
expect(calculator.add(-1, 1)).toBe(0);
});
});
// Divisionstest
describe("divide", () => {
it("sollte zwei Zahlen dividieren", () => {
expect(calculator.divide(10, 2)).toBe(5);
});
it("sollte einen Fehler werfen, wenn durch Null geteilt wird", () => {
// Erwarte, dass ein Fehler geworfen wird
expect(() => calculator.divide(10, 0)).toThrow();
});
});
});
Ausführungsergebnis:
Calculator
add
✓ should add two numbers
✓ should handle negative numbers
divide
✓ should divide two numbers
✓ should throw error when dividing by zero
describe/it:describe wird verwendet, um Tests zu gruppieren, und it (oder test) wird verwendet, um einzelne Testfälle zu definieren.
Service testen
Teste die Geschäftslogik der Service-Schicht.
src/services/userService.ts
export interface User {
id: number;
name: string;
}
// Benutzer-Serviceklasse
export class UserService {
private users: User[] = [];
private nextId = 1;
// Benutzer erstellen
createUser(name: string): User {
const user = { id: this.nextId++, name };
this.users.push(user);
return user;
}
// Benutzer abrufen
getUser(id: number): User | undefined {
return this.users.find(u => u.id === id);
}
// Alle Benutzer abrufen
getAllUsers(): User[] {
return [...this.users];
}
}
src/services/userService.test.ts
describe("UserService", () => {
let service: UserService;
beforeEach(() => {
service = new UserService();
});
describe("createUser", () => {
it("sollte einen Benutzer mit id erstellen", () => {
const user = service.createUser("Alice");
expect(user.id).toBe(1);
expect(user.name).toBe("Alice");
});
it("sollte die id für jeden Benutzer inkrementieren", () => {
const user1 = service.createUser("Alice");
const user2 = service.createUser("Bob");
expect(user2.id).toBe(user1.id + 1);
});
});
describe("getUser", () => {
it("sollte den Benutzer anhand der id zurückgeben", () => {
const created = service.createUser("Alice");
const found = service.getUser(created.id);
// Optionale Verkettung und toBe verwenden
expect(found?.name).toBe("Alice");
});
it("sollte undefined für nicht existierende id zurückgeben", () => {
const found = service.getUser(999);
expect(found).toBeUndefined();
});
});
});
Ausführungsergebnis:
UserService
createUser
✓ should create a user with id
✓ should increment id for each user
getUser
✓ should return user by id
✓ should return undefined for non-existent id
Testisolation:Jeder Testfall sollte unabhängig sein; verwende beforeEach, um sicherzustellen, dass jeder Test einen sauberen Zustand hat.
Mock
Verwende Mocks, um Abhängigkeiten wie externe APIs, Datenbanken usw. zu simulieren.
Beispiel
const mockCallback = jest.fn(x => x * 2);
// Verwende die Mock-Funktion
[1, 2, 3].forEach(mockCallback);
// Überprüfe, ob die Funktion 3 Mal aufgerufen wurde
expect(mockCallback).toHaveBeenCalledTimes(3);
// Überprüfe die Argumente, wenn die Funktion aufgerufen wurde
expect(mockCallback).toHaveBeenCalledWith(2);
// Modul mocken: Ein ganzes Modul mocken
jest.mock("./api", () => ({
fetchUser: jest.fn(() => Promise.resolve({ id: 1, name: "Alice" }))
}));
Ausführungsergebnis:
✓ mock 函数被调用 3 次
Zweck von Mocks:Wenn der getestete Code von externen Systemen abhängt, isolieren Mocks die Abhängigkeiten, sodass nur die Logik des Zielcodes getestet wird.
Hinweise
- Speicherort der Testdatei:Im Verzeichnis __tests__ ablegen oder das Suffix .test.ts verwenden
- Testbenennung:Verwende beschreibende Testnamen, die das erwartete Verhalten angeben
- Unabhängige Tests:Jeder Test sollte unabhängig ausgeführt werden, ohne sich auf andere Tests zu verlassen
- Abdeckung:Fokus auf die Testabdeckung der zentralen Geschäftslogik
Bewährte Methoden:Tests sollten schnell, zuverlässig und unabhängig voneinander sein. Befolge das AAA-Prinzip: Arrange (vorbereiten), Act (ausführen), Assert (überprüfen).
Zusammenfassung
Unit-Tests sind ein wichtiges Mittel, um die Qualität von TypeScript-Code sicherzustellen.
- Jest:Das beliebteste TypeScript-Testframework
- describe:Dient zum Gruppieren zusammengehöriger Tests
- it/test:Definiert einzelne Testfälle
- expect:Überprüft Testergebnisse
- Mock:Externe Abhängigkeiten simulieren
Andere ErweiterungenEmpfehlungen:Schreiben Sie Tests für kritische Geschäftslogik, um sicherzustellen, dass Codeänderungen keine Fehler verursachen.