Sin dobles:
  api-tareas.test.js       ✗ falla: getaddrinfo ENOTFOUND api.tallernomada.example
  tiempo.test.js           ✓ 4 pruebas · 1.4 s      (4 × 350 ms de espera real)
  http.test.js             ✓ 3 pruebas · 6.8 s      (reintentos con backoff de verdad)
  repositorio.test.js      ✗ falla: localStorage is not defined

Con dobles:
  api-tareas.test.js       ✓ 12 pruebas · 0.09 s
  tiempo.test.js           ✓ 4 pruebas · 0.02 s
  http.test.js             ✓ 8 pruebas · 0.05 s
  repositorio.test.js      ✓ 11 pruebas · 0.03 s

// ── DUMMY · solo ocupa un hueco. No se usa, no se comprueba ────────────
const senalDummy = new AbortController().signal;
await listarTareas({ responsable: 'Iván' }, { signal: senalDummy });

// ── STUB · respuesta fija; nadie mira cómo se le llamó ─────────────────
const fetchStub = jest.fn().mockResolvedValue(
  new Response(JSON.stringify(datosBacklog), { status: 200,
    headers: { 'content-type': 'application/json' } })
);

// ── SPY · observa, y (aquí) deja pasar la llamada real ─────────────────
const espia = jest.spyOn(repositorio, 'guardar');
tablero.cambiarEstado(2, 'en-curso');
expect(espia).toHaveBeenCalledTimes(1);           // ← la comprobación ES el objetivo

// ── MOCK · respuesta programada Y expectativas sobre la llamada ────────
const fetchMock = jest.fn().mockResolvedValue(
  new Response(JSON.stringify({ id: 7 }), { status: 201,
    headers: { 'content-type': 'application/json' } })
);
await crearTarea(datosNuevos);
expect(fetchMock).toHaveBeenCalledWith(
  expect.stringContaining('/tareas'),
  expect.objectContaining({ method: 'POST' })
);

// ── FAKE · implementación real, simplificada ───────────────────────────
function almacenFalso(inicial = {}) {
  const mapa = new Map(Object.entries(inicial));
  return {
    getItem: (k) => (mapa.has(k) ? mapa.get(k) : null),
    setItem: (k, v) => { mapa.set(k, String(v)); },
    removeItem: (k) => { mapa.delete(k); },
    clear: () => mapa.clear(),
    get length() { return mapa.size; }
  };
}

import { jest } from '@jest/globals';        // ← con módulos ES, jest se IMPORTA

const alCrear = jest.fn();

alCrear({ id: 7, titulo: 'Revisar extintores' });
alCrear({ id: 8, titulo: 'Pedir tinta negra' });

console.log(alCrear.mock.calls);
// [ [{ id: 7, titulo: 'Revisar extintores' }],
//   [{ id: 8, titulo: 'Pedir tinta negra' }] ]

alCrear.mock.calls.length;      // 2  → cuántas veces se llamó
alCrear.mock.calls[0][0];       // { id: 7, … }  → primer argumento de la primera llamada
alCrear.mock.lastCall[0];       // { id: 8, … }  → primer argumento de la última

const siguienteId = jest.fn(() => 7);         // implementación inicial
const registrar = jest.fn((nivel, evento) => `[${nivel}] ${evento}`);

test('al crear una tarea se avisa al oyente con la tarea creada', () => {
  const alCrear = jest.fn();
  const formulario = { titulo: 'Revisar extintores', horasEstimadas: 2 };

  crearDesdeFormulario(formulario, { alCrear });

  expect(alCrear).toHaveBeenCalledTimes(1);
  expect(alCrear).toHaveBeenCalledWith(expect.objectContaining({
    titulo: 'Revisar extintores',
    estado: 'pendiente'                      // R5: nace en pendiente
  }));
});

expect.anything()                    // cualquier cosa salvo null y undefined
expect.any(Number)                   // cualquier número (o String, Function, Tarea…)
expect.objectContaining({ a: 1 })    // un objeto que contiene AL MENOS esa propiedad
expect.arrayContaining([1, 2])       // un array que contiene al menos esos elementos
expect.stringContaining('/tareas')   // una cadena que contiene ese texto
expect.stringMatching(/^https:/)     // una cadena que casa con la expresión regular
expect.closeTo(8.16, 2)              // un número decimal con tolerancia

expect(fetch).toHaveBeenCalledWith(
  expect.stringContaining('/tareas/3'),
  expect.objectContaining({ method: 'PATCH' })
);

// Un doble que guarda una COPIA de lo que recibe
const guardar = jest.fn((tablero) => estadosGuardados.push(structuredClone(tablero.toJSON())));

