public GestorPrestecs(MaterialRepository materials,
                      EmpleatRepository empleats,
                      PrestecRepository prestecs,
                      ServeiAvisos avisos,
                      PropietatsBiblioTech propietats,
                      Clock rellotge) { ... }

class RepositoriEnMemoria implements RepositoriPrestecs {
    private final Map<Long, Prestec> dades = new HashMap<>();
    private long seguentId = 1;

    @Override public Prestec save(Prestec p) {
        if (p.getId() == null) p.assignarId(seguentId++);
        dades.put(p.getId(), p);
        return p;
    }
    @Override public Optional<Prestec> findById(Long id) {
        return Optional.ofNullable(dades.get(id));
    }
    @Override public List<Prestec> findByEstat(EstatPrestec estat) {
        return dades.values().stream().filter(p -> p.getEstat() == estat).toList();
    }
}

// Amb MOCK: cal programar cada resposta, i no hi ha coherencia
when(repositori.save(any())).thenReturn(prestec);
when(repositori.findById(1L)).thenReturn(Optional.of(prestec));
when(repositori.countByEmpleat(marta)).thenReturn(1L);
// Si el codi desa i despres compta, el mock NO reflecteix el que es va desar.
// Cal mantenir a ma una coherencia que el fake dona gratis.

// Amb FAKE: deses i comptes, i surt el correcte
repositori.save(prestec);
assertThat(repositori.countByEmpleat(marta)).isEqualTo(1);

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>5.12.0</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-junit-jupiter</artifactId>
    <version>5.12.0</version>
    <scope>test</scope>
</dependency>

package com.nexussoftware.bibliotech.servei;

import static org.assertj.core.api.Assertions.*;
import static org.mockito.Mockito.*;

import org.junit.jupiter.api.*;
import org.mockito.*;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)   // activa @Mock, @Spy, @Captor, @InjectMocks
class GestorPrestecsTest {

    @Mock private MaterialRepository materials;
    @Mock private EmpleatRepository empleats;
    @Mock private PrestecRepository prestecs;
    @Mock private ServeiAvisos avisos;

    private GestorPrestecs gestor;

    @BeforeEach
    void preparar() {
        // Construccio explicita: millor que @InjectMocks (apartat 6)
        gestor = new GestorPrestecs(materials, empleats, prestecs, avisos,
                                    propietatsDeProva(), RELLOTGE_FIX);
    }
}

// Forma 1: anotacio (recomanada, mes llegible)
@ExtendWith(MockitoExtension.class)
class ProvaAmbAnotacions {
    @Mock private MaterialRepository materials;
}

// Forma 2: metode de fabrica (util per a mocks locals d'una prova)
class ProvaAmbFabrica {
    @Test
    void exemple() {
        MaterialRepository materials = mock(MaterialRepository.class);
        // ...
    }
}

// Amb nom: els missatges d'error l'identifiquen
MaterialRepository materials = mock(MaterialRepository.class, "repositoriDeMaterials");

// Respostes per defecte diferents
ServeiAvisos avisos = mock(ServeiAvisos.class, Answers.RETURNS_DEEP_STUBS);

// Llanca excepcio si es crida un metode no programat: forca a ser explicit
MaterialRepository estricte = mock(MaterialRepository.class, Answers.RETURNS_SMART_NULLS);

@ExtendWith(MockitoExtension.class)
class GestorPrestecsTest {

    @Mock private MaterialRepository materials;
    @Mock private ServeiAvisos avisos;

    @InjectMocks private GestorPrestecs gestor;   // construit automaticament
}

@BeforeEach
void preparar() {
    gestor = new GestorPrestecs(materials, empleats, prestecs, avisos,
                                propietatsDeProva(), RELLOTGE_FIX);
}

@Test
void prestarRetornaUnPrestecAmbVencimentAQuinzeDies() {

    // PREPARAR: programar el que retornen els col.laboradors
    Material llibre = new Llibre("978-0000000001", "Java Eficac", 3, "J. Bloch");
    Empleat marta = new Empleat("[email protected]", "Marta Ruiz");

    when(materials.findByIsbn("978-0000000001")).thenReturn(Optional.of(llibre));
    when(empleats.findByCorreu("[email protected]")).thenReturn(Optional.of(marta));
    when(prestecs.countByEmpleatAndEstat(marta, EstatPrestec.ACTIU)).thenReturn(0L);
    when(prestecs.save(any(Prestec.class))).thenAnswer(inv -> inv.getArgument(0));

    // ACTUAR
    Prestec prestec = gestor.prestar("978-0000000001", "[email protected]");

    // COMPROVAR
    assertThat(prestec.getDataVenciment())
            .isEqualTo(LocalDate.of(2026, 3, 20).plusDays(15));
}

// Valors diferents en crides successives
when(prestecs.count())
        .thenReturn(0L)      // 1a crida
        .thenReturn(1L)      // 2a
        .thenReturn(2L);     // 3a i seguents

// Equivalent, mes curt
when(prestecs.count()).thenReturn(0L, 1L, 2L);

@Test
void siElRepositoriFallaEnDesarNoSEnviaCapAvis() {

    when(materials.findByIsbn(anyString())).thenReturn(Optional.of(unLlibre()));
    when(empleats.findByCorreu(anyString())).thenReturn(Optional.of(marta()));
    when(prestecs.countByEmpleatAndEstat(any(), any())).thenReturn(0L);

    // El repositori falla en desar
    when(prestecs.save(any()))
            .thenThrow(new DataAccessResourceFailureException("Connexio perduda"));

    assertThatThrownBy(() -> gestor.prestar("978-0000000001", "[email protected]"))
            .isInstanceOf(DataAccessResourceFailureException.class);

    // L'important: NO es va avisar ningu d'un prestec que no es va desar
    verifyNoInteractions(avisos);
}

// Excepcio de concurrencia (el bloqueig optimista d'11-03)
when(materials.findByIsbn(anyString()))
        .thenThrow(new OptimisticLockingFailureException("Versio obsoleta"));

// Temps d'espera esgotat a la xarxa (el ClientMetadades de 09-06)
when(clientHttp.send(any(), any()))
        .thenThrow(new HttpTimeoutException("L'API no respon"));

// Fallada la primera vegada, exit la segona: provar el reintent
when(prestecs.save(any()))
        .thenThrow(new OptimisticLockingFailureException("conflicte"))
        .thenReturn(prestecDesat);

// El cas mes comu: save retorna el que se li va passar
when(prestecs.save(any(Prestec.class))).thenAnswer(inv -> inv.getArgument(0));

// Simular l'assignacio d'id que faria la base de dades
when(prestecs.save(any(Prestec.class))).thenAnswer(invocacio -> {
    Prestec p = invocacio.getArgument(0);
    if (p.getId() == null) {
        p.assignarId(seguentId.getAndIncrement());
    }
    return p;
});

// Resposta segons l'argument
when(materials.findByIsbn(anyString())).thenAnswer(invocacio -> {
    String isbn = invocacio.getArgument(0);
    return catalegDeProva.containsKey(isbn)
            ? Optional.of(catalegDeProva.get(isbn))
            : Optional.empty();
});

// Sintaxi when: l'habitual
when(materials.findByIsbn("x")).thenReturn(Optional.empty());

