Creación de test en nodejs sin librerías

Para iniciar una estrategia de pruebas sin depender de bibliotecas externas, se puede crear un script de JavaScript que invoque las funciones a examinar y verifique manualmente sus resultados. Esta técnica implica ejecutar el script con Node.js y comprobar si se producen errores en la salida. Al no requerir librerías externas, se ofrece un método muy básico de evaluación, aunque suficiente para proyectos pequeños o de demostración.

Un ejemplo sencillo consiste en exportar una función desde un módulo para luego importarla en el script de pruebas y, mediante comprobaciones con bloques if, determinar si la función produce la respuesta esperada. En caso negativo, se lanza un error que detenga la ejecución. 

A continuación se muestra un ejemplo sobre un archivo funciones.mjs:

// archivo funciones.mjs
export function sum(a, b) {
    return a + b;
}

Archivo test.mjs para creación de tests que prueben las funciones del archivo anterior.

// archivo test.mjs
import { sum } from "./funciones.mjs";

function testSum() {
    const resultado = sum(2, 3);
    if (resultado !== 5) {
        throw new Error("La función suma no retorna el valor correcto");
    }
    console.log("Test de suma superado");
}

testSum();
console.log("Todos los test han finalizado");

En el ejemplo anterior, se lanza un error con throw si el resultado no coincide con el valor esperado. De este modo, se controla manualmente la ejecución y se informa al desarrollador en la consola cuando el test ha fallado o ha pasado con éxito. Usar esta aproximación requiere disciplina para ir añadiendo más comprobaciones de manera organizada y, a medida que el proyecto crezca, podría complementarse con técnicas adicionales para abarcar más casos. De todas formas, este sistema ofrece un punto de partida fundamental para entender la mecánica básica de las pruebas en Node.js sin apoyarse en otras dependencias.

Aserciones nativas de nodejs

El módulo assert de Node.js ofrece un conjunto de métodos específicos para verificar valores en los test. Utiliza una sintaxis directa y permite lanzar excepciones si algo no coincide con la expectativa, lo que facilita la identificación de fallos de inmediato. Se importa mediante require en entornos CommonJS y también puede usarse junto con el estándar ES Modules.

Para usar assert, basta con llamar a métodos como strictEqual o deepStrictEqual dentro de tus pruebas. Estas funciones comparan dos valores y lanzan un error en caso de discrepancia. Un ejemplo básico puede verse en este snippet:

// archivo test.mjs
import { sum } from "./funciones.mjs";
import { strictEqual } from "assert";

const result = sum(2, 3);
strictEqual(result, 5, "La suma debería dar 5");

console.log("Test de aserción nativa superado");

Este fragmento emplea la función strictEqual para comprobar que resultado coincida exactamente con el valor esperado. Al originarse un error si los valores no coinciden, se detiene la ejecución y se muestra el mensaje proporcionado. Así se logra un control de verificación en un estilo más claro que el uso de condicionales sueltos.

Existen métodos adicionales como assert.throws() para probar excepciones o assert.deepStrictEqual() para examinar la estructura interna de objetos. Cada método está pensado para cubrir diferentes casuísticas en escenarios de test y se puede intercalar con otras técnicas de prueba sin requerir bibliotecas de terceros. Este enfoque simplifica la detección de errores lógicos y procesa las comprobaciones de forma clara, convirtiéndose en un complemento útil para proyectos que comienzan a requerir validaciones más organizadas.

Testing unitario en nodejs

Para estructurar el testing unitario en proyectos de Node.js, es recomendable ubicar los archivos de prueba en una carpeta independiente, a menudo llamada test. Con esta disposición, se facilita la localización de los test y se crea una separación clara respecto al código fuente. De este modo, cada fichero de prueba puede enfocarse en un único módulo o función, promoviendo la legibilidad y el mantenimiento continuado.

En tests unitarios conviene emplear nombres descriptivos en cada archivo, por ejemplo funciones.test.js, para identificar rápidamente lo que se está verificando. Además, es útil crear pequeños bloques de verificación centrados en un comportamiento específico, de tal forma que sea sencillo aislar errores y mantener cada comprobación bien definida. Este enfoque minimiza la dependencia entre funcionalidades y favorece la corrección temprana de posibles incidencias.

Con Node.js se puede utilizar el módulo integrado node:test, que ofrece una manera organizada de agrupar casos de prueba y simplificar la ejecución. Un ejemplo básico podría verse así:

import test from "node:test";
import { equal, throws } from "node:assert/strict"; // versión strict de las aserciones

function divide(a, b) {
    if (b === 0) {
        throw new Error("Division by zero is not allowed.");
    }
    return a / b;
}

test("Comprobar división con valores positivos", () => {
    const result = divide(6, 3);
    equal(result, 2);
});

test("Comprobar división cuando el divisor es cero", () => {
    throws(() => divide(5, 0), { message: "Division by zero is not allowed." });
});

En este snippet se usan bloques test independientes para realizar verificaciones centradas y autónomas. A cada bloque se le asigna un texto explicativo que agiliza la comprensión de la funcionalidad evaluada. Asimismo, el uso de assert.throws() permite profundizar en el comportamiento ante errores esperados, lo cual es crucial para la robustez del código.

Para ejecutar varios archivos de prueba simultáneamente, se puede definir un script en el fichero package.json. Por ejemplo:

{
  "scripts": {
    "test": "node --test"
  }
}

Con esta configuración, al lanzar npm run test o npm test todos los archivos con extensión .test.js se recolectan y se ejecutan de forma unificada. Dicho enfoque agiliza el ciclo de desarrollo y reduce la posibilidad de pasar por alto algún fichero de pruebas. Además, es factible personalizar la ejecución, incluyendo banderas o restricciones para pruebas más exhaustivas, algo que puede ajustarse a las necesidades de cada proyecto.

El testing unitario dispone de un alto valor si se ejecuta con regularidad y se revisa ante cada cambio de código. El objetivo es detectar regresiones lo antes posible, revisando comportamientos clave y verificando que la funcionalidad se mantenga intacta. Una vez establecidos estos hábitos, la calidad y estabilidad del proyecto mejoran de forma significativa sin necesidad de introducir librerías adicionales.