તમે NestJS એપ્લિકેશનોનું પરીક્ષણ કેવી રીતે કરો છો?

Question

Accepted Answer

NestJS એક બિલ્ટ-ઇન **પરીક્ષણ યુટિલિટી (`@nestjs/testing`)** પ્રદાન કરે છે જે Jest સાથે એકીકૃત છે, અને તેની **dependency-injection આર્કિટેક્ચર પરીક્ષણને ખાસ કરીને સ્વચ્છ બનાવે છે** — તમે એક પરીક્ષણ મોડ્યુલ બનાવો અને dependencies માટે mocks ઇંજેક્ટ કરો. પરીક્ષણો એકમ પરીક્ષણો (અલગ) અને e2e પરીક્ષણો (સંપૂર્ણ એપ) માં પડે છે.

## સેવાનું એકમ પરીક્ષણ (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 તમને **વાસ્તવિક dependencies ને mocks સાથે બદલવા** દે છે પરીક્ષણ મોડ્યુલના providers દ્વારા — તેથી તમે સેવાનું અલગમાં પરીક્ષણ કરો છો, વાસ્તવિક ડેટાબેસ અથવા બાહ્ય સેવાઓ વિના.

## Dependencies ને સરળતાથી Mock કરો

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

કારણ કે ક્લાસો તેમની dependencies બનાતા નથી (DI કરે છે), mocks બદલવાનું તુચ્છ છે — સ્વચ્છ એકમ પરીક્ષણોનો આધાર.

## અંત-થી-અંત (e2e) પરીક્ષણ — 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 પરીક્ષણો** સંપૂર્ણ એપ્લિકેશન bootstrap કરે છે અને વાસ્તવિક HTTP વિનંતીઓ કરે છે (`supertest` દ્વારા), સમગ્ર પ્રવાહ (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.
```

## શા માટે તે મહત્વપૂર્ણ છે

પરીક્ષણ વિશ્વસનીય એપ્લિકેશનો માટે આવશ્યક છે, અને NestJS નું આર્કિટેક્ચર તેને નોંધપાત્રપણે સ્વચ્છ બનાવે છે — પરીક્ષણ કેવી રીતે કરવું તે સમજવું કોડ ગુણવત્તા અને ફ્રેમવર્ક *ટેસ્ટેબિલિટી માટે ડિઝાઇન કર્યું હોવાના* બંને કારણોમાં મહત્વપૂર્ણ છે.

કેન્દ્રીય અંતર્દૃષ્ટિ એ છે કે **dependency injection મocking ને તુચ્છ બનાવે છે**: કારણ કે ક્લાસો તેમની dependencies ઘોષણા કરે છે અને DI તેમને પ્રદાન કરે છે, `@nestjs/testing` મોડ્યુલ તમને કોઈપણ dependency (ડેટાબેસ repositories, બાહ્ય સેવાઓ, config) ને તેના token દ્વારા mock માટે બદલવા દે છે, ઝડપી, અલગ **એકમ પરીક્ષણો** શક્ય બનાવે છે વાસ્તવિક ઇન્ફ્રાસ્ટ્રક્ચર વિના services, guards, અને pipes માટે.

તે testability એ એક મુખ્ય કારણ છે કે કેમ DI-આધારિત ફ્રેમવર્ક્સ જેવા NestJS ની મૂલ્યવાન છે.

એકમ પરીક્ષણોને પૂરક બનાવતા, **e2e પરીક્ષણો** (સંપૂર્ણ એપ bootstrap કરીને અને `supertest` દ્વારા વાસ્તવિક HTTP વિનંતીઓ કરીને) સમગ્ર વિનંતી પાઇપલાઇન — routing, guards, validation, handlers — એક સાથે સાચો કામ કરે છે તે ચકાસે છે.

પરીક્ષણ યુટિલિટીઓ (`Test.createTestingModule`, mocking માટે provider overrides), એકમ અને e2e બંને પરીક્ષણો કેવી રીતે લખવા, અને સમજણીય પરીક્ષણ કોર્યનીતિ (ઘણી ઝડપી અલગ એકમ પરીક્ષણો, ઓછી સંપૂર્ણ e2e પરીક્ષણો, એક પરીક્ષણ ડેટાબેસ) તે વ્યાવસાયિક NestJS વિકાસનું એક વર્ણચિહ્ન છે.

તે પરિપક્વ ઇજનેરી પ્રવર્તનનું પ્રતિબિંબ છે અને બરાબર તે શક્તિ લાભમાં લે છે જે NestJS ની માળખાગત, DI-આધારિત ડિઝાઇન મૂલ્યવાન બનાવે છે, તેને વરિષ્ઠ-સ્તરનું એક મહત્વપૂર્ણ વિષય બનાવે છે.