Mock, stub, spy : les doublures de test

// src/rappels.js : le rappel envoyé la veille de la date de retour
import { formaterDate } from './regles.js';

export function lendemain(dateIso) {
  const date = new Date(`${dateIso}T00:00:00Z`);
  date.setUTCDate(date.getUTCDate() + 1);
  return date.toISOString().slice(0, 10);
}

export async function envoyerRappels({ depot, messagerie, journal, aujourdhui }) {
  const prets = await depot.pretsARendreLe(lendemain(aujourdhui));
  let envoyes = 0;
  for (const pret of prets) {
    try {
      await messagerie.envoyer({
        a: pret.email,
        sujet: `Rappel : ${pret.materiel} à rendre demain`,
        texte: `Bonjour ${pret.prenom}, merci de rapporter ${pret.materiel} à la logistique le ${formaterDate(pret.fin)}.`,
      });
      envoyes += 1;
    } catch (erreur) {
      journal.erreur(`Rappel non envoyé pour le prêt ${pret.id} : ${erreur.message}`);
    }
  }
  return envoyes;
}

// src/rappels.test.js
import { describe, test, expect, vi } from 'vitest';
import { envoyerRappels } from './rappels.js';

const pretDeJulie = {
  id: 41, materiel: 'PC-07', prenom: 'Julie', email: 'julie.lefevre@sorbier.example', fin: '2027-03-14',
};

describe('envoyerRappels', () => {
  test('cherche les prêts à rendre le lendemain', async () => {
    const depot = { pretsARendreLe: vi.fn().mockResolvedValue([]) };          // stub
    const messagerie = { envoyer: vi.fn() };

    await envoyerRappels({ depot, messagerie, journal: {}, aujourdhui: '2027-03-13' });

    expect(depot.pretsARendreLe).toHaveBeenCalledWith('2027-03-14');
  });
});

  test('envoie un courriel à chaque emprunteur concerné', async () => {
    const depot = { pretsARendreLe: vi.fn().mockResolvedValue([pretDeJulie]) }; // stub
    const messagerie = { envoyer: vi.fn().mockResolvedValue(undefined) };       // mock

    const envoyes = await envoyerRappels({ depot, messagerie, journal: {}, aujourdhui: '2027-03-13' });

    expect(envoyes).toBe(1);
    expect(messagerie.envoyer).toHaveBeenCalledTimes(1);
    expect(messagerie.envoyer).toHaveBeenCalledWith({
      a: 'julie.lefevre@sorbier.example',
      sujet: 'Rappel : PC-07 à rendre demain',
      texte: 'Bonjour Julie, merci de rapporter PC-07 à la logistique le 14/03/2027.',
    });
  });

  test("n'envoie rien quand aucun prêt ne se termine demain", async () => {
    const depot = { pretsARendreLe: vi.fn().mockResolvedValue([]) };
    const messagerie = { envoyer: vi.fn() };

    const envoyes = await envoyerRappels({ depot, messagerie, journal: {}, aujourdhui: '2027-03-13' });

    expect(envoyes).toBe(0);
    expect(messagerie.envoyer).not.toHaveBeenCalled();
  });

  test('continue après un échec et le journalise', async () => {
    const pretDeKarim = { ...pretDeJulie, id: 42, prenom: 'Karim', email: 'karim.morel@sorbier.example' };
    const depot = { pretsARendreLe: vi.fn().mockResolvedValue([pretDeJulie, pretDeKarim]) };
    const messagerie = {
      envoyer: vi.fn()
        .mockRejectedValueOnce(new Error('serveur SMTP injoignable'))
        .mockResolvedValueOnce(undefined),
    };
    const journal = { erreur: vi.fn() };

    const envoyes = await envoyerRappels({ depot, messagerie, journal, aujourdhui: '2027-03-13' });

    expect(envoyes).toBe(1);
    expect(messagerie.envoyer).toHaveBeenCalledTimes(2);
    expect(journal.erreur).toHaveBeenCalledWith('Rappel non envoyé pour le prêt 41 : serveur SMTP injoignable');
  });

// src/espion.test.js : un espion sur le vrai dépôt en mémoire
import { test, expect, vi } from 'vitest';
import request from 'supertest';
import { creerApp } from './app.js';
import { creerDepotMemoire } from './depot-memoire.js';
import { AUJOURDHUI, UTILISATEURS, jeuDeTest } from './jeu-de-test.js';

