NestJS applications-ஐ எப்படி test செய்வீர்கள்?

Question

Accepted Answer

NestJS-இல் Jest உடன் ஒருங்கிணைக்கப்பட்ட உள்ளமைந்த **testing utility (`@nestjs/testing`)** உள்ளது, மேலும் அதன் **dependency-injection கட்டிடக்கலை testing-ஐ குறிப்பாக சுத்தமாக்குகிறது** — நீங்கள் ஒரு testing module-ஐ உருவாக்கி dependencies-க்கு mocks-ஐ inject செய்கிறீர்கள். Tests unit tests (isolated) மற்றும் e2e tests (full app) ஆக பிரிகின்றன.

## ஒரு service-ஐ unit testing செய்தல் (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();
  });
});
```

முக்கிய நன்மை: NestJS-இன் DI ஆனது testing module-இன் providers மூலம் **உண்மையான dependencies-ஐ mocks-க்கு மாற்ற** உங்களை அனுமதிக்கிறது — எனவே நீங்கள் service-ஐ isolation-இல், உண்மையான database அல்லது external services இல்லாமல் test செய்கிறீர்கள்.

## Dependencies-ஐ எளிதாக mocking செய்தல்

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

Classes தங்கள் dependencies-ஐ construct செய்யாததால் (DI செய்கிறது), mocks-ஐ பதிலீடு செய்வது எளிது — சுத்தமான unit tests-இன் அடித்தளம்.

## End-to-end (e2e) testing — முழு app 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** முழு application-ஐ bootstrap செய்து உண்மையான HTTP requests-ஐ (`supertest` மூலம்) செய்கின்றன, முழு flow (routing → guards → pipes → handler → response) ஒன்றாக வேலை செய்வதை சரிபார்க்கின்றன.

## Testing strategy

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

## இது ஏன் முக்கியம்

நம்பகமான applications-க்கு testing அவசியம், மேலும் NestJS-இன் கட்டிடக்கலை அதை குறிப்பிடத்தக்க அளவில் சுத்தமாக்குகிறது — எப்படி test செய்வது என்பதைப் புரிந்துகொள்வது code தரத்திற்காகவும், framework testability-க்காக *வடிவமைக்கப்பட்டுள்ளதால்* முக்கியம்.

மைய நுண்ணறிவு என்னவென்றால் **dependency injection ஆனது mocking-ஐ எளிதாக்குகிறது**: classes தங்கள் dependencies-ஐ declare செய்து DI அவற்றை வழங்குவதால், `@nestjs/testing` module ஆனது எந்த dependency-ஐயும் (database repositories, external services, config) அதன் token மூலம் ஒரு mock-க்கு மாற்ற உங்களை அனுமதிக்கிறது, உண்மையான infrastructure இல்லாமல் services, guards, மற்றும் pipes-இன் வேகமான, isolated **unit tests**-ஐ செயல்படுத்துகிறது.

இந்த testability ஆனது NestJS போன்ற DI-based frameworks மதிக்கப்படுவதற்கு ஒரு முக்கிய காரணம்.

Unit tests-ஐ நிறைவுசெய்து, **e2e tests** (முழு app-ஐ bootstrap செய்து `supertest` மூலம் உண்மையான HTTP requests-ஐ செய்தல்) முழு request pipeline — routing, guards, validation, handlers — ஒன்றாக சரியாக வேலை செய்வதை சரிபார்க்கின்றன.

Testing utilities (`Test.createTestingModule`, mocking-க்கான provider overrides), unit மற்றும் e2e tests இரண்டையும் எப்படி எழுதுவது, மற்றும் ஒரு நியாயமான testing strategy (பல வேகமான isolated unit tests, குறைவான முழு e2e tests, ஒரு test database) ஆகியவற்றை அறிந்திருப்பது தொழில்முறை NestJS development-இன் அடையாளமாகும்.

இது முதிர்ந்த engineering நடைமுறையைப் பிரதிபலிக்கிறது மற்றும் NestJS-இன் கட்டமைக்கப்பட்ட, DI-driven வடிவமைப்பை மதிப்புமிக்கதாக ஆக்குவது எதுவோ அதையே சரியாகப் பயன்படுத்துகிறது, இது ஒரு முக்கியமான senior-level தலைப்பாக ஆக்குகிறது.