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 Background Title TypeScript Unit Testing Workflow Source Code Source Code src/utils/calculator.ts src/services/userService.ts Complete Type Annotations Arrow Test Code Test Code *.test.ts describe() / it() expect() Assertion Arrow Test Result Test Result ✓ Passed / ✗ Failed Coverage Report Error Stack Trace Lower Section: Testing Principles Unit Testing Principles Principle 1 Each test verifies only one thing Principle 2 Arrange-Act-Assert Structure Principle 3 Tests should be independent of each other Arrow Marker

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

# Jest und zugehörige Abhängigkeiten 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

module.exports = {
    // 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

// Calculator-Klasse
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

import { Calculator } from "./calculator";

// 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

// User-Typ
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

import { UserService } from "./userService";

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

// Mock-Funktion: Erstelle eine Mock-Funktion
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

Empfehlungen:Schreiben Sie Tests für kritische Geschäftslogik, um sicherzustellen, dass Codeänderungen keine Fehler verursachen.

Andere Erweiterungen