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
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
# - 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
// 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
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
// 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
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
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
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
Autres extensionsRecommandations :Écrivez des tests pour la logique métier critique afin de garantir que les modifications de code n'introduisent pas de bugs.