const pedir = jest.fn()
  .mockRejectedValueOnce(new ErrorDeApi('503', { status: 503, codigo: 'servidor' }))
  .mockRejectedValueOnce(new ErrorDeApi('503', { status: 503, codigo: 'servidor' }))
  .mockResolvedValue({ tareas: datosBacklog });      // a partir de la tercera, éxito

const resultado = await conReintentos(pedir, { intentos: 3, baseMs: 0 });

expect(pedir).toHaveBeenCalledTimes(3);
expect(resultado.tareas).toHaveLength(6);

const buscar = jest.fn((id) => datosBacklog.find((t) => t.id === id) ?? null);

expect(buscar(3).titulo).toBe('Actualizar la web de reservas');
expect(buscar(99)).toBeNull();

// jest.config.js
export default {
  restoreMocks: true,      // mockRestore() automático tras cada prueba
  clearMocks: true         // mockClear() automático antes de cada prueba
};

test('cambiar de estado provoca exactamente un guardado', () => {
  const repositorio = new RepositorioLocal({ almacen: almacenFalso() });
  const tablero = unTablero();
  conectarPersistencia(tablero, repositorio);

  const espia = jest.spyOn(repositorio, 'guardar');   // observa, NO sustituye

  tablero.cambiarEstado(2, 'en-curso');

  expect(espia).toHaveBeenCalledTimes(1);
  expect(espia).toHaveBeenCalledWith(tablero);
  expect(repositorio.cargar().total).toBe(6);          // ← el guardado REAL ocurrió
});

// Observar Y sustituir: simulamos que el almacén está lleno
jest.spyOn(repositorio, 'guardar').mockReturnValue(false);

// Observar y silenciar: evitar que la consola ensucie la salida de las pruebas
const avisos = jest.spyOn(console, 'warn').mockImplementation(() => {});

repositorio.guardar(tablero);

expect(avisos).toHaveBeenCalledWith(expect.stringContaining('Sin espacio'));
avisos.mockRestore();                    // ← imprescindible si no usas restoreMocks

// pruebas/vista/controlador.test.js
import { jest } from '@jest/globals';

// 1 · Declarar el doble ANTES de importar nada del módulo real
jest.unstable_mockModule('../../js/datos/api-tareas.js', () => ({
  listarTareas: jest.fn(),
  crearTarea: jest.fn(),
  actualizarTarea: jest.fn(),
  borrarTarea: jest.fn()
}));

// 2 · Importar DESPUÉS, y de forma dinámica (await import)
const { listarTareas, crearTarea } = await import('../../js/datos/api-tareas.js');
const { cargarTablero } = await import('../../js/app-datos.js');

describe('cargarTablero', () => {
  beforeEach(() => { jest.clearAllMocks(); });

  test('construye el tablero con lo que devuelve la API', async () => {
    listarTareas.mockResolvedValue(datosBacklog.map((d) => new Tarea(d)));

    const tablero = await cargarTablero();

    expect(tablero.total).toBe(6);
    expect(listarTareas).toHaveBeenCalledTimes(1);
  });
});

// En lugar de simular el módulo, INYECTAR la dependencia
export async function cargarTablero({ listar = listarTareas } = {}) {
  return new Tablero('Taller Nómada', await listar());
}

// La prueba, sin ninguna magia de módulos:
test('construye el tablero con lo que devuelve la API', async () => {
  const listar = jest.fn().mockResolvedValue(crearBacklog());

  const tablero = await cargarTablero({ listar });

  expect(tablero.total).toBe(6);
});

import { jest } from '@jest/globals';

// Sustituimos SOLO `dormir`; pedirJson y conReintentos siguen siendo los de verdad
jest.unstable_mockModule('../../js/util/tiempo.js', async () => {
  const real = await import('../../js/util/tiempo.js');
  return {
    ...real,                                // todo lo original…
    dormir: jest.fn().mockResolvedValue()   // …salvo esto
  };
});

const { debounce, dormir } = await import('../../js/util/tiempo.js');

// pruebas/ayudas/red-falsa.js
import { jest } from '@jest/globals';

/** Construye una Response real, con su status y sus cabeceras. */
export function respuestaJson(cuerpo, { status = 200, cabeceras = {} } = {}) {
  return new Response(JSON.stringify(cuerpo), {
    status,
    headers: { 'content-type': 'application/json', ...cabeceras }
  });
}

/** Una Response sin cuerpo, para 204 No Content. */
export const respuestaVacia = () => new Response(null, { status: 204 });

/** Una Response que NO es JSON: el proxy que devuelve HTML de un login. */
export const respuestaHtml = (status = 200) =>
  new Response('<!doctype html><h1>Inicia sesión</h1>', {
    status, headers: { 'content-type': 'text/html' }
  });

/** Instala un fetch falso y devuelve el doble para programarlo. */
export function instalarFetchFalso() {
  const falso = jest.fn();
  globalThis.fetch = falso;
  return falso;
}

