तुम्ही NestJS applications चे परीक्षण कसे करता?

Question

Accepted Answer

NestJS एक बिल्ट-इन **testing utility (`@nestjs/testing`)** प्रदान करता जो Jest सह एकीकृत आहे, आणि त्याचे **dependency-injection architecture testing विशेषतः स्वच्छ करते** — तुम्ही एक testing module तयार करता आणि dependencies साठी mocks inject करता. Tests unit tests (isolated) आणि e2e tests (full app) मध्ये विभागलेले आहेत.

## Unit testing एक service (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 द्वारे mocks साठी actual dependencies स्वॅप करणे** शक्य करते — म्हणून तुम्ही actual database किंवा external services शिवाय service चे isolation मध्ये परीक्षण करता.

## 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 बदलणे trivial आहे — clean unit tests ची foundation.

## 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 करते आणि actual HTTP requests बनवते (via `supertest`), संपूर्ण flow (routing → guards → pipes → handler → response) एकत्रितपणे काम करते हे verify करते.

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

## हे महत्वाचे का आहे

Testing विश्वसनीय applications साठी आवश्यक आहे, आणि NestJS चे architecture हे विशेषतः स्वच्छ बनवते — कसे test करायचे हे समजणे code quality साठी आणि framework *designed* testability साठी आहे हे समजण्यासाठी महत्वाचे आहे.

केंद्रीय insight असे आहे की **dependency injection mocking trivial बनवते**: कारण classes त्यांच्या dependencies घोषित करतात आणि DI त्यांना प्रदान करते, `@nestjs/testing` module तुम्हाला कोणतीही dependency (database repositories, external services, config) त्याच्या token द्वारे mock साठी स्वॅप करणे शक्य करते, actual infrastructure शिवाय services, guards, आणि pipes च्या fast, isolated **unit tests** सक्षम करते.

हा testability हा DI-based frameworks जसे NestJS मूल्यवान असण्याचे मुख्य कारण आहे.

Unit tests पूरक करून, **e2e tests** (पूर्ण app bootstrap करून आणि `supertest` द्वारे actual HTTP requests बनवून) संपूर्ण request pipeline — routing, guards, validation, handlers — एकत्रितपणे योग्यरित्या काम करते हे verify करते.

Testing utilities (`Test.createTestingModule`, mocking साठी provider overrides), unit आणि e2e दोन्ही tests कसे लिहायचे हे जाणून घेणे, आणि sensible testing strategy (अनेक fast isolated unit tests, कमी full e2e tests, एक test database) हे professional NestJS development चे hallmark आहे.

हे mature engineering practice reflect करते आणि NestJS च्या structured, DI-driven design मूल्यवान असे योग्य ठरवते, हे महत्वाचे senior-level topic बनवते.