Módulo assert

Módulo assert

El módulo assert es una herramienta nativa de Node.js que nos permite verificar que nuestro código funciona correctamente mediante pruebas unitarias. Este módulo proporciona un conjunto de funciones de aserción que comprueban si las condiciones que esperamos se cumplen, lanzando errores cuando no es así.

Las pruebas unitarias son fundamentales en el desarrollo profesional porque nos ayudan a detectar errores antes de que lleguen a producción y nos dan confianza para modificar código existente. El módulo assert viene incluido con Node.js, por lo que no necesitamos instalar dependencias adicionales para comenzar a escribir nuestros primeros tests.

Importación y configuración básica

Para utilizar el módulo assert, simplemente lo importamos usando la sintaxis de módulos CommonJS que ya conocemos:

const assert = require('assert');

También podemos usar la versión strict del módulo, que aplica comparaciones más rigurosas:

const assert = require('assert/strict');

La diferencia principal es que la versión strict utiliza comparaciones estrictas (===) por defecto, mientras que la versión normal puede usar comparaciones más flexibles en algunos casos.

Funciones básicas de aserción

El módulo assert proporciona varias funciones para verificar diferentes condiciones. Las más utilizadas son:

assert.strictEqual() comprueba que dos valores sean idénticos:

const assert = require('assert/strict');

function sumar(a, b) {
  return a + b;
}

// Test básico
assert.strictEqual(sumar(2, 3), 5);
console.log('✓ Test de suma pasó correctamente');

assert.deepStrictEqual() verifica que dos objetos o arrays tengan la misma estructura y valores:

const usuario = {
  nombre: 'Ana',
  edad: 25,
  activo: true
};

const usuarioEsperado = {
  nombre: 'Ana',
  edad: 25,
  activo: true
};

assert.deepStrictEqual(usuario, usuarioEsperado);
console.log('✓ Test de objeto pasó correctamente');

assert.throws() verifica que una función lance un error cuando debería:

function dividir(a, b) {
  if (b === 0) {
    throw new Error('División por cero no permitida');
  }
  return a / b;
}

// Verificamos que se lance el error esperado
assert.throws(
  () => dividir(10, 0),
  Error,
  'División por cero no permitida'
);
console.log('✓ Test de error pasó correctamente');

Creando nuestro primer archivo de tests

Para organizar mejor nuestros tests, creamos archivos separados. Supongamos que tenemos un archivo calculadora.js:

// calculadora.js
function sumar(a, b) {
  return a + b;
}

function restar(a, b) {
  return a - b;
}

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

module.exports = { sumar, restar, multiplicar };

Ahora creamos un archivo calculadora.test.js para nuestros tests:

// calculadora.test.js
const assert = require('assert/strict');
const { sumar, restar, multiplicar } = require('./calculadora');

// Test para la función sumar
console.log('Ejecutando tests de calculadora...');

try {
  // Test 1: Suma de números positivos
  assert.strictEqual(sumar(5, 3), 8);
  console.log('✓ Suma de números positivos');

  // Test 2: Suma con cero
  assert.strictEqual(sumar(5, 0), 5);
  console.log('✓ Suma con cero');

  // Test 3: Resta básica
  assert.strictEqual(restar(10, 4), 6);
  console.log('✓ Resta básica');

  // Test 4: Multiplicación
  assert.strictEqual(multiplicar(3, 4), 12);
  console.log('✓ Multiplicación básica');

  console.log('\n🎉 Todos los tests pasaron correctamente');
} catch (error) {
  console.error('❌ Test falló:', error.message);
  process.exit(1);
}

Para ejecutar nuestros tests, simplemente usamos Node.js:

node calculadora.test.js

Organizando tests con funciones

Para hacer nuestros tests más legibles y mantenibles, podemos organizarlos en funciones:

const assert = require('assert/strict');
const { sumar, restar, multiplicar } = require('./calculadora');

