Wie testest du NestJS-Anwendungen?

Question

Accepted Answer

NestJS bietet ein integriertes **Test-Utility (`@nestjs/testing`)**, das mit Jest integriert ist, und seine **Dependency-Injection-Architektur macht Tests besonders sauber** — du erstellst ein Test-Modul und injizierst Mocks für Abhängigkeiten. Tests fallen in Unit-Tests (isoliert) und E2E-Tests (vollständige App).

## Unit-Tests eines Service (mit Mock-Abhängigkeiten)

```ts
import { Test } from "@nestjs/testing";

describe("UsersService", () => {
  let service: UsersService;
  let mockRepo = { find: jest.fn(), save: jest.fn() };

beforeEach(async () => {
    const module = await Test.createTestingModule({
      providers: [
        UsersService,
        // inject a MOCK for the repository — no real database needed
        { provide: getRepositoryToken(User), useValue: mockRepo },
      ],
    }).compile();

service = module.get<UsersService>(UsersService);
  });

it("returns all users", async () => {
    mockRepo.find.mockResolvedValue([{ id: 1, name: "Ann" }]);
    const result = await service.findAll();
    expect(result).toHaveLength(1);
    expect(mockRepo.find).toHaveBeenCalled();
  });
});
```

Der Hauptvorteil: NestJS's DI ermöglicht es dir, **echte Abhängigkeiten durch Mocks auszutauschen** über die Provider des Test-Moduls — sodass du den Service isoliert testest, ohne echte Datenbank oder externe Services.

## Mock-Abhängigkeiten einfach austauschen

```ts
// provide a fake for ANY dependency by its token
{ provide: EmailService, useValue: { send: jest.fn() } }
{ provide: ConfigService, useValue: { get: () => "test-value" } }
```

Da Klassen ihre Abhängigkeiten nicht selbst konstruieren (DI übernimmt das), ist das Ersetzen durch Mocks trivial — die Grundlage für saubere Unit-Tests.

## End-to-End (E2E) Tests — die vollständige App über HTTP

```ts
import * as request from "supertest";

describe("Users (e2e)", () => {
  let app: INestApplication;

beforeAll(async () => {
    const module = await Test.createTestingModule({
      imports: [AppModule],        // the whole app
    }).compile();
    app = module.createNestApplication();
    await app.init();
  });

it("GET /users", () => {
    return request(app.getHttpServer())   // make a real HTTP request
      .get("/users")
      .expect(200)
      .expect(res => expect(res.body).toBeInstanceOf(Array));
  });

afterAll(async () => await app.close());
});
```

**E2E-Tests** starten die vollständige Anwendung und machen echte HTTP-Anfragen (via `supertest`), um zu überprüfen, dass der gesamte Ablauf (Routing → Guards → Pipes → Handler → Response) zusammen funktioniert.

## Test-Strategie

```text
Unit tests  → services, guards, pipes in isolation (mock dependencies) — fast, numerous
Integration → a controller + its real service together via the testing module
E2E tests   → full app over HTTP (supertest) — verify real request flows, fewer
Use a TEST database (or mocks) for e2e; override providers for external services.
```

## Warum es wichtig ist

Testen ist essentiell für zuverlässige Anwendungen, und NestJS's Architektur macht es besonders sauber — zu verstehen, wie man testet, ist wichtig sowohl für Code-Qualität als auch weil das Framework *für Testbarkeit entworfen* ist.

Die zentrale Erkenntnis ist, dass **Dependency Injection das Mocken trivial macht**: Da Klassen ihre Abhängigkeiten deklarieren und DI sie bereitstellt, kannst du mit dem `@nestjs/testing`-Modul jede Abhängigkeit (Datenbank-Repositories, externe Services, Konfiguration) über deren Token durch einen Mock austauschen, was schnelle, isolierte **Unit-Tests** von Services, Guards und Pipes ohne echte Infrastruktur ermöglicht.

Diese Testbarkeit ist ein Hauptgrund, warum DI-basierte Frameworks wie NestJS geschätzt werden.

Ergänzend zu Unit-Tests überprüfen **E2E-Tests** (Starten der vollständigen App und echte HTTP-Anfragen via `supertest`), dass die gesamte Request-Pipeline — Routing, Guards, Validierung, Handler — korrekt zusammen funktioniert.

Die Test-Utilities (`Test.createTestingModule`, Provider-Overrides zum Mocken) zu kennen, zu wissen, wie man Unit- und E2E-Tests schreibt, und eine sinnvolle Test-Strategie zu haben (viele schnelle isolierte Unit-Tests, weniger vollständige E2E-Tests, eine Test-Datenbank) ist ein Kennzeichen professioneller NestJS-Entwicklung.

Es spiegelt reife Engineeringpraxis wider und nutzt genau das, was das strukturierte, DI-getriebene Design von NestJS wertvoll macht, was es zu einem wichtigen Senior-Level-Thema macht.