Testing Completo: Unit, Integration y E2E

Introducción

Un programa de testing sólido es crucial para mantener la calidad y confiabilidad de aplicaciones. Existen tres tipos principales de testing que forman una pirámide: muchos tests unitarios, algunos tests de integración, y pocos tests E2E.

Unit Testing

Unit tests validan que funciones, métodos y componentes individuales funcionan correctamente de forma aislada. Son los tests más rápidos y baratos.

Características:

• Pruebas rápidas (milisegundos)
• Aisladas con mocks y stubs
• Enfocadas en lógica pura
• Fáciles de escribir y mantener
• Deben cubrir casos normales y edge cases

Ejemplo con Jest:

describe('calculateTotal', () => {
  it('should calculate sum correctly', () => {
    expect(calculateTotal([1, 2, 3])).toBe(6);
  });
  
  it('should handle empty array', () => {
    expect(calculateTotal([])).toBe(0);
  });
});
            

Integration Testing

Los tests de integración validan que múltiples componentes, servicios y módulos funcionan correctamente juntos. Prueban la interacción entre sistemas.

• Validan flujos completos
• Pueden usar bases de datos de prueba
• Más lentos que unit tests
• Menos mocks, más componentes reales
• Detectan problemas de integración temprano

Ejemplo: Test de un endpoint API con base de datos:

describe('POST /api/users', () => {
  it('should create user and return 201', async () => {
    const response = await request(app)
      .post('/api/users')
      .send({ name: 'John', email: 'john@test.com' });
    
    expect(response.status).toBe(201);
    expect(response.body.id).toBeDefined();
  });
});
            

E2E Testing (End-to-End)

Los tests E2E simulan la experiencia real del usuario, navegando la aplicación como lo haría un humano. Prueba toda la pila (frontend, backend, base de datos, APIs externas).

• Más lentos (segundos por test)
• Más costosos de mantener
• Validan la experiencia completa del usuario
• Detectan bugs que otros no ven
• Requieren entorno similar a producción

Ejemplo con Cypress:

describe('User Registration Flow', () => {
  it('should register new user successfully', () => {
    cy.visit('https://example.com/register');
    cy.get('[name="email"]').type('user@test.com');
    cy.get('[name="password"]').type('SecurePass123');
    cy.get('button[type="submit"]').click();
    cy.url().should('include', '/dashboard');
  });
});
            

Cobertura de Código

La cobertura de código mide qué porcentaje del código está siendo ejecutado por tests. Métricas comunes:

• Line Coverage: Líneas ejecutadas
• Branch Coverage: Caminos de decisión
• Function Coverage: Funciones probadas
• Statement Coverage: Declaraciones ejecutadas

Objetivo realista: 70-80% de cobertura. El 100% no siempre es posible ni necesario.

Herramientas Esenciales

• Jest: Framework de testing para JavaScript, React
• Vitest: Testing rápido con HMR para Vite
• Cypress: E2E testing con UI interactiva
• Playwright: E2E testing multiplataforma (Chrome, Firefox, Safari)
• Testing Library: Testing de componentes React enfocado en UX
• SuperTest: Testing HTTP para APIs Node.js
• Istanbul: Cobertura de código

Conclusión

Una estrategia de testing equilibrada (muchos unit tests, algunos integration tests, pocos E2E tests) produce código confiable y mantenible. Los tests no son un lujo, son una inversión en calidad.