Tests unitaires TypeScript

Pratiques de tests unitaires dans les projets TypeScript pour garantir la qualité du code.

Les tests unitaires vérifient l'exactitude du code. Le système de types de TypeScript se combine parfaitement avec les frameworks de test, ce qui vous permet d'écrire du code de test sûr au niveau des types.


Diagramme SVG : flux de travail des tests unitaires 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

Pourquoi les tests unitaires sont nécessaires

Les tests unitaires sont un moyen important de garantir la qualité du code. Ils vérifient l'exactitude du code et préviennent les bogues.

Dans les projets TypeScript, le code de test bénéficie également du système de types : les erreurs de type sont détectées au moment de la compilation, l'IDE fournit des suggestions intelligentes et le code de test est plus fiable.

De plus, le code de test est aussi la meilleure documentation ; vous pouvez comprendre le comportement attendu des fonctions/classes grâce aux tests.

Assurance qualité :Les tests unitaires identifient rapidement les problèmes de régression, garantissant que les modifications du code ne cassent pas les fonctionnalités existantes.


Configuration du framework de test

Jest est le framework de test le plus populaire pour les projets TypeScript.

Installer Jest

# Installer Jest et les dépendances associées
# - ts-jest:Permettre à Jest d'exécuter TypeScript
# - @types/jest:Définitions de types pour Jest
npm install --save-dev jest ts-jest @types/jest

# Initialiser la configuration Jest
npx ts-jest config:init

ts-jest:Il s'agit d'un préprocesseur qui permet à Jest d'exécuter directement les fichiers TypeScript sans compilation manuelle.


Configurer jest.config.js

Configurer l'environnement de test Jest.

jest.config.js

module.exports = {
    // Utiliser le préréglage ts-jest
    preset: 'ts-jest',
    // Environnement de test : node ou navigateur
    testEnvironment: 'node',
    // Répertoire des fichiers de test
    roots: ['<rootDir>/src'],
    // Motif de correspondance des fichiers de test
    testMatch: ['**/__tests__/**/*.ts'],
    // Extensions de fichiers prises en charge
    moduleFileExtensions: ['ts', 'js', 'json'],
    // Fichiers pour collecter la couverture
    collectCoverageFrom: [
        'src/**/*.ts',
        '!src/**/*.d.ts'  // Exclure les fichiers de déclaration de type
    ]
}

Notes de configuration :Les fichiers de test sont généralement placés dans le répertoire __tests__ ou se terminent par .test.ts.


Fonctions de test

Tout d'abord, écrivez le code métier qui doit être testé.

src/utils/calculator.ts

// Classe Calculator
export class Calculator {
    // Addition
    add(a: number, b: number): number {
        return a + b;
    }

    // Soustraction
    subtract(a: number, b: number): number {
        return a - b;
    }

    // Multiplication
    multiply(a: number, b: number): number {
        return a * b;
    }

    // Division
    divide(a: number, b: number): number {
        if (b === 0) {
            throw new Error("Impossible de diviser par zéro");
        }
        return a / b;
    }
}

Ensuite, écrivez le code de test correspondant.

src/utils/calculator.test.ts

import { Calculator } from "./calculator";

// Suite de tests : tests pour la classe Calculator
describe("Calculator", () => {
    let calculator: Calculator;

    // Créer une nouvelle instance de Calculator avant chaque test
    beforeEach(() => {
        calculator = new Calculator();
    });

    // Test d'addition
    describe("add", () => {
        it("devrait additionner deux nombres", () => {
            expect(calculator.add(2, 3)).toBe(5);
        });

        it("devrait gérer les nombres négatifs", () => {
            expect(calculator.add(-1, 1)).toBe(0);
        });
    });

    // Test de division
    describe("divide", () => {
        it("devrait diviser deux nombres", () => {
            expect(calculator.divide(10, 2)).toBe(5);
        });

        it("devrait lever une erreur lors d'une division par zéro", () => {
            // S'attendre à ce qu'une erreur soit levée
            expect(() => calculator.divide(10, 0)).toThrow();
        });
    });
});

