Sense dobles:
  api-tasques.test.js      ✗ falla: getaddrinfo ENOTFOUND api.tallernomada.example
  temps.test.js            ✓ 4 proves · 1.4 s      (4 × 350 ms d'espera real)
  http.test.js             ✓ 3 proves · 6.8 s      (reintents amb backoff de debò)
  repositori.test.js       ✗ falla: localStorage is not defined

Amb dobles:
  api-tasques.test.js      ✓ 12 proves · 0.09 s
  temps.test.js            ✓ 4 proves · 0.02 s
  http.test.js             ✓ 8 proves · 0.05 s
  repositori.test.js       ✓ 11 proves · 0.03 s

// ── DUMMY · només ocupa un buit. No es fa servir, no es comprova ───────
const senyalDummy = new AbortController().signal;
await llistarTasques({ responsable: 'Iván' }, { signal: senyalDummy });

// ── STUB · resposta fixa; ningú mira com se li ha cridat ───────────────
const fetchStub = jest.fn().mockResolvedValue(
  new Response(JSON.stringify(dadesBacklog), { status: 200,
    headers: { 'content-type': 'application/json' } })
);

// ── SPY · observa, i (aquí) deixa passar la crida real ─────────────────
const espia = jest.spyOn(repositori, 'desar');
tauler.canviarEstat(2, 'en-curs');
expect(espia).toHaveBeenCalledTimes(1);           // ← la comprovació ÉS l'objectiu

// ── MOCK · resposta programada I expectatives sobre la crida ───────────
const fetchMock = jest.fn().mockResolvedValue(
  new Response(JSON.stringify({ id: 7 }), { status: 201,
    headers: { 'content-type': 'application/json' } })
);
await crearTasca(dadesNoves);
expect(fetchMock).toHaveBeenCalledWith(
  expect.stringContaining('/tasques'),
  expect.objectContaining({ method: 'POST' })
);

// ── FAKE · implementació real, simplificada ────────────────────────────
function magatzemFals(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';        // ← amb mòduls ES, jest s'IMPORTA

const enCrear = jest.fn();

enCrear({ id: 7, titol: 'Revisar els extintors' });
enCrear({ id: 8, titol: 'Demanar tinta negra' });

console.log(enCrear.mock.calls);
// [ [{ id: 7, titol: 'Revisar els extintors' }],
//   [{ id: 8, titol: 'Demanar tinta negra' }] ]

enCrear.mock.calls.length;      // 2  → quantes vegades s'ha cridat
enCrear.mock.calls[0][0];       // { id: 7, … }  → primer argument de la primera crida
enCrear.mock.lastCall[0];       // { id: 8, … }  → primer argument de l'última

const seguentId = jest.fn(() => 7);           // implementació inicial
const registrar = jest.fn((nivell, esdeveniment) => `[${nivell}] ${esdeveniment}`);

test("en crear una tasca s'avisa l'oient amb la tasca creada", () => {
  const enCrear = jest.fn();
  const formulari = { titol: 'Revisar els extintors', horesEstimades: 2 };

  crearDesDeFormulari(formulari, { enCrear });

  expect(enCrear).toHaveBeenCalledTimes(1);
  expect(enCrear).toHaveBeenCalledWith(expect.objectContaining({
    titol: 'Revisar els extintors',
    estat: 'pendent'                         // R5: neix en pendent
  }));
});

expect.anything()                    // qualsevol cosa excepte null i undefined
expect.any(Number)                   // qualsevol número (o String, Function, Tasca…)
expect.objectContaining({ a: 1 })    // un objecte que conté ALMENYS aquesta propietat
expect.arrayContaining([1, 2])       // un array que conté almenys aquests elements
expect.stringContaining('/tasques')  // una cadena que conté aquest text
expect.stringMatching(/^https:/)     // una cadena que casa amb l'expressió regular
expect.closeTo(8.16, 2)              // un número decimal amb tolerància

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

// Un doble que desa una CÒPIA del que rep
const desar = jest.fn((tauler) => estatsDesats.push(structuredClone(tauler.toJSON())));

const demanar = jest.fn()
  .mockRejectedValueOnce(new ErrorDeApi('503', { status: 503, codi: 'servidor' }))
  .mockRejectedValueOnce(new ErrorDeApi('503', { status: 503, codi: 'servidor' }))
  .mockResolvedValue({ tasques: dadesBacklog });     // a partir de la tercera, èxit

const resultat = await ambReintents(demanar, { intents: 3, baseMs: 0 });

expect(demanar).toHaveBeenCalledTimes(3);
expect(resultat.tasques).toHaveLength(6);

const cercar = jest.fn((id) => dadesBacklog.find((t) => t.id === id) ?? null);

expect(cercar(3).titol).toBe('Actualitzar el web de reserves');
expect(cercar(99)).toBeNull();

// jest.config.js
export default {
  restoreMocks: true,      // mockRestore() automàtic després de cada prova
  clearMocks: true         // mockClear() automàtic abans de cada prova
};

test("canviar d'estat provoca exactament un desat", () => {
  const repositori = new RepositoriLocal({ magatzem: magatzemFals() });
  const tauler = unTauler();
  connectarPersistencia(tauler, repositori);

  const espia = jest.spyOn(repositori, 'desar');    // observa, NO substitueix

  tauler.canviarEstat(2, 'en-curs');

  expect(espia).toHaveBeenCalledTimes(1);
  expect(espia).toHaveBeenCalledWith(tauler);
  expect(repositori.carregar().total).toBe(6);      // ← el desat REAL ha passat
});

// Observar I substituir: simulem que el magatzem està ple
jest.spyOn(repositori, 'desar').mockReturnValue(false);

// Observar i silenciar: evitar que la consola embruti la sortida de les proves
const avisos = jest.spyOn(console, 'warn').mockImplementation(() => {});

repositori.desar(tauler);

expect(avisos).toHaveBeenCalledWith(expect.stringContaining('Sense espai'));
avisos.mockRestore();                    // ← imprescindible si no fas servir restoreMocks

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

// 1 · Declarar el doble ABANS d'importar res del mòdul real
jest.unstable_mockModule('../../js/dades/api-tasques.js', () => ({
  llistarTasques: jest.fn(),
  crearTasca: jest.fn(),
  actualitzarTasca: jest.fn(),
  esborrarTasca: jest.fn()
}));

// 2 · Importar DESPRÉS, i de manera dinàmica (await import)
const { llistarTasques, crearTasca } = await import('../../js/dades/api-tasques.js');
const { carregarTauler } = await import('../../js/app-dades.js');

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

  test("construeix el tauler amb el que retorna l'API", async () => {
    llistarTasques.mockResolvedValue(dadesBacklog.map((d) => new Tasca(d)));

    const tauler = await carregarTauler();

    expect(tauler.total).toBe(6);
    expect(llistarTasques).toHaveBeenCalledTimes(1);
  });
});

