¿Cómo pruebas aplicaciones NestJS?

Question

Accepted Answer

NestJS proporciona una **utilidad de pruebas integrada (`@nestjs/testing`)** integrada con Jest, y su **arquitectura de inyección de dependencias hace que las pruebas sean especialmente limpias** — creas un módulo de pruebas e inyectas mocks para las dependencias. Las pruebas se dividen en pruebas unitarias (aisladas) y pruebas e2e (aplicación completa).

## Prueba unitaria de un servicio (con dependencias simuladas)

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

La ventaja clave: la inyección de dependencias de NestJS te permite **intercambiar dependencias reales por mocks** a través de los proveedores del módulo de pruebas — así pruebas el servicio de forma aislada, sin una base de datos real o servicios externos.

## Simulación de dependencias fácilmente

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

Puesto que las clases no construyen sus dependencias (lo hace la inyección de dependencias), sustituir mocks es trivial — la base de pruebas unitarias limpias.

## Prueba end-to-end (e2e) — la aplicación completa sobre 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());
});
```

Las **pruebas e2e** inician la aplicación completa y realizan solicitudes HTTP reales (a través de `supertest`), verificando que todo el flujo (enrutamiento → guards → pipes → handler → respuesta) funciona en conjunto.

## Estrategia de pruebas

```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 qué es importante

Las pruebas son esenciales para aplicaciones confiables, y la arquitectura de NestJS las hace notablemente limpias — entender cómo probar es importante tanto para la calidad del código como porque el framework está *diseñado* para la capacidad de prueba.

La idea central es que **la inyección de dependencias hace que la simulación sea trivial**: como las clases declaran sus dependencias y la inyección de dependencias las proporciona, el módulo `@nestjs/testing` te permite intercambiar cualquier dependencia (repositorios de base de datos, servicios externos, configuración) por un mock por su token, permitiendo pruebas unitarias rápidas y aisladas de servicios, guards y pipes sin infraestructura real.

Esta capacidad de prueba es una razón importante por la que los frameworks basados en inyección de dependencias como NestJS son valorados.

Complementando las pruebas unitarias, las **pruebas e2e** (iniciando la aplicación completa y realizando solicitudes HTTP reales a través de `supertest`) verifican que todo el pipeline de solicitudes — enrutamiento, guards, validación, handlers — funciona correctamente en conjunto.

Conocer las utilidades de pruebas (`Test.createTestingModule`, sobreescrituras de proveedores para la simulación), cómo escribir pruebas unitarias y e2e, y una estrategia de pruebas sensata (muchas pruebas unitarias rápidas y aisladas, menos pruebas e2e completas, una base de datos de prueba) es una característica del desarrollo profesional de NestJS.

Refleja una práctica de ingeniería madura y aprovecha exactamente lo que hace valioso el diseño estructurado y basado en inyección de dependencias de NestJS, convirtiéndolo en un tema importante de nivel senior.