Pire cara ngetesing aplikasi NestJS?

Question

Accepted Answer

NestJS nyediyakake utility testing built-in **(`@nestjs/testing`)** sing terintegrasi karo Jest, lan **arsitektur dependency-injection-e bikin testing luwih bersih** — sampeyan nggawe testing module lan inject mock para dependensi. Test dibagi dadi unit test (terisolasi) lan e2e test (full app).

## Unit testing service (karo dependensi sing 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();
  });
});
```

Keuntungan utama: DI NestJS ngijinake sampeyan **ganti dependensi asli karo mock** liwat provider testing module — dadi sampeyan test service kanthi terisolasi, tanpa database asli utawa layanan eksternal.

## Memock dependensi kanthi gampang

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

Sabab class ora ngkontruksi dependensi-e (DI sing nglakoni), ngganti mock iku trivial — fondasi unit test sing bersih.

## End-to-end (e2e) testing — full app liwat 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 test** bootstrap aplikasi lengkap lan nggawe HTTP request asli (liwat `supertest`), verifikasi alur lengkap (routing → guard → pipe → handler → response) bisa bekerja bareng.

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

## Apa sebabane penting

Testing iku essential kanggo aplikasi sing reliable, lan arsitektur NestJS bikin iku luwih bersih — ngerti cara ngetesing iku penting maneh kanggo kualitas kode lan amarga framework iku *dirancang* kanggo testability.

Insight pusat-e yaiku **dependency injection bikin memock iku trivial**: amarga class nyebutake dependensi-e lan DI nyediyakake, module `@nestjs/testing` ngijinake sampeyan ganti dependensi apa wae (database repository, layanan eksternal, config) kanthi mock menggunakake token-e, ngaktifake **unit test** cepet lan terisolasi saka service, guard, lan pipe tanpa infrastruktur asli.

Testability iki alasan utama framework berbasis DI kaya NestJS dihargai.

Nambah unit test, **e2e test** (bootstrap full app lan nggawe HTTP request asli liwat `supertest`) verifikasi pipeline request lengkap — routing, guard, validasi, handler — bisa bekerja bebarengan kanthi bener.

Ngerti utility testing (`Test.createTestingModule`, provider override kanggo memock), cara nulis unit lan e2e test, lan strategi testing sing masuk akal (akeh fast isolated unit test, sethithik e2e test lengkap, test database) iku ciri professional development NestJS.

Iku ngrefleksikake mature engineering practice lan ngleverase tepatane apa sing bikin desain NestJS sing terstruktur lan driven-DI berharga, dadi iku topik level senior sing penting.