// pruebas/datos/api-tareas.test.js
import { jest } from '@jest/globals';
import { listarTareas, crearTarea, actualizarTarea, borrarTarea } from '../../js/datos/api-tareas.js';
import { Tarea } from '../../js/modelo/tarea.js';
import { ErrorDeApi } from '../../js/modelo/errores.js';
import { datosBacklog } from '../../js/datos/backlog.js';
import { respuestaJson, respuestaVacia, instalarFetchFalso } from '../ayudas/red-falsa.js';

describe('api-tareas', () => {
  let red;
  const fetchOriginal = globalThis.fetch;

  beforeEach(() => { red = instalarFetchFalso(); });
  afterEach(() => { globalThis.fetch = fetchOriginal; });   // ← devolver el mundo como estaba

  describe('listarTareas', () => {
    test('devuelve instancias de Tarea, no objetos planos', async () => {
      red.mockResolvedValue(respuestaJson(datosBacklog));

      const tareas = await listarTareas();

      expect(tareas).toHaveLength(6);
      expect(tareas[0]).toBeInstanceOf(Tarea);              // ← la frontera hace su trabajo
      expect(tareas[0].titulo).toBe('Rediseñar la sala polivalente');
    });

    test('el tablero construido con la respuesta da los números canónicos', async () => {
      red.mockResolvedValue(respuestaJson(datosBacklog));

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

      expect(tablero.resumen('2026-09-20')).toMatchObject({ horasAbiertas: 45, esfuerzo: 124 });
    });

    test('añade los filtros como parámetros de consulta y omite los vacíos', async () => {
      red.mockResolvedValue(respuestaJson([]));

      await listarTareas({ responsable: 'Iván', estado: 'pendiente', texto: '' });

      const url = new URL(red.mock.calls[0][0]);
      expect(url.pathname).toBe('/v1/tareas');
      expect(url.searchParams.get('responsable')).toBe('Iván');
      expect(url.searchParams.get('estado')).toBe('pendiente');
      expect(url.searchParams.has('texto')).toBe(false);    // los vacíos NO se envían
    });
  });

  describe('crearTarea', () => {
    test('envía POST con el cuerpo serializado y devuelve la Tarea con su id', async () => {
      const nueva = { titulo: 'Revisar extintores', responsable: 'Marta',
                      prioridad: 'media', horasEstimadas: 2,
                      fechaLimite: '2026-10-20', etiquetas: ['seguridad'] };
      red.mockResolvedValue(respuestaJson({ ...nueva, id: 7, estado: 'pendiente' }, { status: 201 }));

      const creada = await crearTarea(nueva);

      // Comportamiento: devuelve una Tarea con el id que asignó el servidor (R1)
      expect(creada).toBeInstanceOf(Tarea);
      expect(creada.id).toBe(7);
      expect(creada.estado).toBe('pendiente');              // R5

      // Interacción: el método y el cuerpo SÍ son comportamiento observable
      const [, opciones] = red.mock.calls[0];
      expect(opciones.method).toBe('POST');
      expect(JSON.parse(opciones.body)).toMatchObject({ titulo: 'Revisar extintores' });
      expect(opciones.headers['Content-Type']).toBe('application/json');
    });
  });

  describe('borrarTarea', () => {
    test('envía DELETE y acepta una respuesta 204 sin cuerpo', async () => {
      red.mockResolvedValue(respuestaVacia());

      await expect(borrarTarea(3)).resolves.toBe(true);

      expect(red).toHaveBeenCalledWith(
        expect.stringContaining('/tareas/3'),
        expect.objectContaining({ method: 'DELETE' })
      );
    });
  });
});

describe('api-tareas · manejo de errores (07-03)', () => {
  let red;
  beforeEach(() => { red = instalarFetchFalso(); });

  test('un 404 produce ErrorDeApi con status 404 y código de cliente', async () => {
    red.mockResolvedValue(respuestaJson({ mensaje: 'No existe la tarea 99' }, { status: 404 }));

    const error = await capturarAsync(() => obtenerTarea(99));

    expect(error).toBeInstanceOf(ErrorDeApi);
    expect(error.status).toBe(404);
    expect(error.codigo).toBe('cliente');
    expect(error.reintentable).toBe(false);          // ← un 404 NO se reintenta
    expect(error.message).toBe('No existe la tarea 99');
  });

  test('un 500 produce ErrorDeApi reintentable con código de servidor', async () => {
    red.mockResolvedValue(respuestaJson({ mensaje: 'Error interno' }, { status: 500 }));

    const error = await capturarAsync(() => listarTareas());

    expect(error.status).toBe(500);
    expect(error.codigo).toBe('servidor');
    expect(error.reintentable).toBe(true);           // ← un 500 SÍ
  });

  test('un fallo de transporte produce ErrorDeApi de red, sin status', async () => {
    red.mockRejectedValue(new TypeError('Failed to fetch'));   // red caída, DNS o CORS

    const error = await capturarAsync(() => listarTareas());

    expect(error).toBeInstanceOf(ErrorDeApi);
    expect(error.codigo).toBe('red');
    expect(error.status).toBe(0);
    expect(error.causa).toBeInstanceOf(TypeError);   // la causa original se conserva
  });

  test('una respuesta HTML en lugar de JSON produce ErrorDeApi de formato', async () => {
    red.mockResolvedValue(respuestaHtml(200));       // el proxy que devuelve el login

    const error = await capturarAsync(() => listarTareas());

    expect(error.codigo).toBe('formato');
    expect(error.message).toContain('text/html');
  });

  test('una cancelación produce ErrorDeApi con código cancelado', async () => {
    const abortError = new DOMException('The operation was aborted.', 'AbortError');
    red.mockRejectedValue(abortError);

    const error = await capturarAsync(() => listarTareas());

    expect(error.codigo).toBe('cancelado');
  });
});

