const tauler = new Tauler('Taller Nómada', crearBacklog());
tauler.resum('2026-09-20');
// { total: 6, obertes: 5, horesTotals: 48, horesObertes: 45, vencudes: 1, esforc: 124 }

test('el resum del backlog canònic dóna 45 h obertes de 48', () => {
  const tauler = new Tauler('Taller Nómada', crearBacklog());
  expect(tauler.resum('2026-09-20').horesObertes).toBe(45);
});

describe("Tasca · transicions d'estat (R6)", () => {
  test('pendent → en-curs està permès', () => { … });
  test('en-curs → feta està permès', () => { … });
  test('en-curs → pendent està permès (es pot tornar enrere una tasca)', () => { … });
  test('feta → en-curs llança ErrorDeValidacio: una tasca feta no es reobre', () => { … });
  test('pendent → feta llança ErrorDeValidacio: primer cal començar-la', () => { … });
});

npm install --save-dev jest

nomada-tasques/
  js/                       ← l'aplicació (es desplega)
  proves/                   ← les proves (no es despleguen mai)
    model/
      tasca.test.js
      tauler.test.js
    util/
      dates.test.js
    ajudes/
      backlog-de-prova.js   ← utilitats compartides, sense proves a dins

{
  "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  proves/model/tasca.test.js
 PASS  proves/model/tauler.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' n'hi ha prou per al model: no toca DOM. A 08-05 canviarà a 'jsdom'.
  testEnvironment: 'node',

  // Sense transformacions: Node entén els import tal qual.
  transform: {},

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

  // Fitxers de l'aplicació que compten per a la cobertura
  collectCoverageFrom: ['js/**/*.js', '!js/app.js'],

  // Sortida més llegible quan alguna cosa falla
  verbose: false
};

// babel.config.js — només si tries el camí B
export default {
  presets: [['@babel/preset-env', { targets: { node: 'current' } }]]
};

// proves/model/tasca.test.js
import { Tasca } from '../../js/model/tasca.js';
import { ErrorDeValidacio } from '../../js/model/errors.js';

const DADES_VALIDES = {
  id: 1,
  titol: 'Redissenyar la sala polivalent',
  responsable: 'Iván',
  prioritat: 'alta',
  estat: 'en-curs',
  etiquetes: ['espai', 'disseny'],
  horesEstimades: 12,
  dataLimit: '2026-09-30',
  revisor: 'Marta'
};

describe('Tasca', () => {
  describe('construcció', () => {
    test('conserva el títol sense espais sobrants', () => {
      // Preparar (Arrange)
      const dades = { ...DADES_VALIDES, titol: '  Redissenyar la sala  ' };

      // Actuar (Act)
      const tasca = new Tasca(dades);

      // Comprovar (Assert)
      expect(tasca.titol).toBe('Redissenyar la sala');
    });
  });
});

// Comprova NOMÉS el que importa a aquesta prova; la resta pot canviar sense trencar-la
expect(tauler.resum(AVUI)).toMatchObject({ horesObertes: 45, vencudes: 1 });

// Davant d'això, que es trenca si demà el resum afegeix un camp nou:
expect(tauler.resum(AVUI)).toStrictEqual({
  total: 6, obertes: 5, horesTotals: 48, horesObertes: 45, vencudes: 1, esforc: 124
});

const a = { id: 1, titol: 'Redissenyar la sala' };
const b = { id: 1, titol: 'Redissenyar la sala' };

expect(a).toBe(b);       // ✗ FALLA: són dos objectes diferents en memòria
expect(a).toEqual(b);    // ✓ passa: tenen el mateix contingut
expect(a).toBe(a);       // ✓ passa: és literalment el mateix objecte

// 1 · Propietats amb valor undefined
expect({ id: 1, revisor: undefined }).toEqual({ id: 1 });        // ✓ passa: toEqual les ignora
expect({ id: 1, revisor: undefined }).toStrictEqual({ id: 1 });  // ✗ falla: són diferents

// 2 · Tipus de classe
class Tasca { constructor() { this.id = 1; } }
expect(new Tasca()).toEqual({ id: 1 });          // ✓ passa: mateix contingut
expect(new Tasca()).toStrictEqual({ id: 1 });    // ✗ falla: una és Tasca, l'altre objecte pla

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

test("el getter tasques retorna una còpia, no l'array intern", () => {
  const tauler = new Tauler('Taller Nómada', crearBacklog());

  expect(tauler.tasques).not.toBe(tauler.tasques);   // dues crides, dos arrays diferents
  expect(tauler.tasques).toEqual(tauler.tasques);    // però amb el mateix contingut
});

// ❌ MALAMENT: l'excepció es llança en avaluar l'argument, abans d'arribar a expect
expect(new Tasca({ titol: '' })).toThrow(ErrorDeValidacio);

// ✅ BÉ: es passa una FUNCIÓ que Jest executarà dins d'un try/catch
expect(() => new Tasca({ titol: '' })).toThrow(ErrorDeValidacio);

const crear = () => new Tasca({ id: 1, titol: '   ', horesEstimades: 4 });

