Tests unitaires en JavaScript avec Vitest (et Jest)

npm install --save-dev vitest

{
  "type": "module",
  "scripts": {
    "test": "vitest run",
    "test:watch": "vitest",
    "test:couverture": "vitest run --coverage"
  }
}

// src/regles.test.js
import { describe, test, expect } from 'vitest';
import { dureeEnJours, periodesSeChevauchent, verifierReservation, joursDeRetard } from './regles.js';

describe('dureeEnJours', () => {
  test('compte le premier et le dernier jour', () => {
    expect(dureeEnJours('2027-03-12', '2027-03-18')).toBe(7);
  });

  test('vaut 1 pour un prêt rendu le jour même', () => {
    expect(dureeEnJours('2027-03-12', '2027-03-12')).toBe(1);
  });

  test('traverse la fin du mois de février', () => {
    expect(dureeEnJours('2027-02-26', '2027-03-02')).toBe(5);
  });
});

describe('periodesSeChevauchent', () => {
  const pc07 = { debut: '2027-03-10', fin: '2027-03-14' };

  test.each([
    { cas: 'commence pendant', debut: '2027-03-12', fin: '2027-03-18', attendu: true },
    { cas: 'finit le premier jour', debut: '2027-03-05', fin: '2027-03-10', attendu: true },
    { cas: 'englobe', debut: '2027-03-01', fin: '2027-03-31', attendu: true },
    { cas: 'commence le lendemain', debut: '2027-03-15', fin: '2027-03-20', attendu: false },
    { cas: 'finit la veille', debut: '2027-03-01', fin: '2027-03-09', attendu: false },
  ])('une période qui $cas → $attendu', ({ debut, fin, attendu }) => {
    expect(periodesSeChevauchent(pc07, { debut, fin })).toBe(attendu);
  });
});

describe('verifierReservation', () => {
  const aujourdhui = '2027-03-08';
  const reservations = [{ materiel: 'PC-07', debut: '2027-03-10', fin: '2027-03-14' }];

  test('accepte un matériel libre sur toute la période', () => {
    const demande = { materiel: 'PC-07', debut: '2027-03-15', fin: '2027-03-18' };

    const resultat = verifierReservation(demande, reservations, aujourdhui);

    expect(resultat).toEqual({ acceptee: true });
  });

  test('refuse un matériel déjà réservé sur une partie de la période', () => {
    const demande = { materiel: 'PC-07', debut: '2027-03-12', fin: '2027-03-18' };

    const resultat = verifierReservation(demande, reservations, aujourdhui);

    expect(resultat.acceptee).toBe(false);
    expect(resultat.motif).toBe('PC-07 est déjà réservé du 10/03/2027 au 14/03/2027.');
  });

  test('ignore les réservations des autres matériels', () => {
    const demande = { materiel: 'VP-02', debut: '2027-03-12', fin: '2027-03-13' };

    expect(verifierReservation(demande, reservations, aujourdhui).acceptee).toBe(true);
  });

  test("accepte une réservation qui commence aujourd'hui", () => {
    const demande = { materiel: 'VP-02', debut: '2027-03-08', fin: '2027-03-09' };

    expect(verifierReservation(demande, reservations, aujourdhui).acceptee).toBe(true);
  });

  test('refuse une date de début passée', () => {
    const demande = { materiel: 'VP-02', debut: '2027-03-07', fin: '2027-03-09' };

    expect(verifierReservation(demande, reservations, aujourdhui).motif).toBe('La date de début est déjà passée.');
  });

  test('accepte un prêt de 15 jours, la durée maximale', () => {
    const demande = { materiel: 'VP-02', debut: '2027-03-15', fin: '2027-03-29' };

    expect(verifierReservation(demande, reservations, aujourdhui).acceptee).toBe(true);
  });

  test('refuse un prêt de 16 jours', () => {
    const demande = { materiel: 'VP-02', debut: '2027-03-15', fin: '2027-03-30' };

    expect(verifierReservation(demande, reservations, aujourdhui).motif).toBe('Un prêt dure au plus 15 jours.');
  });

  test('refuse une date de fin avant la date de début', () => {
    const demande = { materiel: 'VP-02', debut: '2027-03-20', fin: '2027-03-19' };

    expect(verifierReservation(demande, reservations, aujourdhui).motif).toBe('La date de fin précède la date de début.');
  });
});