test("n'enregistre rien quand la réservation est refusée", async () => {
  const depot = creerDepotMemoire(jeuDeTest());
  const espion = vi.spyOn(depot, 'ajouterReservation');
  const app = creerApp({ depot, authentifier: async (j) => UTILISATEURS[j] ?? null, aujourdhui: () => AUJOURDHUI });

  await request(app)
    .post('/api/reservations')
    .set('Authorization', 'Bearer jeton-julie')
    .send({ materiel: 'PC-07', debut: '2027-03-12', fin: '2027-03-18' });

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

// src/depot-memoire.js : un dépôt en mémoire, pour les tests et la démonstration
export function creerDepotMemoire({ materiels = [], reservations = [] } = {}) {
  const lignes = reservations.map((r) => ({ ...r }));
  let prochainId = Math.max(0, ...lignes.map((r) => r.id)) + 1;

  return {
    async listerMateriels() {
      return materiels;
    },
    async materielExiste(code) {
      return materiels.some((m) => m.code === code);
    },
    async reservationsDu(code) {
      return lignes.filter((r) => r.materiel === code);
    },
    async reservationsDe(salarie) {
      return lignes.filter((r) => r.salarie === salarie);
    },
    async ajouterReservation(reservation) {
      const ligne = { id: prochainId++, ...reservation, sortie: false };
      lignes.push(ligne);
      return ligne;
    },
    async enregistrerSortie(id) {
      const ligne = lignes.find((r) => r.id === id);
      if (ligne) ligne.sortie = true;
      return ligne ?? null;
    },
  };
}

// src/annulation.js : prévient la logistique quand un salarié annule
import { envoyerCourriel } from './messagerie.js';

export async function prevenirAnnulation(reservation) {
  await envoyerCourriel({
    a: 'logistique@sorbier.example',
    sujet: `Annulation : ${reservation.materiel}`,
    texte: `La réservation n° ${reservation.id} est annulée.`,
  });
}

// src/annulation.test.js
import { test, expect, vi } from 'vitest';
import { prevenirAnnulation } from './annulation.js';
import { envoyerCourriel } from './messagerie.js';

// Remplace tout le module : prevenirAnnulation recevra la fausse fonction.
vi.mock('./messagerie.js', () => ({ envoyerCourriel: vi.fn() }));

test('prévient la logistique avec le numéro de la réservation', async () => {
  await prevenirAnnulation({ id: 12, materiel: 'VP-02' });

  expect(envoyerCourriel).toHaveBeenCalledWith({
    a: 'logistique@sorbier.example',
    sujet: 'Annulation : VP-02',
    texte: 'La réservation n° 12 est annulée.',
  });
});

// front/api.js : les appels du front à l'API de Prêt'Matos
export async function reserver(demande, jeton) {
  const reponse = await fetch('/api/reservations', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${jeton}` },
    body: JSON.stringify(demande),
  });
  if (reponse.ok) return { ok: true };
  const { erreur } = await reponse.json();
  return { ok: false, erreur };
}

// front/api.test.js
import { test, expect, vi, afterEach } from 'vitest';
import { reserver } from './api.js';

afterEach(() => {
  vi.unstubAllGlobals();
});

test("renvoie le motif du refus quand l'API répond 409", async () => {
  const faux = vi.fn().mockResolvedValue(
    new Response(JSON.stringify({ erreur: 'PC-07 est déjà réservé du 10/03/2027 au 14/03/2027.' }), { status: 409 }),
  );
  vi.stubGlobal('fetch', faux);

  const resultat = await reserver({ materiel: 'PC-07', debut: '2027-03-12', fin: '2027-03-18' }, 'jeton-julie');

  expect(resultat).toEqual({ ok: false, erreur: 'PC-07 est déjà réservé du 10/03/2027 au 14/03/2027.' });
  expect(faux).toHaveBeenCalledWith('/api/reservations', expect.objectContaining({ method: 'POST' }));
});

// PretMatos.Domaine/ServiceRappels.cs
using System.Globalization;

namespace PretMatos.Domaine;

public record Pret(int Id, string Materiel, string Prenom, string Email, DateOnly Fin);

public interface IDepotPrets
{
    IReadOnlyList<Pret> PretsARendreLe(DateOnly jour);
}

public interface IMessagerie
{
    void Envoyer(string destinataire, string sujet, string texte);
}

public class ServiceRappels
{
    private readonly IDepotPrets _depot;
    private readonly IMessagerie _messagerie;
    private readonly TimeProvider _horloge;

    public ServiceRappels(IDepotPrets depot, IMessagerie messagerie, TimeProvider horloge)
    {
        _depot = depot;
        _messagerie = messagerie;
        _horloge = horloge;
    }

    // Envoie un rappel pour chaque prêt à rendre demain ; renvoie le nombre de courriels envoyés.
    public int EnvoyerRappels()
    {
        DateOnly demain = DateOnly.FromDateTime(_horloge.GetLocalNow().DateTime).AddDays(1);
        IReadOnlyList<Pret> prets = _depot.PretsARendreLe(demain);
        foreach (Pret pret in prets)
        {
            _messagerie.Envoyer(
                pret.Email,
                $"Rappel : {pret.Materiel} à rendre demain",
                string.Create(CultureInfo.InvariantCulture,
                    $"Bonjour {pret.Prenom}, merci de rapporter {pret.Materiel} à la logistique le {pret.Fin:dd/MM/yyyy}."));
        }
        return prets.Count;
    }
}

// Une doublure écrite à la main : elle retient les courriels au lieu de les envoyer.
public class MessagerieEspion : IMessagerie
{
    public List<(string Destinataire, string Sujet)> Envoyes { get; } = [];

    public void Envoyer(string destinataire, string sujet, string texte) => Envoyes.Add((destinataire, sujet));
}

using Microsoft.Extensions.Time.Testing;
using NSubstitute;
using PretMatos.Domaine;

public class ServiceRappelsTests
{
    private static readonly FakeTimeProvider Horloge = new(new DateTimeOffset(2027, 3, 13, 8, 0, 0, TimeSpan.Zero));
    private static readonly Pret PretDeJulie =
        new(41, "PC-07", "Julie", "julie.lefevre@sorbier.example", new DateOnly(2027, 3, 14));

    [Fact]
    public void EnvoyerRappels_AvecNSubstitute()
    {
        var depot = Substitute.For<IDepotPrets>();                       // stub
        depot.PretsARendreLe(new DateOnly(2027, 3, 14)).Returns([PretDeJulie]);
        var messagerie = Substitute.For<IMessagerie>();                  // mock
        var service = new ServiceRappels(depot, messagerie, Horloge);

        service.EnvoyerRappels();

        messagerie.Received(1).Envoyer(
            "julie.lefevre@sorbier.example",
            "Rappel : PC-07 à rendre demain",
            "Bonjour Julie, merci de rapporter PC-07 à la logistique le 14/03/2027.");
    }

    [Fact]
    public void EnvoyerRappels_AucunPret_NEnvoieRien()
    {
        var depot = Substitute.For<IDepotPrets>();
        depot.PretsARendreLe(Arg.Any<DateOnly>()).Returns([]);
        var messagerie = Substitute.For<IMessagerie>();
        var service = new ServiceRappels(depot, messagerie, Horloge);

        service.EnvoyerRappels();

        messagerie.DidNotReceive().Envoyer(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>());
    }
}

<?php
// src/DepotPrets.php
declare(strict_types=1);

namespace PretMatos;

interface DepotPrets
{
    /** @return list<array{id: int, materiel: string, prenom: string, email: string, fin: string}> */
    public function pretsARendreLe(string $jour): array;
}

<?php
// src/Messagerie.php
declare(strict_types=1);

namespace PretMatos;

interface Messagerie
{
    public function envoyer(string $a, string $sujet, string $texte): void;
}

<?php
// src/ServiceRappels.php
declare(strict_types=1);

namespace PretMatos;

final class ServiceRappels
{
    public function __construct(private DepotPrets $depot, private Messagerie $messagerie)
    {
    }

    /** Envoie un rappel pour chaque prêt à rendre demain ; renvoie le nombre de courriels envoyés. */
    public function envoyerRappels(\DateTimeImmutable $aujourdhui): int
    {
        $demain = $aujourdhui->modify('+1 day')->format('Y-m-d');
        $envoyes = 0;
        foreach ($this->depot->pretsARendreLe($demain) as $pret) {
            $fin = (new \DateTimeImmutable($pret['fin']))->format('d/m/Y');
            $this->messagerie->envoyer(
                $pret['email'],
                sprintf('Rappel : %s à rendre demain', $pret['materiel']),
                sprintf('Bonjour %s, merci de rapporter %s à la logistique le %s.', $pret['prenom'], $pret['materiel'], $fin),
            );
            $envoyes++;
        }
        return $envoyes;
    }
}

<?php
// tests/ServiceRappelsTest.php
declare(strict_types=1);

namespace PretMatos\Tests;

use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\TestCase;
use PretMatos\DepotPrets;
use PretMatos\Messagerie;
use PretMatos\ServiceRappels;

final class ServiceRappelsTest extends TestCase
{
    #[Test]
    public function envoieUnRappelPourChaquePretQuiFinitDemain(): void
    {
        // Stub : le dépôt renvoie une réponse préparée.
        $depot = $this->createStub(DepotPrets::class);
        $depot->method('pretsARendreLe')
            ->willReturn([[
                'id' => 41, 'materiel' => 'PC-07', 'prenom' => 'Julie',
                'email' => 'julie.lefevre@sorbier.example', 'fin' => '2027-03-14',
            ]]);

        // Mock : on annonce l'appel attendu AVANT d'exécuter le code.
        $messagerie = $this->createMock(Messagerie::class);
        $messagerie->expects($this->once())
            ->method('envoyer')
            ->with(
                'julie.lefevre@sorbier.example',
                'Rappel : PC-07 à rendre demain',
                'Bonjour Julie, merci de rapporter PC-07 à la logistique le 14/03/2027.',
            );

        $service = new ServiceRappels($depot, $messagerie);

        $this->assertSame(1, $service->envoyerRappels(new \DateTimeImmutable('2027-03-13')));
    }

    #[Test]
    public function nEnvoieRienQuandAucunPretNeFinitDemain(): void
    {
        $depot = $this->createStub(DepotPrets::class);
        $depot->method('pretsARendreLe')->willReturn([]);
        $messagerie = $this->createMock(Messagerie::class);
        $messagerie->expects($this->never())->method('envoyer');

        $service = new ServiceRappels($depot, $messagerie);

        $this->assertSame(0, $service->envoyerRappels(new \DateTimeImmutable('2027-03-13')));
    }
}