expect(crear).toThrow();                              // 1 · llança alguna cosa
expect(crear).toThrow(ErrorDeValidacio);              // 2 · llança AQUEST tipus
expect(crear).toThrow('El titol no pot estar buit.'); // 3 · el missatge CONTÉ aquest text
expect(crear).toThrow(/titol/i);                      // 4 · el missatge casa amb l'expressió regular

// Patró A · try/catch explícit amb expect.assertions
test("l'error d'hores identifica el camp horesEstimades", () => {
  expect.assertions(3);            // ← garanteix que les 3 assercions s'executen

  try {
    new Tasca({ id: 1, titol: 'Prova', horesEstimades: 99 });
  } catch (error) {
    expect(error).toBeInstanceOf(ErrorDeValidacio);
    expect(error.camp).toBe('horesEstimades');
    expect(error.valorRebut).toBe(99);
  }
});

// Patró B · capturar amb una funció auxiliar (més llegible quan es repeteix)
function capturar(fn) {
  try { fn(); return null; } catch (error) { return error; }
}

test("l'error d'hores identifica el camp horesEstimades", () => {
  const error = capturar(() => new Tasca({ id: 1, titol: 'Prova', horesEstimades: 99 }));

  expect(error).toBeInstanceOf(ErrorDeValidacio);
  expect(error).toMatchObject({ camp: 'horesEstimades', valorRebut: 99 });
});

describe('Tauler', () => {
  let tauler;

  beforeEach(() => {
    // Un tauler NOU per a cada prova: ningú hereta els canvis del veí
    tauler = new Tauler('Taller Nómada', crearBacklog());
  });

  test('afegeix les sis tasques del backlog', () => {
    expect(tauler.total).toBe(6);
  });

  test("canviar d'estat no altera el total", () => {
    tauler.canviarEstat(2, 'en-curs');
    expect(tauler.total).toBe(6);
  });
});

describe('Tauler', () => {
  beforeEach(() => console.log('1 · fora'));

  describe('amb una tasca tancada', () => {
    beforeEach(() => console.log('2 · dins'));

    test('compta 4 obertes', () => console.log('3 · prova'));
  });
});
// Sortida: 1 · fora → 2 · dins → 3 · prova

// ❌ MALAMENT: el tauler es crea UNA vegada i totes les proves el comparteixen
const tauler = new Tauler('Taller Nómada', crearBacklog());

test('la tasca 2 es pot començar', () => {
  tauler.canviarEstat(2, 'en-curs');
  expect(tauler.cercarPerId(2).estat).toBe('en-curs');
});

test('el backlog té 5 tasques obertes', () => {
  expect(tauler.obertes).toHaveLength(5);      // passa… fins que algú en tanqui una a dalt
});

test('la tasca 2 comença en pendent', () => {
  expect(tauler.cercarPerId(2).estat).toBe('pendent');   // ✗ FALLA per culpa de la primera
});

// ✅ BÉ: beforeEach reconstrueix l'estat
let tauler;
beforeEach(() => { tauler = new Tauler('Taller Nómada', crearBacklog()); });

describe("Tasca · transicions d'estat (R6)", () => {
  // ── Les permeses ────────────────────────────────────────────────────
  test.each([
    ['pendent',  'en-curs'],
    ['en-curs',  'feta'],
    ['en-curs',  'pendent']
  ])('permet passar de %s a %s', (origen, desti) => {
    const tasca = new Tasca({ ...DADES_VALIDES, estat: origen });

    tasca.canviarEstat(desti);

    expect(tasca.estat).toBe(desti);
  });

  // ── Les prohibides ──────────────────────────────────────────────────
  test.each([
    ['pendent',  'pendent'],
    ['pendent',  'feta'],       // primer cal començar-la abans d'acabar-la
    ['en-curs',  'en-curs'],
    ['feta',     'pendent'],    // una tasca feta no es reobre
    ['feta',     'en-curs'],
    ['feta',     'feta']
  ])('prohibeix passar de %s a %s', (origen, desti) => {
    const tasca = new Tasca({ ...DADES_VALIDES, estat: origen });

    expect(() => tasca.canviarEstat(desti)).toThrow(ErrorDeValidacio);
  });
});

  Tasca · transicions d'estat (R6)
    ✓ permet passar de pendent a en-curs
    ✓ permet passar de en-curs a feta
    ✓ permet passar de en-curs a pendent
    ✓ prohibeix passar de pendent a pendent
    ✓ prohibeix passar de pendent a feta
    ✓ prohibeix passar de en-curs a en-curs
    ✓ prohibeix passar de feta a pendent
    ✓ prohibeix passar de feta a en-curs
    ✓ prohibeix passar de feta a feta

describe("Tasca · validació d'hores (R3)", () => {
  test.each`
    hores   | valid    | motiu
    ${0}    | ${false} | ${'zero no és un valor vàlid'}
    ${-3}   | ${false} | ${'negatiu'}
    ${0.5}  | ${true}  | ${'mitja hora és admissible'}
    ${1}    | ${true}  | ${'límit inferior'}
    ${40}   | ${true}  | ${'límit superior exacte'}
    ${41}   | ${false} | ${'supera el màxim setmanal'}
    ${NaN}  | ${false} | ${'NaN no és comparable'}
    ${'12'} | ${false} | ${'una cadena no és un número'}
  `('horesEstimades $hores → $valid ($motiu)', ({ hores, valid }) => {
    const crear = () => new Tasca({ ...DADES_VALIDES, horesEstimades: hores });

    if (valid) expect(crear().horesEstimades).toBe(hores);
    else expect(crear).toThrow(ErrorDeValidacio);
  });
});

