1. Qu'est-ce que ts-mockito et pourquoi l'utiliser ?

ts-mockito est une bibliothèque puissante pour créer des mocks, des stubs et des espions (spy) en TypeScript. Inspirée de la célèbre bibliothèque Java Mockito, elle offre une API familière aux développeurs venant de Java ou Python. L'objectif principal de ts-mockito est de simplifier l'écriture de tests unitaires en isolant le code testé des dépendances externes : bases de données, clients HTTP, systèmes de fichiers et autres services.

Pourquoi en avez-vous besoin ? Dans les applications TypeScript modernes, les classes et fonctions dépendent souvent d'autres composants. Sans mocks, tester ces interactions revient à faire des tests d'intégration, nécessitant une configuration d'environnement complexe. ts-mockito vous permet de créer des objets "factices" avec un comportement prédéfini, et de vérifier quels méthodes ont été appelées et avec quels arguments. Résultat : des tests rapides, déterministes et faciles à maintenir.

La bibliothèque prend en charge toutes les fonctionnalités essentielles de Mockito : création de mocks avec mock(), configuration du comportement avec when() et thenReturn(), vérification des appels avec verify(), et utilisation d'espions avec spy(). ts-mockito est entièrement typée et s'intègre parfaitement avec les frameworks de test populaires comme Jest, Mocha et Jasmine.

2. Installation

L'installation de ts-mockito se fait via npm (Node Package Manager). Exécutez la commande suivante à la racine de votre projet :

npm install ts-mockito --save-dev

Si vous utilisez yarn :

yarn add ts-mockito --dev

La bibliothèque n'a pas de dépendances obligatoires, en dehors de TypeScript lui-même (version 4.0+). Après l'installation, vous pouvez importer les fonctions nécessaires dans vos fichiers de test :

import { mock, when, verify, instance, anything, anyOfClass, deepEqual, spy } from 'ts-mockito';

Note importante : ts-mockito utilise des objets proxy pour intercepter les appels. Cela signifie que vous travaillez toujours avec des objets "enveloppés", et non avec des instances réelles de classes.

3. Démarrage rapide — un exemple minimal fonctionnel

Prenons un exemple simple : une classe UserService qui dépend de UserRepository. Nous voulons tester la méthode getUser sans accéder à une vraie base de données.

// user-repository.ts
export class UserRepository {
    async findById(id: number): Promise<{ id: number; name: string } | null> {
        // Requête réelle à la base de données
        return null;
    }
}

// user-service.ts
export class UserService {
    constructor(private repository: UserRepository) {}

    async getUser(id: number): Promise<string> {
        const user = await this.repository.findById(id);
        if (!user) {
            throw new Error('Utilisateur non trouvé');
        }
        return `Utilisateur : ${user.name}`;
    }
}

// user-service.spec.ts
import { mock, when, instance, verify, anything } from 'ts-mockito';
import { UserService } from './user-service';
import { UserRepository } from './user-repository';

describe('UserService', () => {
    it('doit retourner le nom de l\'utilisateur quand il existe', async () => {
        // 1. Création du mock du repository
        const mockRepository: UserRepository = mock(UserRepository);
        
        // 2. Configuration du comportement : quand findById(1) est appelé, retourner un objet
        when(mockRepository.findById(1)).thenResolve({ id: 1, name: 'Alice' });
        
        // 3. Obtention de l'instance réelle du mock
        const repositoryInstance = i