describe('joursDeRetard', () => {
  test('vaut 0 le jour du retour prévu', () => {
    expect(joursDeRetard('2027-03-14', '2027-03-14')).toBe(0);
  });

  test('vaut 0 avant le retour prévu', () => {
    expect(joursDeRetard('2027-03-14', '2027-03-10')).toBe(0);
  });

  test('compte les jours après le retour prévu', () => {
    expect(joursDeRetard('2027-03-14', '2027-03-17')).toBe(3);
  });
});

// src/regles.js : les règles de réservation de Prêt'Matos
export const DUREE_MAX_JOURS = 15;

const MS_PAR_JOUR = 24 * 60 * 60 * 1000;

// « 2027-03-12 » devient un numéro de jour : on compare des jours, pas des heures.
function numeroDeJour(dateIso) {
  const [annee, mois, jour] = dateIso.split('-').map(Number);
  return Date.UTC(annee, mois - 1, jour) / MS_PAR_JOUR;
}

// « 2027-03-12 » devient « 12/03/2027 ».
export function formaterDate(dateIso) {
  const [annee, mois, jour] = dateIso.split('-');
  return `${jour}/${mois}/${annee}`;
}

// Du 12 au 18 mars : 7 jours, le premier et le dernier compris.
export function dureeEnJours(debut, fin) {
  return numeroDeJour(fin) - numeroDeJour(debut) + 1;
}

// Deux périodes se chevauchent si chacune commence avant la fin de l'autre.
export function periodesSeChevauchent(a, b) {
  return numeroDeJour(a.debut) <= numeroDeJour(b.fin) && numeroDeJour(b.debut) <= numeroDeJour(a.fin);
}

export function verifierReservation(demande, reservations, aujourdhui) {
  if (numeroDeJour(demande.fin) < numeroDeJour(demande.debut)) {
    return { acceptee: false, motif: 'La date de fin précède la date de début.' };
  }
  if (numeroDeJour(demande.debut) < numeroDeJour(aujourdhui)) {
    return { acceptee: false, motif: 'La date de début est déjà passée.' };
  }
  if (dureeEnJours(demande.debut, demande.fin) > DUREE_MAX_JOURS) {
    return { acceptee: false, motif: `Un prêt dure au plus ${DUREE_MAX_JOURS} jours.` };
  }
  const conflit = reservations.find(
    (r) => r.materiel === demande.materiel && periodesSeChevauchent(r, demande),
  );
  if (conflit) {
    return {
      acceptee: false,
      motif: `${demande.materiel} est déjà réservé du ${formaterDate(conflit.debut)} au ${formaterDate(conflit.fin)}.`,
    };
  }
  return { acceptee: true };
}

// Nombre de jours de retard d'un prêt à la date du jour (0 s'il n'est pas en retard).
export function joursDeRetard(retourPrevu, aujourdhui) {
  return Math.max(0, numeroDeJour(aujourdhui) - numeroDeJour(retourPrevu));
}

$ npx vitest run src/regles.test.js

 ✓ src/regles.test.js (19 tests) 6ms

 Test Files  1 passed (1)
      Tests  19 passed (19)

 ✓ src/regles.test.js > periodesSeChevauchent > une période qui commence pendant → true 1ms
 ✓ src/regles.test.js > periodesSeChevauchent > une période qui finit le premier jour → true 0ms
 ✓ src/regles.test.js > verifierReservation > refuse un prêt de 16 jours 0ms

import { describe, test, expect, beforeEach } from 'vitest';

