Saltar al contenido
Herramientas y ecosistema

Testing

Lección 4 de 612 min4 ejercicios

Cambiar código da miedo cuando no sabes qué puedes romper. Las pruebas automáticas son código que comprueba tu código: las ejecutas en segundos, cada vez que cambias algo, y te avisan si algo dejó de funcionar. Con ellas puedes mejorar un programa sin miedo.

Una prueba

Una prueba ejecuta una pieza de código y comprueba el resultado. Si la comprobación falla, la prueba falla:

// precio.js
export function conDescuento(precio, porcentaje) {
  if (porcentaje < 0 || porcentaje > 100) throw new RangeError("porcentaje inválido");
  return precio * (1 - porcentaje / 100);
}
// precio.test.js, con el ejecutor incluido en Node.js
import { describe, it } from "node:test";
import assert from "node:assert/strict";
import { conDescuento } from "./precio.js";

describe("conDescuento", () => {
  it("aplica el porcentaje", () => {
    assert.equal(conDescuento(200, 25), 150);
  });

  it("sin descuento devuelve el mismo precio", () => {
    assert.equal(conDescuento(80, 0), 80);
  });

  it("rechaza porcentajes imposibles", () => {
    assert.throws(() => conDescuento(80, 120), RangeError);
  });
});
node --test            # busca y ejecuta los archivos *.test.js
node --test --watch    # vuelve a ejecutar al guardar

Vitest

Vitest es el ejecutor más usado en proyectos con Vite. Usa expect, con la API de Jest, y se integra con la configuración de Vite (TypeScript, alias, plugins):

import { describe, it, expect } from "vitest";
import { conDescuento } from "./precio.js";

describe("conDescuento", () => {
  it("aplica el porcentaje", () => {
    expect(conDescuento(200, 25)).toBe(150);
  });

  it("devuelve objetos iguales", () => {
    expect({ total: 150, moneda: "PEN" }).toEqual({ total: 150, moneda: "PEN" });   // compara el contenido
  });
});

toBe compara con ===; toEqual, el contenido de objetos y arrays. Hay muchos más: toContain, toThrow, toMatch, toBeCloseTo (para decimales)…

Asíncronas, ganchos y mocks

import { describe, it, expect, beforeEach, vi } from "vitest";

describe("carrito", () => {
  let carrito;
  beforeEach(() => {
    carrito = [];   // cada prueba empieza con un carrito limpio
  });

  it("espera promesas con async/await", async () => {
    const datos = await Promise.resolve({ ok: true });
    expect(datos.ok).toBe(true);
  });

  it("controla el tiempo y las funciones con mocks", () => {
    vi.useFakeTimers();
    const avisar = vi.fn();                 // una función de mentira que registra sus llamadas
    setTimeout(avisar, 1000);
    vi.advanceTimersByTime(1000);           // adelanta el reloj sin esperar
    expect(avisar).toHaveBeenCalledTimes(1);
    vi.useRealTimers();
  });
});

Qué probar

  • Pruebas unitarias: una función o un módulo, aislados. Muchas, rápidas.
  • Pruebas de integración: varias piezas juntas (tu API con una base de datos de prueba).
  • Pruebas de extremo a extremo (E2E): la aplicación entera en un navegador real, como un usuario, con Playwright. Pocas, pero valiosas: este sitio se prueba así.

Prueba el comportamiento (qué devuelve, qué muestra), no los detalles internos: así puedes reescribir el código sin reescribir las pruebas. Y prueba los casos borde: vacío, cero, negativo, el máximo, el error.

Resumen

  • Una prueba ejecuta código y comprueba el resultado; corre en segundos cada vez que cambias algo.
  • node:test + node:assert vienen con Node.js; Vitest es la opción con Vite.
  • toBe compara con ===; toEqual, el contenido.
  • Pruebas asíncronas con async/await; beforeEach para empezar limpio; mocks para la red, el tiempo y las dependencias.
  • Muchas unitarias, algunas de integración, pocas E2E. Prueba el comportamiento y los casos borde.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Código que comprueba código

Elige una respuesta en cada pregunta.

  1. ¿Qué es una prueba unitaria?

  2. ¿Necesitas instalar algo para escribir pruebas en Node.js?

  3. ¿Qué es un mock?

  4. Si una prueba falla, ¿dónde está el error?

Ordena la salida: Los ganchos de una suite

Una suite con ganchos que avisan cuándo corren. Ordena lo que aparecería en la terminal.

import { describe, it, before, beforeEach, after } from "node:test"; describe("carrito", () => {  let n = 0;  before(() => console.log("before"));  beforeEach(() => console.log("beforeEach", ++n));  after(() => console.log("after"));   it("agrega", () => console.log("prueba: agrega"));  it("quita", () => console.log("prueba: quita"));});

Consola, de arriba abajo

  1. beforeEach 2
  2. after
  3. before
  4. prueba: agrega
  5. prueba: quita
  6. beforeEach 1

Detective: Una prueba que falla

Una prueba falla. Antes de tocar el código, encuentra dónde está el error de verdad y elige el arreglo.

Consola

✖ suma dos números (0.8ms)
  AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:

  2 !== 3

      at TestContext.<anonymous> (file:///proyecto/sumar.test.js:6:10)

ℹ tests 1
ℹ pass 0
ℹ fail 1

Paso 1: toca la línea de código que causa el error.

Laboratorio: Probar y arreglar

Con un mini ejecutor de pruebas, escribe tres pruebas para precioFinal, descubre el error y arréglalo.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Hay al menos tres pruebas (pendiente)
  • Todas las pruebas pasan (pendiente)
  • La función está arreglada: precioFinal(80, 25) da 60 (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.