// Sintaxi do: equivalent, pero el metode s'anomena al final
doReturn(Optional.empty()).when(materials).findByIsbn("x");

// NO COMPILA: avisar() retorna void, no hi ha res per passar a when()
when(avisos.avisar(marta, "missatge")).thenThrow(new RuntimeException());

// CORRECTE
doThrow(new ServeiAvisosException("SMTP caigut"))
        .when(avisos).avisar(any(Empleat.class), anyString());

// I perque un void no faci res (es el comportament per defecte,
// pero explicitar-ho de vegades aclareix la intencio)
doNothing().when(avisos).avisar(any(), anyString());

List<String> llista = new ArrayList<>();
List<String> espia = spy(llista);

// MALAMENT: when() CRIDA DE VERITAT get(0) sobre una llista buida
// -> IndexOutOfBoundsException abans de programar res
when(espia.get(0)).thenReturn("Java Eficac");

// BE: do... NO invoca el metode real
doReturn("Java Eficac").when(espia).get(0);

when(materials.findByIsbn(anyString())).thenReturn(Optional.of(llibre));
// Mes endavant, canviar el comportament:
doReturn(Optional.empty()).when(materials).findByIsbn("978-9999999999");

org.mockito.exceptions.misusing.UnnecessaryStubbingException:
Unnecessary stubbings detected.
Clean & maintainable test code requires zero unnecessary code.
  1. -> at GestorPrestecsTest.preparar(GestorPrestecsTest.java:44)

@Test
void retornarAmbRetardRegistraLaMultaIAvisaLEmpleat() {

    Prestec vencut = prestecVencutFa(10);
    when(prestecs.findById(1L)).thenReturn(Optional.of(vencut));

    gestor.retornar(1L);

    // Es va desar el prestec actualitzat
    verify(prestecs).save(vencut);

    // Es va avisar l'empleat
    verify(avisos).avisar(eq(vencut.getEmpleat()), contains("multa"));
}

verify(avisos, times(1)).avisar(any(), anyString());        // exactament 1 (per defecte)
verify(avisos, times(3)).avisar(any(), anyString());        // exactament 3
verify(avisos, never()).avisar(any(), anyString());         // MAI
verify(avisos, atLeastOnce()).avisar(any(), anyString());   // 1 o mes
verify(avisos, atLeast(2)).avisar(any(), anyString());      // 2 o mes
verify(avisos, atMost(5)).avisar(any(), anyString());       // 5 o menys
verify(avisos, only()).avisar(any(), anyString());          // aquesta crida I CAP ALTRA

verifyNoInteractions(avisos);                    // el mock no es va fer servir en absolut
verifyNoMoreInteractions(prestecs);              // no hi va haver mes crides de les verificades

@Test
void unPrestecRetornatEnTerminiNoGeneraAvis() {
    when(prestecs.findById(1L)).thenReturn(Optional.of(prestecEnTermini()));

    gestor.retornar(1L);

    verify(avisos, never()).avisar(any(), anyString());
}

@Test
void esDecrementaLEstocAbansDeDesarElPrestec() {

    InOrder ordre = inOrder(materials, prestecs, avisos);

    gestor.prestar("978-0000000001", "[email protected]");

    ordre.verify(materials).findByIsbn("978-0000000001");
    ordre.verify(prestecs).save(any(Prestec.class));
    ordre.verify(avisos).avisar(any(), anyString());
}

gestor.consultar("978-0000000001");

verify(materials).findByIsbn("978-0000000001");
verifyNoMoreInteractions(materials);   // no es va cridar res mes

// MALAMENT: verificar una consulta
verify(materials).findByIsbn("978-0000000001");
verify(prestecs).countByEmpleatAndEstat(marta, EstatPrestec.ACTIU);

// BE: verificar una ordre
verify(avisos).avisar(marta, "El teu prestec de Java Eficac venc en 2 dies");

when(materials.findByIsbn(anyString())).thenReturn(Optional.of(llibre));

verify(avisos).avisar(any(Empleat.class), contains("venc"));

// argThat: condicions arbitraries
verify(prestecs).save(argThat(p ->
        p.getEstat() == EstatPrestec.ACTIU
        && p.getDataVenciment().equals(LocalDate.of(2026, 4, 4))));

// NO FUNCIONA
verify(avisos).avisar(marta, anyString());

org.mockito.exceptions.misusing.InvalidUseOfMatchersException:
Invalid use of argument matchers!
2 matchers expected, 1 recorded.
This exception may occur if matchers are combined with raw values:
    //incorrect:
    someMethod(anyObject(), "raw String");
When using matchers, all arguments have to be provided by matchers.

// CORRECTE
verify(avisos).avisar(eq(marta), anyString());

// Tambe correcte: cap matcher
verify(avisos).avisar(marta, "El teu prestec venc en 2 dies");

// Tambe correcte: tots matchers
verify(avisos).avisar(any(Empleat.class), anyString());

@ExtendWith(MockitoExtension.class)
class ServeiAvisosVencimentTest {

    @Mock private PrestecRepository prestecs;
    @Mock private ServeiAvisos avisos;

    @Captor private ArgumentCaptor<String> capturadorMissatge;
    @Captor private ArgumentCaptor<Empleat> capturadorEmpleat;

    @Test
    void elMissatgeDAvisInclouElTitolIElsDiesRestants() {

        Prestec prestec = prestecQueVenc(AVUI.plusDays(2), marta(), "Java Eficac");
        when(prestecs.cercarActius()).thenReturn(List.of(prestec));

        servei.enviarAvisosDelDia();

        // Capturar els arguments REALS de la crida
        verify(avisos).avisar(capturadorEmpleat.capture(), capturadorMissatge.capture());

        assertThat(capturadorEmpleat.getValue().getCorreu())
                .isEqualTo("[email protected]");
        assertThat(capturadorMissatge.getValue())
                .contains("Java Eficac")
                .contains("2 dies")
                .doesNotContain("null");        // el classic bug de concatenacio
    }
}

@Test
void sAvisaCadaEmpleatAmbPrestecProximAVencer() {

    when(prestecs.cercarActius()).thenReturn(List.of(
            prestecQueVenc(AVUI.plusDays(2), marta(), "Java Eficac"),
            prestecQueVenc(AVUI.plusDays(2), diego(), "Patrons de Disseny"),
            prestecQueVenc(AVUI.plusDays(9), nuria(), "Refactoritzacio")));   // encara no toca

    servei.enviarAvisosDelDia();

    verify(avisos, times(2)).avisar(capturadorEmpleat.capture(), capturadorMissatge.capture());

    assertThat(capturadorEmpleat.getAllValues())
            .extracting(Empleat::getCorreu)
            .containsExactly("[email protected]",
                             "[email protected]");

    assertThat(capturadorMissatge.getAllValues())
            .allSatisfy(missatge -> assertThat(missatge).contains("2 dies"));
}

@ExtendWith(MockitoExtension.class)
class CalculadoraMultesTest {

    @Spy private CalculadoraMultes calculadora =
            new CalculadoraMultes(propietatsDeProva(), RELLOTGE_FIX);

