Bagaimanakah anda menguji aplikasi NestJS?

Question

Accepted Answer

NestJS menyediakan satu **utiliti testing terbina (`@nestjs/testing`)** yang berintegrasi dengan Jest, dan seni bina **dependency-injection-nya menjadikan testing amat bersih** — anda mencipta satu testing module dan menyuntik mocks untuk dependencies. Tests terbahagi kepada unit tests (terasing) dan e2e tests (aplikasi penuh).

## Unit testing satu service (dengan dependencies yang dimock)

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

Kelebihan utama: DI NestJS membolehkan anda **menukar dependencies sebenar dengan mocks** melalui providers testing module — jadi anda menguji service secara terasing, tanpa database sebenar atau perkhidmatan luaran.

## Memock dependencies dengan mudah

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

Kerana kelas tidak membina dependencies-nya (DI yang melakukannya), menggantikan mocks adalah remeh — asas kepada unit tests yang bersih.

## End-to-end (e2e) testing — aplikasi penuh 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());
});
```

**E2E tests** membootstrap aplikasi penuh dan membuat request HTTP sebenar (melalui `supertest`), mengesahkan keseluruhan aliran (routing → guards → pipes → handler → response) berfungsi bersama-sama.

## Strategi testing

```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 ia penting

Testing adalah penting untuk aplikasi yang boleh dipercayai, dan seni bina NestJS menjadikannya amat bersih — memahami cara menguji adalah penting baik untuk kualiti kod mahupun kerana framework ini *direka* untuk kebolehujian.

Wawasan utama ialah bahawa **dependency injection menjadikan mocking remeh**: kerana kelas mengisytiharkan dependencies-nya dan DI menyediakannya, module `@nestjs/testing` membolehkan anda menukar mana-mana dependency (repository database, perkhidmatan luaran, config) dengan satu mock mengikut tokennya, membolehkan **unit tests** yang pantas dan terasing bagi services, guards, dan pipes tanpa infrastruktur sebenar.

Kebolehujian ini ialah satu sebab utama framework berasaskan DI seperti NestJS dihargai.

Melengkapkan unit tests, **e2e tests** (membootstrap aplikasi penuh dan membuat request HTTP sebenar melalui `supertest`) mengesahkan bahawa keseluruhan paip request — routing, guards, validation, handlers — berfungsi bersama-sama dengan betul.

Mengetahui utiliti testing (`Test.createTestingModule`, override provider untuk mocking), cara menulis kedua-dua unit dan e2e tests, dan satu strategi testing yang munasabah (banyak unit tests terasing yang pantas, lebih sedikit e2e tests penuh, satu database ujian) ialah tanda pembangunan NestJS yang profesional.

Ia mencerminkan amalan kejuruteraan yang matang dan memanfaatkan tepat apa yang menjadikan reka bentuk NestJS yang berstruktur dan dipacu-DI itu berharga, menjadikannya satu topik peringkat senior yang penting.