Kako testirate NestJS aplikacije?

Question

Accepted Answer

NestJS pruža ugrađeni **testing utility (`@nestjs/testing`)** integriran sa Jest-om, a njegova **arhitektura dependency-injection čini testiranje posebno čistim** — kreirate testing modul i injektirate mock-ove za zavisnosti. Testovi se dijele na unit testove (izolirane) i e2e testove (cijela aplikacija).

## Unit testiranje servisa (sa mockiranim zavisnostima)

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

Klučna prednost: NestJS-ova DI vam omogućava **zamjenu stvarnih zavisnosti sa mock-ovima** preko providera testing modula — pa testirate servis u izolaciji, bez stvarne baze podataka ili vanjskih servisa.

## Jednostavno mockiranje zavisnosti

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

Jer klase ne konstruiraju svoje zavisnosti (DI to radi), zamjena mock-ova je trivijalna — osnova čistih unit testova.

## End-to-end (e2e) testiranje — cijela aplikacija preko HTTP-a

```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 testovi** pokrenuju cijelu aplikaciju i stvaraju HTTP zahtjeve (preko `supertest`), provjeravajući da je cijeli tok (rutiranje → guardovi → pipes → handler → odgovor) funkcionalan zajedno.

## Strategija testiranja

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

## Zašto je to važno

Testiranje je bitno za pouzdane aplikacije, a NestJS-ova arhitektura čini ga izuzetno čistim — razumijevanje kako testirati važno je kako za kvalitetu koda tako i jer je framework *dizajniran* za testabilnost.

Centralna ideja je da **dependency injection čini mockiranje trivijalno**: jer klase deklariraju svoje zavisnosti a DI ih pruža, `@nestjs/testing` modul vam omogućava zamjenu bilo koje zavisnosti (repositories baza podataka, vanjski servisi, konfiguracija) sa mock-om preko njegova tokena, omogućavajući brze, izolirane **unit testove** servisa, guardova i pipes-a bez stvarne infrastrukture.

Ova testabilnost je главан razlog zašto su DI-bazirani frameworki poput NestJS-a cijenjeni.

Dopunjavajući unit testove, **e2e testovi** (pokretanje cijele aplikacije i stvaranje HTTP zahtjeva preko `supertest`) provjeravaju da je cijeli request pipeline — rutiranje, guardovi, validacija, handleri — funkcionalan zajedno.

Znati testing utilitije (`Test.createTestingModule`, provider overrides za mockiranje), kako pisati unit i e2e testove, i razumnu strategiju testiranja (mnogo brzih izolirantih unit testova, manje punih e2e testova, test bazu podataka) odlika je profesionalnog NestJS razvoja.

To odražava zrelu praksu inženjerstva i iskorištava upravo ono što čini NestJS-ovu strukturiranu, DI-vođenu dizajnu vrijednom, čineći ga važnom temom za senior razinu.