Pruebas en JavaScript: unit, integration, e2e de la A a la Z

Pruebas en JavaScript: Unit, Integration, E2E — de la A a la Z

El desarrollo de aplicaciones web modernas en JavaScript (especialmente en Node.js) es imposible sin pruebas de calidad. Las pruebas no solo detectan errores antes de llegar a producción, sino que también sirven como documentación viva y permiten refactorizar código sin miedo a romper algo. En este artículo, analizaremos los tres niveles principales de la pirámide de pruebas: unit (unitarias), integration (integración) y e2e (extremas a extremo). Aprenderás en qué se diferencian, qué herramientas usar y verás ejemplos listos en Node.js.

1. Pruebas unitarias: probando módulos aislados

Las pruebas unitarias son la base de la pirámide. Verifican el funcionamiento de funciones, clases o componentes individuales en completo aislamiento de dependencias externas (BD, API, sistema de archivos). El objetivo principal es asegurarse de que la lógica del módulo funcione correctamente con cualquier entrada de datos.

Para Node.js, el framework más popular es Jest (de Facebook). No requiere configuración compleja, tiene aserciones integradas, mocks y cobertura de código.

Ejemplo: probando una función de ordenamiento de array

// utils.jsfunction sortNumbers(arr) {  if (!Array.isArray(arr)) {    throw new Error('Input must be an array');  }  return [...arr].sort((a, b) => a - b);}

module.exports = { sortNumbers };

// utils.test.jsconst { sortNumbers } = require('./utils');

describe('sortNumbers', () => {  test('should sort an array of numbers in ascending order', () => {    expect(sortNumbers([3, 1, 2])).toEqual([1, 2, 3]);  });

  test('should handle an empty array', () => {    expect(sortNumbers([])).toEqual([]);  });

  test('should throw error for non-array input', () => {    expect(() => sortNumbers('string')).toThrow('Input must be an array');  });});

Mejores prácticas para pruebas unitarias:

• Una prueba — una verificación (un assert).
• Usa describe para agrupar pruebas por funciones.
• Mockea las dependencias externas (con jest.mock()).
• Escribe las pruebas antes de escribir el código (TDD — Test-Driven Development).

2. Pruebas de integración: verificando la interacción de componentes

Las pruebas de integración verifican cómo diferentes módulos del sistema trabajan juntos. Por ejemplo, cómo tu controlador interactúa con la base de datos o una API externa. A diferencia de las pruebas unitarias, aquí no mockeamos todo, sino que usamos entornos reales (o de prueba).

Para probar servidores HTTP en Express, la biblioteca Supertest en combinación con Jest es excelente.

Ejemplo: probando un endpoint REST

// app.jsconst express = require('express');const app = express();

app.get('/api/hello', (req, res) => {  res.json({ message: 'Hello, World!' });});

app.post('/api/data', (req, res) => {  const { name } = req.body;  if (!name) {    return res.status(400).json({ error: 'Name is required' });  }  res.status(201).json({ received: name });});

module.exports = app;

// app.test.jsconst request = require('supertest');const app = require('./app');

describe('Integration tests for API', () => {  test('GET /api/hello should return a greeting', async () => {    const response = await request(app)      .get('/api/hello')      .expect(200);

    expect(response.body).toEqual({ message: 'Hello, World!' });  });

  test('POST /api/data with valid body should return 201', async () => {    const response = await request(app)      .post('/api/data')      .send({ name: 'Alice' })      .expect(201);

    expect(response.body).toEqual({ received: 'Alice' });  });

  test('POST /api/data without name should return 400', async () => {