    @Test
    void exemple() {
        // Comportament REAL per defecte
        assertThat(calculadora.calcular(prestecAmbRetard(5))).isEqualByComparingTo("2.50");

        // Substituir NOMES un metode (nota: do... obligatori, apartat 10)
        doReturn(new BigDecimal("999.99")).when(calculadora).calcular(any());
        assertThat(calculadora.calcular(prestecAmbRetard(5))).isEqualByComparingTo("999.99");
    }
}

// TRAMPA: l'espia es una COPIA, no l'objecte original
List<String> original = new ArrayList<>();
List<String> espia = spy(original);

espia.add("Java Eficac");
assertThat(espia).hasSize(1);       // ok
assertThat(original).isEmpty();     // l'original NO va canviar!

// TRAMPA: les crides internes NO passen per l'espia
// Es exactament el problema del proxy d'11-02 §26.
// Si metodeA() crida this.metodeB(), substituir metodeB no afecta metodeA.

@Test
void exempleAmbEstatic() {
    try (MockedStatic<LocalDate> data = mockStatic(LocalDate.class)) {
        data.when(LocalDate::now).thenReturn(LocalDate.of(2026, 3, 20));

        // dins d'aquest bloc, LocalDate.now() retorna la data fixa
        assertThat(LocalDate.now()).isEqualTo(LocalDate.of(2026, 3, 20));
    }
    // fora, comportament normal
}

// Opcio A: mockStatic. Funciona, i arrossega problemes.
try (MockedStatic<LocalDate> f = mockStatic(LocalDate.class)) {
    f.when(LocalDate::now).thenReturn(LocalDate.of(2026, 3, 20));
    assertThat(calculadora.calcular(prestec)).isEqualByComparingTo("2.50");
}

// Opcio B: Clock injectat. El disseny elimina la necessitat del mock.
var calculadora = new CalculadoraMultes(propietats, Clock.fixed(...));
assertThat(calculadora.calcular(prestec)).isEqualByComparingTo("2.50");

@Mock private HttpClient http;

when(http.send(any(), any())).thenReturn(respostaSimulada);

@Test
void prestar() {
    when(materials.findByIsbn("978-0000000001")).thenReturn(Optional.of(llibre));
    when(empleats.findByCorreu("[email protected]")).thenReturn(Optional.of(marta));
    when(prestecs.countByEmpleatAndEstat(marta, ACTIU)).thenReturn(0L);
    when(propietats.prestec()).thenReturn(new Prestec(15, 3));
    when(calculadora.calcular(any())).thenReturn(BigDecimal.ZERO);
    when(prestecs.save(any())).thenReturn(prestecDesat);

    gestor.prestar("978-0000000001", "[email protected]");

    verify(materials).findByIsbn("978-0000000001");
    verify(empleats).findByCorreu("[email protected]");
    verify(prestecs).countByEmpleatAndEstat(marta, ACTIU);
    verify(prestecs).save(any());
    verify(avisos).avisar(any(), anyString());
    verifyNoMoreInteractions(materials, empleats, prestecs, avisos);
}

@Test
void prestarCreaUnPrestecActiuAmbVencimentAQuinzeDies() {

    when(materials.findByIsbn("978-0000000001")).thenReturn(Optional.of(llibre));
    when(empleats.findByCorreu("[email protected]")).thenReturn(Optional.of(marta));
    when(prestecs.save(any(Prestec.class))).thenAnswer(inv -> inv.getArgument(0));

    Prestec prestec = gestor.prestar("978-0000000001", "[email protected]");

    // COMPORTAMENT: que es va produir
    assertThat(prestec)
            .satisfies(p -> {
                assertThat(p.getMaterial()).isEqualTo(llibre);
                assertThat(p.getEmpleat()).isEqualTo(marta);
                assertThat(p.getEstat()).isEqualTo(EstatPrestec.ACTIU);
                assertThat(p.getDataVenciment()).isEqualTo(LocalDate.of(2026, 4, 4));
            });

    // EFECTES observables (ordres)
    verify(prestecs).save(prestec);
    verify(avisos).avisar(eq(marta), contains("Java Eficac"));
}

@Test
void retornarAmbRetardRegistraLaMulta_interaccio() {

    Prestec vencut = prestecVencutFa(10);
    when(prestecs.findById(1L)).thenReturn(Optional.of(vencut));
    when(calculadora.calcular(vencut)).thenReturn(new BigDecimal("5.00"));

    gestor.retornar(1L);

    verify(calculadora).calcular(vencut);
    verify(multes).registrar(eq(vencut), eq(new BigDecimal("5.00")));
}

@Test
void retornarAmbRetardRegistraLaMulta_estat() {

    // Col.laboradors REALS per al que es barat i determinista
    var calculadora = new CalculadoraMultes(propietatsDeProva(), RELLOTGE_FIX);
    var multesEnMemoria = new RegistreMultesEnMemoria();          // fake
    var gestor = new GestorPrestecs(prestecs, calculadora, multesEnMemoria, avisos, RELLOTGE_FIX);

    Prestec vencut = prestecVencutFa(10);
    when(prestecs.findById(1L)).thenReturn(Optional.of(vencut));

    gestor.retornar(1L);

    // Es comprova l'ESTAT resultant
    assertThat(multesEnMemoria.perEmpleat(vencut.getEmpleat()))
            .singleElement()
            .satisfies(multa -> {
                assertThat(multa.quantitat()).isEqualByComparingTo("5.00");
                assertThat(multa.prestec()).isEqualTo(vencut);
            });

    assertThat(vencut.getEstat()).isEqualTo(EstatPrestec.RETORNAT);
}

// Sense Clock: cal simular un metode estatic
try (MockedStatic<LocalDate> f = mockStatic(LocalDate.class)) {
    f.when(LocalDate::now).thenReturn(LocalDate.of(2026, 3, 20));
    // ... prova lenta, fragil i amb risc de contaminacio
}

// Amb Clock injectat: NO cal cap mock
var calculadora = new CalculadoraMultes(propietats, Clock.fixed(...));

@Test
void lAvisConteTotesLesDadesDelPrestec() {

    when(prestecs.cercarActius()).thenReturn(List.of(prestecDeMarta(), prestecDeDiego()));

    servei.enviarAvisosDelDia();

    ArgumentCaptor<Avis> captor = ArgumentCaptor.forClass(Avis.class);
    verify(avisos, times(2)).enviar(captor.capture());

    // AssertJ sobre el capturat: expressiu i amb bons missatges d'error
    assertThat(captor.getAllValues())
            .hasSize(2)
            .extracting(Avis::destinatari, Avis::assumpte)
            .containsExactly(
                    tuple("[email protected]",  "El teu prestec venc en 2 dies"),
                    tuple("[email protected]","El teu prestec venc en 2 dies"));

    assertThat(captor.getAllValues())
            .allSatisfy(avis -> {
                assertThat(avis.cos()).doesNotContain("null");
                assertThat(avis.destinatari()).endsWith("@nexussoftware.com");
            });
}

when(prestecs.save(any())).thenThrow(new DataAccessResourceFailureException("Sense connexio"));

assertThatThrownBy(() -> gestor.prestar("978-0000000001", "[email protected]"))
        .isInstanceOf(BiblioTechException.class)                  // es tradueix l'excepcio
        .hasCauseInstanceOf(DataAccessResourceFailureException.class)
        .hasMessageContaining("978-0000000001");

package com.nexussoftware.bibliotech.servei;