// ❌ MALAMENT: la prova acaba abans que la promesa es resolgui. Passa sempre.
test('importa les tasques', () => {
  carregarTauler().then((tauler) => {
    expect(tauler.total).toBe(6);       // ← això s'executa quan ningú mira
  });
});

// ✅ BÉ: la funció és async i s'espera
test('importa les tasques', async () => {
  const tauler = await carregarTauler();
  expect(tauler.total).toBe(6);
});

// ✅ TAMBÉ BÉ: retornar la promesa
test('importa les tasques', () => {
  return carregarTauler().then((tauler) => {
    expect(tauler.total).toBe(6);
  });
});

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

// rejects: aplica el matcher al motiu del REBUIG
await expect(carregarTauler('trencat')).rejects.toThrow(ErrorDeDades);
await expect(carregarTauler('trencat')).rejects.toBeInstanceOf(ErrorDeDades);

test('importar dades corrompudes llança ErrorDeDades amb la causa a dins', async () => {
  expect.assertions(2);

  try {
    await repositori.carregarDesDe('{{{ això no és JSON');
  } catch (error) {
    expect(error).toBeInstanceOf(ErrorDeDades);
    expect(error.causa).toBeInstanceOf(SyntaxError);
  }
});

// ── A · Funció pura: entra una dada, surt una dada ────────────────────
export function estaVencuda(dataLimit, estat, avui = AVUI) {
  return dataLimit < avui && estat !== 'feta';
}

// ── B · Funció impura: depèn del món i el modifica ────────────────────
export function marcarVencudes() {
  const avui = new Date().toISOString().slice(0, 10);        // ① el rellotge real
  const desat = JSON.parse(localStorage.getItem('nomada:tauler:v1'));   // ② el magatzem
  for (const t of desat.tasques) {
    if (t.dataLimit < avui && t.estat !== 'feta') {
      document.querySelector(`[data-id="${t.id}"]`).classList.add('vencuda');  // ③ el DOM
    }
  }
}

test('una tasca amb data passada i sense acabar està vençuda (R10)', () => {
  expect(estaVencuda('2026-09-05', 'pendent', '2026-09-20')).toBe(true);
});

// js/util/dates.js — la data ENTRA com a paràmetre, amb un valor per defecte
export function estaVencuda(dataLimit, estat, avui = AVUI) { … }