// En lloc de simular el mòdul, INJECTAR la dependència
export async function carregarTauler({ llistar = llistarTasques } = {}) {
  return new Tauler('Taller Nómada', await llistar());
}

// La prova, sense cap màgia de mòduls:
test("construeix el tauler amb el que retorna l'API", async () => {
  const llistar = jest.fn().mockResolvedValue(crearBacklog());

  const tauler = await carregarTauler({ llistar });

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

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

// Substituïm NOMÉS `dormir`; demanarJson i ambReintents continuen sent els de debò
jest.unstable_mockModule('../../js/util/temps.js', async () => {
  const real = await import('../../js/util/temps.js');
  return {
    ...real,                                // tot l'original…
    dormir: jest.fn().mockResolvedValue()   // …excepte això
  };
});

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

// proves/ajudes/xarxa-falsa.js
import { jest } from '@jest/globals';

/** Construeix una Response real, amb el seu status i les seves capçaleres. */
export function respostaJson(cos, { status = 200, capcaleres = {} } = {}) {
  return new Response(JSON.stringify(cos), {
    status,
    headers: { 'content-type': 'application/json', ...capcaleres }
  });
}

/** Una Response sense cos, per a 204 No Content. */
export const respostaBuida = () => new Response(null, { status: 204 });

/** Una Response que NO és JSON: el proxy que retorna l'HTML d'un login. */
export const respostaHtml = (status = 200) =>
  new Response('<!doctype html><h1>Inicia la sessió</h1>', {
    status, headers: { 'content-type': 'text/html' }
  });

/** Instal·la un fetch fals i retorna el doble per programar-lo. */
export function instalarFetchFals() {
  const fals = jest.fn();
  globalThis.fetch = fals;
  return fals;
}

// proves/dades/api-tasques.test.js
import { jest } from '@jest/globals';
import { llistarTasques, crearTasca, actualitzarTasca, esborrarTasca } from '../../js/dades/api-tasques.js';
import { Tasca } from '../../js/model/tasca.js';
import { ErrorDeApi } from '../../js/model/errors.js';
import { dadesBacklog } from '../../js/dades/backlog.js';
import { respostaJson, respostaBuida, instalarFetchFals } from '../ajudes/xarxa-falsa.js';

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

  beforeEach(() => { xarxa = instalarFetchFals(); });
  afterEach(() => { globalThis.fetch = fetchOriginal; });   // ← tornar el món com estava

  describe('llistarTasques', () => {
    test('retorna instàncies de Tasca, no objectes plans', async () => {
      xarxa.mockResolvedValue(respostaJson(dadesBacklog));

      const tasques = await llistarTasques();

      expect(tasques).toHaveLength(6);
      expect(tasques[0]).toBeInstanceOf(Tasca);             // ← la frontera fa la seva feina
      expect(tasques[0].titol).toBe('Redissenyar la sala polivalent');
    });

    test('el tauler construït amb la resposta dóna els números canònics', async () => {
      xarxa.mockResolvedValue(respostaJson(dadesBacklog));

      const tauler = new Tauler('Taller Nómada', await llistarTasques());

      expect(tauler.resum('2026-09-20')).toMatchObject({ horesObertes: 45, esforc: 124 });
    });

    test('afegeix els filtres com a paràmetres de consulta i omet els buits', async () => {
      xarxa.mockResolvedValue(respostaJson([]));

      await llistarTasques({ responsable: 'Iván', estat: 'pendent', text: '' });

      const url = new URL(xarxa.mock.calls[0][0]);
      expect(url.pathname).toBe('/v1/tasques');
      expect(url.searchParams.get('responsable')).toBe('Iván');
      expect(url.searchParams.get('estat')).toBe('pendent');
      expect(url.searchParams.has('text')).toBe(false);     // els buits NO s'envien
    });
  });

  describe('crearTasca', () => {
    test('envia POST amb el cos serialitzat i retorna la Tasca amb el seu id', async () => {
      const nova = { titol: 'Revisar els extintors', responsable: 'Marta',
                     prioritat: 'mitjana', horesEstimades: 2,
                     dataLimit: '2026-10-20', etiquetes: ['seguretat'] };
      xarxa.mockResolvedValue(respostaJson({ ...nova, id: 7, estat: 'pendent' }, { status: 201 }));

      const creada = await crearTasca(nova);

      // Comportament: retorna una Tasca amb l'id que ha assignat el servidor (R1)
      expect(creada).toBeInstanceOf(Tasca);
      expect(creada.id).toBe(7);
      expect(creada.estat).toBe('pendent');                 // R5

      // Interacció: el mètode i el cos SÍ que són comportament observable
      const [, opcions] = xarxa.mock.calls[0];
      expect(opcions.method).toBe('POST');
      expect(JSON.parse(opcions.body)).toMatchObject({ titol: 'Revisar els extintors' });
      expect(opcions.headers['Content-Type']).toBe('application/json');
    });
  });

  describe('esborrarTasca', () => {
    test('envia DELETE i accepta una resposta 204 sense cos', async () => {
      xarxa.mockResolvedValue(respostaBuida());

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

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

describe("api-tasques · gestió d'errors (07-03)", () => {
  let xarxa;
  beforeEach(() => { xarxa = instalarFetchFals(); });

  test('un 404 produeix ErrorDeApi amb status 404 i codi de client', async () => {
    xarxa.mockResolvedValue(respostaJson({ missatge: 'No existeix la tasca 99' }, { status: 404 }));

    const error = await capturarAsinc(() => obtenirTasca(99));

    expect(error).toBeInstanceOf(ErrorDeApi);
    expect(error.status).toBe(404);
    expect(error.codi).toBe('client');
    expect(error.reintentable).toBe(false);          // ← un 404 NO es reintenta
    expect(error.message).toBe('No existeix la tasca 99');
  });

  test('un 500 produeix ErrorDeApi reintentable amb codi de servidor', async () => {
    xarxa.mockResolvedValue(respostaJson({ missatge: 'Error intern' }, { status: 500 }));

    const error = await capturarAsinc(() => llistarTasques());

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

  test('una fallada de transport produeix ErrorDeApi de xarxa, sense status', async () => {
    xarxa.mockRejectedValue(new TypeError('Failed to fetch'));   // xarxa caiguda, DNS o CORS

    const error = await capturarAsinc(() => llistarTasques());

    expect(error).toBeInstanceOf(ErrorDeApi);
    expect(error.codi).toBe('xarxa');
    expect(error.status).toBe(0);
    expect(error.causa).toBeInstanceOf(TypeError);   // la causa original es conserva
  });

  test('una resposta HTML en lloc de JSON produeix ErrorDeApi de format', async () => {
    xarxa.mockResolvedValue(respostaHtml(200));      // el proxy que retorna el login

    const error = await capturarAsinc(() => llistarTasques());

    expect(error.codi).toBe('format');
    expect(error.message).toContain('text/html');
  });

  test('una cancel·lació produeix ErrorDeApi amb codi cancel·lat', async () => {
    const abortError = new DOMException('The operation was aborted.', 'AbortError');
    xarxa.mockRejectedValue(abortError);

    const error = await capturarAsinc(() => llistarTasques());

    expect(error.codi).toBe('cancel·lat');
  });
});

// proves/ajudes/backlog-de-prova.js — versió asíncrona de capturar()
export async function capturarAsinc(fn) {
  try { await fn(); return null; } catch (error) { return error; }
}

jest.useFakeTimers();          // a partir d'aquí, el temps no passa sol

jest.advanceTimersByTime(300); // avançar 300 ms virtuals, a l'instant
jest.runAllTimers();           // executar TOTS els temporitzadors pendents
jest.runOnlyPendingTimers();   // només els actuals (evita bucles amb setInterval)
jest.advanceTimersToNextTimer(); // saltar just al següent

jest.useRealTimers();          // tornar el rellotge de debò

// proves/util/temps.test.js
import { jest } from '@jest/globals';
import { debounce } from '../../js/util/temps.js';

describe('debounce', () => {
  beforeEach(() => { jest.useFakeTimers(); });
  afterEach(() => { jest.useRealTimers(); });      // ← imprescindible: no deixar el rellotge parat

  test("no executa la funció abans que expiri l'espera", () => {
    const cercar = jest.fn();
    const ambRetard = debounce(cercar, 300);

    ambRetard('fus');
    jest.advanceTimersByTime(299);

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

  test("executa una sola vegada després de l'espera completa", () => {
    const cercar = jest.fn();
    const ambRetard = debounce(cercar, 300);

    ambRetard('fus');
    jest.advanceTimersByTime(300);

    expect(cercar).toHaveBeenCalledTimes(1);
    expect(cercar).toHaveBeenCalledWith('fus');
  });

  test("vuit pulsacions ràpides produeixen UNA sola crida, amb l'últim valor", () => {
    const cercar = jest.fn();
    const ambRetard = debounce(cercar, 300);

    // L'Iván tecleja "fusteria" a 50 ms per lletra
    for (const text of ['f', 'fu', 'fus', 'fust', 'fuste', 'fuster', 'fusteri', 'fusteria']) {
      ambRetard(text);
      jest.advanceTimersByTime(50);
    }

    expect(cercar).not.toHaveBeenCalled();          // encara no: cada tecla ha reiniciat el compte

    jest.advanceTimersByTime(300);                  // l'Iván para de teclejar

    expect(cercar).toHaveBeenCalledTimes(1);
    expect(cercar).toHaveBeenCalledWith('fusteria'); // ← l'ÚLTIM valor, no el primer
  });

  test('una pausa llarga entre pulsacions produeix dues crides', () => {
    const cercar = jest.fn();
    const ambRetard = debounce(cercar, 300);

    ambRetard('fus');
    jest.advanceTimersByTime(400);      // passa el llindar: primera crida
    ambRetard('tinta');
    jest.advanceTimersByTime(400);      // segona

    expect(cercar).toHaveBeenCalledTimes(2);
    expect(cercar).toHaveBeenNthCalledWith(1, 'fus');
    expect(cercar).toHaveBeenNthCalledWith(2, 'tinta');
  });
});

// proves/dades/http.test.js
import { jest } from '@jest/globals';
import { ambReintents } from '../../js/dades/http.js';
import { ErrorDeApi } from '../../js/model/errors.js';

const errorServidor = () => new ErrorDeApi('Caigut', { status: 503, codi: 'servidor' });
const errorClient   = () => new ErrorDeApi('No existeix', { status: 404, codi: 'client' });

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

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

  test("no reintenta quan l'operació té èxit a la primera", async () => {
    const operacio = jest.fn().mockResolvedValue('ok');

    await expect(ambReintents(operacio)).resolves.toBe('ok');

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

  test('reintenta un 503 i retorna el resultat del tercer intent', async () => {
    const operacio = jest.fn()
      .mockRejectedValueOnce(errorServidor())
      .mockRejectedValueOnce(errorServidor())
      .mockResolvedValue('recuperat');

    const promesa = ambReintents(operacio, { intents: 3, baseMs: 300 });

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

    await expect(promesa).resolves.toBe('recuperat');
    expect(operacio).toHaveBeenCalledTimes(3);
  });

  test('NO reintenta un 404: no té remei', async () => {
    const operacio = jest.fn().mockRejectedValue(errorClient());

    await expect(ambReintents(operacio, { intents: 3 })).rejects.toMatchObject({ status: 404 });

    expect(operacio).toHaveBeenCalledTimes(1);         // ← una sola vegada
  });

  test("es rendeix després d'esgotar els intents i propaga l'últim error", async () => {
    const operacio = jest.fn().mockRejectedValue(errorServidor());

    const promesa = ambReintents(operacio, { intents: 3, baseMs: 300 });
    const resultat = promesa.catch((e) => e);          // capturem ja, per no deixar-la penjant

    await jest.runAllTimersAsync();

    await expect(resultat).resolves.toMatchObject({ status: 503 });
    expect(operacio).toHaveBeenCalledTimes(3);
  });

  test("l'espera creix de manera exponencial entre intents", async () => {
    const esperes = [];
    jest.spyOn(globalThis, 'setTimeout').mockImplementation((fn, ms) => { esperes.push(ms); fn(); });

    const operacio = jest.fn().mockRejectedValue(errorServidor());
    await ambReintents(operacio, { intents: 4, baseMs: 100 }).catch(() => {});

    // 100·1 + jitter, 100·2 + jitter, 100·4 + jitter — cadascuna més gran que l'anterior
    expect(esperes).toHaveLength(3);
    expect(esperes[1]).toBeGreaterThan(esperes[0]);
    expect(esperes[2]).toBeGreaterThan(esperes[1]);
  });
});

describe('venciment amb el rellotge congelat', () => {
  beforeEach(() => {
    // El sistema sencer creu que és el 20 de setembre de 2026, a les 9:00
    jest.useFakeTimers({ now: new Date('2026-09-20T09:00:00Z') });
  });

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

  test('estaVencuda fa servir AVUI per defecte i dóna el mateix resultat qualsevol dia', () => {
    const tasca = unaTasca({ dataLimit: '2026-09-05', estat: 'pendent' });

    expect(tasca.estaVencuda()).toBe(true);           // sense passar data
  });

  test('la data del sistema és la congelada', () => {
    expect(new Date().toISOString().slice(0, 10)).toBe('2026-09-20');
  });

  test('el resum sense data explícita dóna una sola vençuda', () => {
    expect(unTauler().resum()).toMatchObject({ vencudes: 1 });
  });
});

// proves/ajudes/magatzem-fals.js

/**
 * FAKE de Web Storage: implementació real, simplificada, en memòria.
 * Compleix la interfície que fa servir RepositoriLocal, més un mode "ple" per
 * poder provocar el QuotaExceededError sense omplir un disc de debò.
 */
export function magatzemFals({ inicial = {}, ple = false } = {}) {
  const mapa = new Map(Object.entries(inicial));

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

    setItem: (clau, valor) => {
      if (ple) {
        const error = new Error('Quota superada');
        error.name = 'QuotaExceededError';           // ← el que comprova el repositori
        throw error;
      }
      mapa.set(clau, String(valor));                 // Web Storage NOMÉS desa cadenes
    },

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

    // Utilitats només per a les proves
    _abocar: () => Object.fromEntries(mapa)
  };
}

// proves/dades/repositori-local.test.js
import { jest } from '@jest/globals';
import { RepositoriLocal } from '../../js/dades/repositori-local.js';
import { magatzemFals } from '../ajudes/magatzem-fals.js';
import { unTauler } from '../ajudes/backlog-de-prova.js';

describe('RepositoriLocal', () => {
  test('desa i recupera el tauler complet', () => {
    const repositori = new RepositoriLocal({ magatzem: magatzemFals() });
    const tauler = unTauler();

    expect(repositori.desar(tauler)).toBe(true);
    const recuperat = repositori.carregar();

    expect(recuperat.total).toBe(6);
    expect(recuperat.resum('2026-09-20')).toMatchObject({ horesObertes: 45, esforc: 124 });
  });

  test('desa sota la clau versionada del projecte', () => {
    const magatzem = magatzemFals();
    new RepositoriLocal({ magatzem }).desar(unTauler());

    expect(Object.keys(magatzem._abocar())).toEqual(['nomada:tauler:v1']);
  });

  test('retorna null si no hi ha res desat', () => {
    expect(new RepositoriLocal({ magatzem: magatzemFals() }).carregar()).toBeNull();
  });

  test('descarta dades corrompudes sense llançar i avisa per consola', () => {
    const avisos = jest.spyOn(console, 'warn').mockImplementation(() => {});
    const magatzem = magatzemFals({ inicial: { 'nomada:tauler:v1': '{{{ no és JSON' } });

    expect(new RepositoriLocal({ magatzem }).carregar()).toBeNull();
    expect(avisos).toHaveBeenCalledWith(expect.stringContaining('corrompudes'));

    avisos.mockRestore();
  });

  test("sense espai retorna false, no llança: perdre persistència no tomba l'app", () => {
    const avisos = jest.spyOn(console, 'warn').mockImplementation(() => {});
    const repositori = new RepositoriLocal({ magatzem: magatzemFals({ ple: true }) });

    expect(repositori.desar(unTauler())).toBe(false);   // ← degrada, no explota

    avisos.mockRestore();
  });

  test('netejar elimina la clau i deixa el magatzem buit', () => {
    const magatzem = magatzemFals();
    const repositori = new RepositoriLocal({ magatzem });

    repositori.desar(unTauler());
    repositori.netejar();

    expect(repositori.carregar()).toBeNull();
    expect(magatzem.length).toBe(0);
  });
});

// ── Camí A · Mockeig agressiu: la dependència està importada a dins ────
// js/dades/sincronitzador.js
import { llistarTasques } from './api-tasques.js';

export async function sincronitzar(tauler) {
  const remotes = await llistarTasques();
  return tauler.importar(remotes);
}

// La prova necessita interceptar el sistema de mòduls
jest.unstable_mockModule('../../js/dades/api-tasques.js', () => ({ llistarTasques: jest.fn() }));
const { llistarTasques } = await import('../../js/dades/api-tasques.js');
const { sincronitzar } = await import('../../js/dades/sincronitzador.js');
llistarTasques.mockResolvedValue(crearBacklog());

// ── Camí B · Injecció: la dependència entra per paràmetre ──────────────
// js/dades/sincronitzador.js
import { llistarTasques } from './api-tasques.js';

export async function sincronitzar(tauler, { llistar = llistarTasques } = {}) {
  const remotes = await llistar();
  return tauler.importar(remotes);
}

// La prova, sense màgia
const llistar = jest.fn().mockResolvedValue(crearBacklog());
await sincronitzar(tauler, { llistar });

// ❌ Aquesta prova no comprova RES útil
test('canviarEstat funciona', () => {
  const tauler = unTauler();
  const cercar = jest.spyOn(tauler, 'cercarPerId');
  const canviar = jest.spyOn(Tasca.prototype, 'canviarEstat');

  tauler.canviarEstat(2, 'en-curs');

  expect(cercar).toHaveBeenCalledWith(2);
  expect(canviar).toHaveBeenCalledWith('en-curs');
});

// ✅ Comprova el comportament observable
test("canviarEstat deixa la tasca en l'estat indicat i recalcula les hores", () => {
  const tauler = unTauler();

  tauler.canviarEstat(1, 'feta');               // tasca 1: 12 h de l'Iván

  expect(tauler.cercarPerId(1).estat).toBe('feta');
  expect(tauler.horesObertes).toBe(33);         // 45 − 12
});

test('crearTasca funciona', async () => {
  const xarxa = instalarFetchFals();
  xarxa.mockResolvedValue(respostaJson({ id: 7 }, { status: 201 }));
  const construir = jest.spyOn(Tasca, 'desDeJSON');
  const serialitzar = jest.spyOn(JSON, 'stringify');

  await crearTasca({ titol: 'Revisar els extintors', horesEstimades: 2 });

  expect(xarxa).toHaveBeenCalled();
  expect(serialitzar).toHaveBeenCalled();
  expect(construir).toHaveBeenCalled();
});

// proves/dades/http.test.js
import { jest } from '@jest/globals';
import { demanarJson } from '../../js/dades/http.js';
import { ErrorDeApi } from '../../js/model/errors.js';
import { instalarFetchFals, respostaJson, respostaBuida, respostaHtml } from '../ajudes/xarxa-falsa.js';
import { capturarAsinc } from '../ajudes/backlog-de-prova.js';

// Fem servir `new Response(...)` i no un objecte literal perquè la Response real
// deriva `ok` de `status`, exposa `headers` amb l'API de Headers i permet
// llegir el cos UNA sola vegada. Un objecte casolà és més permissiu que
// l'original: deixaria passar codi que al navegador fallaria.

describe('demanarJson', () => {
  let xarxa;
  const fetchOriginal = globalThis.fetch;

  beforeEach(() => { xarxa = instalarFetchFals(); });
  afterEach(() => { globalThis.fetch = fetchOriginal; });

  test('retorna el JSON en una resposta 200 correcta', async () => {
    xarxa.mockResolvedValue(respostaJson({ tasques: 6 }));

    await expect(demanarJson('/tasques')).resolves.toEqual({ tasques: 6 });
  });

  test.each`
    cas                     | error                                                          | codi             | reintentable
    ${'xarxa caiguda'}      | ${new TypeError('Failed to fetch')}                             | ${'xarxa'}       | ${true}
    ${'timeout'}            | ${Object.assign(new Error('t'), { name: 'TimeoutError' })}      | ${'timeout'}     | ${true}
    ${'cancel·lació'}       | ${Object.assign(new Error('a'), { name: 'AbortError' })}        | ${'cancel·lat'}  | ${false}
  `('$cas → ErrorDeApi amb codi $codi', async ({ error, codi, reintentable }) => {
    xarxa.mockRejectedValue(error);

    const capturat = await capturarAsinc(() => demanarJson('/tasques'));

    expect(capturat).toBeInstanceOf(ErrorDeApi);
    expect(capturat.codi).toBe(codi);
    expect(capturat.status).toBe(0);
    expect(capturat.reintentable).toBe(reintentable);
    expect(capturat.causa).toBe(error);            // la causa original es conserva
  });

  test.each`
    status | codi           | reintentable | motiu
    ${400} | ${'client'}    | ${false}     | ${'dades mal enviades'}
    ${401} | ${'client'}    | ${false}     | ${'sessió caducada'}
    ${404} | ${'client'}    | ${false}     | ${'no existeix'}
    ${408} | ${'client'}    | ${true}      | ${'timeout del servidor: sí que es reintenta'}
    ${429} | ${'client'}    | ${true}      | ${'massa peticions: sí que es reintenta'}
    ${500} | ${'servidor'}  | ${true}      | ${'error intern'}
    ${503} | ${'servidor'}  | ${true}      | ${'servei no disponible'}
  `('un $status dóna codi $codi, reintentable: $reintentable ($motiu)',
    async ({ status, codi, reintentable }) => {
      xarxa.mockResolvedValue(respostaJson({ missatge: `Error ${status}` }, { status }));

      const error = await capturarAsinc(() => demanarJson('/tasques'));

      expect(error.status).toBe(status);
      expect(error.codi).toBe(codi);
      expect(error.reintentable).toBe(reintentable);
      expect(error.message).toBe(`Error ${status}`);   // fa servir el missatge del servidor
    });

  test('una resposta HTML en lloc de JSON dóna codi de format', async () => {
    xarxa.mockResolvedValue(respostaHtml(200));

    const error = await capturarAsinc(() => demanarJson('/tasques'));

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

  test('un 204 sense cos retorna null en lloc de llançar', async () => {
    xarxa.mockResolvedValue(respostaBuida());

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

  test('un cos JSON malformat dóna codi de format, no un SyntaxError solt', async () => {
    xarxa.mockResolvedValue(new Response('{{{ trencat', {
      status: 200, headers: { 'content-type': 'application/json' }
    }));

    const error = await capturarAsinc(() => demanarJson('/tasques'));

    expect(error).toBeInstanceOf(ErrorDeApi);        // mai escapa un SyntaxError cru
    expect(error.codi).toBe('format');
  });
});

// proves/ajudes/canal-fals.js
/**
 * FAKE de CanalTauler: mateixa interfície (EventTarget + enviar/tancar), zero sockets.
 * Afegeix utilitats simular* que només existeixen per a les proves.
 */
export class CanalFals extends EventTarget {
  enviats = [];
  cua = [];
  connectat = true;
  intentsDeReconnexio = 0;

  enviar(tipus, dades) {
    if (!this.connectat) { this.cua.push({ tipus, dades }); return false; }
    this.enviats.push({ tipus, dades });
    return true;
  }

  tancar() { this.connectat = false; }

  // ── Utilitats de prova ──────────────────────────────────────────────
  simularMissatge(tipus, dades) {
    this.dispatchEvent(new CustomEvent(tipus, { detail: dades }));
  }

  simularCaiguda() {
    this.connectat = false;
    this.dispatchEvent(new CustomEvent('canal:tancat'));
  }

  simularReconnexio() {
    this.connectat = true;
    this.intentsDeReconnexio += 1;
    for (const pendent of this.cua.splice(0)) this.enviar(pendent.tipus, pendent.dades);
    this.dispatchEvent(new CustomEvent('canal:obert'));
  }
}

// proves/dades/temps-real.test.js
import { jest } from '@jest/globals';
import { connectarTempsReal } from '../../js/dades/temps-real.js';
import { CanalFals } from '../ajudes/canal-fals.js';
import { unTauler } from '../ajudes/backlog-de-prova.js';

describe('sincronització en temps real', () => {
  let canal, tauler;

  beforeEach(() => {
    jest.useFakeTimers();
    canal = new CanalFals();
    tauler = unTauler();
    connectarTempsReal(tauler, { canal });           // ← injecció, no mockeig de mòdul
  });

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

  test('(a) un missatge tasca:actualitzada aplica el canvi al tauler', () => {
    canal.simularMissatge('tasca:actualitzada', { id: 2, estat: 'en-curs' });

    expect(tauler.cercarPerId(2).estat).toBe('en-curs');
    expect(tauler.horesObertes).toBe(45);            // l'estat obert no canvia
  });

  test("(b) un missatge amb un id desconegut s'ignora sense llançar", () => {
    expect(() => canal.simularMissatge('tasca:actualitzada', { id: 999, estat: 'feta' }))
      .not.toThrow();

    expect(tauler.total).toBe(6);                    // res no s'ha afegit ni trencat
  });

  test("(c) els canvis durant una caiguda s'encuen i s'envien en reconnectar", () => {
    canal.simularCaiguda();

    tauler.canviarEstat(2, 'en-curs');               // canvi local mentre no hi ha xarxa

    expect(canal.enviats).toHaveLength(0);
    expect(canal.cua).toHaveLength(1);

    canal.simularReconnexio();

    expect(canal.cua).toHaveLength(0);
    expect(canal.enviats).toHaveLength(1);
    expect(canal.enviats[0]).toMatchObject({ tipus: 'tasca:canviada', dades: { id: 2 } });
  });

  test('la reconnexió respecta el retrocés exponencial', async () => {
    canal.simularCaiguda();

    await jest.advanceTimersByTimeAsync(1000);
    expect(canal.intentsDeReconnexio).toBe(0);       // encara no toca

    canal.simularReconnexio();
    expect(canal.intentsDeReconnexio).toBe(1);
  });
});

// Reescrita: comprova comportament, i només la interacció que és observable
test('crearTasca envia POST amb el cos correcte i retorna la Tasca amb el seu id', async () => {
  const xarxa = instalarFetchFals();
  const nova = { titol: 'Revisar els extintors', responsable: 'Marta', prioritat: 'mitjana',
                 horesEstimades: 2, dataLimit: '2026-10-20', etiquetes: ['seguretat'] };
  xarxa.mockResolvedValue(respostaJson({ ...nova, id: 7, estat: 'pendent' }, { status: 201 }));

  const creada = await crearTasca(nova);

  // 1 · El resultat: el que promet la funció
  expect(creada).toBeInstanceOf(Tasca);
  expect(creada.id).toBe(7);                    // R1: l'id l'assigna el servidor
  expect(creada.estat).toBe('pendent');         // R5
  expect(creada.titol).toBe('Revisar els extintors');

  // 2 · La interacció, NOMÉS on és comportament observable pel servidor
  const [url, opcions] = xarxa.mock.calls[0];
  expect(String(url)).toContain('/tasques');
  expect(opcions.method).toBe('POST');
  expect(opcions.headers['Content-Type']).toBe('application/json');
  expect(JSON.parse(opcions.body)).toMatchObject({
    titol: 'Revisar els extintors', horesEstimades: 2
  });
});

test('crearTasca propaga un 422 de validació com a ErrorDeApi de client', async () => {
  const xarxa = instalarFetchFals();
  xarxa.mockResolvedValue(respostaJson({ missatge: 'Falten hores' }, { status: 422 }));

  const error = await capturarAsinc(() => crearTasca({ titol: 'Sense hores' }));

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