import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;

import java.math.BigDecimal;
import java.time.*;
import java.util.*;
import org.junit.jupiter.api.*;
import org.mockito.*;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
@DisplayName("GestorPrestecs")
class GestorPrestecsTest {

    private static final ZoneId MADRID = ZoneId.of("Europe/Madrid");
    private static final LocalDate AVUI = LocalDate.of(2026, 3, 20);
    private static final Clock RELLOTGE = Clock.fixed(AVUI.atStartOfDay(MADRID).toInstant(), MADRID);

    @Mock private MaterialRepository materials;
    @Mock private EmpleatRepository empleats;
    @Mock private PrestecRepository prestecs;
    @Mock private ServeiAvisos avisos;

    private GestorPrestecs gestor;
    private Material llibre;
    private Empleat marta;

    @BeforeEach
    void preparar() {
        // Propietats i calculadora REALS: son barates, deterministes i sense efectes
        var propietats = new PropietatsBiblioTech(
                "BiblioTech",
                new PropietatsBiblioTech.Prestec(15, 3),
                new PropietatsBiblioTech.Multa(new BigDecimal("0.50"), new BigDecimal("20.00")),
                new PropietatsBiblioTech.Reserva(3));
        var calculadora = new CalculadoraMultes(propietats, RELLOTGE);

        gestor = new GestorPrestecs(materials, empleats, prestecs, calculadora,
                                    avisos, propietats, RELLOTGE);

        llibre = new Llibre("978-0000000001", "Java Eficac", 3, "J. Bloch");
        marta = new Empleat("[email protected]", "Marta Ruiz");
    }

    @Nested
    @DisplayName("en prestar")
    class Prestar {

        @Test
        @DisplayName("crea un préstec actiu amb venciment a 15 dies")
        void creaPrestecCorrecte() {
            when(materials.findByIsbn("978-0000000001")).thenReturn(Optional.of(llibre));
            when(empleats.findByCorreu(marta.getCorreu())).thenReturn(Optional.of(marta));
            when(prestecs.save(any(Prestec.class))).thenAnswer(inv -> inv.getArgument(0));

            Prestec prestec = gestor.prestar("978-0000000001", marta.getCorreu());

            assertThat(prestec.getMaterial()).isEqualTo(llibre);
            assertThat(prestec.getEmpleat()).isEqualTo(marta);
            assertThat(prestec.getEstat()).isEqualTo(EstatPrestec.ACTIU);
            assertThat(prestec.getDataPrestec()).isEqualTo(AVUI);
            assertThat(prestec.getDataVenciment()).isEqualTo(AVUI.plusDays(15));
        }

        @Test
        @DisplayName("decrementa els exemplars disponibles del material")
        void decrementaExemplars() {
            when(materials.findByIsbn("978-0000000001")).thenReturn(Optional.of(llibre));
            when(empleats.findByCorreu(marta.getCorreu())).thenReturn(Optional.of(marta));
            when(prestecs.save(any(Prestec.class))).thenAnswer(inv -> inv.getArgument(0));

            gestor.prestar("978-0000000001", marta.getCorreu());

            assertThat(llibre.getExemplarsDisponibles()).isEqualTo(2);   // estat real
        }

        @Test
        @DisplayName("falla si el material no existeix, i no desa res")
        void materialInexistent() {
            when(materials.findByIsbn("978-9999999999")).thenReturn(Optional.empty());

            assertThatThrownBy(() -> gestor.prestar("978-9999999999", marta.getCorreu()))
                    .isInstanceOf(MaterialNoTrobatException.class)
                    .hasMessageContaining("978-9999999999");

            verify(prestecs, never()).save(any());
            verifyNoInteractions(avisos);
        }

        @Test
        @DisplayName("falla si el material no té exemplars disponibles")
        void senseExemplars() {
            Material exhaurit = new Llibre("978-0000000003", "Refactoritzacio", 0, "M. Fowler");
            when(materials.findByIsbn("978-0000000003")).thenReturn(Optional.of(exhaurit));
            when(empleats.findByCorreu(marta.getCorreu())).thenReturn(Optional.of(marta));

            assertThatThrownBy(() -> gestor.prestar("978-0000000003", marta.getCorreu()))
                    .isInstanceOf(SenseExemplarsException.class);

            verify(prestecs, never()).save(any());
        }

        @Test
        @DisplayName("falla si l'empleat ha assolit el límit de 3 préstecs")
        void limitAssolit() {
            when(materials.findByIsbn("978-0000000001")).thenReturn(Optional.of(llibre));
            when(empleats.findByCorreu(marta.getCorreu())).thenReturn(Optional.of(marta));
            when(prestecs.countByEmpleatAndEstat(marta, EstatPrestec.ACTIU))
                    .thenReturn(3L);

            assertThatThrownBy(() -> gestor.prestar("978-0000000001", marta.getCorreu()))
                    .isInstanceOf(LimitPrestecsException.class)
                    .hasMessageContaining(marta.getCorreu());

            verify(prestecs, never()).save(any());
            assertThat(llibre.getExemplarsDisponibles()).isEqualTo(3);   // sense efectes
        }
    }

    @Nested
    @DisplayName("davant de fallades d'infraestructura")
    class Fallades {

        @Test
        @DisplayName("si el desat falla, no s'avisa ningú")
        void fallaElDesat() {
            when(materials.findByIsbn("978-0000000001")).thenReturn(Optional.of(llibre));
            when(empleats.findByCorreu(marta.getCorreu())).thenReturn(Optional.of(marta));
            when(prestecs.save(any()))
                    .thenThrow(new DataAccessResourceFailureException("Connexio perduda"));

            assertThatThrownBy(() -> gestor.prestar("978-0000000001", marta.getCorreu()))
                    .isInstanceOf(DataAccessResourceFailureException.class);

            verifyNoInteractions(avisos);   // requisit: no es notifica el no persistit
        }

        @Test
        @DisplayName("reintenta davant d'un conflicte de concurrència i acaba amb èxit")
        void reintentaDavantConflicte() {
            when(materials.findByIsbn("978-0000000001")).thenReturn(Optional.of(llibre));
            when(empleats.findByCorreu(marta.getCorreu())).thenReturn(Optional.of(marta));
            when(prestecs.save(any()))
                    .thenThrow(new OptimisticLockingFailureException("versio obsoleta"))
                    .thenAnswer(inv -> inv.getArgument(0));   // segona vegada, exit

            Resultat<Prestec> resultat =
                    gestor.prestarAmbReintent("978-0000000001", marta.getCorreu());

            assertThat(resultat.esExit()).isTrue();
            verify(prestecs, times(2)).save(any());   // es va intentar dues vegades
        }
    }
}

@ExtendWith(MockitoExtension.class)
@DisplayName("Avisos de venciment")
class ServeiAvisosVencimentTest {

    private static final ZoneId MADRID = ZoneId.of("Europe/Madrid");
    private static final LocalDate AVUI = LocalDate.of(2026, 3, 20);
    private static final Clock RELLOTGE = Clock.fixed(AVUI.atStartOfDay(MADRID).toInstant(), MADRID);

    @Mock private PrestecRepository prestecs;
    @Mock private ServeiAvisos avisos;