describe('le dépôt en mémoire', () => {
  let depot;

  beforeEach(() => {
    // Un dépôt neuf avant CHAQUE test : aucun test ne voit les ajouts d'un autre.
    depot = creerDepotMemoire(jeuDeTest());
  });

  test('ajoute une réservation', async () => {
    await depot.ajouterReservation({ materiel: 'VP-02', debut: '2027-03-15', fin: '2027-03-18', salarie: 3 });

    expect(await depot.reservationsDu('VP-02')).toHaveLength(1);
  });

  test('ne contient au départ aucune réservation de VP-02', async () => {
    expect(await depot.reservationsDu('VP-02')).toHaveLength(0);
  });
});

AssertionError: expected { acceptee: true } to be { acceptee: true } // Object.is equality

If it should pass with deep equality, replace "toBe" with "toStrictEqual"

// src/dates.js
export function exigerDateIso(valeur) {
  if (!/^\d{4}-\d{2}-\d{2}$/.test(valeur)) {
    throw new TypeError(`Date invalide : ${valeur}`);
  }
  return valeur;
}

test('lève une TypeError pour une date au format français', () => {
  expect(() => exigerDateIso('14/03/2027')).toThrow(TypeError);
  expect(() => exigerDateIso('14/03/2027')).toThrow('Date invalide : 14/03/2027');
});

test('ajoute une réservation et la retrouve', async () => {
  const depot = creerDepotMemoire(jeuDeTest());

  await depot.ajouterReservation({ materiel: 'VP-02', debut: '2027-03-15', fin: '2027-03-18', salarie: 3 });
  const reservations = await depot.reservationsDu('VP-02');

  expect(reservations).toHaveLength(1);
});

await expect(depot.reservationsDu('VP-02')).resolves.toHaveLength(0);
await expect(lireFichierAbsent()).rejects.toThrow('ENOENT');

test.each([
  ['2027-03-31', '2027-04-01'],
  ['2027-12-31', '2028-01-01'],
  ['2028-02-28', '2028-02-29'],
])('le lendemain du %s est le %s', (date, attendu) => {
  expect(lendemain(date)).toBe(attendu);
});

// src/dates.js
// La date du jour à Paris, au format AAAA-MM-JJ (le format suédois « sv-SE » est justement celui-ci).
export function aujourdhuiAParis() {
  return new Date().toLocaleDateString('sv-SE', { timeZone: 'Europe/Paris' });
}

import { describe, test, expect, vi, afterEach } from 'vitest';
import { aujourdhuiAParis } from './dates.js';

describe('aujourdhuiAParis', () => {
  afterEach(() => {
    vi.useRealTimers();
  });

  test('donne la date de Paris, pas celle de Londres', () => {
    vi.useFakeTimers();
    vi.setSystemTime(new Date('2027-03-13T23:30:00Z')); // 00 h 30 le 14 mars à Paris

    expect(aujourdhuiAParis()).toBe('2027-03-14');
  });
});

// vitest.config.js
import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    environment: 'node',          // 'jsdom' pour tester des composants React (chapitre 9)
    include: ['src/**/*.test.js'], // où chercher les tests
    coverage: {
      provider: 'v8',
      include: ['src/**/*.js'],
    },
  },
});

 ❯ src/regles.test.js (19 tests | 1 failed) 7ms
   ❯ periodesSeChevauchent (5)
     × une période qui finit le premier jour → true 4ms

 FAIL  src/regles.test.js > periodesSeChevauchent > une période qui finit le premier jour → true
AssertionError: expected false to be true // Object.is equality

- Expected
+ Received

- true
+ false

 ❯ src/regles.test.js:29:57

// regles.test.js, version Jest : describe, test et expect sont globaux
const { dureeEnJours } = require('./regles.cjs');

describe('dureeEnJours', () => {
  test('compte le premier et le dernier jour', () => {
    expect(dureeEnJours('2027-03-12', '2027-03-18')).toBe(7);
  });
});

npm install --save-dev jest
npx jest