आप NestJS applications का परीक्षण कैसे करते हैं?

Question

Accepted Answer

NestJS Jest के साथ एकीकृत एक बिल्ट-इन **testing utility (`@nestjs/testing`)** प्रदान करता है, और इसका **dependency-injection architecture परीक्षण को विशेष रूप से स्वच्छ बनाता है** — आप एक testing module बनाते हैं और dependencies के लिए mocks inject करते हैं। Tests unit tests (पृथक) और e2e tests (पूर्ण 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 का पृथक रूप से परीक्षण कर सकें, बिना किसी असली database या external services के।

## Dependencies को आसानी से mock करना

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

चूँकि classes अपनी dependencies को नहीं बनातीं (DI बनाता है), mocks को बदलना तुच्छ है — स्वच्छ unit tests की नींव।

## End-to-end (e2e) testing — HTTP पर पूर्ण app

```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) एक साथ काम करता है।

## परीक्षण रणनीति

```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 के लिए परीक्षण आवश्यक है, और NestJS का architecture इसे उल्लेखनीय रूप से स्वच्छ बनाता है — परीक्षण कैसे करें यह समझना code गुणवत्ता के लिए और इसलिए भी महत्वपूर्ण है क्योंकि framework testability के लिए *डिज़ाइन* किया गया है।

केंद्रीय अंतर्दृष्टि यह है कि **dependency injection mocking को तुच्छ बना देता है**: चूँकि classes अपनी dependencies घोषित करती हैं और DI उन्हें प्रदान करता है, `@nestjs/testing` module आपको किसी भी dependency (database repositories, external services, config) को उसके token के आधार पर एक mock से बदलने देता है, जिससे असली infrastructure के बिना services, guards, और pipes के तेज़, पृथक **unit tests** सक्षम होते हैं।

यह testability ही एक प्रमुख कारण है कि NestJS जैसे DI-आधारित 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 दोनों कैसे लिखें, और एक समझदार परीक्षण रणनीति (कई तेज़ पृथक unit tests, कम पूर्ण e2e tests, एक test database) को जानना पेशेवर NestJS विकास की पहचान है।

यह परिपक्व engineering अभ्यास को दर्शाता है और ठीक उसी चीज़ का लाभ उठाता है जो NestJS के संरचित, DI-आधारित डिज़ाइन को मूल्यवान बनाती है, जिससे यह एक महत्वपूर्ण senior-स्तरीय विषय बन जाता है।