    @Captor private ArgumentCaptor<Empleat> capturadorEmpleat;
    @Captor private ArgumentCaptor<String> capturadorMissatge;

    private ServeiAvisosVenciment servei;

    @BeforeEach
    void preparar() {
        servei = new ServeiAvisosVenciment(prestecs, avisos, propietatsAmbAntelacio(2), RELLOTGE);
    }

    @Test
    @DisplayName("el missatge inclou el títol del material i els dies restants")
    void contingutDelMissatge() {
        when(prestecs.cercarActius()).thenReturn(List.of(
                prestec("Java Eficac", marta(), AVUI.plusDays(2))));

        servei.enviarAvisosDelDia();

        verify(avisos).avisar(capturadorEmpleat.capture(), capturadorMissatge.capture());

        assertThat(capturadorEmpleat.getValue().getCorreu())
                .isEqualTo("[email protected]");

        assertThat(capturadorMissatge.getValue())
                .contains("Java Eficac")
                .contains("2 dies")
                .doesNotContain("null")          // bug classic de concatenacio
                .doesNotContain("@{");           // plantilla sense substituir
    }

    @Test
    @DisplayName("avisa només els empleats el préstec dels quals venç en exactament 2 dies")
    void finestraDAvis() {
        when(prestecs.cercarActius()).thenReturn(List.of(
                prestec("Java Eficac",        marta(), AVUI.plusDays(2)),   // SI
                prestec("Patrons de Disseny", diego(), AVUI.plusDays(2)),   // SI
                prestec("Refactoritzacio",    nuria(), AVUI.plusDays(1)),   // no
                prestec("Java Eficac",        nuria(), AVUI.plusDays(3)),   // no
                prestec("Refactoritzacio",    diego(), AVUI.minusDays(5))));// no

        servei.enviarAvisosDelDia();

        verify(avisos, times(2)).avisar(capturadorEmpleat.capture(), anyString());

        assertThat(capturadorEmpleat.getAllValues())
                .extracting(Empleat::getCorreu)
                .containsExactly("[email protected]",
                                 "[email protected]");
    }

    @Test
    @DisplayName("un canal caigut no impedeix els avisos restants")
    void unaFalladaNoAturaLaResta() {
        when(prestecs.cercarActius()).thenReturn(List.of(
                prestec("Java Eficac",        marta(), AVUI.plusDays(2)),
                prestec("Patrons de Disseny", diego(), AVUI.plusDays(2)),
                prestec("Refactoritzacio",    nuria(), AVUI.plusDays(2))));

        // El segon avis falla
        doNothing()
                .doThrow(new ServeiAvisosException("SMTP no respon"))
                .doNothing()
                .when(avisos).avisar(any(), anyString());

        int enviats = servei.enviarAvisosDelDia();

        assertThat(enviats).isEqualTo(2);                        // 3 intents, 2 amb exit
        verify(avisos, times(3)).avisar(any(), anyString());     // es van intentar els 3
    }
}

package com.nexussoftware.bibliotech.xarxa;

// Interficie PROPIA que expressa el que el domini necessita
public interface PassarelaMetadades {
    Optional<MetadadesLlibre> cercarPerIsbn(String isbn);
}

// Implementacio real, que si que fa servir HttpClient
@Component
public class PassarelaMetadadesHttp implements PassarelaMetadades {

    private final HttpClient http;
    private final String urlBase;

    public PassarelaMetadadesHttp(HttpClient http,
                                  @Value("${bibliotech.metadades.url}") String urlBase) {
        this.http = http;
        this.urlBase = urlBase;
    }

    @Override
    public Optional<MetadadesLlibre> cercarPerIsbn(String isbn) { /* HTTP real */ }
}

@Service
public class EnriquidorCataleg {

    private final PassarelaMetadades passarela;   // la INTERFICIE, no HttpClient
    private final MaterialRepository materials;

    public EnriquidorCataleg(PassarelaMetadades passarela, MaterialRepository materials) {
        this.passarela = passarela;
        this.materials = materials;
    }

    public int enriquirCataleg() {
        int enriquits = 0;
        for (Material material : materials.findByAutorIsNull()) {
            try {
                Optional<MetadadesLlibre> metadades = passarela.cercarPerIsbn(material.getIsbn());
                if (metadades.isPresent()) {
                    material.completarAmb(metadades.get());
                    materials.save(material);
                    enriquits++;
                }
            } catch (PassarelaNoDisponibleException e) {
                log.warn("No s'ha pogut enriquir {}: {}", material.getIsbn(), e.getMessage());
                // continua amb el seguent
            }
        }
        return enriquits;
    }
}

@ExtendWith(MockitoExtension.class)
@DisplayName("Enriquiment del catàleg")
class EnriquidorCatalegTest {

    @Mock private PassarelaMetadades passarela;
    @Mock private MaterialRepository materials;

    private EnriquidorCataleg enriquidor;

    @BeforeEach
    void preparar() { enriquidor = new EnriquidorCataleg(passarela, materials); }

    @Test
    @DisplayName("completa l'autor dels materials que el tenen buit")
    void completaLesDades() {
        Material senseAutor = new Llibre("978-0000000001", "Java Eficac", 3, null);
        when(materials.findByAutorIsNull()).thenReturn(List.of(senseAutor));
        when(passarela.cercarPerIsbn("978-0000000001"))
                .thenReturn(Optional.of(new MetadadesLlibre("Joshua Bloch", 2018, "Addison-Wesley")));

        int enriquits = enriquidor.enriquirCataleg();

        assertThat(enriquits).isEqualTo(1);
        assertThat(senseAutor.getAutor()).isEqualTo("Joshua Bloch");
        verify(materials).save(senseAutor);
    }

    @Test
    @DisplayName("no desa res si l'API no coneix l'ISBN")
    void isbnDesconegut() {
        Material senseAutor = new Llibre("978-0000000099", "Titol rar", 1, null);
        when(materials.findByAutorIsNull()).thenReturn(List.of(senseAutor));
        when(passarela.cercarPerIsbn(anyString())).thenReturn(Optional.empty());

        assertThat(enriquidor.enriquirCataleg()).isZero();
        verify(materials, never()).save(any());
    }

    @Test
    @DisplayName("si l'API està caiguda, continua amb la resta del catàleg")
    void apiCaigudaParcialment() {
        Material un = new Llibre("978-0000000001", "Java Eficac", 3, null);
        Material dos = new Llibre("978-0000000002", "Patrons de Disseny", 2, null);
        when(materials.findByAutorIsNull()).thenReturn(List.of(un, dos));

        when(passarela.cercarPerIsbn("978-0000000001"))
                .thenThrow(new PassarelaNoDisponibleException("504 Gateway Timeout"));
        when(passarela.cercarPerIsbn("978-0000000002"))
                .thenReturn(Optional.of(new MetadadesLlibre("GoF", 1994, "Addison-Wesley")));

        assertThat(enriquidor.enriquirCataleg()).isEqualTo(1);
        assertThat(dos.getAutor()).isEqualTo("GoF");
        verify(materials, times(1)).save(dos);
    }

    @Test
    @DisplayName("no crida l'API si no hi ha materials incomplets")
    void catalegComplet() {
        when(materials.findByAutorIsNull()).thenReturn(List.of());

        assertThat(enriquidor.enriquirCataleg()).isZero();
        verifyNoInteractions(passarela);     // ni una peticio innecessaria
    }
}

