En el desarrollo de software, las pruebas unitarias son una práctica crucial que ayuda a garantizar la corrección de su código.

El capítulo 9 de Clean Code: A Handbook of Agile Software Craftsmanship, titulado "Pruebas unitarias", profundiza en los principios y prácticas para escribir pruebas unitarias limpias y efectivas.

En este artículo, resumiremos las conclusiones clave del capítulo y proporcionaremos ejemplos de JavaScript para ilustrar estos conceptos.

? Por qué son importantes las pruebas unitarias

Las pruebas unitarias implican escribir pruebas para unidades o componentes individuales de su código para verificar que funcionan como se espera. Los objetivos principales de las pruebas unitarias son:

1- Detectar errores tempranamente: Detectar problemas durante el desarrollo antes de que lleguen a producción.

2- Facilite la refactorización: Asegúrese de que los cambios en su código no interrumpan la funcionalidad existente.

3- Comportamiento del código del documento: Sirve como documentación sobre cómo se pretende utilizar el código.

? Principios de pruebas unitarias efectivas

⚡ Pruebe una cosa a la vez

Cada prueba unitaria debe centrarse en un único aspecto de la funcionalidad. Esto hace que las pruebas sean más fáciles de entender y mantener. Si una prueba falla, sabrá exactamente dónde radica el problema.

function add(a, b) {
    return a   b;
}

// Test case for the add function
function testAdd() {
    // Test adding positive numbers
    assertEqual(add(2, 3), 5, '2   3 should be 5');
    // Test adding negative numbers
    assertEqual(add(-1, -1), -2, '-1   -1 should be -2');
}

// A simple assertion function
function assertEqual(actual, expected, message) {
    if (actual !== expected) {
        throw new Error(message);
    }
}

⚡ Hacer que las pruebas sean legibles

Tus pruebas deben ser fáciles de leer y comprender. Utilice nombres descriptivos para sus funciones de prueba y afirmaciones claras. Esto ayuda a otros (y a usted mismo) a comprender rápidamente lo que verifica cada prueba.

function isEven(number) {
    return number % 2 === 0;
}

// Descriptive test function
function testIsEven() {
    assertEqual(isEven(4), true, '4 should be even');
    assertEqual(isEven(5), false, '5 should be odd');
}

⚡ Utilice nombres claros y descriptivos

Los nombres de los casos de prueba deben describir lo que están probando. Esto mejora la legibilidad y el mantenimiento de sus pruebas.

function calculateTotalPrice(items) {
    return items.reduce((total, item) => total   item.price, 0);
}

// Descriptive test case names
function testCalculateTotalPrice() {
    assertEqual(calculateTotalPrice([{ price: 10 }, { price: 20 }]), 30, 'Total price should be 30 for items costing 10 and 20');
    assertEqual(calculateTotalPrice([{ price: 5 }]), 5, 'Total price should be 5 for a single item costing 5');
}

⚡ Mantenga las pruebas independientes

Cada prueba debe ser independiente de las demás. Las pruebas que dependen del estado compartido pueden generar pruebas inestables y dificultar la depuración.

function multiply(a, b) {
    return a * b;
}

// Independent test cases
function testMultiply() {
    assertEqual(multiply(2, 3), 6, '2 * 3 should be 6');
    assertEqual(multiply(0, 10), 0, '0 * 10 should be 0');
}

⚡ Utilice simulacros y talones de forma adecuada

Los simulacros y apéndices pueden ayudar a aislar la unidad de código bajo prueba mediante la simulación de dependencias. Sin embargo, utilícelos con prudencia para evitar complicar demasiado las pruebas.

// Example of using a mock for a database call
function getUser(id) {
    // Imagine this function makes a database call
    return database.getUserById(id);
}

function testGetUser() {
    const mockDatabase = {
        getUserById: (id) => ({ id, name: 'John Doe' }),
    };

    const result = getUser(1, mockDatabase);
    assertEqual(result.name, 'John Doe', 'User name should be John Doe');
}

⚡ Automatizar pruebas

Automatice la ejecución de sus pruebas unitarias para garantizar que se ejecuten con regularidad. Las herramientas de integración continua (CI) pueden ayudarle a ejecutar sus pruebas automáticamente cada vez que se realicen cambios.

Si estás utilizando un marco de prueba como Jest, puedes configurar un script en tu paquete.json:

"scripts": {
    "test": "jest"
}

La ejecución de npm test ejecutará todas sus pruebas y proporcionará comentarios sobre su estado.

Conclusión

Escribir pruebas unitarias limpias y efectivas es esencial para mantener un código de alta calidad.

Si sigue los principios descritos en el Capítulo 9 del Código Limpio, puede asegurarse de que sus pruebas sean confiables, comprensibles y valiosas.

La implementación de estas prácticas en su código JavaScript no solo mejorará la calidad de sus pruebas, sino que también contribuirá a una base de código más sólida y fácil de mantener.

¡Feliz codificación!