Bagaimana Anda menguji aplikasi NestJS?

Question

Accepted Answer

NestJS menyediakan **utilitas pengujian bawaan (`@nestjs/testing`)** yang terintegrasi dengan Jest, dan **arsitektur dependency-injection-nya membuat pengujian sangat bersih** — Anda membuat modul pengujian dan menyuntikkan mock untuk dependensi. Tes terbagi menjadi tes unit (terisolasi) dan tes e2e (aplikasi lengkap).

## Pengujian unit dari service (dengan dependensi yang di-mock)

```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();
  });
});
```

Keuntungan utama: DI NestJS memungkinkan Anda **menukar dependensi nyata dengan mock** melalui provider modul pengujian — jadi Anda menguji service secara terisolasi, tanpa database nyata atau layanan eksternal.

## Mock dependensi dengan mudah

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

Karena class tidak membangun dependensi mereka sendiri (DI yang melakukannya), mengganti mock sangat mudah — fondasi dari tes unit yang bersih.

## Pengujian end-to-end (e2e) — aplikasi lengkap melalui 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());
});
```

**Tes E2E** bootstrap aplikasi lengkap dan membuat permintaan HTTP nyata (melalui `supertest`), memverifikasi seluruh alur (routing → guards → pipes → handler → response) bekerja bersama.

## Strategi pengujian

```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.
```

## Mengapa ini penting

Pengujian sangat penting untuk aplikasi yang dapat diandalkan, dan arsitektur NestJS membuatnya sangat bersih — memahami cara menguji penting baik untuk kualitas kode maupun karena framework ini *dirancang* untuk testability.

Wawasan utamanya adalah bahwa **dependency injection membuat mocking trivial**: karena class mendeklarasikan dependensi mereka dan DI menyediakannya, modul `@nestjs/testing` memungkinkan Anda menukar dependensi apa pun (repository database, layanan eksternal, config) dengan mock berdasarkan tokennya, memungkinkan **tes unit** yang cepat dan terisolasi dari services, guards, dan pipes tanpa infrastruktur nyata.

Testability ini adalah alasan utama framework berbasis DI seperti NestJS sangat dihargai.

Melengkapi tes unit, **tes e2e** (bootstrap aplikasi lengkap dan membuat permintaan HTTP nyata melalui `supertest`) memverifikasi bahwa seluruh pipeline permintaan — routing, guards, validasi, handlers — bekerja bersama dengan benar.

Mengetahui utilitas pengujian (`Test.createTestingModule`, provider override untuk mocking), cara menulis tes unit dan e2e, dan strategi pengujian yang masuk akal (banyak tes unit terisolasi cepat, lebih sedikit tes e2e lengkap, database tes) adalah ciri khas pengembangan NestJS profesional.

Ini mencerminkan praktik engineering yang matang dan memanfaatkan dengan tepat apa yang membuat desain terstruktur dan berbasis DI NestJS sangat berharga, menjadikannya topik penting tingkat senior.