Si testoni aplikacionet NestJS?

Question

Accepted Answer

NestJS ofron një **utility të integruar për testim (`@nestjs/testing`)** i integruar me Jest, dhe **arkitektura e tij e dependency-injection e bën testimin veçanërisht të pastër** — krijoni një modul testimi dhe injektoni mock-e për varësitë. Testet ndahen në unit tests (të izoluar) dhe e2e tests (aplikacioni i plotë).

## Testimi i njësisë të një shërbimi (me varësi të mock-uara)

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

Avantazhi kryesor: DI e NestJS ju lejon të **zëvendësoni varësitë reale me mock-e** përmes providers të modulit të testimit — kështu testoni shërbimin në izolim, pa një bazë të dhënash reale ose shërbime të jashtme.

## Mock-imi i varësive me lehtësi

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

Sepse klasat nuk konstruktojnë varësitë e tyre (DI e bën atë), zëvendësimi i mock-eve është trivial — themeli i unit tests të pastër.

## Testimi end-to-end (e2e) — aplikacioni i plotë mbi 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());
});
```

**Testet e2e** nisën aplikacionin e plotë dhe bëjnë kërkesa të vërteta HTTP (përmes `supertest`), duke verifikuar se i gjithë fluxhi (routing → guards → pipes → handler → response) funksionon së bashku.

## Strategjia e testimit

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

## Pse është e rëndësishme

Testimi është thelbësor për aplikacionet e besueshme, dhe arkitektura e NestJS e bën atë dukshëm të pastër — kuptimi se si të testohet është i rëndësishëm si për cilësinë e kodit ashtu edhe sepse framework-u është *i dizajnuar* për testabilitet.

Fiksa qendrore është se **dependency injection e bën mock-imin trivial**: sepse klasat deklarojnë varësitë e tyre dhe DI i ofron ato, moduli `@nestjs/testing` ju lejon të zëvendësoni çdo varësi (repository të bazave të dhënave, shërbime të jashtme, konfiguracion) me një mock sipas token-it të saj, duke mundësuar **unit tests** të shpejta, të izoluara të shërbimeve, guards-eve, dhe pipes pa infrastrukturë reale.

Kjo testabilitet është një arsye kryesore përse framework-et e bazuara në DI si NestJS janë të vlerësuara.

Më pas unit tests-eve, **testet e2e** (duke nisur aplikacionin e plotë dhe bërë kërkesa të vërteta HTTP përmes `supertest`) verifikojnë se i gjithë pipeline-i i kërkesave — routing, guards, validim, handlers — funksionon së bashku saktë.

Dija e utility-eve të testimit (`Test.createTestingModule`, zëvendësimet e provider-ave për mock-im), si të shkruhen unit dhe e2e tests, dhe një strategji sensate testimi (shumë unit tests të shpejtë të izoluar, më pak testet e plotë e2e, një bazë të dhënash testimi) është shenja e zhvillimit profesional të NestJS.

Ijo pasqyron praktikën inxhinierike të pjekur dhe shfrytëzon pikërisht atë që e bën vlerësuese për dizajnin e strukturuar të NestJS, të drejtuar nga DI, duke e bërë atë një temë të rëndësishme të nivelit senior.