function testSumar() {
  console.log('Probando función sumar...');
  
  assert.strictEqual(sumar(2, 3), 5);
  assert.strictEqual(sumar(-1, 1), 0);
  assert.strictEqual(sumar(0, 0), 0);
  
  console.log('✓ Todos los tests de sumar pasaron');
}

function testRestar() {
  console.log('Probando función restar...');
  
  assert.strictEqual(restar(5, 3), 2);
  assert.strictEqual(restar(0, 5), -5);
  assert.strictEqual(restar(10, 10), 0);
  
  console.log('✓ Todos los tests de restar pasaron');
}

function ejecutarTodos() {
  try {
    testSumar();
    testRestar();
    console.log('\n🎉 Suite de tests completada exitosamente');
  } catch (error) {
    console.error('❌ Error en tests:', error.message);
    process.exit(1);
  }
}

// Ejecutar todos los tests
ejecutarTodos();

Probando funciones asíncronas

Cuando trabajamos con funciones asíncronas, necesitamos adaptar nuestros tests. Supongamos que tenemos una función que simula una operación asíncrona:

// async-utils.js
function operacionAsincrona(valor) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (valor > 0) {
        resolve(valor * 2);
      } else {
        reject(new Error('El valor debe ser positivo'));
      }
    }, 100);
  });
}

module.exports = { operacionAsincrona };

Para probar esta función, creamos tests asíncronos:

// async-utils.test.js
const assert = require('assert/strict');
const { operacionAsincrona } = require('./async-utils');

async function testOperacionExitosa() {
  console.log('Probando operación asíncrona exitosa...');
  
  const resultado = await operacionAsincrona(5);
  assert.strictEqual(resultado, 10);
  
  console.log('✓ Test asíncrono exitoso pasó');
}

async function testOperacionConError() {
  console.log('Probando operación asíncrona con error...');
  
  try {
    await operacionAsincrona(-1);
    assert.fail('Debería haber lanzado un error');
  } catch (error) {
    assert.strictEqual(error.message, 'El valor debe ser positivo');
  }
  
  console.log('✓ Test asíncrono con error pasó');
}

async function ejecutarTestsAsincronos() {
  try {
    await testOperacionExitosa();
    await testOperacionConError();
    console.log('\n🎉 Tests asíncronos completados');
  } catch (error) {
    console.error('❌ Error en tests asíncronos:', error.message);
    process.exit(1);
  }
}

ejecutarTestsAsincronos();

Buenas prácticas para tests básicos

Al escribir tests con el módulo assert, es importante seguir algunas prácticas recomendadas:

• Nombres descriptivos: Cada test debe tener un nombre que explique claramente qué está probando.

• Un concepto por test: Cada test debe verificar una sola funcionalidad específica.

• Casos límite: Incluye tests para valores extremos como cero, números negativos, strings vacíos, etc.

• Mensajes claros: Usa mensajes descriptivos en las aserciones para facilitar la depuración.

const assert = require('assert/strict');

function validarEmail(email) {
  if (!email || !email.includes('@')) {
    throw new Error('Email inválido');
  }
  return true;
}

// Tests con buenas prácticas
function testValidacionEmail() {
  // Test caso válido
  assert.strictEqual(validarEmail('usuario@ejemplo.com'), true);
  
  // Test email vacío
  assert.throws(
    () => validarEmail(''),
    Error,
    'Email inválido'
  );
  
  // Test email sin @
  assert.throws(
    () => validarEmail('usuarioejemplo.com'),
    Error,
    'Email inválido'
  );
  
  // Test email null
  assert.throws(
    () => validarEmail(null),
    Error,
    'Email inválido'
  );
  
  console.log('✓ Todos los tests de validación de email pasaron');
}

testValidacionEmail();

El módulo assert nos proporciona una base sólida para comenzar con el testing unitario en Node.js. Aunque existen frameworks más avanzados, dominar assert nos ayuda a entender los fundamentos del testing y nos permite crear verificaciones rápidas y efectivas para nuestro código.