const board = new Board('Taller Nómada', createBacklog());
board.summary('2026-09-20');
// { total: 6, open: 5, totalHours: 48, openHours: 45, overdue: 1, effort: 124 }

test('the canonical backlog summary gives 45 open hours out of 48', () => {
  const board = new Board('Taller Nómada', createBacklog());
  expect(board.summary('2026-09-20').openHours).toBe(45);
});

describe('Task · status transitions (R6)', () => {
  test('pending → in-progress is allowed', () => { … });
  test('in-progress → done is allowed', () => { … });
  test('in-progress → pending is allowed (a task can be handed back)', () => { … });
  test('done → in-progress throws ValidationError: a finished task is not reopened', () => { … });
  test('pending → done throws ValidationError: it has to be started first', () => { … });
});

npm install --save-dev jest

nomada-tasks/
  js/                       ← the application (gets deployed)
  test/                     ← the tests (never deployed)
    model/
      task.test.js
      board.test.js
    util/
      dates.test.js
    helpers/
      test-backlog.js       ← shared utilities, with no tests inside

{
  "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  test/model/task.test.js
 PASS  test/model/board.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' is enough for the model: it does not touch the DOM. In 08-05 it becomes 'jsdom'.
  testEnvironment: 'node',

  // No transformations: Node understands the imports as they are.
  transform: {},

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

  // Application files that count towards coverage
  collectCoverageFrom: ['js/**/*.js', '!js/app.js'],

  // More readable output when something fails
  verbose: false
};

// babel.config.js — only if you choose route B
export default {
  presets: [['@babel/preset-env', { targets: { node: 'current' } }]]
};

// test/model/task.test.js
import { Task } from '../../js/model/task.js';
import { ValidationError } from '../../js/model/errors.js';

const VALID_DATA = {
  id: 1,
  title: 'Redesign the multipurpose room',
  assignee: 'Iván',
  priority: 'high',
  status: 'in-progress',
  tags: ['space', 'design'],
  estimatedHours: 12,
  dueDate: '2026-09-30',
  reviewer: 'Marta'
};

describe('Task', () => {
  describe('construction', () => {
    test('keeps the title with no surrounding whitespace', () => {
      // Arrange
      const data = { ...VALID_DATA, title: '  Redesign the room  ' };

      // Act
      const task = new Task(data);

      // Assert
      expect(task.title).toBe('Redesign the room');
    });
  });
});

// Checks ONLY what matters to this test; the rest can change without breaking it
expect(board.summary(TODAY)).toMatchObject({ openHours: 45, overdue: 1 });

// As opposed to this, which breaks if tomorrow the summary adds a new field:
expect(board.summary(TODAY)).toStrictEqual({
  total: 6, open: 5, totalHours: 48, openHours: 45, overdue: 1, effort: 124
});

const a = { id: 1, title: 'Redesign the room' };
const b = { id: 1, title: 'Redesign the room' };

expect(a).toBe(b);       // ✗ FAILS: they are two different objects in memory
expect(a).toEqual(b);    // ✓ passes: they have the same contents
expect(a).toBe(a);       // ✓ passes: it is literally the same object

// 1 · Properties whose value is undefined
expect({ id: 1, reviewer: undefined }).toEqual({ id: 1 });        // ✓ passes: toEqual ignores them
expect({ id: 1, reviewer: undefined }).toStrictEqual({ id: 1 });  // ✗ fails: they are different

// 2 · Class type
class Task { constructor() { this.id = 1; } }
expect(new Task()).toEqual({ id: 1 });          // ✓ passes: same contents
expect(new Task()).toStrictEqual({ id: 1 });    // ✗ fails: one is a Task, the other a plain object

// 3 · Holes in arrays
expect([, 1]).toEqual([undefined, 1]);           // ✓ passes
expect([, 1]).toStrictEqual([undefined, 1]);     // ✗ fails

test('the tasks getter returns a copy, not the internal array', () => {
  const board = new Board('Taller Nómada', createBacklog());

  expect(board.tasks).not.toBe(board.tasks);   // two calls, two different arrays
  expect(board.tasks).toEqual(board.tasks);    // but with the same contents
});

// ❌ WRONG: the exception is thrown while evaluating the argument, before expect is reached
expect(new Task({ title: '' })).toThrow(ValidationError);

// ✅ RIGHT: you pass a FUNCTION that Jest will run inside a try/catch
expect(() => new Task({ title: '' })).toThrow(ValidationError);

const create = () => new Task({ id: 1, title: '   ', estimatedHours: 4 });