// pruebas/ayudas/backlog-de-prueba.js — versión asíncrona de capturar()
export async function capturarAsync(fn) {
  try { await fn(); return null; } catch (error) { return error; }
}

jest.useFakeTimers();          // a partir de aquí, el tiempo no pasa solo

jest.advanceTimersByTime(300); // avanzar 300 ms virtuales, al instante
jest.runAllTimers();           // ejecutar TODOS los temporizadores pendientes
jest.runOnlyPendingTimers();   // solo los actuales (evita bucles con setInterval)
jest.advanceTimersToNextTimer(); // saltar justo al siguiente

jest.useRealTimers();          // devolver el reloj de verdad

// pruebas/util/tiempo.test.js
import { jest } from '@jest/globals';
import { debounce } from '../../js/util/tiempo.js';

describe('debounce', () => {
  beforeEach(() => { jest.useFakeTimers(); });
  afterEach(() => { jest.useRealTimers(); });      // ← imprescindible: no dejar el reloj parado

  test('no ejecuta la función antes de que expire la espera', () => {
    const buscar = jest.fn();
    const conRetardo = debounce(buscar, 300);

    conRetardo('car');
    jest.advanceTimersByTime(299);

    expect(buscar).not.toHaveBeenCalled();
  });

  test('ejecuta una sola vez tras la espera completa', () => {
    const buscar = jest.fn();
    const conRetardo = debounce(buscar, 300);

    conRetardo('car');
    jest.advanceTimersByTime(300);

    expect(buscar).toHaveBeenCalledTimes(1);
    expect(buscar).toHaveBeenCalledWith('car');
  });

  test('ocho pulsaciones rápidas producen UNA sola llamada, con el último valor', () => {
    const buscar = jest.fn();
    const conRetardo = debounce(buscar, 300);

    // Iván teclea "carpintería" a 50 ms por letra
    for (const texto of ['c', 'ca', 'car', 'carp', 'carpi', 'carpin', 'carpint', 'carpinte']) {
      conRetardo(texto);
      jest.advanceTimersByTime(50);
    }

    expect(buscar).not.toHaveBeenCalled();          // aún no: cada tecla reinició la cuenta

    jest.advanceTimersByTime(300);                  // Iván para de teclear

    expect(buscar).toHaveBeenCalledTimes(1);
    expect(buscar).toHaveBeenCalledWith('carpinte'); // ← el ÚLTIMO valor, no el primero
  });

  test('una pausa larga entre pulsaciones produce dos llamadas', () => {
    const buscar = jest.fn();
    const conRetardo = debounce(buscar, 300);

    conRetardo('car');
    jest.advanceTimersByTime(400);      // pasa el umbral: primera llamada
    conRetardo('tinta');
    jest.advanceTimersByTime(400);      // segunda

    expect(buscar).toHaveBeenCalledTimes(2);
    expect(buscar).toHaveBeenNthCalledWith(1, 'car');
    expect(buscar).toHaveBeenNthCalledWith(2, 'tinta');
  });
});

// pruebas/datos/http.test.js
import { jest } from '@jest/globals';
import { conReintentos } from '../../js/datos/http.js';
import { ErrorDeApi } from '../../js/modelo/errores.js';

const errorServidor = () => new ErrorDeApi('Caído', { status: 503, codigo: 'servidor' });
const errorCliente  = () => new ErrorDeApi('No existe', { status: 404, codigo: 'cliente' });

