const tablero = new Tablero('Taller Nómada', crearBacklog());
tablero.resumen('2026-09-20');
// { total: 6, abiertas: 5, horasTotales: 48, horasAbiertas: 45, vencidas: 1, esfuerzo: 124 }

test('el resumen del backlog canónico da 45 h abiertas de 48', () => {
  const tablero = new Tablero('Taller Nómada', crearBacklog());
  expect(tablero.resumen('2026-09-20').horasAbiertas).toBe(45);
});

describe('Tarea · transiciones de estado (R6)', () => {
  test('pendiente → en-curso está permitido', () => { … });
  test('en-curso → hecha está permitido', () => { … });
  test('en-curso → pendiente está permitido (se puede devolver una tarea)', () => { … });
  test('hecha → en-curso lanza ErrorDeValidacion: una tarea hecha no se reabre', () => { … });
  test('pendiente → hecha lanza ErrorDeValidacion: hay que empezarla antes', () => { … });
});

npm install --save-dev jest

nomada-tareas/
  js/                       ← la aplicación (se despliega)
  pruebas/                  ← las pruebas (nunca se despliegan)
    modelo/
      tarea.test.js
      tablero.test.js
    util/
      fechas.test.js
    ayudas/
      backlog-de-prueba.js  ← utilidades compartidas, sin pruebas dentro

{
  "scripts": {
    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
    "test:watch": "npm test -- --watch",
    "test:cov": "npm test -- --coverage"
  }
}

$ npm test

 PASS  pruebas/modelo/tarea.test.js
 PASS  pruebas/modelo/tablero.test.js

Test Suites: 2 passed, 2 total
Tests:       31 passed, 31 total
Snapshots:   0 total
Time:        0.842 s

npm run test:watch

// package.json
{
  "type": "module",
  "scripts": {
    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
  }
}

// jest.config.js
export default {
  // 'node' basta para el modelo: no toca DOM. En 08-05 cambiará a 'jsdom'.
  testEnvironment: 'node',

  // Sin transformaciones: Node entiende los import tal cual.
  transform: {},

  testMatch: ['**/pruebas/**/*.test.js'],

  // Ficheros de la aplicación que cuentan para la cobertura
  collectCoverageFrom: ['js/**/*.js', '!js/app.js'],

  // Salida más legible cuando algo falla
  verbose: false
};

// babel.config.js — solo si eliges el camino B
export default {
  presets: [['@babel/preset-env', { targets: { node: 'current' } }]]
};

// pruebas/modelo/tarea.test.js
import { Tarea } from '../../js/modelo/tarea.js';
import { ErrorDeValidacion } from '../../js/modelo/errores.js';

const DATOS_VALIDOS = {
  id: 1,
  titulo: 'Rediseñar la sala polivalente',
  responsable: 'Iván',
  prioridad: 'alta',
  estado: 'en-curso',
  etiquetas: ['espacio', 'diseño'],
  horasEstimadas: 12,
  fechaLimite: '2026-09-30',
  revisor: 'Marta'
};

describe('Tarea', () => {
  describe('construcción', () => {
    test('conserva el título sin espacios sobrantes', () => {
      // Preparar (Arrange)
      const datos = { ...DATOS_VALIDOS, titulo: '  Rediseñar la sala  ' };

      // Actuar (Act)
      const tarea = new Tarea(datos);

      // Comprobar (Assert)
      expect(tarea.titulo).toBe('Rediseñar la sala');
    });
  });
});

// Comprueba SOLO lo que importa a esta prueba; el resto puede cambiar sin romperla
expect(tablero.resumen(HOY)).toMatchObject({ horasAbiertas: 45, vencidas: 1 });

// Frente a esto, que se rompe si mañana el resumen añade un campo nuevo:
expect(tablero.resumen(HOY)).toStrictEqual({
  total: 6, abiertas: 5, horasTotales: 48, horasAbiertas: 45, vencidas: 1, esfuerzo: 124
});

const a = { id: 1, titulo: 'Rediseñar la sala' };
const b = { id: 1, titulo: 'Rediseñar la sala' };

expect(a).toBe(b);       // ✗ FALLA: son dos objetos distintos en memoria
expect(a).toEqual(b);    // ✓ pasa: tienen el mismo contenido
expect(a).toBe(a);       // ✓ pasa: es literalmente el mismo objeto

// 1 · Propiedades con valor undefined
expect({ id: 1, revisor: undefined }).toEqual({ id: 1 });        // ✓ pasa: toEqual las ignora
expect({ id: 1, revisor: undefined }).toStrictEqual({ id: 1 });  // ✗ falla: son distintos

// 2 · Tipo de clase
class Tarea { constructor() { this.id = 1; } }
expect(new Tarea()).toEqual({ id: 1 });          // ✓ pasa: mismo contenido
expect(new Tarea()).toStrictEqual({ id: 1 });    // ✗ falla: una es Tarea, el otro objeto plano

// 3 · Huecos en arrays
expect([, 1]).toEqual([undefined, 1]);           // ✓ pasa
expect([, 1]).toStrictEqual([undefined, 1]);     // ✗ falla

test('el getter tareas devuelve una copia, no el array interno', () => {
  const tablero = new Tablero('Taller Nómada', crearBacklog());

  expect(tablero.tareas).not.toBe(tablero.tareas);   // dos llamadas, dos arrays distintos
  expect(tablero.tareas).toEqual(tablero.tareas);    // pero con el mismo contenido
});

