Testing en JavaScript

El testing o pruebas de software representa una disciplina fundamental en el desarrollo moderno de aplicaciones JavaScript. Esta práctica consiste en escribir código específico para verificar que nuestro código principal funciona correctamente bajo diferentes condiciones y escenarios.

En el ecosistema JavaScript, las pruebas automatizadas han evolucionado desde simples verificaciones manuales hasta sofisticados frameworks que permiten validar desde funciones individuales hasta flujos completos de aplicación. Esta evolución responde a la creciente complejidad de las aplicaciones web y la necesidad de mantener la calidad del código a medida que los proyectos crecen.

Fundamentos del testing

Las pruebas unitarias constituyen la base del testing en JavaScript. Estas pruebas se enfocan en verificar el comportamiento de unidades individuales de código, típicamente funciones o métodos, de forma aislada. El objetivo es asegurar que cada componente funciona correctamente por sí mismo antes de integrarlo con otros elementos.

// Función a probar
function sumar(a, b) {
    return a + b;
}

// Prueba básica
function testSumar() {
    const resultado = sumar(2, 3);
    if (resultado === 5) {
        console.log('✓ Test pasado');
    } else {
        console.log('✗ Test fallido');
    }
}

Las aserciones son el mecanismo fundamental para verificar que los resultados obtenidos coinciden con los esperados. Una aserción es una declaración que debe ser verdadera; si es falsa, la prueba falla.

Estructura de las pruebas

Una prueba bien estructurada sigue el patrón AAA (Arrange, Act, Assert):

• Arrange: Preparar los datos y el entorno necesario
• Act: Ejecutar la función o código a probar
• Assert: Verificar que el resultado es el esperado

function testCalcularDescuento() {
    // Arrange - Preparar datos
    const precio = 100;
    const porcentajeDescuento = 20;
    
    // Act - Ejecutar función
    const precioFinal = calcularDescuento(precio, porcentajeDescuento);
    
    // Assert - Verificar resultado
    console.assert(precioFinal === 80, 'El descuento no se calculó correctamente');
}

Tipos de pruebas

Las pruebas de integración verifican que diferentes módulos o componentes funcionan correctamente cuando se combinan. Mientras que las pruebas unitarias se enfocan en elementos aislados, las pruebas de integración validan las interacciones entre estos elementos.

// Prueba de integración entre módulos
function testProcesarPedido() {
    const producto = { id: 1, precio: 50 };
    const cliente = { id: 123, descuento: 10 };
    
    const pedido = crearPedido(producto, cliente);
    const total = calcularTotal(pedido);
    
    console.assert(total === 45, 'El total del pedido es incorrecto');
}

Las pruebas end-to-end (E2E) simulan el comportamiento real del usuario, probando flujos completos desde la interfaz hasta la base de datos. Estas pruebas son especialmente importantes en aplicaciones web donde múltiples sistemas interactúan.

Frameworks de testing

Los frameworks de testing proporcionan herramientas y estructuras para organizar, ejecutar y reportar pruebas de manera eficiente. Estos frameworks incluyen funcionalidades como:

• Runners: Ejecutan las pruebas automáticamente
• Matchers: Proporcionan métodos para hacer aserciones más expresivas
• Mocking: Permiten simular dependencias externas
• Reporting: Generan reportes detallados de los resultados

// Ejemplo con sintaxis típica de framework
describe('Calculadora', () => {
    test('debe sumar dos números correctamente', () => {
        expect(sumar(2, 3)).toBe(5);
    });
    
    test('debe manejar números negativos', () => {
        expect(sumar(-1, 1)).toBe(0);
    });
});

Mocking y stubs

El mocking es una técnica esencial para aislar el código bajo prueba de sus dependencias externas. Los mocks son objetos simulados que imitan el comportamiento de dependencias reales como APIs, bases de datos o servicios externos.

// Mock de una función de API
const mockFetch = jest.fn();
mockFetch.mockResolvedValue({
    json: () => Promise.resolve({ usuario: 'Juan' })
});

// Usar el mock en la prueba
test('debe obtener datos del usuario', async () => {
    const usuario = await obtenerUsuario(123);
    expect(usuario.nombre).toBe('Juan');
    expect(mockFetch).toHaveBeenCalledWith('/api/usuario/123');
});

Los stubs son versiones simplificadas de funciones que devuelven valores predeterminados, útiles para controlar el flujo de ejecución durante las pruebas.

Cobertura de código

La cobertura de código mide qué porcentaje del código fuente es ejecutado durante las pruebas. Esta métrica ayuda a identificar áreas del código que no están siendo probadas, aunque una alta cobertura no garantiza necesariamente la calidad de las pruebas.

Los tipos principales de cobertura incluyen:

• Cobertura de líneas: Porcentaje de líneas ejecutadas
• Cobertura de funciones: Porcentaje de funciones llamadas
• Cobertura de ramas: Porcentaje de ramas condicionales ejecutadas
• Cobertura de declaraciones: Porcentaje de declaraciones ejecutadas

Testing asíncrono

JavaScript maneja extensivamente operaciones asíncronas mediante callbacks, promesas y async/await. Las pruebas deben adaptarse a estos patrones para verificar correctamente el comportamiento asíncrono.

// Prueba con async/await
test('debe cargar datos del servidor', async () => {
    const datos = await cargarDatos();
    expect(datos).toBeDefined();
    expect(datos.length).toBeGreaterThan(0);
});

// Prueba con promesas
test('debe procesar archivo', () => {
    return procesarArchivo('test.txt')
        .then(resultado => {
            expect(resultado.estado).toBe('completado');
        });
});

El testing asíncrono requiere especial atención al manejo de errores y timeouts para evitar pruebas que fallen intermitentemente o que no terminen nunca.