1. Was ist ts-mockito und warum braucht man es?

ts-mockito ist eine leistungsstarke Bibliothek zum Erstellen von Mocks, Stubs und Spies in TypeScript. Sie ist von der populären Java-Bibliothek Mockito inspiriert und bietet ein vertrautes API für Entwickler, die von Java oder Python umsteigen. Das Hauptziel von ts-mockito ist es, das Schreiben von Unit-Tests zu vereinfachen, indem der getestete Code von externen Abhängigkeiten wie Datenbanken, HTTP-Clients, Dateisystemen und anderen Diensten isoliert wird.

Warum ist das wichtig? In modernen TypeScript-Anwendungen sind Klassen und Funktionen oft von anderen Komponenten abhängig. Ohne Mocks wird das Testen solcher Verknüpfungen zu Integrationstests, die eine Umgebungskonfiguration erfordern. ts-mockito ermöglicht es Ihnen, "falsche" Objekte mit vordefiniertem Verhalten zu erstellen und zu überprüfen, welche Methoden mit welchen Argumenten aufgerufen wurden. Das macht Tests schnell, deterministisch und leicht wartbar.

Die Bibliothek unterstützt alle wichtigen Mockito-Funktionen: Erstellen von Mocks mit mock(), Verhaltensdefinition mit when() und thenReturn(), Aufrufverifikation mit verify() sowie die Arbeit mit Spies über spy(). ts-mockito ist vollständig typisiert und lässt sich hervorragend in gängige Test-Frameworks wie Jest, Mocha und Jasmine integrieren.

2. Installation

Die Installation von ts-mockito erfolgt über npm (Node Package Manager). Führen Sie folgenden Befehl im Stammverzeichnis Ihres Projekts aus:

npm install ts-mockito --save-dev

Wenn Sie yarn verwenden:

yarn add ts-mockito --dev

Die Bibliothek hat außer TypeScript selbst (Version 4.0+) keine zwingenden Abhängigkeiten. Nach der Installation können Sie die benötigten Funktionen in Ihren Testdateien importieren:

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

Hinweis: ts-mockito verwendet Proxy-Objekte, um Aufrufe abzufangen. Das bedeutet, dass Sie immer mit "umhüllten" Objekten arbeiten, nicht mit echten Klasseninstanzen.

3. Schnellstart – Minimales Arbeitsbeispiel

Betrachten wir ein einfaches Beispiel: Wir haben eine Klasse UserService, die von UserRepository abhängt. Wir möchten die Methode getUser testen, ohne auf eine echte Datenbank zuzugreifen.

// user-repository.ts
export class UserRepository {
    async findById(id: number): Promise<{ id: number; name: string } | null> {
        // Echte Datenbankabfrage
        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('User not found');
        }
        return `User: ${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('should return user name when user exists', async () => {
        // 1. Mock des Repositorys erstellen
        const mockRepository: UserRepository = mock(UserRepository);
        
        // 2. Verhalten definieren: bei Aufruf von findById(1) ein Objekt zurückgeben
        when(mockRepository.findById(1)).thenResolve({ id: 1, name: 'Alice' });
        
        // 3. Echte Instanz des Mocks holen
        const repositoryInstance = i