describe('conReintentos', () => {
  beforeEach(() => {
    jest.useFakeTimers();
    jest.spyOn(Math, 'random').mockReturnValue(0.5);   // jitter DETERMINISTA
  });

  afterEach(() => {
    jest.useRealTimers();
    jest.restoreAllMocks();                            // devuelve Math.random
  });

  test('no reintenta cuando la operación tiene éxito a la primera', async () => {
    const operacion = jest.fn().mockResolvedValue('ok');

    await expect(conReintentos(operacion)).resolves.toBe('ok');

    expect(operacion).toHaveBeenCalledTimes(1);
  });

  test('reintenta un 503 y devuelve el resultado del tercer intento', async () => {
    const operacion = jest.fn()
      .mockRejectedValueOnce(errorServidor())
      .mockRejectedValueOnce(errorServidor())
      .mockResolvedValue('recuperado');

    const promesa = conReintentos(operacion, { intentos: 3, baseMs: 300 });

    await jest.advanceTimersByTimeAsync(300 + 150);    // 1ª espera: 300 + jitter(0.5 × 300 × 0.3)
    await jest.advanceTimersByTimeAsync(600 + 270);    // 2ª espera: exponencial

    await expect(promesa).resolves.toBe('recuperado');
    expect(operacion).toHaveBeenCalledTimes(3);
  });

  test('NO reintenta un 404: no tiene remedio', async () => {
    const operacion = jest.fn().mockRejectedValue(errorCliente());

    await expect(conReintentos(operacion, { intentos: 3 })).rejects.toMatchObject({ status: 404 });

    expect(operacion).toHaveBeenCalledTimes(1);        // ← una sola vez
  });

  test('se rinde tras agotar los intentos y propaga el último error', async () => {
    const operacion = jest.fn().mockRejectedValue(errorServidor());

    const promesa = conReintentos(operacion, { intentos: 3, baseMs: 300 });
    const resultado = promesa.catch((e) => e);         // capturamos ya, para no dejarla colgando

    await jest.runAllTimersAsync();

    await expect(resultado).resolves.toMatchObject({ status: 503 });
    expect(operacion).toHaveBeenCalledTimes(3);
  });

  test('la espera crece de forma exponencial entre intentos', async () => {
    const esperas = [];
    jest.spyOn(globalThis, 'setTimeout').mockImplementation((fn, ms) => { esperas.push(ms); fn(); });

    const operacion = jest.fn().mockRejectedValue(errorServidor());
    await conReintentos(operacion, { intentos: 4, baseMs: 100 }).catch(() => {});

    // 100·1 + jitter, 100·2 + jitter, 100·4 + jitter — cada una mayor que la anterior
    expect(esperas).toHaveLength(3);
    expect(esperas[1]).toBeGreaterThan(esperas[0]);
    expect(esperas[2]).toBeGreaterThan(esperas[1]);
  });
});

describe('vencimiento con el reloj congelado', () => {
  beforeEach(() => {
    // El sistema entero cree que es el 20 de septiembre de 2026, a las 9:00
    jest.useFakeTimers({ now: new Date('2026-09-20T09:00:00Z') });
  });

  afterEach(() => { jest.useRealTimers(); });

  test('estaVencida usa HOY por defecto y da el mismo resultado cualquier día', () => {
    const tarea = unaTarea({ fechaLimite: '2026-09-05', estado: 'pendiente' });

    expect(tarea.estaVencida()).toBe(true);           // sin pasar fecha
  });

  test('fechaDeHoy() devuelve la fecha congelada', () => {
    expect(new Date().toISOString().slice(0, 10)).toBe('2026-09-20');
  });

  test('el resumen sin fecha explícita da una sola vencida', () => {
    expect(unTablero().resumen()).toMatchObject({ vencidas: 1 });
  });
});

// pruebas/ayudas/almacen-falso.js

/**
 * FAKE de Web Storage: implementación real, simplificada, en memoria.
 * Cumple la interfaz que usa RepositorioLocal, más un modo "lleno" para
 * poder provocar el QuotaExceededError sin llenar un disco de verdad.
 */
export function almacenFalso({ inicial = {}, lleno = false } = {}) {
  const mapa = new Map(Object.entries(inicial));

  return {
    getItem: (clave) => (mapa.has(clave) ? mapa.get(clave) : null),

    setItem: (clave, valor) => {
      if (lleno) {
        const error = new Error('Cuota superada');
        error.name = 'QuotaExceededError';           // ← lo que comprueba el repositorio
        throw error;
      }
      mapa.set(clave, String(valor));                // Web Storage SOLO guarda cadenas
    },

    removeItem: (clave) => { mapa.delete(clave); },
    clear: () => mapa.clear(),
    key: (i) => [...mapa.keys()][i] ?? null,
    get length() { return mapa.size; },

    // Utilidades solo para las pruebas
    _volcar: () => Object.fromEntries(mapa)
  };
}

// pruebas/datos/repositorio-local.test.js
import { jest } from '@jest/globals';
import { RepositorioLocal } from '../../js/datos/repositorio-local.js';
import { almacenFalso } from '../ayudas/almacen-falso.js';
import { unTablero } from '../ayudas/backlog-de-prueba.js';