@SpringBootTest
@ActiveProfiles("test")
class GestorPrestecsIT {           // sufix IT: l'executa failsafe (11-05)

    @Autowired private GestorPrestecs gestor;
    @Autowired private MaterialRepository materials;

    // Substitueix el bean real al context de Spring per un mock
    @MockitoBean private ServeiAvisos avisos;

    @Test
    void prestarPersisteixIAvisa() {
        materials.save(new Llibre("978-0000000001", "Java Eficac", 3, "J. Bloch"));

        Prestec prestec = gestor.prestar("978-0000000001", "[email protected]");

        assertThat(prestec.getId()).isNotNull();      // es va persistir de veritat
        verify(avisos).avisar(any(), contains("Java Eficac"));   // no es va enviar correu real
    }
}

@DataJpaTest                       // nomes JPA: repositoris, EntityManager, BD incrustada
@Tag("integracio")
class PrestecRepositoryIT {

    @Autowired private PrestecRepository repositori;
    @Autowired private TestEntityManager em;

    @Test
    @DisplayName("troba els préstecs vençuts sense retornar, amb les relacions carregades")
    void trobaVencuts() {
        Material llibre = em.persist(new Llibre("978-0000000001", "Java Eficac", 3, "J. Bloch"));
        Empleat marta = em.persist(new Empleat("[email protected]", "Marta Ruiz"));

        em.persist(new Prestec(llibre, marta, LocalDate.of(2026, 3, 1), LocalDate.of(2026, 3, 10)));
        em.persist(new Prestec(llibre, marta, LocalDate.of(2026, 3, 1), LocalDate.of(2026, 4, 10)));
        em.flush();
        em.clear();                // buida el context: forca a llegir de la BD de veritat

        List<Prestec> vencuts = repositori.vencuts(LocalDate.of(2026, 3, 20));

        assertThat(vencuts).hasSize(1);
        // El JOIN FETCH d'11-03 funciona: no hi ha LazyInitializationException
        assertThat(vencuts.get(0).getMaterial().getTitol()).isEqualTo("Java Eficac");
    }
}

@SpringBootTest
@Testcontainers
class PrestecRepositoryPostgresIT {

    @Container
    @ServiceConnection    // Spring Boot 3.1+: configura el DataSource sol
    static PostgreSQLContainer<?> postgres =
            new PostgreSQLContainer<>("postgres:16-alpine");

    @Autowired private PrestecRepository repositori;

    @Test
    void funcionaContraPostgresDeVeritat() {
        // S'executa contra PostgreSQL 16 real, arrencat i destruit per la prova
    }
}

@Test
void coberturaAlta() {
    when(materials.findByIsbn(anyString())).thenReturn(Optional.of(llibre));
    when(empleats.findByCorreu(anyString())).thenReturn(Optional.of(marta));
    when(prestecs.save(any())).thenReturn(prestec);

    gestor.prestar("978-0000000001", "[email protected]");
    // Ni una asercio. Cobertura del metode: 100 %. Valor: zero.
}

@ExtendWith(MockitoExtension.class)
class ProcessadorReservesTest {

    @Mock private ReservaRepository reserves;
    @Mock private GestorPrestecs gestor;
    @Mock private PropietatsBiblioTech propietats;
    @Mock private PropietatsBiblioTech.Reserva propietatsReserva;
    @Mock private Clock rellotge;
    @Mock private Reserva reserva;
    @Mock private Material material;

    @InjectMocks private ProcessadorReserves processador;

    @Test
    void test() {
        when(propietats.reserva()).thenReturn(propietatsReserva);
        when(propietatsReserva.diesCaducitat()).thenReturn(3);
        when(rellotge.instant()).thenReturn(Instant.parse("2026-03-20T10:00:00Z"));
        when(rellotge.getZone()).thenReturn(ZoneId.of("Europe/Madrid"));
        when(reserves.pendents()).thenReturn(List.of(reserva));
        when(reserva.getDataSolicitud()).thenReturn(LocalDate.of(2026, 3, 10));
        when(reserva.getMaterial()).thenReturn(material);
        when(material.getIsbn()).thenReturn("978-0000000001");
        when(gestor.hiHaDisponible(anyString())).thenReturn(false);

        processador.processarPendents();

        verify(propietats).reserva();
        verify(propietatsReserva).diesCaducitat();
        verify(reserves).pendents();
        verify(reserva).getDataSolicitud();
        verify(reserves).caducar(reserva);
        verifyNoMoreInteractions(reserves, gestor, propietats);
    }
}

@Service
public class GestorDevolucions {

    private final PrestecRepository prestecs;
    private final CalculadoraMultes calculadora;
    private final RegistreMultes multes;
    private final ProcessadorReserves reserves;
    private final ServeiAvisos avisos;
    private final Clock rellotge;

    @Transactional
    public ResultatDevolucio retornar(Long prestecId) {

        Prestec prestec = prestecs.findById(prestecId)
                .orElseThrow(() -> new PrestecNoTrobatException(prestecId));

        if (prestec.getDataDevolucio().isPresent()) {
            throw new PrestecJaRetornatException(prestecId);
        }

        LocalDate avui = LocalDate.now(rellotge);
        BigDecimal multa = calculadora.calcular(prestec);

        prestec.retornar(avui);
        prestec.getMaterial().retornarUnExemplar();
        prestecs.save(prestec);

        if (multa.compareTo(BigDecimal.ZERO) > 0) {
            multes.registrar(prestec, multa);
            avisos.avisar(prestec.getEmpleat(),
                    "S'ha registrat una multa de " + multa + " EUR per la devolucio tardana de "
                    + prestec.getMaterial().getTitol());
        }

        Optional<Reserva> seguent = reserves.seguentDe(prestec.getMaterial());
        seguent.ifPresent(r -> {
            r.avisar(rellotge);
            avisos.avisar(r.getEmpleat(),
                    "Ja esta disponible el material que vas reservar: "
                    + prestec.getMaterial().getTitol());
        });

        return new ResultatDevolucio(prestec, multa, seguent.isPresent());
    }
}

// 1. Sense dobles: tot real
var calculadora = new CalculadoraMultes(propietatsDeProva(), Clock.fixed(...));
assertThat(calculadora.calcular(prestecAmbRetard(200))).isEqualByComparingTo("20.00");

// 2. Mock per verificar l'ordre
verify(avisos).avisar(eq(bibliotecariResponsable), contains("ultim exemplar"));

// 3. Stub per a la consulta, verify(never) per a l'absencia d'ordre
when(prestecs.countByEmpleatAndEstat(marta, ACTIU)).thenReturn(3L);
assertThatThrownBy(() -> gestor.prestar(...)).isInstanceOf(LimitPrestecsException.class);
verify(prestecs, never()).save(any());

// 4. Fake: coherencia entre consultes, gratis
var repositori = new RepositoriPrestecsEnMemoria();
repositori.save(prestecDe(marta, "978-0000000001"));
repositori.save(prestecDe(marta, "978-0000000002"));
repositori.save(prestecDe(diego, "978-0000000001"));

var estadistiques = new EstadistiquesBiblioTech(repositori);
assertThat(estadistiques.materialMesPrestat()).contains("978-0000000001");
assertThat(estadistiques.prestecsPerEmpleat()).containsEntry("Marta Ruiz", 2L);