// js/model/tasca.js
estaVencuda(avui = AVUI) { return dataVencuda(this.dataLimit, this.#estat, avui); }

// js/dades/repositori-local.js — el magatzem ENTRA pel constructor
constructor({ clau = CLAU, magatzem } = {}) {
  this.#magatzem = magatzem ?? (this.#persistent ? window.localStorage : magatzemEnMemoria());
}

test('el pressupost de la fusteria està vençut el 20 de setembre', () => {
  const tauler = new Tauler('Taller Nómada', crearBacklog());

  expect(tauler.vencudes('2026-09-20')).toHaveLength(1);
  expect(tauler.vencudes('2026-09-20')[0].titol).toBe('Pressupost de la fusteria');
});

npm run test:cov

-------------------------|---------|----------|---------|---------|-------------------
File                     | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
-------------------------|---------|----------|---------|---------|-------------------
All files                |   84.21 |    78.94 |   88.23 |   84.05 |
 js/model                |   97.14 |    95.45 |     100 |   97.10 |
  errors.js              |     100 |      100 |     100 |     100 |
  tasca.js               |   96.42 |    94.11 |     100 |   96.36 | 88
  tauler.js              |     100 |      100 |     100 |     100 |
 js/util                 |     100 |      100 |     100 |     100 |
  dates.js               |     100 |      100 |     100 |     100 |
  format.js              |     100 |      100 |     100 |     100 |
 js/dades                |   42.85 |    28.57 |   50.00 |   42.30 | 34-58,71-88
  backlog.js             |     100 |      100 |     100 |     100 |
  repositori-local.js    |   31.25 |    20.00 |   33.33 |   30.76 | 34-58,71-88
-------------------------|---------|----------|---------|---------|-------------------

// Aquesta "prova" dóna 100 % de cobertura de la funció… i no comprova res
test('resum', () => {
  const tauler = new Tauler('Taller Nómada', crearBacklog());
  tauler.resum('2026-09-20');     // s'executa sencera. Zero assercions.
});

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

// ❌ No diuen res
test('tauler', …);
test('funciona', …);
test('test 3', …);
test('canviarEstat', …);

// ✅ Subjecte + comportament + condició
test('canviarEstat llança ErrorDeValidacio si la tasca no existeix', …);
test('el resum del backlog canònic dóna 45 h obertes de 48', …);
test('afegir rebutja un id duplicat (R1)', …);
test('les etiquetes es normalitzen a minúscules i sense duplicats (R9)', …);

// ❌ Si falla, què està trencat? Cal llegir l'informe amb lupa
test('el tauler funciona', () => {
  const tauler = new Tauler('Taller Nómada', crearBacklog());
  expect(tauler.total).toBe(6);
  tauler.canviarEstat(2, 'en-curs');
  expect(tauler.cercarPerId(2).estat).toBe('en-curs');
  expect(tauler.resum(AVUI).horesObertes).toBe(45);
  expect(() => tauler.afegir(new Tasca(DADES_VALIDES))).toThrow();
});

// ✅ Quatre proves, quatre noms, quatre diagnòstics
test('el backlog canònic té 6 tasques', …);
test('canviarEstat aplica la transició a la tasca indicada', …);
test('el resum del backlog canònic dóna 45 h obertes', …);
test('afegir rebutja un id duplicat (R1)', …);

test("l'error d'hores identifica el camp i el valor rebut", () => {
  const error = capturar(() => new Tasca({ ...DADES_VALIDES, horesEstimades: 99 }));

  expect(error).toBeInstanceOf(ErrorDeValidacio);   // tres assercions…
  expect(error.camp).toBe('horesEstimades');        // …sobre el MATEIX error…
  expect(error.valorRebut).toBe(99);                // …= un sol motiu de fallada
});

describe('Tasca · escalat de prioritat (R11)', () => {
  test('una tasca vençuda i de prioritat baixa escala a alta', () => {
    const tasca = new Tasca({ ...DADES_VALIDES, prioritat: 'baixa',
                              dataLimit: '2026-09-05', estat: 'pendent' });

    expect(tasca.prioritatEfectiva('2026-09-20')).toBe('alta');
  });
});

● Tasca · escalat de prioritat (R11) › una tasca vençuda i de prioritat baixa escala a alta
  TypeError: tasca.prioritatEfectiva is not a function

// js/model/tasca.js
prioritatEfectiva(avui = AVUI) {
  return 'alta';       // sí, així de mínim. Ja ho corregiran les proves següents.
}

test('una tasca no vençuda conserva la seva prioritat', () => {
  const tasca = new Tasca({ ...DADES_VALIDES, prioritat: 'baixa', dataLimit: '2026-11-30' });

  expect(tasca.prioritatEfectiva('2026-09-20')).toBe('baixa');
});

Expected: "baixa"   Received: "alta"

prioritatEfectiva(avui = AVUI) {
  return this.estaVencuda(avui) ? 'alta' : this.prioritat;
}

test('una tasca vençuda de prioritat mitjana conserva la seva prioritat', () => {
  const tasca = new Tasca({ ...DADES_VALIDES, prioritat: 'mitjana', dataLimit: '2026-09-05' });

  expect(tasca.prioritatEfectiva('2026-09-20')).toBe('mitjana');
});

prioritatEfectiva(avui = AVUI) {
  return this.estaVencuda(avui) && this.prioritat === 'baixa' ? 'alta' : this.prioritat;
}

// js/model/tasca.js
/** R11: el que està vençut i de baixa prioritat escala; la resta conserva la seva. */
get #vencudaIDeBaixaPrioritat() {
  return this.estaVencuda() && this.prioritat === 'baixa';
}

prioritatEfectiva(avui = AVUI) {
  return this.estaVencuda(avui) && this.prioritat === 'baixa' ? 'alta' : this.prioritat;
}

// proves/ajudes/backlog-de-prova.js
import { Tasca } from '../../js/model/tasca.js';
import { Tauler } from '../../js/model/tauler.js';
import { crearBacklog } from '../../js/dades/backlog.js';

/** Data canònica del projecte: fixa, perquè les proves no depenguin del calendari. */
export const AVUI = '2026-09-20';

export const DADES_VALIDES = Object.freeze({
  id: 1, titol: 'Redissenyar la sala polivalent', responsable: 'Iván',
  prioritat: 'alta', estat: 'en-curs', etiquetes: ['espai', 'disseny'],
  horesEstimades: 12, dataLimit: '2026-09-30', revisor: 'Marta'
});

/** Una tasca vàlida a la qual es canvia el que interessi. */
export const unaTasca = (canvis = {}) => new Tasca({ ...DADES_VALIDES, ...canvis });

/** Un tauler NOU amb el backlog canònic. Instàncies fresques a cada crida. */
export const unTauler = () => new Tauler('Taller Nómada', crearBacklog());

/** Captura l'excepció de fn, o retorna null si no llança. */
export function capturar(fn) {
  try { fn(); return null; } catch (error) { return error; }
}

// proves/model/tasca.test.js
import { Tasca } from '../../js/model/tasca.js';
import { ErrorDeValidacio } from '../../js/model/errors.js';
import { AVUI, DADES_VALIDES, unaTasca, capturar } from '../ajudes/backlog-de-prova.js';

describe('Tasca', () => {
  // ── Construcció i validació ───────────────────────────────────────────
  describe('construcció', () => {
    test('conserva les dades vàlides que rep', () => {
      const tasca = unaTasca();

      expect(tasca).toMatchObject({
        id: 1, titol: 'Redissenyar la sala polivalent',
        responsable: 'Iván', prioritat: 'alta', horesEstimades: 12
      });
    });

    test('retalla els espais del títol', () => {
      expect(unaTasca({ titol: '   Cartelleria   ' }).titol).toBe('Cartelleria');
    });

    test.each([['', 'cadena buida'], ['   ', 'només espais'], [null, 'null'], [42, 'un número']])(
      'rebutja el títol %p (%s) amb ErrorDeValidacio (R2)',
      (titol) => {
        expect(() => unaTasca({ titol })).toThrow(ErrorDeValidacio);
      }
    );

    test('el títol invàlid identifica el camp i el valor rebut', () => {
      const error = capturar(() => unaTasca({ titol: '  ' }));

      expect(error).toBeInstanceOf(ErrorDeValidacio);
      expect(error.camp).toBe('titol');
      expect(error.valorRebut).toBe('  ');
    });

    test('neix en pendent quan no es rep cap estat (R5)', () => {
      const { estat, ...senseEstat } = DADES_VALIDES;   // desestructuració de 04-07

      expect(new Tasca(senseEstat).estat).toBe('pendent');
    });

    test('rebutja un estat desconegut', () => {
      expect(() => unaTasca({ estat: 'arxivada' })).toThrow(ErrorDeValidacio);
    });

    test('una tasca sense responsable el desa com a null, mai com a cadena buida (R8)', () => {
      expect(unaTasca({ responsable: '' }).responsable).toBeNull();
      expect(unaTasca({ responsable: undefined }).responsable).toBeNull();
    });

    test('normalitza les etiquetes a minúscules i sense duplicats (R9)', () => {
      const tasca = unaTasca({ etiquetes: ['Espai', ' DISSENY ', 'espai', 'disseny'] });

      expect(tasca.etiquetes).toEqual(['espai', 'disseny']);
    });
  });

  // ── Hores (R3), amb els valors frontera ───────────────────────────────
  describe('horesEstimades (R3)', () => {
    test.each`
      hores   | valid    | motiu
      ${0}    | ${false} | ${'zero'}
      ${-3}   | ${false} | ${'negatiu'}
      ${1}    | ${true}  | ${'límit inferior'}
      ${40}   | ${true}  | ${'límit superior exacte'}
      ${41}   | ${false} | ${'supera el màxim'}
      ${NaN}  | ${false} | ${'NaN'}
      ${'12'} | ${false} | ${'cadena, no número'}
    `('$hores → vàlid: $valid ($motiu)', ({ hores, valid }) => {
      const crear = () => unaTasca({ horesEstimades: hores });

      if (valid) expect(crear().horesEstimades).toBe(hores);
      else expect(crear).toThrow(ErrorDeValidacio);
    });

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

      expect(() => { tasca.horesEstimades = 99; }).toThrow(ErrorDeValidacio);
      expect(tasca.horesEstimades).toBe(12);        // i NO s'ha modificat
    });
  });

  // ── Transicions (R6) ──────────────────────────────────────────────────
  describe("transicions d'estat (R6)", () => {
    test.each([
      ['pendent', 'en-curs'], ['en-curs', 'feta'], ['en-curs', 'pendent']
    ])('permet %s → %s', (origen, desti) => {
      const tasca = unaTasca({ estat: origen });

      expect(tasca.canviarEstat(desti).estat).toBe(desti);   // retorna this: encadenable
    });

    test.each([
      ['pendent', 'pendent'], ['pendent', 'feta'], ['en-curs', 'en-curs'],
      ['feta', 'pendent'], ['feta', 'en-curs'], ['feta', 'feta']
    ])('prohibeix %s → %s', (origen, desti) => {
      expect(() => unaTasca({ estat: origen }).canviarEstat(desti)).toThrow(ErrorDeValidacio);
    });

    test('una transició invàlida no deixa la tasca a mitges', () => {
      const tasca = unaTasca({ estat: 'feta' });

      capturar(() => tasca.canviarEstat('pendent'));

      expect(tasca.estat).toBe('feta');             // l'estat no s'ha corromput
    });
  });

  // ── Venciment (R10) i derivats ────────────────────────────────────────
  describe('venciment (R10)', () => {
    test('vençuda si la data ha passat i no està feta', () => {
      expect(unaTasca({ dataLimit: '2026-09-05', estat: 'pendent' }).estaVencuda(AVUI)).toBe(true);
    });

    test('no vençuda si està feta, encara que la data hagi passat', () => {
      expect(unaTasca({ dataLimit: '2026-09-05', estat: 'feta' }).estaVencuda(AVUI)).toBe(false);
    });

    test('no vençuda el mateix dia del límit', () => {
      expect(unaTasca({ dataLimit: AVUI, estat: 'pendent' }).estaVencuda(AVUI)).toBe(false);
    });

    test('oberta és false només quan està feta', () => {
      expect(unaTasca({ estat: 'pendent' }).oberta).toBe(true);
      expect(unaTasca({ estat: 'en-curs' }).oberta).toBe(true);
      expect(unaTasca({ estat: 'feta' }).oberta).toBe(false);
    });

    test('esforç = hores × pes de prioritat', () => {
      expect(unaTasca({ prioritat: 'alta', horesEstimades: 12 }).esforc).toBe(36);
      expect(unaTasca({ prioritat: 'mitjana', horesEstimades: 6 }).esforc).toBe(12);
      expect(unaTasca({ prioritat: 'baixa', horesEstimades: 3 }).esforc).toBe(3);
    });
  });

  // ── Serialització (reprenent 04-08) ───────────────────────────────────
  describe('serialització', () => {
    test('toJSON inclou el camp privat estat, que altrament es perdria', () => {
      const tasca = unaTasca({ estat: 'en-curs' });

      expect(tasca.toJSON()).toStrictEqual({
        id: 1, titol: 'Redissenyar la sala polivalent', responsable: 'Iván',
        prioritat: 'alta', estat: 'en-curs', etiquetes: ['espai', 'disseny'],
        horesEstimades: 12, dataLimit: '2026-09-30', revisor: 'Marta'
      });
    });

    test('el cicle de serialització i reconstrucció conserva tots els camps', () => {
      const original = unaTasca({ estat: 'en-curs' });

      const copia = Tasca.desDeJSON(JSON.stringify(original));

      expect(copia.toJSON()).toStrictEqual(original.toJSON());
      expect(copia).not.toBe(original);                  // és UNA ALTRA instància
      expect(copia).toBeInstanceOf(Tasca);               // però de la mateixa classe
    });

    test("toJSON retorna una còpia de les etiquetes, no l'array intern", () => {
      const tasca = unaTasca();

      tasca.toJSON().etiquetes.push('injectada');

      expect(tasca.etiquetes).toEqual(['espai', 'disseny']);   // intacte
    });
  });
});

