Miten testaat NestJS-sovelluksia?

Question

Accepted Answer

NestJS tarjoaa sisäänrakennetun **testaustyökalun (`@nestjs/testing`)**, joka on integroitu Jestin kanssa, ja sen **riippuvuuksien injektointiarkitehtuuri tekee testaamisesta erityisen puhdasta** — luot testaamismoduulin ja injektoit riippuvuuksille mock-objekteja. Testit jaetaan yksikkötesteihin (eristetyt) ja e2e-testeihin (koko sovellus).

## Palvelun yksikkötestaus (mock-riippuvuuksilla)

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

Pääetu: NestJS:n DI:n ansiosta voit **vaihtaa todelliset riippuvuudet mock-objekteiksi** testaamismoduulin providersien kautta — joten testaat palvelua eristettynä, ilman todellista tietokantaa tai ulkoisia palveluita.

## Riippuvuuksien helppoa mockausta

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

Koska luokat eivät rakenna omia riippuvuuksiaan (DI tekee sen), mock-objektien korvaaminen on triviaalia — puhtaiden yksikkötestien perusta.

## Päästä päähän (e2e) testaus — koko sovellus HTTP:n yli

```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-testit** käynnistävät täyden sovelluksen ja tekevät todelliset HTTP-pyynnöt (`supertest`-kirjaston kautta), varmistamalla, että koko flow (reititys → guardlit → putket → käsittelijä → vastaus) toimii yhteen.

## Testausstrategia

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

## Miksi se on tärkeää

Testaus on välttämätöntä luotettavien sovelluksien kannalta, ja NestJS:n arkkitehtuuri tekee siitä erityisen puhdasta — ymmärtäminen siitä, miten testataan, on tärkeää sekä koodin laadun että sille, että kehys on *suunniteltu* testattavuutta ajatellen.

Keskeisin näkemys on, että **riippuvuuksien injektointi tekee mockauksesta triviaalia**: koska luokat ilmoittavat riippuvuuksistaan ja DI toimittaa ne, `@nestjs/testing`-moduuli antaa sinun vaihtaa minkä tahansa riippuvuuden (tietokantahakemistot, ulkoiset palvelut, konfiguraatio) mock-objektiksi sen tokenin perusteella, mahdollistaen nopeat, eristetyt **yksikkötestit** palveluista, guardeista ja putkista ilman todellista infrastruktuuria.

Tämä testattavuus on merkittävä syy siihen, miksi DI-pohjaiset kehykset, kuten NestJS, ovat arvostettuja.

Yksikkötestejä täydentävinä **e2e-testit** (koko sovelluksen käynnistäminen ja todelliset HTTP-pyynnöt `supertestilla`) varmistamaan, että koko pyyntöputki — reititys, guardlit, validointi, käsittelijät — toimii yhteen oikein.

Testaustyökalujen (`Test.createTestingModule`, providerin ohitukset mockausta varten), sekä yksikkö- että e2e-testien kirjoittamisen ja järkevän testaustsetraatgian (monet nopeat eristetyt yksikkötestit, harvemmat täydet e2e-testit, testaus­tietokanta) tunteminen on ammattimaisen NestJS-kehityksen tunnusmerkki.

Se heijastaa kypsää insinöörikäytäntöä ja hyödyntää tarkalleen sitä, mikä tekee NestJS:n strukturoidusta, DI-pohjaisesta suunnittelusta arvokasta, mikä tekee siitä tärkeän kokeneiden kehittäjien aiheen.