// ❌ MAL: la excepción se lanza al evaluar el argumento, antes de llegar a expect
expect(new Tarea({ titulo: '' })).toThrow(ErrorDeValidacion);

// ✅ BIEN: se pasa una FUNCIÓN que Jest ejecutará dentro de un try/catch
expect(() => new Tarea({ titulo: '' })).toThrow(ErrorDeValidacion);

const crear = () => new Tarea({ id: 1, titulo: '   ', horasEstimadas: 4 });

expect(crear).toThrow();                              // 1 · lanza algo
expect(crear).toThrow(ErrorDeValidacion);             // 2 · lanza ESE tipo
expect(crear).toThrow('El título no puede estar vacío.');  // 3 · el mensaje CONTIENE ese texto
expect(crear).toThrow(/título/i);                     // 4 · el mensaje casa con la expresión regular

// Patrón A · try/catch explícito con expect.assertions
test('el error de horas identifica el campo horasEstimadas', () => {
  expect.assertions(3);            // ← garantiza que las 3 aserciones se ejecutan

  try {
    new Tarea({ id: 1, titulo: 'Prueba', horasEstimadas: 99 });
  } catch (error) {
    expect(error).toBeInstanceOf(ErrorDeValidacion);
    expect(error.campo).toBe('horasEstimadas');
    expect(error.valorRecibido).toBe(99);
  }
});

// Patrón B · capturar con una función auxiliar (más legible cuando se repite)
function capturar(fn) {
  try { fn(); return null; } catch (error) { return error; }
}

test('el error de horas identifica el campo horasEstimadas', () => {
  const error = capturar(() => new Tarea({ id: 1, titulo: 'Prueba', horasEstimadas: 99 }));

  expect(error).toBeInstanceOf(ErrorDeValidacion);
  expect(error).toMatchObject({ campo: 'horasEstimadas', valorRecibido: 99 });
});

describe('Tablero', () => {
  let tablero;

  beforeEach(() => {
    // Un tablero NUEVO para cada prueba: nadie hereda los cambios del vecino
    tablero = new Tablero('Taller Nómada', crearBacklog());
  });

  test('agrega las seis tareas del backlog', () => {
    expect(tablero.total).toBe(6);
  });

  test('cambiar de estado no altera el total', () => {
    tablero.cambiarEstado(2, 'en-curso');
    expect(tablero.total).toBe(6);
  });
});

describe('Tablero', () => {
  beforeEach(() => console.log('1 · fuera'));

  describe('con una tarea cerrada', () => {
    beforeEach(() => console.log('2 · dentro'));

    test('cuenta 4 abiertas', () => console.log('3 · prueba'));
  });
});
// Salida: 1 · fuera → 2 · dentro → 3 · prueba

// ❌ MAL: el tablero se crea UNA vez y todas las pruebas lo comparten
const tablero = new Tablero('Taller Nómada', crearBacklog());

test('la tarea 2 se puede empezar', () => {
  tablero.cambiarEstado(2, 'en-curso');
  expect(tablero.buscarPorId(2).estado).toBe('en-curso');
});

test('el backlog tiene 5 tareas abiertas', () => {
  expect(tablero.abiertas).toHaveLength(5);      // pasa… hasta que alguien cierre una arriba
});

test('la tarea 2 empieza en pendiente', () => {
  expect(tablero.buscarPorId(2).estado).toBe('pendiente');   // ✗ FALLA por culpa de la primera
});

// ✅ BIEN: beforeEach reconstruye el estado
let tablero;
beforeEach(() => { tablero = new Tablero('Taller Nómada', crearBacklog()); });

describe('Tarea · transiciones de estado (R6)', () => {
  // ── Las permitidas ──────────────────────────────────────────────────
  test.each([
    ['pendiente', 'en-curso'],
    ['en-curso',  'hecha'],
    ['en-curso',  'pendiente']
  ])('permite pasar de %s a %s', (desde, hasta) => {
    const tarea = new Tarea({ ...DATOS_VALIDOS, estado: desde });

    tarea.cambiarEstado(hasta);

    expect(tarea.estado).toBe(hasta);
  });

  // ── Las prohibidas ──────────────────────────────────────────────────
  test.each([
    ['pendiente', 'pendiente'],
    ['pendiente', 'hecha'],       // hay que empezarla antes de terminarla
    ['en-curso',  'en-curso'],
    ['hecha',     'pendiente'],   // una tarea hecha no se reabre
    ['hecha',     'en-curso'],
    ['hecha',     'hecha']
  ])('prohíbe pasar de %s a %s', (desde, hasta) => {
    const tarea = new Tarea({ ...DATOS_VALIDOS, estado: desde });

    expect(() => tarea.cambiarEstado(hasta)).toThrow(ErrorDeValidacion);
  });
});

  Tarea · transiciones de estado (R6)
    ✓ permite pasar de pendiente a en-curso
    ✓ permite pasar de en-curso a hecha
    ✓ permite pasar de en-curso a pendiente
    ✓ prohíbe pasar de pendiente a pendiente
    ✓ prohíbe pasar de pendiente a hecha
    ✓ prohíbe pasar de en-curso a en-curso
    ✓ prohíbe pasar de hecha a pendiente
    ✓ prohíbe pasar de hecha a en-curso
    ✓ prohíbe pasar de hecha a hecha