// proves/model/tauler.test.js
import { Tasca } from '../../js/model/tasca.js';
import { ErrorDeValidacio } from '../../js/model/errors.js';
import { AVUI, unaTasca, unTauler } from '../ajudes/backlog-de-prova.js';

describe('Tauler', () => {
  let tauler;

  beforeEach(() => { tauler = unTauler(); });      // ← instàncies noves: proves independents

  describe('el backlog canònic', () => {
    test('té 6 tasques i 5 obertes', () => {
      expect(tauler.total).toBe(6);
      expect(tauler.obertes).toHaveLength(5);
    });

    test('suma 48 h totals i 45 h obertes', () => {
      expect(tauler.horesTotals).toBe(48);
      expect(tauler.horesObertes).toBe(45);        // ← la prova que faltava al cas 3 de 08-01
    });

    test('té un esforç ponderat de 124', () => {
      expect(tauler.esforc).toBe(124);
    });

    test('té exactament una tasca vençuda: el pressupost de la fusteria (R10)', () => {
      const vencudes = tauler.vencudes(AVUI);

      expect(vencudes).toHaveLength(1);
      expect(vencudes[0].titol).toBe('Pressupost de la fusteria');
    });

    test('reparteix les hores obertes: Iván 25, Lucía 14, Marta 6', () => {
      expect(tauler.horesPerResponsable()).toEqual({ 'Iván': 25, 'Lucía': 14, 'Marta': 6 });
    });

    test('el resum complet coincideix amb el valor esperat', () => {
      expect(tauler.resum(AVUI)).toStrictEqual({
        total: 6, obertes: 5, horesTotals: 48,
        horesObertes: 45, vencudes: 1, esforc: 124
      });
    });
  });

  describe('afegir', () => {
    test('afegeix una tasca nova i actualitza el total', () => {
      tauler.afegir(unaTasca({ id: 7, titol: 'Revisar els extintors', horesEstimades: 2 }));

      expect(tauler.total).toBe(7);
      expect(tauler.cercarPerId(7).titol).toBe('Revisar els extintors');
    });

    test('rebutja un id duplicat (R1)', () => {
      expect(() => tauler.afegir(unaTasca({ id: 3 }))).toThrow(ErrorDeValidacio);
      expect(tauler.total).toBe(6);                 // i no ha afegit res
    });

    test('rebutja qualsevol cosa que no sigui una Tasca', () => {
      expect(() => tauler.afegir({ id: 9, titol: 'Objecte pla' })).toThrow(ErrorDeValidacio);
    });
  });

  describe('canviarEstat', () => {
    test('aplica la transició a la tasca indicada', () => {
      tauler.canviarEstat(2, 'en-curs');

      expect(tauler.cercarPerId(2).estat).toBe('en-curs');
    });

    test('recalcula les hores obertes en tancar una tasca', () => {
      tauler.canviarEstat(1, 'feta');               // tasca 1: en-curs, 12 h, de l'Iván

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

    test('llança ErrorDeValidacio si la tasca no existeix', () => {
      expect(() => tauler.canviarEstat(99, 'en-curs')).toThrow(ErrorDeValidacio);
    });

    test("propaga l'error d'una transició prohibida (R6)", () => {
      expect(() => tauler.canviarEstat(4, 'en-curs')).toThrow(ErrorDeValidacio);  // la 4 està feta
    });
  });

  describe('consultes', () => {
    test('cercarPerId retorna null si no existeix, mai undefined', () => {
      expect(tauler.cercarPerId(99)).toBeNull();
    });

    test('filtrar retorna un array nou sense tocar el tauler', () => {
      const altes = tauler.filtrar((t) => t.prioritat === 'alta');

      expect(altes).toHaveLength(3);
      expect(tauler.total).toBe(6);
    });

    test('el getter tasques retorna una còpia defensiva (05-03)', () => {
      const copia = tauler.tasques;

      copia.push(unaTasca({ id: 99 }));
      copia.sort((a, b) => a.titol.localeCompare(b.titol, 'ca'));

      expect(tauler.total).toBe(6);                 // el push no ha afectat
      expect(tauler.tasques[0].id).toBe(1);         // ni el sort
    });

    test('és iterable: for…of recorre les sis tasques (05-08)', () => {
      const titols = [...tauler].map((t) => t.titol);

      expect(titols).toHaveLength(6);
      expect(titols[0]).toBe('Redissenyar la sala polivalent');
    });
  });
});

$ npm test

 PASS  proves/model/tasca.test.js
 PASS  proves/model/tauler.test.js

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

      # .github/workflows/qualitat.yml — un pas més
      - name: Executar les proves
        run: npm test -- --coverage --ci

import { Tauler } from '../../js/model/tauler.js';
import { crearBacklog } from '../../js/dades/backlog.js';

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

describe('tauler', () => {
  test('funciona', () => {
    expect(tauler.total).toBe(6);
    tauler.canviarEstat(2, 'en-curs');
    expect(tauler.cercarPerId(2).estat).toBe('en-curs');
  });

  test('resum', () => {
    const r = tauler.resum(new Date().toISOString().slice(0, 10));
    expect(r).toBe({ total: 6, obertes: 5, horesTotals: 48,
                     horesObertes: 45, vencudes: 1, esforc: 124 });
  });

  test('càrrega', () => {
    carregarDesDelServidor().then((t) => {
      expect(t.total).toBe(6);
    });
  });

  test.only('id duplicat', () => {
    expect(() => tauler.afegir(tauler.tasques[0])).toThrow();
  });
});

// proves/util/dates.test.js
import { AVUI, diesEntre, estaVencuda, dataLlegible } from '../../js/util/dates.js';

// Cap prova crida new Date() sense arguments: si ho fes, el resultat dependria
// del dia d'execució i la suite es trencaria sola un dimarts qualsevol sense que
// ningú hagués tocat el codi. El temps entra SEMPRE com a dada.

describe('AVUI', () => {
  test('és la data canònica del projecte en format ISO', () => {
    expect(AVUI).toBe('2026-09-20');
    expect(AVUI).toMatch(/^\d{4}-\d{2}-\d{2}$/);
  });
});

describe('diesEntre', () => {
  test.each`
    inici             | fi                | esperat  | cas
    ${'2026-09-20'}   | ${'2026-09-30'}   | ${10}    | ${'deu dies endavant'}
    ${'2026-09-20'}   | ${'2026-09-05'}   | ${-15}   | ${'quinze dies enrere'}
    ${'2026-09-20'}   | ${'2026-09-20'}   | ${0}     | ${'el mateix dia'}
    ${'2026-09-20'}   | ${'2026-10-02'}   | ${12}    | ${'canvi de mes'}
    ${'2026-12-28'}   | ${'2027-01-03'}   | ${6}     | ${"canvi d'any"}
    ${'2028-02-27'}   | ${'2028-03-01'}   | ${3}     | ${'any de traspàs'}
  `('$cas: $inici → $fi = $esperat', ({ inici, fi, esperat }) => {
    expect(diesEntre(inici, fi)).toBe(esperat);
  });
});

describe('estaVencuda (R10)', () => {
  test.each`
    data              | estat           | esperat  | motiu
    ${'2026-09-05'}   | ${'pendent'}    | ${true}  | ${'passada i sense començar'}
    ${'2026-09-05'}   | ${'en-curs'}    | ${true}  | ${'passada i en curs'}
    ${'2026-09-05'}   | ${'feta'}       | ${false} | ${'passada però acabada'}
    ${'2026-10-30'}   | ${'pendent'}    | ${false} | ${'futura i sense començar'}
    ${'2026-10-30'}   | ${'feta'}       | ${false} | ${'futura i acabada'}
    ${'2026-09-20'}   | ${'pendent'}    | ${false} | ${'venç avui: encara hi ha temps'}
  `('$data + $estat → $esperat ($motiu)', ({ data, estat, esperat }) => {
    expect(estaVencuda(data, estat, '2026-09-20')).toBe(esperat);
  });

  test('fa servir AVUI per defecte si no es passa data de referència', () => {
    expect(estaVencuda('2026-09-05', 'pendent')).toBe(true);
    expect(estaVencuda('2026-12-01', 'pendent')).toBe(false);
  });
});

describe('dataLlegible', () => {
  test.each([
    ['2026-01-01', '1 de gener de 2026'],
    ['2026-09-05', '5 de setembre de 2026'],
    ['2026-09-20', '20 de setembre de 2026'],
    ['2026-12-31', '31 de desembre de 2026']
  ])('%s → %s', (iso, esperat) => {
    expect(dataLlegible(iso)).toBe(esperat);
  });

  test('treu el zero inicial del dia', () => {
    expect(dataLlegible('2026-03-08')).toBe('8 de març de 2026');
    expect(dataLlegible('2026-03-08')).not.toContain('08');
  });
});

VOLTA 1 · VERMELL — el cas permès

test('Iván, amb 25 h obertes, pot acceptar 10 h més (R7)', () => {
  expect(unTauler().potAssignar('Iván', 10)).toBe(true);
});
// ✗ TypeError: tauler.potAssignar is not a function

VOLTA 1 · VERD — el mínim

potAssignar() { return true; }

VOLTA 2 · VERMELL — el cas prohibit

test('Iván, amb 25 h obertes, NO pot acceptar 16 h més (25 + 16 = 41 > 40)', () => {
  expect(unTauler().potAssignar('Iván', 16)).toBe(false);
});
// ✗ Expected: false   Received: true

VOLTA 2 · VERD

potAssignar(responsable, hores) {
  return (this.horesPerResponsable()[responsable] ?? 0) + hores <= 40;
}

VOLTA 3 · VERMELL — el límit exacte i qui no té res assignat

test('el límit exacte de 40 h està permès (25 + 15)', () => {
  expect(unTauler().potAssignar('Iván', 15)).toBe(true);
});

test('una persona sense tasques pot acceptar fins a 40 h', () => {
  const tauler = unTauler();

  expect(tauler.potAssignar('Berta', 40)).toBe(true);
  expect(tauler.potAssignar('Berta', 41)).toBe(false);
});
// Totes dues passen: el <= i el ?? 0 ja estaven bé. Verd a la primera,
// però valia la pena escriure-les: documenten les vores.

VOLTA 4 · VERMELL — les tasques fetes no compten

test('les tasques fetes no consumeixen quota setmanal', () => {
  const tauler = unTauler();

  tauler.canviarEstat(1, 'feta');        // l'Iván tanca 12 h: li queden 13 obertes

  expect(tauler.potAssignar('Iván', 27)).toBe(true);    // 13 + 27 = 40
  expect(tauler.potAssignar('Iván', 28)).toBe(false);   // 13 + 28 = 41
});
// Passa, perquè horesPerResponsable ja filtra per `obertes`. La prova
// documenta i protegeix aquest detall, que és fàcil de trencar en un refactor.

REFACTOR — amb les cinc proves en verd

// js/model/tauler.js
const MAXIM_SETMANAL = 40;                      // R7, en una constant amb nom

/**
 * R7: ningú pot superar 40 h estimades OBERTES.
 * Les tasques fetes no consumeixen quota.
 *
 * @param {string} responsable
 * @param {number} hores  Hores que es pretenen assignar
 * @returns {boolean}
 */
potAssignar(responsable, hores) {
  const assignades = this.horesPerResponsable()[responsable] ?? 0;
  return assignades + hores <= MAXIM_SETMANAL;
}

/** Hores que encara es poden assignar a algú sense incomplir R7. */
quotaDisponible(responsable) {
  return MAXIM_SETMANAL - (this.horesPerResponsable()[responsable] ?? 0);
}

// Suite corregida
import { Tauler } from '../../js/model/tauler.js';
import { ErrorDeValidacio } from '../../js/model/errors.js';
import { crearBacklog } from '../../js/dades/backlog.js';
import { carregarDesDelServidor } from '../../js/dades/api-tasques.js';

const AVUI = '2026-09-20';                    // ← data fixa: el temps entra com a dada

describe('Tauler', () => {
  let tauler;

  beforeEach(() => {                          // ← estat nou per a cada prova
    tauler = new Tauler('Taller Nómada', crearBacklog());
  });

  test('el backlog canònic té 6 tasques', () => {
    expect(tauler.total).toBe(6);
  });

  test('canviarEstat aplica la transició a la tasca indicada', () => {
    tauler.canviarEstat(2, 'en-curs');

    expect(tauler.cercarPerId(2).estat).toBe('en-curs');
  });

  test('el resum del backlog canònic coincideix amb el valor esperat', () => {
    expect(tauler.resum(AVUI)).toStrictEqual({   // ← toStrictEqual, no toBe
      total: 6, obertes: 5, horesTotals: 48,
      horesObertes: 45, vencudes: 1, esforc: 124
    });
  });

  test('afegir rebutja un id duplicat (R1)', () => {   // ← sense .only
    expect(() => tauler.afegir(tauler.tasques[0])).toThrow(ErrorDeValidacio);
    expect(tauler.total).toBe(6);
  });

  test('carregarDesDelServidor retorna les 6 tasques del backlog', async () => {
    const carregat = await carregarDesDelServidor();   // ← async + await

    expect(carregat.total).toBe(6);
  });
  // Nota: aquesta última prova encara depèn de la xarxa de debò, cosa que la fa
  // lenta i no determinista. A 08-04 se substitueix fetch per un doble i passa a
  // executar-se en mil·lisegons, sense sortir de la màquina.
});