expect(create).toThrow();                              // 1 · it throws something
expect(create).toThrow(ValidationError);               // 2 · it throws THAT type
expect(create).toThrow('The title cannot be empty.');  // 3 · the message CONTAINS that text
expect(create).toThrow(/title/i);                      // 4 · the message matches the regular expression

// Pattern A · explicit try/catch with expect.assertions
test('the hours error identifies the estimatedHours field', () => {
  expect.assertions(3);            // ← guarantees that all 3 assertions run

  try {
    new Task({ id: 1, title: 'Test', estimatedHours: 99 });
  } catch (error) {
    expect(error).toBeInstanceOf(ValidationError);
    expect(error.field).toBe('estimatedHours');
    expect(error.receivedValue).toBe(99);
  }
});

// Pattern B · capture with a helper function (more readable when it repeats)
function capture(fn) {
  try { fn(); return null; } catch (error) { return error; }
}

test('the hours error identifies the estimatedHours field', () => {
  const error = capture(() => new Task({ id: 1, title: 'Test', estimatedHours: 99 }));

  expect(error).toBeInstanceOf(ValidationError);
  expect(error).toMatchObject({ field: 'estimatedHours', receivedValue: 99 });
});

describe('Board', () => {
  let board;

  beforeEach(() => {
    // A NEW board for every test: nobody inherits the neighbor's changes
    board = new Board('Taller Nómada', createBacklog());
  });

  test('adds the six backlog tasks', () => {
    expect(board.total).toBe(6);
  });

  test('changing a status does not alter the total', () => {
    board.changeStatus(2, 'in-progress');
    expect(board.total).toBe(6);
  });
});

describe('Board', () => {
  beforeEach(() => console.log('1 · outer'));

  describe('with one closed task', () => {
    beforeEach(() => console.log('2 · inner'));

    test('counts 4 open', () => console.log('3 · test'));
  });
});
// Output: 1 · outer → 2 · inner → 3 · test

// ❌ WRONG: the board is created ONCE and every test shares it
const board = new Board('Taller Nómada', createBacklog());

test('task 2 can be started', () => {
  board.changeStatus(2, 'in-progress');
  expect(board.findById(2).status).toBe('in-progress');
});

test('the backlog has 5 open tasks', () => {
  expect(board.openTasks).toHaveLength(5);      // passes… until somebody closes one above
});

test('task 2 starts out pending', () => {
  expect(board.findById(2).status).toBe('pending');   // ✗ FAILS because of the first one
});

// ✅ RIGHT: beforeEach rebuilds the state
let board;
beforeEach(() => { board = new Board('Taller Nómada', createBacklog()); });

describe('Task · status transitions (R6)', () => {
  // ── The allowed ones ────────────────────────────────────────────────
  test.each([
    ['pending',     'in-progress'],
    ['in-progress', 'done'],
    ['in-progress', 'pending']
  ])('allows going from %s to %s', (from, to) => {
    const task = new Task({ ...VALID_DATA, status: from });

    task.changeStatus(to);

    expect(task.status).toBe(to);
  });

  // ── The forbidden ones ──────────────────────────────────────────────
  test.each([
    ['pending',     'pending'],
    ['pending',     'done'],         // it has to be started before it can be finished
    ['in-progress', 'in-progress'],
    ['done',        'pending'],      // a finished task is not reopened
    ['done',        'in-progress'],
    ['done',        'done']
  ])('forbids going from %s to %s', (from, to) => {
    const task = new Task({ ...VALID_DATA, status: from });

    expect(() => task.changeStatus(to)).toThrow(ValidationError);
  });
});

  Task · status transitions (R6)
    ✓ allows going from pending to in-progress
    ✓ allows going from in-progress to done
    ✓ allows going from in-progress to pending
    ✓ forbids going from pending to pending
    ✓ forbids going from pending to done
    ✓ forbids going from in-progress to in-progress
    ✓ forbids going from done to pending
    ✓ forbids going from done to in-progress
    ✓ forbids going from done to done

describe('Task · hours validation (R3)', () => {
  test.each`
    hours   | valid    | reason
    ${0}    | ${false} | ${'zero is not a valid value'}
    ${-3}   | ${false} | ${'negative'}
    ${0.5}  | ${true}  | ${'half an hour is acceptable'}
    ${1}    | ${true}  | ${'lower bound'}
    ${40}   | ${true}  | ${'exact upper bound'}
    ${41}   | ${false} | ${'over the weekly maximum'}
    ${NaN}  | ${false} | ${'NaN is not comparable'}
    ${'12'} | ${false} | ${'a string is not a number'}
  `('estimatedHours $hours → $valid ($reason)', ({ hours, valid }) => {
    const create = () => new Task({ ...VALID_DATA, estimatedHours: hours });

    if (valid) expect(create().estimatedHours).toBe(hours);
    else expect(create).toThrow(ValidationError);
  });
});