describe('Tarea · validación de horas (R3)', () => {
  test.each`
    horas   | valido   | motivo
    ${0}    | ${false} | ${'cero no es un valor válido'}
    ${-3}   | ${false} | ${'negativo'}
    ${0.5}  | ${true}  | ${'media hora es admisible'}
    ${1}    | ${true}  | ${'límite inferior'}
    ${40}   | ${true}  | ${'límite superior exacto'}
    ${41}   | ${false} | ${'supera el máximo semanal'}
    ${NaN}  | ${false} | ${'NaN no es comparable'}
    ${'12'} | ${false} | ${'una cadena no es un número'}
  `('horasEstimadas $horas → $valido ($motivo)', ({ horas, valido }) => {
    const crear = () => new Tarea({ ...DATOS_VALIDOS, horasEstimadas: horas });

    if (valido) expect(crear().horasEstimadas).toBe(horas);
    else expect(crear).toThrow(ErrorDeValidacion);
  });
});

// ❌ MAL: la prueba termina antes de que la promesa se resuelva. Pasa siempre.
test('importa las tareas', () => {
  cargarTablero().then((tablero) => {
    expect(tablero.total).toBe(6);       // ← esto se ejecuta cuando nadie mira
  });
});

// ✅ BIEN: la función es async y se espera
test('importa las tareas', async () => {
  const tablero = await cargarTablero();
  expect(tablero.total).toBe(6);
});

// ✅ TAMBIÉN BIEN: devolver la promesa
test('importa las tareas', () => {
  return cargarTablero().then((tablero) => {
    expect(tablero.total).toBe(6);
  });
});

// resolves: aplica el matcher al valor RESUELTO
await expect(cargarTablero()).resolves.toMatchObject({ total: 6 });

// rejects: aplica el matcher al motivo del RECHAZO
await expect(cargarTablero('roto')).rejects.toThrow(ErrorDeDatos);
await expect(cargarTablero('roto')).rejects.toBeInstanceOf(ErrorDeDatos);

test('importar datos corruptos lanza ErrorDeDatos con la causa dentro', async () => {
  expect.assertions(2);

  try {
    await repositorio.cargarDesde('{{{ esto no es JSON');
  } catch (error) {
    expect(error).toBeInstanceOf(ErrorDeDatos);
    expect(error.causa).toBeInstanceOf(SyntaxError);
  }
});

// ── A · Función pura: entra un dato, sale un dato ─────────────────────
export function estaVencida(fechaLimite, estado, hoy = HOY) {
  return fechaLimite < hoy && estado !== 'hecha';
}

// ── B · Función impura: depende del mundo y lo modifica ───────────────
export function marcarVencidas() {
  const hoy = new Date().toISOString().slice(0, 10);        // ① el reloj real
  const guardado = JSON.parse(localStorage.getItem('nomada:tablero:v1'));   // ② el almacén
  for (const t of guardado.tareas) {
    if (t.fechaLimite < hoy && t.estado !== 'hecha') {
      document.querySelector(`[data-id="${t.id}"]`).classList.add('vencida');  // ③ el DOM
    }
  }
}

test('una tarea con fecha pasada y sin terminar está vencida (R10)', () => {
  expect(estaVencida('2026-09-05', 'pendiente', '2026-09-20')).toBe(true);
});

// js/util/fechas.js — la fecha ENTRA como parámetro, con un valor por defecto
export function estaVencida(fechaLimite, estado, hoy = HOY) { … }