// 5. thenThrow: l'escenari impossible de reproduir
when(passarela.cercarPerIsbn("978-0000000001"))
        .thenThrow(new PassarelaNoDisponibleException("503 Service Unavailable"));

// 6. Captor per al contingut de l'auditoria
verify(registre).anotar(captorEntrada.capture());
assertThat(captorEntrada.getValue())
        .extracting(EntradaAuditoria::operacio, EntradaAuditoria::isbn)
        .containsExactly("PRESTEC", "978-0000000001");

// 7. Rellotge fix REAL, no mock de Clock
var processador = new ProcessadorReserves(repositori, gestor, propietats,
                                          Clock.fixed(Instant.parse("2026-03-20T10:00:00Z"), MADRID));

@ExtendWith(MockitoExtension.class)
@DisplayName("ProcessadorReserves")
class ProcessadorReservesTest {

    private static final ZoneId MADRID = ZoneId.of("Europe/Madrid");
    private static final LocalDate AVUI = LocalDate.of(2026, 3, 20);
    private static final Clock RELLOTGE = Clock.fixed(AVUI.atStartOfDay(MADRID).toInstant(), MADRID);

    @Mock private ReservaRepository reserves;      // col.laborador extern: mock
    @Mock private GestorPrestecs gestor;           // col.laborador amb efectes: mock

    private ProcessadorReserves processador;
    private Material llibre;
    private Empleat marta;

    @BeforeEach
    void preparar() {
        // Objectes REALS: records de configuracio, rellotge fix i entitats de domini
        var propietats = new PropietatsBiblioTech(
                "BiblioTech",
                new PropietatsBiblioTech.Prestec(15, 3),
                new PropietatsBiblioTech.Multa(new BigDecimal("0.50"), new BigDecimal("20.00")),
                new PropietatsBiblioTech.Reserva(3));       // 3 dies de caducitat

        // Construccio explicita, no @InjectMocks
        processador = new ProcessadorReserves(reserves, gestor, propietats, RELLOTGE);

        llibre = new Llibre("978-0000000001", "Java Eficac", 0, "J. Bloch");
        marta = new Empleat("[email protected]", "Marta Ruiz");
    }

    @Test
    @DisplayName("caduca les reserves sol·licitades fa més de 3 dies")
    void caducaLesReservesAntigues() {
        // Sol.licitada el 10 -> caducava el 13 -> avui es 20: caducada
        Reserva antiga = new Reserva(llibre, marta, LocalDate.of(2026, 3, 10), 3);
        when(reserves.pendents()).thenReturn(List.of(antiga));

        processador.processarPendents();

        verify(reserves).caducar(antiga);                        // ORDRE: es verifica
        assertThat(antiga.getEstat()).isEqualTo(EstatReserva.CADUCADA);   // ESTAT real
        verify(gestor, never()).prestar(anyString(), anyString());
    }

    @Test
    @DisplayName("no caduca una reserva dins del termini de 3 dies")
    void noCaducaLesRecents() {
        // Sol.licitada el 18 -> caduca el 21 -> avui es 20: encara vigent
        Reserva recent = new Reserva(llibre, marta, LocalDate.of(2026, 3, 18), 3);
        when(reserves.pendents()).thenReturn(List.of(recent));
        when(gestor.hiHaDisponible("978-0000000001")).thenReturn(false);

        processador.processarPendents();

        verify(reserves, never()).caducar(any());
        assertThat(recent.getEstat()).isEqualTo(EstatReserva.PENDENT);
    }

    @Test
    @DisplayName("presta i completa la reserva quan hi ha exemplar disponible")
    void completaLaReservaSiHiHaExemplar() {
        Reserva vigent = new Reserva(llibre, marta, LocalDate.of(2026, 3, 18), 3);
        when(reserves.pendents()).thenReturn(List.of(vigent));
        when(gestor.hiHaDisponible("978-0000000001")).thenReturn(true);

        processador.processarPendents();

        verify(gestor).prestar("978-0000000001", marta.getCorreu());   // ORDRE
        verify(reserves).completar(vigent);                            // ORDRE
        verify(reserves, never()).caducar(any());
    }

    @Test
    @DisplayName("el dia exacte de caducitat la reserva encara és vàlida")
    void limitDelTermini() {
        // Sol.licitada el 17 -> caduca el 20 -> avui es 20: ES l'ultim dia, encara val
        Reserva alLimit = new Reserva(llibre, marta, LocalDate.of(2026, 3, 17), 3);
        when(reserves.pendents()).thenReturn(List.of(alLimit));
        when(gestor.hiHaDisponible(anyString())).thenReturn(false);

        processador.processarPendents();

        verify(reserves, never()).caducar(any());
    }

    @Test
    @DisplayName("no fa res si no hi ha reserves pendents")
    void senseReserves() {
        when(reserves.pendents()).thenReturn(List.of());

        processador.processarPendents();

        verifyNoInteractions(gestor);
    }
}

package com.nexussoftware.bibliotech.servei;

import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;

import java.math.BigDecimal;
import java.time.*;
import java.util.*;
import org.junit.jupiter.api.*;
import org.mockito.*;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
@DisplayName("GestorDevolucions")
class GestorDevolucionsTest {

    private static final ZoneId MADRID = ZoneId.of("Europe/Madrid");
    private static final LocalDate AVUI = LocalDate.of(2026, 3, 20);
    private static final Clock RELLOTGE = Clock.fixed(AVUI.atStartOfDay(MADRID).toInstant(), MADRID);

    // MOCKS: col.laboradors amb efectes externs o infraestructura
    @Mock private PrestecRepository prestecs;
    @Mock private RegistreMultes multes;
    @Mock private ProcessadorReserves reserves;
    @Mock private ServeiAvisos avisos;

    @Captor private ArgumentCaptor<String> capturadorMissatge;
    @Captor private ArgumentCaptor<Empleat> capturadorEmpleat;
    @Captor private ArgumentCaptor<BigDecimal> capturadorQuantitat;

    private GestorDevolucions gestor;
    private Material llibre;
    private Empleat marta;
    private Empleat diego;

    @BeforeEach
    void preparar() {
        var propietats = new PropietatsBiblioTech(
                "BiblioTech",
                new PropietatsBiblioTech.Prestec(15, 3),
                new PropietatsBiblioTech.Multa(new BigDecimal("0.50"), new BigDecimal("20.00")),
                new PropietatsBiblioTech.Reserva(3));

        // REAL: pura, barata, determinista. Simular-la debilitaria la prova
        var calculadora = new CalculadoraMultes(propietats, RELLOTGE);

        gestor = new GestorDevolucions(prestecs, calculadora, multes, reserves, avisos, RELLOTGE);

        llibre = new Llibre("978-0000000001", "Java Eficac", 2, "J. Bloch");
        marta  = new Empleat("[email protected]", "Marta Ruiz");
        diego  = new Empleat("[email protected]", "Diego Alonso");
    }

    // ============ (1) EN TERMINI ============
    @Nested
    @DisplayName("devolució en termini")
    class EnTermini {