// ❌ WRONG: the test finishes before the promise resolves. It always passes.
test('imports the tasks', () => {
  loadBoard().then((board) => {
    expect(board.total).toBe(6);       // ← this runs when nobody is watching
  });
});

// ✅ RIGHT: the function is async and it is awaited
test('imports the tasks', async () => {
  const board = await loadBoard();
  expect(board.total).toBe(6);
});

// ✅ ALSO RIGHT: return the promise
test('imports the tasks', () => {
  return loadBoard().then((board) => {
    expect(board.total).toBe(6);
  });
});

// resolves: applies the matcher to the RESOLVED value
await expect(loadBoard()).resolves.toMatchObject({ total: 6 });

// rejects: applies the matcher to the REJECTION reason
await expect(loadBoard('broken')).rejects.toThrow(DataError);
await expect(loadBoard('broken')).rejects.toBeInstanceOf(DataError);

test('importing corrupt data throws DataError with the cause inside', async () => {
  expect.assertions(2);

  try {
    await repository.loadFrom('{{{ this is not JSON');
  } catch (error) {
    expect(error).toBeInstanceOf(DataError);
    expect(error.cause).toBeInstanceOf(SyntaxError);
  }
});

// ── A · Pure function: data in, data out ──────────────────────────────
export function isOverdue(dueDate, status, today = TODAY) {
  return dueDate < today && status !== 'done';
}

// ── B · Impure function: it depends on the world and modifies it ──────
export function markOverdue() {
  const today = new Date().toISOString().slice(0, 10);                    // ① the real clock
  const saved = JSON.parse(localStorage.getItem('nomada:board:v1'));      // ② the store
  for (const t of saved.tasks) {
    if (t.dueDate < today && t.status !== 'done') {
      document.querySelector(`[data-id="${t.id}"]`).classList.add('overdue');  // ③ the DOM
    }
  }
}

test('a task with a past date and unfinished is overdue (R10)', () => {
  expect(isOverdue('2026-09-05', 'pending', '2026-09-20')).toBe(true);
});

// js/util/dates.js — the date COMES IN as a parameter, with a default value
export function isOverdue(dueDate, status, today = TODAY) { … }