// js/modelo/tarea.js
estaVencida(hoy = HOY) { return fechaVencida(this.fechaLimite, this.#estado, hoy); }

// js/datos/repositorio-local.js — el almacén ENTRA por el constructor
constructor({ clave = CLAVE, almacen } = {}) {
  this.#almacen = almacen ?? (this.#persistente ? window.localStorage : almacenEnMemoria());
}

test('el presupuesto de la carpintería está vencido el 20 de septiembre', () => {
  const tablero = new Tablero('Taller Nómada', crearBacklog());

  expect(tablero.vencidas('2026-09-20')).toHaveLength(1);
  expect(tablero.vencidas('2026-09-20')[0].titulo).toBe('Presupuesto de la carpintería');
});

npm run test:cov

-------------------------|---------|----------|---------|---------|-------------------
File                     | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
-------------------------|---------|----------|---------|---------|-------------------
All files                |   84.21 |    78.94 |   88.23 |   84.05 |
 js/modelo               |   97.14 |    95.45 |     100 |   97.10 |
  errores.js             |     100 |      100 |     100 |     100 |
  tarea.js               |   96.42 |    94.11 |     100 |   96.36 | 88
  tablero.js             |     100 |      100 |     100 |     100 |
 js/util                 |     100 |      100 |     100 |     100 |
  fechas.js              |     100 |      100 |     100 |     100 |
  formato.js             |     100 |      100 |     100 |     100 |
 js/datos                |   42.85 |    28.57 |   50.00 |   42.30 | 34-58,71-88
  backlog.js             |     100 |      100 |     100 |     100 |
  repositorio-local.js   |   31.25 |    20.00 |   33.33 |   30.76 | 34-58,71-88
-------------------------|---------|----------|---------|---------|-------------------

// Esta "prueba" da 100 % de cobertura de la función… y no comprueba nada
test('resumen', () => {
  const tablero = new Tablero('Taller Nómada', crearBacklog());
  tablero.resumen('2026-09-20');     // se ejecuta entera. Cero aserciones.
});

export default {
  // …
  coverageThreshold: {
    global:                  { branches: 70, functions: 80, lines: 80 },
    './js/modelo/':          { branches: 95, functions: 100, lines: 95 },   // el corazón: exigente
    './js/vista/':           { branches: 50, functions: 60, lines: 60 }     // el DOM: integración (08-05)
  }
};

// ❌ No dicen nada
test('tablero', …);
test('funciona', …);
test('test 3', …);
test('cambiarEstado', …);

// ✅ Sujeto + comportamiento + condición
test('cambiarEstado lanza ErrorDeValidacion si la tarea no existe', …);
test('el resumen del backlog canónico da 45 h abiertas de 48', …);
test('agregar rechaza un id duplicado (R1)', …);
test('las etiquetas se normalizan a minúsculas y sin duplicados (R9)', …);

// ❌ Si falla, ¿qué está roto? Hay que leer el informe con lupa
test('el tablero funciona', () => {
  const tablero = new Tablero('Taller Nómada', crearBacklog());
  expect(tablero.total).toBe(6);
  tablero.cambiarEstado(2, 'en-curso');
  expect(tablero.buscarPorId(2).estado).toBe('en-curso');
  expect(tablero.resumen(HOY).horasAbiertas).toBe(45);
  expect(() => tablero.agregar(new Tarea(DATOS_VALIDOS))).toThrow();
});

// ✅ Cuatro pruebas, cuatro nombres, cuatro diagnósticos
test('el backlog canónico tiene 6 tareas', …);
test('cambiarEstado aplica la transición a la tarea indicada', …);
test('el resumen del backlog canónico da 45 h abiertas', …);
test('agregar rechaza un id duplicado (R1)', …);

test('el error de horas identifica el campo y el valor recibido', () => {
  const error = capturar(() => new Tarea({ ...DATOS_VALIDOS, horasEstimadas: 99 }));

  expect(error).toBeInstanceOf(ErrorDeValidacion);   // tres aserciones…
  expect(error.campo).toBe('horasEstimadas');        // …sobre el MISMO error…
  expect(error.valorRecibido).toBe(99);              // …= un solo motivo de fallo
});

describe('Tarea · escalado de prioridad (R11)', () => {
  test('una tarea vencida y de prioridad baja se escala a alta', () => {
    const tarea = new Tarea({ ...DATOS_VALIDOS, prioridad: 'baja',
                              fechaLimite: '2026-09-05', estado: 'pendiente' });

    expect(tarea.prioridadEfectiva('2026-09-20')).toBe('alta');
  });
});

● Tarea · escalado de prioridad (R11) › una tarea vencida y de prioridad baja se escala a alta
  TypeError: tarea.prioridadEfectiva is not a function

// js/modelo/tarea.js
prioridadEfectiva(hoy = HOY) {
  return 'alta';       // sí, así de mínimo. Ya lo corregirán las siguientes pruebas.
}

test('una tarea no vencida conserva su prioridad', () => {
  const tarea = new Tarea({ ...DATOS_VALIDOS, prioridad: 'baja', fechaLimite: '2026-11-30' });

  expect(tarea.prioridadEfectiva('2026-09-20')).toBe('baja');
});

Expected: "baja"   Received: "alta"

prioridadEfectiva(hoy = HOY) {
  return this.estaVencida(hoy) ? 'alta' : this.prioridad;
}

test('una tarea vencida de prioridad media conserva su prioridad', () => {
  const tarea = new Tarea({ ...DATOS_VALIDOS, prioridad: 'media', fechaLimite: '2026-09-05' });

  expect(tarea.prioridadEfectiva('2026-09-20')).toBe('media');
});

prioridadEfectiva(hoy = HOY) {
  return this.estaVencida(hoy) && this.prioridad === 'baja' ? 'alta' : this.prioridad;
}

// js/modelo/tarea.js
/** R11: lo vencido y de baja prioridad se escala; el resto conserva la suya. */
get #vencidaYDeBajaPrioridad() {
  return this.estaVencida() && this.prioridad === 'baja';
}

prioridadEfectiva(hoy = HOY) {
  return this.estaVencida(hoy) && this.prioridad === 'baja' ? 'alta' : this.prioridad;
}

// pruebas/ayudas/backlog-de-prueba.js
import { Tarea } from '../../js/modelo/tarea.js';
import { Tablero } from '../../js/modelo/tablero.js';
import { crearBacklog } from '../../js/datos/backlog.js';

/** Fecha canónica del proyecto: fija, para que las pruebas no dependan del calendario. */
export const HOY = '2026-09-20';

export const DATOS_VALIDOS = Object.freeze({
  id: 1, titulo: 'Rediseñar la sala polivalente', responsable: 'Iván',
  prioridad: 'alta', estado: 'en-curso', etiquetas: ['espacio', 'diseño'],
  horasEstimadas: 12, fechaLimite: '2026-09-30', revisor: 'Marta'
});

/** Una tarea válida a la que se le cambia lo que interese. */
export const unaTarea = (cambios = {}) => new Tarea({ ...DATOS_VALIDOS, ...cambios });

/** Un tablero NUEVO con el backlog canónico. Instancias frescas en cada llamada. */
export const unTablero = () => new Tablero('Taller Nómada', crearBacklog());

/** Captura la excepción de fn, o devuelve null si no lanza. */
export function capturar(fn) {
  try { fn(); return null; } catch (error) { return error; }
}

// pruebas/modelo/tarea.test.js
import { Tarea } from '../../js/modelo/tarea.js';
import { ErrorDeValidacion } from '../../js/modelo/errores.js';
import { HOY, DATOS_VALIDOS, unaTarea, capturar } from '../ayudas/backlog-de-prueba.js';

describe('Tarea', () => {
  // ── Construcción y validación ─────────────────────────────────────────
  describe('construcción', () => {
    test('conserva los datos válidos que recibe', () => {
      const tarea = unaTarea();

      expect(tarea).toMatchObject({
        id: 1, titulo: 'Rediseñar la sala polivalente',
        responsable: 'Iván', prioridad: 'alta', horasEstimadas: 12
      });
    });

    test('recorta los espacios del título', () => {
      expect(unaTarea({ titulo: '   Cartelería   ' }).titulo).toBe('Cartelería');
    });

    test.each([['', 'cadena vacía'], ['   ', 'solo espacios'], [null, 'null'], [42, 'un número']])(
      'rechaza el título %p (%s) con ErrorDeValidacion (R2)',
      (titulo) => {
        expect(() => unaTarea({ titulo })).toThrow(ErrorDeValidacion);
      }
    );

    test('el error de título identifica el campo y el valor recibido', () => {
      const error = capturar(() => unaTarea({ titulo: '  ' }));

      expect(error).toBeInstanceOf(ErrorDeValidacion);
      expect(error.campo).toBe('titulo');
      expect(error.valorRecibido).toBe('  ');
    });

    test('nace en pendiente si no se indica estado (R5)', () => {
      const { estado, ...sinEstado } = DATOS_VALIDOS;   // desestructuración de 04-07

      expect(new Tarea(sinEstado).estado).toBe('pendiente');
    });

    test('rechaza un estado desconocido', () => {
      expect(() => unaTarea({ estado: 'archivada' })).toThrow(ErrorDeValidacion);
    });

    test('una tarea sin responsable lo guarda como null, nunca como cadena vacía (R8)', () => {
      expect(unaTarea({ responsable: '' }).responsable).toBeNull();
      expect(unaTarea({ responsable: undefined }).responsable).toBeNull();
    });

    test('normaliza las etiquetas a minúsculas y sin duplicados (R9)', () => {
      const tarea = unaTarea({ etiquetas: ['Espacio', ' DISEÑO ', 'espacio', 'diseño'] });

      expect(tarea.etiquetas).toEqual(['espacio', 'diseño']);
    });
  });

  // ── Horas (R3), con los valores frontera ──────────────────────────────
  describe('horasEstimadas (R3)', () => {
    test.each`
      horas   | valido   | motivo
      ${0}    | ${false} | ${'cero'}
      ${-3}   | ${false} | ${'negativo'}
      ${1}    | ${true}  | ${'límite inferior'}
      ${40}   | ${true}  | ${'límite superior exacto'}
      ${41}   | ${false} | ${'supera el máximo'}
      ${NaN}  | ${false} | ${'NaN'}
      ${'12'} | ${false} | ${'cadena, no número'}
    `('$horas → válido: $valido ($motivo)', ({ horas, valido }) => {
      const crear = () => unaTarea({ horasEstimadas: horas });

      if (valido) expect(crear().horasEstimadas).toBe(horas);
      else expect(crear).toThrow(ErrorDeValidacion);
    });

    test('el setter valida igual que el constructor', () => {
      const tarea = unaTarea();

      expect(() => { tarea.horasEstimadas = 99; }).toThrow(ErrorDeValidacion);
      expect(tarea.horasEstimadas).toBe(12);        // y NO se ha modificado
    });
  });

  // ── Transiciones (R6) ─────────────────────────────────────────────────
  describe('transiciones de estado (R6)', () => {
    test.each([
      ['pendiente', 'en-curso'], ['en-curso', 'hecha'], ['en-curso', 'pendiente']
    ])('permite %s → %s', (desde, hasta) => {
      const tarea = unaTarea({ estado: desde });

      expect(tarea.cambiarEstado(hasta).estado).toBe(hasta);   // devuelve this: encadenable
    });

    test.each([
      ['pendiente', 'pendiente'], ['pendiente', 'hecha'], ['en-curso', 'en-curso'],
      ['hecha', 'pendiente'], ['hecha', 'en-curso'], ['hecha', 'hecha']
    ])('prohíbe %s → %s', (desde, hasta) => {
      expect(() => unaTarea({ estado: desde }).cambiarEstado(hasta)).toThrow(ErrorDeValidacion);
    });

    test('una transición inválida no deja la tarea a medias', () => {
      const tarea = unaTarea({ estado: 'hecha' });

      capturar(() => tarea.cambiarEstado('pendiente'));

      expect(tarea.estado).toBe('hecha');           // el estado no se ha corrompido
    });
  });

  // ── Vencimiento (R10) y derivados ─────────────────────────────────────
  describe('vencimiento (R10)', () => {
    test('vencida si la fecha pasó y no está hecha', () => {
      expect(unaTarea({ fechaLimite: '2026-09-05', estado: 'pendiente' }).estaVencida(HOY)).toBe(true);
    });

    test('no vencida si está hecha, aunque la fecha haya pasado', () => {
      expect(unaTarea({ fechaLimite: '2026-09-05', estado: 'hecha' }).estaVencida(HOY)).toBe(false);
    });

    test('no vencida el mismo día del límite', () => {
      expect(unaTarea({ fechaLimite: HOY, estado: 'pendiente' }).estaVencida(HOY)).toBe(false);
    });

    test('abierta es false solo cuando está hecha', () => {
      expect(unaTarea({ estado: 'pendiente' }).abierta).toBe(true);
      expect(unaTarea({ estado: 'en-curso' }).abierta).toBe(true);
      expect(unaTarea({ estado: 'hecha' }).abierta).toBe(false);
    });

    test('el esfuerzo es horas × peso de prioridad', () => {
      expect(unaTarea({ prioridad: 'alta', horasEstimadas: 12 }).esfuerzo).toBe(36);
      expect(unaTarea({ prioridad: 'media', horasEstimadas: 6 }).esfuerzo).toBe(12);
      expect(unaTarea({ prioridad: 'baja', horasEstimadas: 3 }).esfuerzo).toBe(3);
    });
  });

  // ── Serialización (retomando 04-08) ───────────────────────────────────
  describe('serialización', () => {
    test('toJSON incluye el estado privado, que de otro modo se perdería', () => {
      const tarea = unaTarea({ estado: 'en-curso' });

      expect(tarea.toJSON()).toStrictEqual({
        id: 1, titulo: 'Rediseñar la sala polivalente', responsable: 'Iván',
        prioridad: 'alta', estado: 'en-curso', etiquetas: ['espacio', 'diseño'],
        horasEstimadas: 12, fechaLimite: '2026-09-30', revisor: 'Marta'
      });
    });

    test('el viaje de ida y vuelta conserva todos los campos', () => {
      const original = unaTarea({ estado: 'en-curso' });

      const copia = Tarea.desdeJSON(JSON.stringify(original));

      expect(copia.toJSON()).toStrictEqual(original.toJSON());
      expect(copia).not.toBe(original);                  // es OTRA instancia
      expect(copia).toBeInstanceOf(Tarea);               // pero de la misma clase
    });

    test('toJSON devuelve una copia de las etiquetas, no el array interno', () => {
      const tarea = unaTarea();

      tarea.toJSON().etiquetas.push('inyectada');

      expect(tarea.etiquetas).toEqual(['espacio', 'diseño']);   // intacto
    });
  });
});

// pruebas/modelo/tablero.test.js
import { Tarea } from '../../js/modelo/tarea.js';
import { ErrorDeValidacion } from '../../js/modelo/errores.js';
import { HOY, unaTarea, unTablero } from '../ayudas/backlog-de-prueba.js';

describe('Tablero', () => {
  let tablero;

  beforeEach(() => { tablero = unTablero(); });      // ← instancias nuevas: pruebas independientes

  describe('el backlog canónico', () => {
    test('tiene 6 tareas y 5 abiertas', () => {
      expect(tablero.total).toBe(6);
      expect(tablero.abiertas).toHaveLength(5);
    });

    test('suma 48 h totales y 45 h abiertas', () => {
      expect(tablero.horasTotales).toBe(48);
      expect(tablero.horasAbiertas).toBe(45);        // ← la prueba que faltaba en el caso 3 de 08-01
    });

    test('tiene un esfuerzo ponderado de 124', () => {
      expect(tablero.esfuerzo).toBe(124);
    });

    test('tiene exactamente una tarea vencida: el presupuesto de la carpintería (R10)', () => {
      const vencidas = tablero.vencidas(HOY);

      expect(vencidas).toHaveLength(1);
      expect(vencidas[0].titulo).toBe('Presupuesto de la carpintería');
    });

    test('reparte las horas abiertas: Iván 25, Lucía 14, Marta 6', () => {
      expect(tablero.horasPorResponsable()).toEqual({ 'Iván': 25, 'Lucía': 14, 'Marta': 6 });
    });

    test('el resumen completo es exactamente el esperado', () => {
      expect(tablero.resumen(HOY)).toStrictEqual({
        total: 6, abiertas: 5, horasTotales: 48,
        horasAbiertas: 45, vencidas: 1, esfuerzo: 124
      });
    });
  });

  describe('agregar', () => {
    test('añade una tarea nueva y actualiza el total', () => {
      tablero.agregar(unaTarea({ id: 7, titulo: 'Revisar extintores', horasEstimadas: 2 }));

      expect(tablero.total).toBe(7);
      expect(tablero.buscarPorId(7).titulo).toBe('Revisar extintores');
    });

    test('rechaza un id duplicado (R1)', () => {
      expect(() => tablero.agregar(unaTarea({ id: 3 }))).toThrow(ErrorDeValidacion);
      expect(tablero.total).toBe(6);                 // y no ha añadido nada
    });

    test('rechaza cualquier cosa que no sea una Tarea', () => {
      expect(() => tablero.agregar({ id: 9, titulo: 'Objeto plano' })).toThrow(ErrorDeValidacion);
    });
  });

  describe('cambiarEstado', () => {
    test('aplica la transición a la tarea indicada', () => {
      tablero.cambiarEstado(2, 'en-curso');

      expect(tablero.buscarPorId(2).estado).toBe('en-curso');
    });

    test('recalcula las horas abiertas al cerrar una tarea', () => {
      tablero.cambiarEstado(1, 'hecha');             // tarea 1: en-curso, 12 h, de Iván

      expect(tablero.horasAbiertas).toBe(33);        // 45 − 12
      expect(tablero.horasPorResponsable()).toEqual({ 'Iván': 13, 'Lucía': 14, 'Marta': 6 });
    });

    test('lanza ErrorDeValidacion si la tarea no existe', () => {
      expect(() => tablero.cambiarEstado(99, 'en-curso')).toThrow(ErrorDeValidacion);
    });

    test('propaga el error de una transición prohibida (R6)', () => {
      expect(() => tablero.cambiarEstado(4, 'en-curso')).toThrow(ErrorDeValidacion);  // la 4 está hecha
    });
  });

  describe('consultas', () => {
    test('buscarPorId devuelve null si no existe, nunca undefined', () => {
      expect(tablero.buscarPorId(99)).toBeNull();
    });

    test('filtrar devuelve un array nuevo sin tocar el tablero', () => {
      const altas = tablero.filtrar((t) => t.prioridad === 'alta');

      expect(altas).toHaveLength(3);
      expect(tablero.total).toBe(6);
    });

    test('el getter tareas devuelve una copia defensiva (05-03)', () => {
      const copia = tablero.tareas;

      copia.push(unaTarea({ id: 99 }));
      copia.sort((a, b) => a.titulo.localeCompare(b.titulo));

      expect(tablero.total).toBe(6);                 // el push no afectó
      expect(tablero.tareas[0].id).toBe(1);          // ni el sort
    });

    test('es iterable: for…of recorre las seis tareas (05-08)', () => {
      const titulos = [...tablero].map((t) => t.titulo);

      expect(titulos).toHaveLength(6);
      expect(titulos[0]).toBe('Rediseñar la sala polivalente');
    });
  });
});

$ npm test

 PASS  pruebas/modelo/tarea.test.js
 PASS  pruebas/modelo/tablero.test.js

Test Suites: 2 passed, 2 total
Tests:       48 passed, 48 total
Time:        0.913 s

      # .github/workflows/calidad.yml — un paso más
      - name: Ejecutar las pruebas
        run: npm test -- --coverage --ci

import { Tablero } from '../../js/modelo/tablero.js';
import { crearBacklog } from '../../js/datos/backlog.js';

const tablero = new Tablero('Taller Nómada', crearBacklog());

describe('tablero', () => {
  test('funciona', () => {
    expect(tablero.total).toBe(6);
    tablero.cambiarEstado(2, 'en-curso');
    expect(tablero.buscarPorId(2).estado).toBe('en-curso');
  });

  test('resumen', () => {
    const r = tablero.resumen(new Date().toISOString().slice(0, 10));
    expect(r).toBe({ total: 6, abiertas: 5, horasTotales: 48,
                     horasAbiertas: 45, vencidas: 1, esfuerzo: 124 });
  });

  test('carga', () => {
    cargarDesdeServidor().then((t) => {
      expect(t.total).toBe(6);
    });
  });

  test.only('id duplicado', () => {
    expect(() => tablero.agregar(tablero.tareas[0])).toThrow();
  });
});

// pruebas/util/fechas.test.js
import { HOY, diasEntre, estaVencida, fechaLegible } from '../../js/util/fechas.js';

// Ninguna prueba llama a new Date() sin argumentos: si lo hiciera, el resultado
// dependería del día de ejecución y la suite se rompería sola un martes cualquiera
// sin que nadie hubiera tocado el código. El tiempo entra SIEMPRE como dato.

describe('HOY', () => {
  test('es la fecha canónica del proyecto en formato ISO', () => {
    expect(HOY).toBe('2026-09-20');
    expect(HOY).toMatch(/^\d{4}-\d{2}-\d{2}$/);
  });
});

describe('diasEntre', () => {
  test.each`
    desde             | hasta             | esperado | caso
    ${'2026-09-20'}   | ${'2026-09-30'}   | ${10}    | ${'diez días adelante'}
    ${'2026-09-20'}   | ${'2026-09-05'}   | ${-15}   | ${'quince días atrás'}
    ${'2026-09-20'}   | ${'2026-09-20'}   | ${0}     | ${'el mismo día'}
    ${'2026-09-20'}   | ${'2026-10-02'}   | ${12}    | ${'cambio de mes'}
    ${'2026-12-28'}   | ${'2027-01-03'}   | ${6}     | ${'cambio de año'}
    ${'2028-02-27'}   | ${'2028-03-01'}   | ${3}     | ${'año bisiesto'}
  `('$caso: $desde → $hasta = $esperado', ({ desde, hasta, esperado }) => {
    expect(diasEntre(desde, hasta)).toBe(esperado);
  });
});

describe('estaVencida (R10)', () => {
  test.each`
    fecha             | estado          | esperado | motivo
    ${'2026-09-05'}   | ${'pendiente'}  | ${true}  | ${'pasada y sin empezar'}
    ${'2026-09-05'}   | ${'en-curso'}   | ${true}  | ${'pasada y en curso'}
    ${'2026-09-05'}   | ${'hecha'}      | ${false} | ${'pasada pero terminada'}
    ${'2026-10-30'}   | ${'pendiente'}  | ${false} | ${'futura y sin empezar'}
    ${'2026-10-30'}   | ${'hecha'}      | ${false} | ${'futura y terminada'}
    ${'2026-09-20'}   | ${'pendiente'}  | ${false} | ${'vence hoy: aún hay tiempo'}
  `('$fecha + $estado → $esperado ($motivo)', ({ fecha, estado, esperado }) => {
    expect(estaVencida(fecha, estado, '2026-09-20')).toBe(esperado);
  });

  test('usa HOY por defecto si no se pasa fecha de referencia', () => {
    expect(estaVencida('2026-09-05', 'pendiente')).toBe(true);
    expect(estaVencida('2026-12-01', 'pendiente')).toBe(false);
  });
});

describe('fechaLegible', () => {
  test.each([
    ['2026-01-01', '1 de enero de 2026'],
    ['2026-09-05', '5 de septiembre de 2026'],
    ['2026-09-20', '20 de septiembre de 2026'],
    ['2026-12-31', '31 de diciembre de 2026']
  ])('%s → %s', (iso, esperado) => {
    expect(fechaLegible(iso)).toBe(esperado);
  });

  test('quita el cero a la izquierda del día', () => {
    expect(fechaLegible('2026-03-08')).toBe('8 de marzo de 2026');
    expect(fechaLegible('2026-03-08')).not.toContain('08');
  });
});

VUELTA 1 · ROJO — el caso permitido

test('Iván, con 25 h abiertas, puede aceptar 10 h más (R7)', () => {
  expect(unTablero().puedeAsignar('Iván', 10)).toBe(true);
});
// ✗ TypeError: tablero.puedeAsignar is not a function

VUELTA 1 · VERDE — lo mínimo

puedeAsignar() { return true; }

VUELTA 2 · ROJO — el caso prohibido

test('Iván, con 25 h abiertas, NO puede aceptar 16 h más (25 + 16 = 41 > 40)', () => {
  expect(unTablero().puedeAsignar('Iván', 16)).toBe(false);
});
// ✗ Expected: false   Received: true

VUELTA 2 · VERDE

puedeAsignar(responsable, horas) {
  return (this.horasPorResponsable()[responsable] ?? 0) + horas <= 40;
}

VUELTA 3 · ROJO — el límite exacto y quien no tiene nada asignado

test('el límite exacto de 40 h está permitido (25 + 15)', () => {
  expect(unTablero().puedeAsignar('Iván', 15)).toBe(true);
});

test('una persona sin tareas puede aceptar hasta 40 h', () => {
  const tablero = unTablero();

  expect(tablero.puedeAsignar('Berta', 40)).toBe(true);
  expect(tablero.puedeAsignar('Berta', 41)).toBe(false);
});
// Ambas pasan: el <= y el ?? 0 ya estaban bien. Verde a la primera,
// pero merecía la pena escribirlas: documentan los bordes.

VUELTA 4 · ROJO — las tareas hechas no cuentan

test('las tareas hechas no consumen cupo semanal', () => {
  const tablero = unTablero();

  tablero.cambiarEstado(1, 'hecha');        // Iván cierra 12 h: le quedan 13 abiertas

  expect(tablero.puedeAsignar('Iván', 27)).toBe(true);    // 13 + 27 = 40
  expect(tablero.puedeAsignar('Iván', 28)).toBe(false);   // 13 + 28 = 41
});
// Pasa, porque horasPorResponsable ya filtra por `abiertas`. La prueba
// documenta y protege ese detalle, que es fácil de romper en un refactor.

REFACTOR — con las cinco pruebas en verde

// js/modelo/tablero.js
const MAXIMO_SEMANAL = 40;                      // R7, en una constante con nombre

/**
 * R7: nadie puede superar 40 h estimadas ABIERTAS.
 * Las tareas hechas no consumen cupo.
 *
 * @param {string} responsable
 * @param {number} horas  Horas que se pretenden asignar
 * @returns {boolean}
 */
puedeAsignar(responsable, horas) {
  const asignadas = this.horasPorResponsable()[responsable] ?? 0;
  return asignadas + horas <= MAXIMO_SEMANAL;
}

/** Horas que aún se le pueden asignar a alguien sin incumplir R7. */
cupoDisponible(responsable) {
  return MAXIMO_SEMANAL - (this.horasPorResponsable()[responsable] ?? 0);
}

// Suite corregida
import { Tablero } from '../../js/modelo/tablero.js';
import { ErrorDeValidacion } from '../../js/modelo/errores.js';
import { crearBacklog } from '../../js/datos/backlog.js';
import { cargarDesdeServidor } from '../../js/datos/api-tareas.js';

const HOY = '2026-09-20';                     // ← fecha fija: el tiempo entra como dato

describe('Tablero', () => {
  let tablero;

  beforeEach(() => {                          // ← estado nuevo para cada prueba
    tablero = new Tablero('Taller Nómada', crearBacklog());
  });

  test('el backlog canónico tiene 6 tareas', () => {
    expect(tablero.total).toBe(6);
  });

  test('cambiarEstado aplica la transición a la tarea indicada', () => {
    tablero.cambiarEstado(2, 'en-curso');

    expect(tablero.buscarPorId(2).estado).toBe('en-curso');
  });

  test('el resumen del backlog canónico es exactamente el esperado', () => {
    expect(tablero.resumen(HOY)).toStrictEqual({   // ← toStrictEqual, no toBe
      total: 6, abiertas: 5, horasTotales: 48,
      horasAbiertas: 45, vencidas: 1, esfuerzo: 124
    });
  });

  test('agregar rechaza un id duplicado (R1)', () => {   // ← sin .only
    expect(() => tablero.agregar(tablero.tareas[0])).toThrow(ErrorDeValidacion);
    expect(tablero.total).toBe(6);
  });

  test('cargarDesdeServidor devuelve las 6 tareas del backlog', async () => {
    const cargado = await cargarDesdeServidor();       // ← async + await

    expect(cargado.total).toBe(6);
  });
  // Nota: esta última prueba todavía depende de la red de verdad, lo que la hace
  // lenta y no determinista. En 08-04 se sustituye fetch por un doble y pasa a
  // ejecutarse en milisegundos, sin salir de la máquina.
});