describe('RepositorioLocal', () => {
  test('guarda y recupera el tablero completo', () => {
    const repositorio = new RepositorioLocal({ almacen: almacenFalso() });
    const tablero = unTablero();

    expect(repositorio.guardar(tablero)).toBe(true);
    const recuperado = repositorio.cargar();

    expect(recuperado.total).toBe(6);
    expect(recuperado.resumen('2026-09-20')).toMatchObject({ horasAbiertas: 45, esfuerzo: 124 });
  });

  test('guarda bajo la clave versionada del proyecto', () => {
    const almacen = almacenFalso();
    new RepositorioLocal({ almacen }).guardar(unTablero());

    expect(Object.keys(almacen._volcar())).toEqual(['nomada:tablero:v1']);
  });

  test('devuelve null si no hay nada guardado', () => {
    expect(new RepositorioLocal({ almacen: almacenFalso() }).cargar()).toBeNull();
  });

  test('descarta datos corruptos sin lanzar y avisa por consola', () => {
    const avisos = jest.spyOn(console, 'warn').mockImplementation(() => {});
    const almacen = almacenFalso({ inicial: { 'nomada:tablero:v1': '{{{ no es JSON' } });

    expect(new RepositorioLocal({ almacen }).cargar()).toBeNull();
    expect(avisos).toHaveBeenCalledWith(expect.stringContaining('corruptos'));

    avisos.mockRestore();
  });

  test('sin espacio devuelve false, no lanza: perder persistencia no tumba la app', () => {
    const avisos = jest.spyOn(console, 'warn').mockImplementation(() => {});
    const repositorio = new RepositorioLocal({ almacen: almacenFalso({ lleno: true }) });

    expect(repositorio.guardar(unTablero())).toBe(false);   // ← degrada, no explota

    avisos.mockRestore();
  });

  test('limpiar elimina la clave y deja el almacén vacío', () => {
    const almacen = almacenFalso();
    const repositorio = new RepositorioLocal({ almacen });

    repositorio.guardar(unTablero());
    repositorio.limpiar();

    expect(repositorio.cargar()).toBeNull();
    expect(almacen.length).toBe(0);
  });
});

// ── Camino A · Mockeo agresivo: la dependencia está importada dentro ──
// js/datos/sincronizador.js
import { listarTareas } from './api-tareas.js';

export async function sincronizar(tablero) {
  const remotas = await listarTareas();
  return tablero.importar(remotas);
}

// La prueba necesita interceptar el sistema de módulos
jest.unstable_mockModule('../../js/datos/api-tareas.js', () => ({ listarTareas: jest.fn() }));
const { listarTareas } = await import('../../js/datos/api-tareas.js');
const { sincronizar } = await import('../../js/datos/sincronizador.js');
listarTareas.mockResolvedValue(crearBacklog());

// ── Camino B · Inyección: la dependencia entra por parámetro ──────────
// js/datos/sincronizador.js
import { listarTareas } from './api-tareas.js';

export async function sincronizar(tablero, { listar = listarTareas } = {}) {
  const remotas = await listar();
  return tablero.importar(remotas);
}

// La prueba, sin magia
const listar = jest.fn().mockResolvedValue(crearBacklog());
await sincronizar(tablero, { listar });

// ❌ Esta prueba no comprueba NADA útil
test('cambiarEstado funciona', () => {
  const tablero = unTablero();
  const buscar = jest.spyOn(tablero, 'buscarPorId');
  const cambiar = jest.spyOn(Tarea.prototype, 'cambiarEstado');

  tablero.cambiarEstado(2, 'en-curso');

  expect(buscar).toHaveBeenCalledWith(2);
  expect(cambiar).toHaveBeenCalledWith('en-curso');
});

// ✅ Comprueba el comportamiento observable
test('cambiarEstado deja la tarea en el estado indicado y recalcula las horas', () => {
  const tablero = unTablero();

  tablero.cambiarEstado(1, 'hecha');            // tarea 1: 12 h de Iván

  expect(tablero.buscarPorId(1).estado).toBe('hecha');
  expect(tablero.horasAbiertas).toBe(33);       // 45 − 12
});

test('crearTarea funciona', async () => {
  const red = instalarFetchFalso();
  red.mockResolvedValue(respuestaJson({ id: 7 }, { status: 201 }));
  const construir = jest.spyOn(Tarea, 'desdeJSON');
  const serializar = jest.spyOn(JSON, 'stringify');

  await crearTarea({ titulo: 'Revisar extintores', horasEstimadas: 2 });

  expect(red).toHaveBeenCalled();
  expect(serializar).toHaveBeenCalled();
  expect(construir).toHaveBeenCalled();
});

