Testing en TypeScript

El testing representa una disciplina fundamental en el desarrollo de software que cobra especial relevancia cuando trabajamos con TypeScript. La naturaleza tipada de este lenguaje nos proporciona ventajas únicas para crear pruebas más robustas y mantenibles, mientras que su integración con el ecosistema JavaScript nos permite aprovechar las herramientas de testing más maduras del mercado.

Fundamentos del testing en TypeScript

TypeScript transforma la experiencia de testing tradicional al introducir verificación de tipos en tiempo de compilación. Esta característica elimina una categoría completa de errores antes de que las pruebas se ejecuten, permitiendo que nos concentremos en la lógica de negocio y los casos edge más complejos.

La inferencia de tipos de TypeScript también mejora significativamente la experiencia de desarrollo de pruebas. Los editores pueden proporcionar autocompletado preciso para los métodos de testing, reduciendo errores tipográficos y mejorando la productividad.

// TypeScript detecta errores de tipo antes de ejecutar las pruebas
function sumar(a: number, b: number): number {
    return a + b;
}

// Error detectado en tiempo de compilación
// const resultado = sumar("5", 3); // Error: Argument of type 'string' is not assignable

Configuración del entorno de testing

El ecosistema de testing en TypeScript se beneficia de herramientas especializadas que comprenden tanto JavaScript como TypeScript. Jest, Vitest y Mocha son frameworks populares que ofrecen soporte nativo o mediante configuración adicional.

La configuración típica requiere un transpilador como ts-jest o esbuild para procesar archivos TypeScript durante la ejecución de pruebas. Esta configuración permite mantener la velocidad de ejecución mientras preservamos todas las ventajas del tipado estático.

// jest.config.js
module.exports = {
    preset: 'ts-jest',
    testEnvironment: 'node',
    roots: ['<rootDir>/src'],
    testMatch: ['**/__tests__/**/*.ts', '**/?(*.)+(spec|test).ts'],
    collectCoverageFrom: [
        'src/**/*.ts',
        '!src/**/*.d.ts'
    ]
};

Tipos de pruebas en TypeScript

Las pruebas unitarias en TypeScript se benefician enormemente del sistema de tipos. Podemos crear pruebas que no solo verifican el comportamiento, sino que también validan que los tipos de entrada y salida sean correctos.

describe('Calculadora', () => {
    test('debe sumar dos números correctamente', () => {
        const resultado = sumar(2, 3);
        expect(resultado).toBe(5);
        // TypeScript garantiza que resultado es number
    });
});

Las pruebas de integración aprovechan las interfaces de TypeScript para definir contratos claros entre componentes. Esto facilita la creación de mocks y stubs que respeten exactamente la estructura esperada.

interface UsuarioService {
    obtenerUsuario(id: string): Promise<Usuario>;
    crearUsuario(datos: CrearUsuarioDto): Promise<Usuario>;
}

// Mock que respeta la interfaz
const mockUsuarioService: UsuarioService = {
    obtenerUsuario: jest.fn(),
    crearUsuario: jest.fn()
};

Mocking y stubbing con tipos

El mocking en TypeScript requiere especial atención a los tipos para mantener la seguridad que proporciona el lenguaje. Las librerías modernas como jest ofrecen utilidades específicas para crear mocks tipados.

// Mock tipado de una función
const mockFetch = jest.fn() as jest.MockedFunction<typeof fetch>;

// Mock de una clase completa
jest.mock('./UserService');
const MockedUserService = UserService as jest.MockedClass<typeof UserService>;

Los test doubles en TypeScript pueden implementarse usando tipos genéricos para crear soluciones reutilizables que mantengan la compatibilidad de tipos en diferentes contextos.

Aserciones y matchers tipados

Las aserciones tipadas representan una evolución natural del testing tradicional. TypeScript permite crear matchers personalizados que no solo verifican valores, sino que también proporcionan información de tipos precisa.

// Matcher personalizado con tipos
expect.extend({
    toBeValidEmail(received: string) {
        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
        const pass = emailRegex.test(received);
        
        return {
            message: () => `expected ${received} ${pass ? 'not ' : ''}to be a valid email`,
            pass
        };
    }
});

// Uso con autocompletado y verificación de tipos
expect("usuario@ejemplo.com").toBeValidEmail();

Testing de código asíncrono

El testing asíncrono en TypeScript se beneficia del soporte nativo para async/await y Promises tipadas. Esto elimina muchos de los problemas comunes relacionados con el manejo de operaciones asíncronas en las pruebas.

async function obtenerDatosUsuario(id: string): Promise<Usuario> {
    const response = await fetch(`/api/usuarios/${id}`);
    return response.json();
}

test('debe obtener datos de usuario', async () => {
    const usuario = await obtenerDatosUsuario('123');
    expect(usuario).toHaveProperty('id', '123');
    // TypeScript infiere que usuario es de tipo Usuario
});

Cobertura de código y métricas

La cobertura de código en proyectos TypeScript debe considerar tanto el código fuente como los archivos de definición de tipos. Las herramientas modernas pueden generar reportes que excluyen automáticamente archivos .d.ts y se centran en el código de implementación real.

El análisis de cobertura también puede extenderse para incluir cobertura de tipos, verificando que todas las ramas de tipos union y los casos de tipos condicionales estén adecuadamente probados.

type EstadoPedido = 'pendiente' | 'procesando' | 'completado' | 'cancelado';

function procesarPedido(estado: EstadoPedido): string {
    switch (estado) {
        case 'pendiente':
            return 'Pedido recibido';
        case 'procesando':
            return 'Preparando pedido';
        case 'completado':
            return 'Pedido entregado';
        case 'cancelado':
            return 'Pedido cancelado';
        default:
            // TypeScript garantiza exhaustividad
            const _exhaustive: never = estado;
            throw new Error(`Estado no manejado: ${_exhaustive}`);
    }
}