Como você testa aplicações NestJS?

Question

Accepted Answer

NestJS fornece um **utilitário de testes integrado (`@nestjs/testing`)** integrado ao Jest, e sua **arquitetura de injeção de dependência torna os testes especialmente limpos** — você cria um módulo de testes e injeta mocks para as dependências. Os testes se dividem em testes unitários (isolados) e testes e2e (app completo).

## Teste unitário de um serviço (com dependências mockadas)

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

A vantagem principal: a DI do NestJS permite **trocar dependências reais por mocks** através dos provedores do módulo de testes — então você testa o serviço isoladamente, sem um banco de dados real ou serviços externos.

## Mockando dependências facilmente

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

Como as classes não constroem suas próprias dependências (a DI faz isso), substituir mocks é trivial — a base dos testes unitários limpos.

## Testes end-to-end (e2e) — a app completa por 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());
});
```

**Testes E2E** inicializam a aplicação completa e fazem requisições HTTP reais (via `supertest`), verificando se todo o fluxo (roteamento → guards → pipes → handler → resposta) funciona junto.

## Estratégia de testes

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

## Por que isso importa

Testes são essenciais para aplicações confiáveis, e a arquitetura do NestJS torna isso notavelmente limpo — entender como testar é importante tanto para a qualidade do código quanto porque o framework é *projetado* para testabilidade.

O insight central é que **injeção de dependência torna mocking trivial**: como as classes declaram suas dependências e a DI as fornece, o módulo `@nestjs/testing` permite trocar qualquer dependência (repositórios de banco de dados, serviços externos, config) por um mock pelo seu token, habilitando **testes unitários** rápidos e isolados de serviços, guards e pipes sem infraestrutura real.

Esta testabilidade é uma razão importante pela qual frameworks baseados em DI como NestJS são valorizados.

Complementando testes unitários, **testes e2e** (inicializando a app completa e fazendo requisições HTTP reais via `supertest`) verificam que todo o pipeline de requisição — roteamento, guards, validação, handlers — funciona corretamente em conjunto.

Conhecer os utilitários de testes (`Test.createTestingModule`, overrides de provedores para mocking), como escrever tanto testes unitários quanto e2e, e uma estratégia de testes sensata (muitos testes unitários rápidos e isolados, menos testes e2e completos, um banco de dados de testes) é uma marca de desenvolvimento profissional em NestJS.

Isso reflete prática de engenharia madura e aproveita exatamente o que torna o design estruturado e dirigido por DI do NestJS valioso, tornando-o um tópico importante de nível sênior.