// pruebas/datos/http.test.js
import { jest } from '@jest/globals';
import { pedirJson } from '../../js/datos/http.js';
import { ErrorDeApi } from '../../js/modelo/errores.js';
import { instalarFetchFalso, respuestaJson, respuestaVacia, respuestaHtml } from '../ayudas/red-falsa.js';
import { capturarAsync } from '../ayudas/backlog-de-prueba.js';

// Usamos `new Response(...)` y no un objeto literal porque la Response real
// deriva `ok` de `status`, expone `headers` con la API de Headers y permite
// leer el cuerpo UNA sola vez. Un objeto casero es más permisivo que el
// original: dejaría pasar código que en el navegador fallaría.

describe('pedirJson', () => {
  let red;
  const fetchOriginal = globalThis.fetch;

  beforeEach(() => { red = instalarFetchFalso(); });
  afterEach(() => { globalThis.fetch = fetchOriginal; });

  test('devuelve el JSON en una respuesta 200 correcta', async () => {
    red.mockResolvedValue(respuestaJson({ tareas: 6 }));

    await expect(pedirJson('/tareas')).resolves.toEqual({ tareas: 6 });
  });

  test.each`
    caso                  | error                                                          | codigo         | reintentable
    ${'red caída'}        | ${new TypeError('Failed to fetch')}                             | ${'red'}       | ${true}
    ${'timeout'}          | ${Object.assign(new Error('t'), { name: 'TimeoutError' })}      | ${'timeout'}   | ${true}
    ${'cancelación'}      | ${Object.assign(new Error('a'), { name: 'AbortError' })}        | ${'cancelado'} | ${false}
  `('$caso → ErrorDeApi con código $codigo', async ({ error, codigo, reintentable }) => {
    red.mockRejectedValue(error);

    const capturado = await capturarAsync(() => pedirJson('/tareas'));

    expect(capturado).toBeInstanceOf(ErrorDeApi);
    expect(capturado.codigo).toBe(codigo);
    expect(capturado.status).toBe(0);
    expect(capturado.reintentable).toBe(reintentable);
    expect(capturado.causa).toBe(error);            // la causa original se conserva
  });

  test.each`
    status | codigo         | reintentable | motivo
    ${400} | ${'cliente'}   | ${false}     | ${'datos mal enviados'}
    ${401} | ${'cliente'}   | ${false}     | ${'sesión caducada'}
    ${404} | ${'cliente'}   | ${false}     | ${'no existe'}
    ${408} | ${'cliente'}   | ${true}      | ${'timeout del servidor: sí se reintenta'}
    ${429} | ${'cliente'}   | ${true}      | ${'demasiadas peticiones: sí se reintenta'}
    ${500} | ${'servidor'}  | ${true}      | ${'error interno'}
    ${503} | ${'servidor'}  | ${true}      | ${'servicio no disponible'}
  `('un $status da código $codigo, reintentable: $reintentable ($motivo)',
    async ({ status, codigo, reintentable }) => {
      red.mockResolvedValue(respuestaJson({ mensaje: `Error ${status}` }, { status }));

      const error = await capturarAsync(() => pedirJson('/tareas'));

      expect(error.status).toBe(status);
      expect(error.codigo).toBe(codigo);
      expect(error.reintentable).toBe(reintentable);
      expect(error.message).toBe(`Error ${status}`);   // usa el mensaje del servidor
    });

  test('una respuesta HTML en lugar de JSON da código de formato', async () => {
    red.mockResolvedValue(respuestaHtml(200));

    const error = await capturarAsync(() => pedirJson('/tareas'));

    expect(error.codigo).toBe('formato');
    expect(error.message).toContain('text/html');
    expect(error.reintentable).toBe(false);
  });

  test('un 204 sin cuerpo devuelve null en lugar de lanzar', async () => {
    red.mockResolvedValue(respuestaVacia());

    await expect(pedirJson('/tareas/3', { method: 'DELETE' })).resolves.toBeNull();
  });

  test('un cuerpo JSON malformado da código de formato, no un SyntaxError suelto', async () => {
    red.mockResolvedValue(new Response('{{{ roto', {
      status: 200, headers: { 'content-type': 'application/json' }
    }));

    const error = await capturarAsync(() => pedirJson('/tareas'));

    expect(error).toBeInstanceOf(ErrorDeApi);        // nunca escapa un SyntaxError crudo
    expect(error.codigo).toBe('formato');
  });
});

// pruebas/ayudas/canal-falso.js
/**
 * FAKE de CanalTablero: misma interfaz (EventTarget + enviar/cerrar), cero sockets.
 * Añade utilidades _simular* que solo existen para las pruebas.
 */
export class CanalFalso extends EventTarget {
  enviados = [];
  cola = [];
  conectado = true;
  intentosDeReconexion = 0;

  enviar(tipo, datos) {
    if (!this.conectado) { this.cola.push({ tipo, datos }); return false; }
    this.enviados.push({ tipo, datos });
    return true;
  }

