Tests en TypeScript : Guide complet des frameworks et outils

Tests en TypeScript : Frameworks et outils pour un développement de qualité

TypeScript est un langage puissant qui ajoute le typage statique à JavaScript. Cependant, même des types stricts ne garantissent pas l'absence d'erreurs logiques. Pour assurer la fiabilité du code, il est nécessaire d'utiliser des tests. Dans cet article, nous allons passer en revue les outils et frameworks clés pour tester les applications TypeScript : des tests unitaires aux tests de bout en bout (E2E).

Pourquoi tester le code TypeScript ?

Le compilateur TypeScript détecte les erreurs de type, mais ne vérifie pas la logique métier. Les tests aident à :

• Détecter les régressions lors du refactoring
• Documenter le comportement attendu des fonctions
• Accélérer les revues de code grâce à une vérification automatique
• Augmenter la confiance dans le fonctionnement de l'application

Catégories principales de tests

• Tests unitaires — vérification de fonctions, classes ou modules individuels.
• Tests d'intégration — interaction entre modules (par exemple, avec une base de données).
• Tests E2E — simulation des actions de l'utilisateur dans le navigateur.

1. Jest — framework universel pour les tests unitaires

Jest de Facebook est le choix le plus populaire pour TypeScript. Il fonctionne « prêt à l'emploi » : ne nécessite pas de configuration complexe, dispose d'un moteur de simulation (mock) intégré et d'un rapport de couverture de code.

Installation :

npm install --save-dev jest @types/jest ts-jest

Ajoutez dans jest.config.ts :

export default {  preset: 'ts-jest',  testEnvironment: 'node',};

Exemple de test unitaire pour une fonction :

// math.tsexport const add = (a: number, b: number): number => a + b;

// math.test.tsimport { add } from './math';

describe('add', () => {  it('should return sum of two numbers', () => {    expect(add(2, 3)).toBe(5);  });

  it('should handle negative numbers', () => {    expect(add(-1, -2)).toBe(-3);  });});

Mocks (simulations) dans Jest :

// api.tsexport const fetchData = async (id: string) => {  const response = await fetch(`/api/${id}`);  return response.json();};

// api.test.tsjest.mock('./api', () => ({  fetchData: jest.fn().mockResolvedValue({ id: '1', name: 'Test' }),}));

import { fetchData } from './api';

test('should return mocked data', async () => {  const data = await fetchData('1');  expect(data.name).toBe('Test');});

2. Mocha + Chai — une alternative flexible

Mocha est un exécuteur de tests qui offre un contrôle total sur le processus. Chai ajoute des assertions expressives.

Installation :

npm install --save-dev mocha chai @types/mocha @types/chai ts-node

Exemple de test d'intégration asynchrone :

// database.tsexport class Database {  async getUser(id: number): Promise<{ id: number; name: string }> {    // simulation de requête    return { id, name: 'Alice' };  }}

// database.test.tsimport { expect } from 'chai';import { Database } from './database';

describe('Database', () => {  it('should return user by id', async () => {    const db = new Database();    const user = await db.getUser(1);    expect(user).to.have.property('name', 'Alice');  });});

Pour exécuter, utilisez la commande mocha --require ts-node/register src/**/*.test.ts.

3. Cypress — tests E2E pour les applications web

Cypress est idéal pour tester le frontend en TypeScript. Il fonctionne dans un navigateur réel et dispose d'une interface graphique pratique.

Installation :

npm install --save-dev cypress @cypress/types

Exemple de test E2E pour une page de connexion