// js/model/task.js
isOverdue(today = TODAY) { return dateIsOverdue(this.dueDate, this.#status, today); }

// js/data/local-repository.js — the store COMES IN through the constructor
constructor({ key = KEY, store } = {}) {
  this.#store = store ?? (this.#persistent ? window.localStorage : inMemoryStore());
}

test('the carpentry workshop quote is overdue on 20 September', () => {
  const board = new Board('Taller Nómada', createBacklog());

  expect(board.overdue('2026-09-20')).toHaveLength(1);
  expect(board.overdue('2026-09-20')[0].title).toBe('Carpentry workshop quote');
});

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 |
  task.js                |   96.42 |    94.11 |     100 |   96.36 | 88
  board.js               |     100 |      100 |     100 |     100 |
 js/util                 |     100 |      100 |     100 |     100 |
  dates.js               |     100 |      100 |     100 |     100 |
  format.js              |     100 |      100 |     100 |     100 |
 js/data                 |   42.85 |    28.57 |   50.00 |   42.30 | 34-58,71-88
  backlog.js             |     100 |      100 |     100 |     100 |
  local-repository.js    |   31.25 |    20.00 |   33.33 |   30.76 | 34-58,71-88
-------------------------|---------|----------|---------|---------|-------------------

// This "test" gives 100% coverage of the function… and checks nothing
test('summary', () => {
  const board = new Board('Taller Nómada', createBacklog());
  board.summary('2026-09-20');     // it runs in full. Zero assertions.
});

export default {
  // …
  coverageThreshold: {
    global:            { branches: 70, functions: 80, lines: 80 },
    './js/model/':     { branches: 95, functions: 100, lines: 95 },   // the heart: demanding
    './js/view/':      { branches: 50, functions: 60, lines: 60 }     // the DOM: integration (08-05)
  }
};

// ❌ They say nothing
test('board', …);
test('works', …);
test('test 3', …);
test('changeStatus', …);

// ✅ Subject + behavior + condition
test('changeStatus throws ValidationError if the task does not exist', …);
test('the canonical backlog summary gives 45 open hours out of 48', …);
test('add rejects a duplicate id (R1)', …);
test('tags are normalized to lowercase with no duplicates (R9)', …);

// ❌ If it fails, what is broken? You have to read the report with a magnifying glass
test('the board works', () => {
  const board = new Board('Taller Nómada', createBacklog());
  expect(board.total).toBe(6);
  board.changeStatus(2, 'in-progress');
  expect(board.findById(2).status).toBe('in-progress');
  expect(board.summary(TODAY).openHours).toBe(45);
  expect(() => board.add(new Task(VALID_DATA))).toThrow();
});

// ✅ Four tests, four names, four diagnoses
test('the canonical backlog has 6 tasks', …);
test('changeStatus applies the transition to the given task', …);
test('the canonical backlog summary gives 45 open hours', …);
test('add rejects a duplicate id (R1)', …);

test('the hours error identifies the field and the received value', () => {
  const error = capture(() => new Task({ ...VALID_DATA, estimatedHours: 99 }));

  expect(error).toBeInstanceOf(ValidationError);   // three assertions…
  expect(error.field).toBe('estimatedHours');      // …about the SAME error…
  expect(error.receivedValue).toBe(99);            // …= one single reason to fail
});

describe('Task · priority escalation (R11)', () => {
  test('an overdue low-priority task is escalated to high', () => {
    const task = new Task({ ...VALID_DATA, priority: 'low',
                            dueDate: '2026-09-05', status: 'pending' });

    expect(task.effectivePriority('2026-09-20')).toBe('high');
  });
});

● Task · priority escalation (R11) › an overdue low-priority task is escalated to high
  TypeError: task.effectivePriority is not a function

// js/model/task.js
effectivePriority(today = TODAY) {
  return 'high';       // yes, that minimal. The next tests will fix it.
}

test('a task that is not overdue keeps its priority', () => {
  const task = new Task({ ...VALID_DATA, priority: 'low', dueDate: '2026-11-30' });

  expect(task.effectivePriority('2026-09-20')).toBe('low');
});

Expected: "low"   Received: "high"

effectivePriority(today = TODAY) {
  return this.isOverdue(today) ? 'high' : this.priority;
}

test('an overdue medium-priority task keeps its priority', () => {
  const task = new Task({ ...VALID_DATA, priority: 'medium', dueDate: '2026-09-05' });

  expect(task.effectivePriority('2026-09-20')).toBe('medium');
});

effectivePriority(today = TODAY) {
  return this.isOverdue(today) && this.priority === 'low' ? 'high' : this.priority;
}

// js/model/task.js
/** R11: overdue and low priority gets escalated; everything else keeps its own. */
get #isOverdueAndLowPriority() {
  return this.isOverdue() && this.priority === 'low';
}

effectivePriority(today = TODAY) {
  return this.isOverdue(today) && this.priority === 'low' ? 'high' : this.priority;
}

// test/helpers/test-backlog.js
import { Task } from '../../js/model/task.js';
import { Board } from '../../js/model/board.js';
import { createBacklog } from '../../js/data/backlog.js';

/** The project's canonical date: fixed, so the tests do not depend on the calendar. */
export const TODAY = '2026-09-20';

export const VALID_DATA = Object.freeze({
  id: 1, title: 'Redesign the multipurpose room', assignee: 'Iván',
  priority: 'high', status: 'in-progress', tags: ['space', 'design'],
  estimatedHours: 12, dueDate: '2026-09-30', reviewer: 'Marta'
});

/** A valid task with whatever you want changed. */
export const aTask = (changes = {}) => new Task({ ...VALID_DATA, ...changes });

/** A NEW board with the canonical backlog. Fresh instances on every call. */
export const aBoard = () => new Board('Taller Nómada', createBacklog());

/** Captures the exception thrown by fn, or returns null if it does not throw. */
export function capture(fn) {
  try { fn(); return null; } catch (error) { return error; }
}

// test/model/task.test.js
import { Task } from '../../js/model/task.js';
import { ValidationError } from '../../js/model/errors.js';
import { TODAY, VALID_DATA, aTask, capture } from '../helpers/test-backlog.js';

describe('Task', () => {
  // ── Construction and validation ───────────────────────────────────────
  describe('construction', () => {
    test('keeps the valid data it receives', () => {
      const task = aTask();

      expect(task).toMatchObject({
        id: 1, title: 'Redesign the multipurpose room',
        assignee: 'Iván', priority: 'high', estimatedHours: 12
      });
    });

    test('trims the whitespace around the title', () => {
      expect(aTask({ title: '   Signage   ' }).title).toBe('Signage');
    });

    test.each([['', 'empty string'], ['   ', 'whitespace only'], [null, 'null'], [42, 'a number']])(
      'rejects the title %p (%s) with ValidationError (R2)',
      (title) => {
        expect(() => aTask({ title })).toThrow(ValidationError);
      }
    );

    test('the title error identifies the field and the received value', () => {
      const error = capture(() => aTask({ title: '  ' }));

      expect(error).toBeInstanceOf(ValidationError);
      expect(error.field).toBe('title');
      expect(error.receivedValue).toBe('  ');
    });

    test('starts out pending when no status is given (R5)', () => {
      const { status, ...withoutStatus } = VALID_DATA;   // destructuring from 04-07

      expect(new Task(withoutStatus).status).toBe('pending');
    });

    test('rejects an unknown status', () => {
      expect(() => aTask({ status: 'archived' })).toThrow(ValidationError);
    });

    test('a task with no assignee stores it as null, never as an empty string (R8)', () => {
      expect(aTask({ assignee: '' }).assignee).toBeNull();
      expect(aTask({ assignee: undefined }).assignee).toBeNull();
    });

    test('normalizes tags to lowercase with no duplicates (R9)', () => {
      const task = aTask({ tags: ['Space', ' DESIGN ', 'space', 'design'] });

      expect(task.tags).toEqual(['space', 'design']);
    });
  });

  // ── Hours (R3), with the boundary values ──────────────────────────────
  describe('estimatedHours (R3)', () => {
    test.each`
      hours   | valid    | reason
      ${0}    | ${false} | ${'zero'}
      ${-3}   | ${false} | ${'negative'}
      ${1}    | ${true}  | ${'lower bound'}
      ${40}   | ${true}  | ${'exact upper bound'}
      ${41}   | ${false} | ${'over the maximum'}
      ${NaN}  | ${false} | ${'NaN'}
      ${'12'} | ${false} | ${'a string, not a number'}
    `('$hours → valid: $valid ($reason)', ({ hours, valid }) => {
      const create = () => aTask({ estimatedHours: hours });

      if (valid) expect(create().estimatedHours).toBe(hours);
      else expect(create).toThrow(ValidationError);
    });

    test('the setter validates just like the constructor', () => {
      const task = aTask();

      expect(() => { task.estimatedHours = 99; }).toThrow(ValidationError);
      expect(task.estimatedHours).toBe(12);        // and it has NOT been modified
    });
  });

  // ── Transitions (R6) ──────────────────────────────────────────────────
  describe('status transitions (R6)', () => {
    test.each([
      ['pending', 'in-progress'], ['in-progress', 'done'], ['in-progress', 'pending']
    ])('allows %s → %s', (from, to) => {
      const task = aTask({ status: from });

      expect(task.changeStatus(to).status).toBe(to);   // it returns this: chainable
    });

    test.each([
      ['pending', 'pending'], ['pending', 'done'], ['in-progress', 'in-progress'],
      ['done', 'pending'], ['done', 'in-progress'], ['done', 'done']
    ])('forbids %s → %s', (from, to) => {
      expect(() => aTask({ status: from }).changeStatus(to)).toThrow(ValidationError);
    });

    test('an invalid transition does not leave the task half changed', () => {
      const task = aTask({ status: 'done' });

      capture(() => task.changeStatus('pending'));

      expect(task.status).toBe('done');             // the status has not been corrupted
    });
  });

  // ── Overdue status (R10) and derived values ───────────────────────────
  describe('overdue status (R10)', () => {
    test('overdue if the date has passed and it is not done', () => {
      expect(aTask({ dueDate: '2026-09-05', status: 'pending' }).isOverdue(TODAY)).toBe(true);
    });

    test('not overdue if it is done, even if the date has passed', () => {
      expect(aTask({ dueDate: '2026-09-05', status: 'done' }).isOverdue(TODAY)).toBe(false);
    });

    test('not overdue on the due date itself', () => {
      expect(aTask({ dueDate: TODAY, status: 'pending' }).isOverdue(TODAY)).toBe(false);
    });

    test('isOpen is false only when it is done', () => {
      expect(aTask({ status: 'pending' }).isOpen).toBe(true);
      expect(aTask({ status: 'in-progress' }).isOpen).toBe(true);
      expect(aTask({ status: 'done' }).isOpen).toBe(false);
    });

    test('the effort is hours × priority weight', () => {
      expect(aTask({ priority: 'high', estimatedHours: 12 }).effort).toBe(36);
      expect(aTask({ priority: 'medium', estimatedHours: 6 }).effort).toBe(12);
      expect(aTask({ priority: 'low', estimatedHours: 3 }).effort).toBe(3);
    });
  });

  // ── Serialization (picking up 04-08) ──────────────────────────────────
  describe('serialization', () => {
    test('toJSON includes the private state, which would otherwise be lost', () => {
      const task = aTask({ status: 'in-progress' });

      expect(task.toJSON()).toStrictEqual({
        id: 1, title: 'Redesign the multipurpose room', assignee: 'Iván',
        priority: 'high', status: 'in-progress', tags: ['space', 'design'],
        estimatedHours: 12, dueDate: '2026-09-30', reviewer: 'Marta'
      });
    });

    test('the round trip preserves every field', () => {
      const original = aTask({ status: 'in-progress' });

      const copy = Task.fromJSON(JSON.stringify(original));

      expect(copy.toJSON()).toStrictEqual(original.toJSON());
      expect(copy).not.toBe(original);                   // it is ANOTHER instance
      expect(copy).toBeInstanceOf(Task);                 // but of the same class
    });

    test('toJSON returns a copy of the tags, not the internal array', () => {
      const task = aTask();

      task.toJSON().tags.push('injected');

      expect(task.tags).toEqual(['space', 'design']);    // untouched
    });
  });
});

// test/model/board.test.js
import { Task } from '../../js/model/task.js';
import { ValidationError } from '../../js/model/errors.js';
import { TODAY, aTask, aBoard } from '../helpers/test-backlog.js';

describe('Board', () => {
  let board;

  beforeEach(() => { board = aBoard(); });          // ← new instances: independent tests

  describe('the canonical backlog', () => {
    test('has 6 tasks and 5 open', () => {
      expect(board.total).toBe(6);
      expect(board.openTasks).toHaveLength(5);
    });

    test('adds up to 48 total hours and 45 open hours', () => {
      expect(board.totalHours).toBe(48);
      expect(board.openHours).toBe(45);              // ← the test missing in case 3 of 08-01
    });

    test('has a weighted effort of 124', () => {
      expect(board.effort).toBe(124);
    });

    test('has exactly one overdue task: the carpentry workshop quote (R10)', () => {
      const overdue = board.overdue(TODAY);

      expect(overdue).toHaveLength(1);
      expect(overdue[0].title).toBe('Carpentry workshop quote');
    });

    test('splits the open hours: Iván 25, Lucía 14, Marta 6', () => {
      expect(board.hoursByAssignee()).toEqual({ 'Iván': 25, 'Lucía': 14, 'Marta': 6 });
    });

    test('the complete summary is exactly what is expected', () => {
      expect(board.summary(TODAY)).toStrictEqual({
        total: 6, open: 5, totalHours: 48,
        openHours: 45, overdue: 1, effort: 124
      });
    });
  });

  describe('add', () => {
    test('adds a new task and updates the total', () => {
      board.add(aTask({ id: 7, title: 'Check the fire extinguishers', estimatedHours: 2 }));

      expect(board.total).toBe(7);
      expect(board.findById(7).title).toBe('Check the fire extinguishers');
    });

    test('rejects a duplicate id (R1)', () => {
      expect(() => board.add(aTask({ id: 3 }))).toThrow(ValidationError);
      expect(board.total).toBe(6);                   // and it added nothing
    });

    test('rejects anything that is not a Task', () => {
      expect(() => board.add({ id: 9, title: 'Plain object' })).toThrow(ValidationError);
    });
  });

  describe('changeStatus', () => {
    test('applies the transition to the given task', () => {
      board.changeStatus(2, 'in-progress');

      expect(board.findById(2).status).toBe('in-progress');
    });

    test('recalculates the open hours when a task is closed', () => {
      board.changeStatus(1, 'done');                 // task 1: in-progress, 12 h, Iván's

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

    test('throws ValidationError if the task does not exist', () => {
      expect(() => board.changeStatus(99, 'in-progress')).toThrow(ValidationError);
    });

    test('propagates the error of a forbidden transition (R6)', () => {
      expect(() => board.changeStatus(4, 'in-progress')).toThrow(ValidationError);  // task 4 is done
    });
  });

  describe('queries', () => {
    test('findById returns null when it does not exist, never undefined', () => {
      expect(board.findById(99)).toBeNull();
    });

    test('filter returns a new array without touching the board', () => {
      const high = board.filter((t) => t.priority === 'high');

      expect(high).toHaveLength(3);
      expect(board.total).toBe(6);
    });

    test('the tasks getter returns a defensive copy (05-03)', () => {
      const copy = board.tasks;

      copy.push(aTask({ id: 99 }));
      copy.sort((a, b) => a.title.localeCompare(b.title));

      expect(board.total).toBe(6);                   // the push had no effect
      expect(board.tasks[0].id).toBe(1);             // nor did the sort
    });

    test('it is iterable: for…of walks the six tasks (05-08)', () => {
      const titles = [...board].map((t) => t.title);

      expect(titles).toHaveLength(6);
      expect(titles[0]).toBe('Redesign the multipurpose room');
    });
  });
});

$ npm test

 PASS  test/model/task.test.js
 PASS  test/model/board.test.js

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

      # .github/workflows/quality.yml — one more step
      - name: Run the tests
        run: npm test -- --coverage --ci

import { Board } from '../../js/model/board.js';
import { createBacklog } from '../../js/data/backlog.js';

const board = new Board('Taller Nómada', createBacklog());

describe('board', () => {
  test('works', () => {
    expect(board.total).toBe(6);
    board.changeStatus(2, 'in-progress');
    expect(board.findById(2).status).toBe('in-progress');
  });

  test('summary', () => {
    const r = board.summary(new Date().toISOString().slice(0, 10));
    expect(r).toBe({ total: 6, open: 5, totalHours: 48,
                     openHours: 45, overdue: 1, effort: 124 });
  });

  test('load', () => {
    loadFromServer().then((b) => {
      expect(b.total).toBe(6);
    });
  });

  test.only('duplicate id', () => {
    expect(() => board.add(board.tasks[0])).toThrow();
  });
});

// test/util/dates.test.js
import { TODAY, daysBetween, isOverdue, readableDate } from '../../js/util/dates.js';

// No test calls new Date() with no arguments: if it did, the result would depend
// on the day it ran and the suite would break by itself on some random Tuesday
// without anybody having touched the code. Time ALWAYS comes in as data.

describe('TODAY', () => {
  test('is the project canonical date in ISO format', () => {
    expect(TODAY).toBe('2026-09-20');
    expect(TODAY).toMatch(/^\d{4}-\d{2}-\d{2}$/);
  });
});

describe('daysBetween', () => {
  test.each`
    from              | to                | expected | scenario
    ${'2026-09-20'}   | ${'2026-09-30'}   | ${10}    | ${'ten days forward'}
    ${'2026-09-20'}   | ${'2026-09-05'}   | ${-15}   | ${'fifteen days back'}
    ${'2026-09-20'}   | ${'2026-09-20'}   | ${0}     | ${'the same day'}
    ${'2026-09-20'}   | ${'2026-10-02'}   | ${12}    | ${'across a month boundary'}
    ${'2026-12-28'}   | ${'2027-01-03'}   | ${6}     | ${'across a year boundary'}
    ${'2028-02-27'}   | ${'2028-03-01'}   | ${3}     | ${'leap year'}
  `('$scenario: $from → $to = $expected', ({ from, to, expected }) => {
    expect(daysBetween(from, to)).toBe(expected);
  });
});

describe('isOverdue (R10)', () => {
  test.each`
    date              | status          | expected | reason
    ${'2026-09-05'}   | ${'pending'}    | ${true}  | ${'past and not started'}
    ${'2026-09-05'}   | ${'in-progress'}| ${true}  | ${'past and under way'}
    ${'2026-09-05'}   | ${'done'}       | ${false} | ${'past but finished'}
    ${'2026-10-30'}   | ${'pending'}    | ${false} | ${'future and not started'}
    ${'2026-10-30'}   | ${'done'}       | ${false} | ${'future and finished'}
    ${'2026-09-20'}   | ${'pending'}    | ${false} | ${'due today: there is still time'}
  `('$date + $status → $expected ($reason)', ({ date, status, expected }) => {
    expect(isOverdue(date, status, '2026-09-20')).toBe(expected);
  });

  test('uses TODAY by default when no reference date is passed', () => {
    expect(isOverdue('2026-09-05', 'pending')).toBe(true);
    expect(isOverdue('2026-12-01', 'pending')).toBe(false);
  });
});

describe('readableDate', () => {
  test.each([
    ['2026-01-01', '1 January 2026'],
    ['2026-09-05', '5 September 2026'],
    ['2026-09-20', '20 September 2026'],
    ['2026-12-31', '31 December 2026']
  ])('%s → %s', (iso, expected) => {
    expect(readableDate(iso)).toBe(expected);
  });

  test('strips the leading zero from the day', () => {
    expect(readableDate('2026-03-08')).toBe('8 March 2026');
    expect(readableDate('2026-03-08')).not.toContain('08');
  });
});

ROUND 1 · RED — the allowed case

test('Iván, with 25 open hours, can take 10 more (R7)', () => {
  expect(aBoard().canAssign('Iván', 10)).toBe(true);
});
// ✗ TypeError: board.canAssign is not a function

ROUND 1 · GREEN — the minimum

canAssign() { return true; }

ROUND 2 · RED — the forbidden case

test('Iván, with 25 open hours, can NOT take 16 more (25 + 16 = 41 > 40)', () => {
  expect(aBoard().canAssign('Iván', 16)).toBe(false);
});
// ✗ Expected: false   Received: true

ROUND 2 · GREEN

canAssign(assignee, hours) {
  return (this.hoursByAssignee()[assignee] ?? 0) + hours <= 40;
}

ROUND 3 · RED — the exact limit and somebody with nothing assigned

test('the exact 40 h limit is allowed (25 + 15)', () => {
  expect(aBoard().canAssign('Iván', 15)).toBe(true);
});

test('somebody with no tasks can take up to 40 h', () => {
  const board = aBoard();

  expect(board.canAssign('Berta', 40)).toBe(true);
  expect(board.canAssign('Berta', 41)).toBe(false);
});
// Both pass: the <= and the ?? 0 were already right. Green first time,
// but they were worth writing: they document the edges.

ROUND 4 · RED — done tasks do not count

test('done tasks do not consume weekly capacity', () => {
  const board = aBoard();

  board.changeStatus(1, 'done');            // Iván closes 12 h: 13 open left

  expect(board.canAssign('Iván', 27)).toBe(true);    // 13 + 27 = 40
  expect(board.canAssign('Iván', 28)).toBe(false);   // 13 + 28 = 41
});
// It passes, because hoursByAssignee already filters by `openTasks`. The test
// documents and protects that detail, which is easy to break in a refactor.

REFACTOR — with the five tests green

// js/model/board.js
const MAX_WEEKLY_HOURS = 40;                    // R7, in a named constant

/**
 * R7: nobody may go over 40 estimated OPEN hours.
 * Done tasks do not consume capacity.
 *
 * @param {string} assignee
 * @param {number} hours  Hours you intend to assign
 * @returns {boolean}
 */
canAssign(assignee, hours) {
  const assigned = this.hoursByAssignee()[assignee] ?? 0;
  return assigned + hours <= MAX_WEEKLY_HOURS;
}

/** Hours that can still be assigned to somebody without breaking R7. */
availableCapacity(assignee) {
  return MAX_WEEKLY_HOURS - (this.hoursByAssignee()[assignee] ?? 0);
}

// Corrected suite
import { Board } from '../../js/model/board.js';
import { ValidationError } from '../../js/model/errors.js';
import { createBacklog } from '../../js/data/backlog.js';
import { loadFromServer } from '../../js/data/tasks-api.js';

const TODAY = '2026-09-20';                   // ← a fixed date: time comes in as data

describe('Board', () => {
  let board;

  beforeEach(() => {                          // ← fresh state for every test
    board = new Board('Taller Nómada', createBacklog());
  });

  test('the canonical backlog has 6 tasks', () => {
    expect(board.total).toBe(6);
  });

  test('changeStatus applies the transition to the given task', () => {
    board.changeStatus(2, 'in-progress');

    expect(board.findById(2).status).toBe('in-progress');
  });

  test('the canonical backlog summary is exactly what is expected', () => {
    expect(board.summary(TODAY)).toStrictEqual({   // ← toStrictEqual, not toBe
      total: 6, open: 5, totalHours: 48,
      openHours: 45, overdue: 1, effort: 124
    });
  });

  test('add rejects a duplicate id (R1)', () => {   // ← no .only
    expect(() => board.add(board.tasks[0])).toThrow(ValidationError);
    expect(board.total).toBe(6);
  });

  test('loadFromServer returns the 6 backlog tasks', async () => {
    const loaded = await loadFromServer();          // ← async + await

    expect(loaded.total).toBe(6);
  });
  // Note: this last test still depends on the real network, which makes it slow
  // and non-deterministic. In 08-04 fetch is replaced by a double and it starts
  // running in milliseconds, without leaving the machine.
});