Unajaribuje (test) programu za NestJS?

Question

Accepted Answer

NestJS inatoa **testing utility iliyojengwa ndani (`@nestjs/testing`)** iliyojumuishwa na Jest, na **architecture yake ya dependency-injection inafanya upimaji kuwa safi hasa** — unaunda testing module na kuingiza mocks kwa dependencies. Tests zinagawanyika katika unit tests (zilizotengwa) na e2e tests (full app).

## Unit testing ya service (yenye mocked dependencies)

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

Faida muhimu: DI ya NestJS inakuruhusu **kubadilisha dependencies halisi kwa mocks** kupitia providers za testing module — kwa hivyo unajaribu service ikiwa imetengwa, bila database halisi au external services.

## Kufanya mock kwa dependencies kwa urahisi

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

Kwa kuwa classes hazitengenezi dependencies zao (DI ndiyo inafanya), kubadilisha mocks ni rahisi sana — msingi wa unit tests safi.

## End-to-end (e2e) testing — full app kupitia 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** zinaanzisha (bootstrap) programu nzima na kufanya maombi halisi ya HTTP (kupitia `supertest`), zikithibitisha kwamba mtiririko mzima (routing → guards → pipes → handler → response) unafanya kazi pamoja.

## Mkakati wa upimaji

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

## Kwa nini ni muhimu

Upimaji ni muhimu kwa programu zinazoaminika, na architecture ya NestJS inaufanya kuwa safi sana — kuelewa jinsi ya kujaribu ni muhimu kwa ubora wa code na kwa sababu framework imebuniwa *kwa ajili ya* uwezo wa kupimwa.

Utambuzi mkuu ni kwamba **dependency injection inafanya mocking kuwa rahisi**: kwa kuwa classes zinatangaza dependencies zao na DI inazitoa, module ya `@nestjs/testing` inakuruhusu kubadilisha dependency yoyote (database repositories, external services, config) kwa mock kupitia token yake, ikiwezesha **unit tests** za haraka, zilizotengwa za services, guards, na pipes bila infrastructure halisi.

Uwezo huu wa kupimwa ni sababu kuu kwa nini frameworks zinazotegemea DI kama NestJS zinathaminiwa.

Kwa kukamilisha unit tests, **e2e tests** (kuanzisha programu nzima na kufanya maombi halisi ya HTTP kupitia `supertest`) zinathibitisha kwamba mtiririko mzima wa ombi — routing, guards, validation, handlers — unafanya kazi pamoja kwa usahihi.

Kujua testing utilities (`Test.createTestingModule`, provider overrides kwa mocking), jinsi ya kuandika unit na e2e tests, na mkakati wa upimaji wenye mantiki (unit tests nyingi za haraka zilizotengwa, e2e tests chache za full, test database) ni alama ya utendaji wa kitaalamu wa NestJS.

Inaonyesha utendaji uliokomaa wa uhandisi na inatumia haswa kile kinachofanya muundo uliopangwa, unaotegemea DI wa NestJS kuwa wa thamani, ikiifanya kuwa mada muhimu ya kiwango cha senior.