Résultat de l'exécution :

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 est utilisé pour regrouper des tests, et it (ou test) est utilisé pour définir des cas de test individuels.


Tester le service

Tester la logique métier de la couche Service.

src/services/userService.ts

// Type User
export interface User {
    id: number;
    name: string;
}

// Classe de service utilisateur
export class UserService {
    private users: User[] = [];
    private nextId = 1;

    // Créer un utilisateur
    createUser(name: string): User {
        const user = { id: this.nextId++, name };
        this.users.push(user);
        return user;
    }

    // Récupérer l'utilisateur
    getUser(id: number): User | undefined {
        return this.users.find(u => u.id === id);
    }

    // Obtenir tous les utilisateurs
    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("doit créer un utilisateur avec id", () => {
            const user = service.createUser("Alice");
            expect(user.id).toBe(1);
            expect(user.name).toBe("Alice");
        });

        it("devrait incrémenter l'id pour chaque utilisateur", () => {
            const user1 = service.createUser("Alice");
            const user2 = service.createUser("Bob");
            expect(user2.id).toBe(user1.id + 1);
        });
    });

    describe("getUser", () => {
        it("devrait retourner l'utilisateur par id", () => {
            const created = service.createUser("Alice");
            const found = service.getUser(created.id);
            // Utiliser le chaînage optionnel et toBe
            expect(found?.name).toBe("Alice");
        });

        it("devrait renvoyer undefined pour un id inexistant", () => {
            const found = service.getUser(999);
            expect(found).toBeUndefined();
        });
    });
});

Résultat de l'exécution :

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

Isolation des tests :Chaque cas de test doit être indépendant ; utilisez beforeEach pour garantir que chaque test dispose d'un état propre.


Mock

Utilisez des mocks pour simuler des dépendances, telles que des API externes, des bases de données, etc.

Exemple

// Fonction mock : créer une fonction mock
const mockCallback = jest.fn(x => x * 2);

// Utiliser la fonction mock
[1, 2, 3].forEach(mockCallback);

// Vérifier que la fonction a été appelée 3 fois
expect(mockCallback).toHaveBeenCalledTimes(3);
// Vérifier les arguments lorsque la fonction a été appelée
expect(mockCallback).toHaveBeenCalledWith(2);

// Module mock : Simuler un module entier
jest.mock("./api", () => ({
    fetchUser: jest.fn(() => Promise.resolve({ id: 1, name: "Alice" }))
}));

Résultat de l'exécution :

✓ mock 函数被调用 3 次

Objectif des mocks :Lorsque le code testé dépend de systèmes externes, l'utilisation de mocks isole les dépendances afin que seule la logique du code cible soit testée.


Notes

  • Emplacement du fichier de test :Placez-le dans le répertoire __tests__ ou utilisez le suffixe .test.ts
  • Nommage des tests :Utilisez des noms de tests descriptifs qui indiquent le comportement attendu
  • Tests indépendants :Chaque test doit s'exécuter indépendamment sans dépendre d'autres tests
  • Couverture :Concentrez-vous sur la couverture de tests de la logique métier principale

Bonnes pratiques :Les tests doivent être rapides, fiables et indépendants les uns des autres. Suivez le principe AAA : Arrange (préparer), Act (exécuter), Assert (vérifier).


Résumé

Les tests unitaires sont un moyen important de garantir la qualité du code TypeScript.

  • Jest:Le framework de test TypeScript le plus populaire
  • describe:Utilisé pour regrouper des tests associés
  • it/test:Définir des cas de test individuels
  • expect:Vérifier les résultats des tests
  • Mock:Simuler les dépendances externes

Recommandations :Écrivez des tests pour la logique métier critique afin de garantir que les modifications de code n'introduisent pas de bugs.

Autres extensions