        @Test
        @DisplayName("no genera multa ni avís")
        void senseMultaNiAvis() {
            Prestec prestec = prestecQueVenc(AVUI.plusDays(5));   // encara en termini
            when(prestecs.findById(1L)).thenReturn(Optional.of(prestec));
            when(reserves.seguentDe(llibre)).thenReturn(Optional.empty());

            ResultatDevolucio resultat = gestor.retornar(1L);

            assertThat(resultat.multa()).isEqualByComparingTo("0.00");
            assertThat(resultat.hiHaReservaPendent()).isFalse();
            assertThat(prestec.getEstat()).isEqualTo(EstatPrestec.RETORNAT);
            assertThat(prestec.getDataDevolucio()).contains(AVUI);

            verify(prestecs).save(prestec);            // ORDRE
            verifyNoInteractions(multes);              // no es va registrar multa
            verify(avisos, never()).avisar(any(), anyString());
        }

        // ============ (6) EXEMPLARS ============
        @Test
        @DisplayName("el material recupera un exemplar disponible")
        void recuperaExemplar() {
            Prestec prestec = prestecQueVenc(AVUI.plusDays(5));
            when(prestecs.findById(1L)).thenReturn(Optional.of(prestec));
            when(reserves.seguentDe(llibre)).thenReturn(Optional.empty());

            int abans = llibre.getExemplarsDisponibles();
            gestor.retornar(1L);

            assertThat(llibre.getExemplarsDisponibles()).isEqualTo(abans + 1);
        }
    }

    // ============ (2) AMB RETARD ============
    @Nested
    @DisplayName("devolució amb retard")
    class AmbRetard {

        @Test
        @DisplayName("registra una multa de 5,00 € per 10 dies i avisa amb el detall")
        void multaDeDeuDies() {
            Prestec prestec = prestecQueVenc(AVUI.minusDays(10));
            when(prestecs.findById(1L)).thenReturn(Optional.of(prestec));
            when(reserves.seguentDe(llibre)).thenReturn(Optional.empty());

            ResultatDevolucio resultat = gestor.retornar(1L);

            // La multa la calcula el codi REAL: 10 dies x 0,50 EUR = 5,00 EUR
            assertThat(resultat.multa()).isEqualByComparingTo("5.00");

            // ORDRE 1: registre de la multa, amb captura dels arguments reals
            verify(multes).registrar(eq(prestec), capturadorQuantitat.capture());
            assertThat(capturadorQuantitat.getValue()).isEqualByComparingTo("5.00");

            // ORDRE 2: avis, amb el CONTINGUT verificat
            verify(avisos).avisar(capturadorEmpleat.capture(), capturadorMissatge.capture());
            assertThat(capturadorEmpleat.getValue()).isEqualTo(marta);
            assertThat(capturadorMissatge.getValue())
                    .contains("multa")
                    .contains("5.00")
                    .contains("Java Eficac")
                    .doesNotContain("null");
        }

        @Test
        @DisplayName("la multa es limita al màxim de 20 € amb retards molt llargs")
        void multaLimitada() {
            Prestec prestec = prestecQueVenc(AVUI.minusDays(300));
            when(prestecs.findById(1L)).thenReturn(Optional.of(prestec));
            when(reserves.seguentDe(llibre)).thenReturn(Optional.empty());

            assertThat(gestor.retornar(1L).multa()).isEqualByComparingTo("20.00");
            verify(multes).registrar(eq(prestec), argThat(m -> m.compareTo(new BigDecimal("20.00")) == 0));
        }
    }

    // ============ (3) AMB RESERVA PENDENT ============
    @Nested
    @DisplayName("quan hi ha una reserva pendent del material")
    class AmbReserva {

        @Test
        @DisplayName("avisa també el següent empleat de la cua")
        void avisaAlSeguent() {
            Prestec prestec = prestecQueVenc(AVUI.plusDays(5));   // en termini: nomes 1 avis
            Reserva reservaDeDiego = new Reserva(llibre, diego, AVUI.minusDays(1), 3);

            when(prestecs.findById(1L)).thenReturn(Optional.of(prestec));
            when(reserves.seguentDe(llibre)).thenReturn(Optional.of(reservaDeDiego));

            ResultatDevolucio resultat = gestor.retornar(1L);

            assertThat(resultat.hiHaReservaPendent()).isTrue();
            assertThat(reservaDeDiego.getEstat()).isEqualTo(EstatReserva.AVISADA);
            assertThat(reservaDeDiego.getInstantAvis()).isPresent();

            verify(avisos).avisar(capturadorEmpleat.capture(), capturadorMissatge.capture());
            assertThat(capturadorEmpleat.getValue()).isEqualTo(diego);
            assertThat(capturadorMissatge.getValue())
                    .contains("disponible")
                    .contains("Java Eficac");
        }

        @Test
        @DisplayName("amb retard I reserva s'envien dos avisos, primer la multa")
        void dosAvisosEnOrdre() {
            Prestec prestec = prestecQueVenc(AVUI.minusDays(10));
            Reserva reservaDeDiego = new Reserva(llibre, diego, AVUI.minusDays(1), 3);

            when(prestecs.findById(1L)).thenReturn(Optional.of(prestec));
            when(reserves.seguentDe(llibre)).thenReturn(Optional.of(reservaDeDiego));

            gestor.retornar(1L);

            verify(avisos, times(2))
                    .avisar(capturadorEmpleat.capture(), capturadorMissatge.capture());

            // L'ordre aqui SI que es un requisit: l'afectat per la multa se n'assabenta primer
            assertThat(capturadorEmpleat.getAllValues()).containsExactly(marta, diego);
            assertThat(capturadorMissatge.getAllValues().get(0)).contains("multa");
            assertThat(capturadorMissatge.getAllValues().get(1)).contains("disponible");
        }
    }

    // ============ (4) i (5) CASOS D'ERROR ============
    @Nested
    @DisplayName("casos d'error")
    class Errors {

        @Test
        @DisplayName("préstec inexistent: excepció i cap efecte")
        void prestecInexistent() {
            when(prestecs.findById(99L)).thenReturn(Optional.empty());

            assertThatThrownBy(() -> gestor.retornar(99L))
                    .isInstanceOf(PrestecNoTrobatException.class)
                    .hasMessageContaining("99");

            verify(prestecs, never()).save(any());
            verifyNoInteractions(multes, avisos, reserves);
        }

        @Test
        @DisplayName("préstec ja retornat: excepció i cap efecte")
        void prestecJaRetornat() {
            Prestec retornat = prestecQueVenc(AVUI.minusDays(10));
            retornat.retornar(AVUI.minusDays(5));                 // ja retornat
            when(prestecs.findById(1L)).thenReturn(Optional.of(retornat));

            int exemplarsAbans = llibre.getExemplarsDisponibles();

            assertThatThrownBy(() -> gestor.retornar(1L))
                    .isInstanceOf(PrestecJaRetornatException.class);

            verify(prestecs, never()).save(any());
            verifyNoInteractions(multes, avisos, reserves);
            // Cap efecte sobre l'estat del material
            assertThat(llibre.getExemplarsDisponibles()).isEqualTo(exemplarsAbans);
        }
    }

    // --- fabrica d'escenaris ---
    private Prestec prestecQueVenc(LocalDate venciment) {
        return new Prestec(llibre, marta, venciment.minusDays(15), venciment);
    }
}