  cerrar() { this.conectado = false; }

  // ── Utilidades de prueba ────────────────────────────────────────────
  simularMensaje(tipo, datos) {
    this.dispatchEvent(new CustomEvent(tipo, { detail: datos }));
  }

  simularCaida() {
    this.conectado = false;
    this.dispatchEvent(new CustomEvent('canal:cerrado'));
  }

  simularReconexion() {
    this.conectado = true;
    this.intentosDeReconexion += 1;
    for (const pendiente of this.cola.splice(0)) this.enviar(pendiente.tipo, pendiente.datos);
    this.dispatchEvent(new CustomEvent('canal:abierto'));
  }
}

// pruebas/datos/tiempo-real.test.js
import { jest } from '@jest/globals';
import { conectarTiempoReal } from '../../js/datos/tiempo-real.js';
import { CanalFalso } from '../ayudas/canal-falso.js';
import { unTablero } from '../ayudas/backlog-de-prueba.js';

describe('sincronización en tiempo real', () => {
  let canal, tablero;

  beforeEach(() => {
    jest.useFakeTimers();
    canal = new CanalFalso();
    tablero = unTablero();
    conectarTiempoReal(tablero, { canal });          // ← inyección, no mockeo de módulo
  });

  afterEach(() => { jest.useRealTimers(); });

  test('(a) un mensaje tarea:actualizada aplica el cambio al tablero', () => {
    canal.simularMensaje('tarea:actualizada', { id: 2, estado: 'en-curso' });

    expect(tablero.buscarPorId(2).estado).toBe('en-curso');
    expect(tablero.horasAbiertas).toBe(45);          // el estado abierto no cambia
  });

  test('(b) un mensaje con un id desconocido se ignora sin lanzar', () => {
    expect(() => canal.simularMensaje('tarea:actualizada', { id: 999, estado: 'hecha' }))
      .not.toThrow();

    expect(tablero.total).toBe(6);                   // nada se ha añadido ni roto
  });

  test('(c) los cambios durante una caída se encolan y se envían al reconectar', () => {
    canal.simularCaida();

    tablero.cambiarEstado(2, 'en-curso');            // cambio local mientras no hay red

    expect(canal.enviados).toHaveLength(0);
    expect(canal.cola).toHaveLength(1);

    canal.simularReconexion();

    expect(canal.cola).toHaveLength(0);
    expect(canal.enviados).toHaveLength(1);
    expect(canal.enviados[0]).toMatchObject({ tipo: 'tarea:cambiada', datos: { id: 2 } });
  });

  test('la reconexión respeta el retroceso exponencial', async () => {
    canal.simularCaida();

    await jest.advanceTimersByTimeAsync(1000);
    expect(canal.intentosDeReconexion).toBe(0);      // aún no toca

    canal.simularReconexion();
    expect(canal.intentosDeReconexion).toBe(1);
  });
});

// Reescrita: comprueba comportamiento, y solo la interacción que es observable
test('crearTarea envía POST con el cuerpo correcto y devuelve la Tarea con su id', async () => {
  const red = instalarFetchFalso();
  const nueva = { titulo: 'Revisar extintores', responsable: 'Marta', prioridad: 'media',
                  horasEstimadas: 2, fechaLimite: '2026-10-20', etiquetas: ['seguridad'] };
  red.mockResolvedValue(respuestaJson({ ...nueva, id: 7, estado: 'pendiente' }, { status: 201 }));

  const creada = await crearTarea(nueva);

  // 1 · El resultado: lo que promete la función
  expect(creada).toBeInstanceOf(Tarea);
  expect(creada.id).toBe(7);                    // R1: el id lo asigna el servidor
  expect(creada.estado).toBe('pendiente');      // R5
  expect(creada.titulo).toBe('Revisar extintores');

  // 2 · La interacción, SOLO donde es comportamiento observable por el servidor
  const [url, opciones] = red.mock.calls[0];
  expect(String(url)).toContain('/tareas');
  expect(opciones.method).toBe('POST');
  expect(opciones.headers['Content-Type']).toBe('application/json');
  expect(JSON.parse(opciones.body)).toMatchObject({
    titulo: 'Revisar extintores', horasEstimadas: 2
  });
});

test('crearTarea propaga un 422 de validación como ErrorDeApi de cliente', async () => {
  const red = instalarFetchFalso();
  red.mockResolvedValue(respuestaJson({ mensaje: 'Faltan horas' }, { status: 422 }));

  const error = await capturarAsync(() => crearTarea({ titulo: 'Sin horas' }));

  expect(error).toBeInstanceOf(ErrorDeApi);
  expect(error.status).toBe(422);
  expect(error.reintentable).toBe(false);
  expect(error.message).toBe('Faltan horas');
});