public GestorPrestamos(MaterialRepository materiales,
                       EmpleadoRepository empleados,
                       PrestamoRepository prestamos,
                       ServicioAvisos avisos,
                       PropiedadesBiblioTech propiedades,
                       Clock reloj) { ... }

class RepositorioEnMemoria implements RepositorioPrestamos {
    private final Map<Long, Prestamo> datos = new HashMap<>();
    private long siguienteId = 1;

    @Override public Prestamo save(Prestamo p) {
        if (p.getId() == null) p.asignarId(siguienteId++);
        datos.put(p.getId(), p);
        return p;
    }
    @Override public Optional<Prestamo> findById(Long id) {
        return Optional.ofNullable(datos.get(id));
    }
    @Override public List<Prestamo> findByEstado(EstadoPrestamo estado) {
        return datos.values().stream().filter(p -> p.getEstado() == estado).toList();
    }
}

// Con MOCK: hay que programar cada respuesta, y no hay coherencia
when(repositorio.save(any())).thenReturn(prestamo);
when(repositorio.findById(1L)).thenReturn(Optional.of(prestamo));
when(repositorio.countByEmpleado(marta)).thenReturn(1L);
// Si el código guarda y luego cuenta, el mock NO refleja lo que se guardó.
// Hay que mantener a mano una coherencia que el fake da gratis.

// Con FAKE: guardas y cuentas, y sale lo correcto
repositorio.save(prestamo);
assertThat(repositorio.countByEmpleado(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.servicio;

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 GestorPrestamosTest {

    @Mock private MaterialRepository materiales;
    @Mock private EmpleadoRepository empleados;
    @Mock private PrestamoRepository prestamos;
    @Mock private ServicioAvisos avisos;

    private GestorPrestamos gestor;

    @BeforeEach
    void preparar() {
        // Construcción explícita: mejor que @InjectMocks (apartado 6)
        gestor = new GestorPrestamos(materiales, empleados, prestamos, avisos,
                                     propiedadesDePrueba(), RELOJ_FIJO);
    }
}

// Forma 1: anotación (recomendada, más legible)
@ExtendWith(MockitoExtension.class)
class PruebaConAnotaciones {
    @Mock private MaterialRepository materiales;
}

// Forma 2: método de fábrica (útil para mocks locales de una prueba)
class PruebaConFabrica {
    @Test
    void ejemplo() {
        MaterialRepository materiales = mock(MaterialRepository.class);
        // ...
    }
}

// Con nombre: los mensajes de error lo identifican
MaterialRepository materiales = mock(MaterialRepository.class, "repositorioDeMateriales");

// Respuestas por defecto distintas
ServicioAvisos avisos = mock(ServicioAvisos.class, Answers.RETURNS_DEEP_STUBS);

// Lanza excepción si se llama a un método no programado: fuerza a ser explícito
MaterialRepository estricto = mock(MaterialRepository.class, Answers.RETURNS_SMART_NULLS);

@ExtendWith(MockitoExtension.class)
class GestorPrestamosTest {

    @Mock private MaterialRepository materiales;
    @Mock private ServicioAvisos avisos;

    @InjectMocks private GestorPrestamos gestor;   // construido automáticamente
}

@BeforeEach
void preparar() {
    gestor = new GestorPrestamos(materiales, empleados, prestamos, avisos,
                                 propiedadesDePrueba(), RELOJ_FIJO);
}

@Test
void prestarDevuelveUnPrestamoConVencimientoAQuinceDias() {

    // PREPARAR: programar lo que devuelven los colaboradores
    Material libro = new Libro("978-0000000001", "Java Efectivo", 3, "J. Bloch");
    Empleado marta = new Empleado("[email protected]", "Marta Ruiz");

    when(materiales.findByIsbn("978-0000000001")).thenReturn(Optional.of(libro));
    when(empleados.findByCorreo("[email protected]")).thenReturn(Optional.of(marta));
    when(prestamos.countByEmpleadoAndEstado(marta, EstadoPrestamo.ACTIVO)).thenReturn(0L);
    when(prestamos.save(any(Prestamo.class))).thenAnswer(inv -> inv.getArgument(0));

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

    // COMPROBAR
    assertThat(prestamo.getFechaVencimiento())
            .isEqualTo(LocalDate.of(2026, 3, 20).plusDays(15));
}

// Valores distintos en llamadas sucesivas
when(prestamos.count())
        .thenReturn(0L)      // 1ª llamada
        .thenReturn(1L)      // 2ª
        .thenReturn(2L);     // 3ª y siguientes

// Equivalente, más corto
when(prestamos.count()).thenReturn(0L, 1L, 2L);

@Test
void siElRepositorioFallaAlGuardarNoSeEnviaNingunAviso() {

    when(materiales.findByIsbn(anyString())).thenReturn(Optional.of(unLibro()));
    when(empleados.findByCorreo(anyString())).thenReturn(Optional.of(marta()));
    when(prestamos.countByEmpleadoAndEstado(any(), any())).thenReturn(0L);

    // El repositorio falla al guardar
    when(prestamos.save(any()))
            .thenThrow(new DataAccessResourceFailureException("Conexión perdida"));

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

    // Lo importante: NO se avisó a nadie de un préstamo que no se guardó
    verifyNoInteractions(avisos);
}

// Excepción de concurrencia (el bloqueo optimista de 11-03)
when(materiales.findByIsbn(anyString()))
        .thenThrow(new OptimisticLockingFailureException("Versión obsoleta"));

// Tiempo de espera agotado en la red (el ClienteMetadatos de 09-06)
when(clienteHttp.send(any(), any()))
        .thenThrow(new HttpTimeoutException("La API no responde"));

// Fallo la primera vez, éxito la segunda: probar el reintento
when(prestamos.save(any()))
        .thenThrow(new OptimisticLockingFailureException("conflicto"))
        .thenReturn(prestamoGuardado);

// El caso más común: save devuelve lo que se le pasó
when(prestamos.save(any(Prestamo.class))).thenAnswer(inv -> inv.getArgument(0));

// Simular la asignación de id que haría la base de datos
when(prestamos.save(any(Prestamo.class))).thenAnswer(invocacion -> {
    Prestamo p = invocacion.getArgument(0);
    if (p.getId() == null) {
        p.asignarId(siguienteId.getAndIncrement());
    }
    return p;
});

// Respuesta según el argumento
when(materiales.findByIsbn(anyString())).thenAnswer(invocacion -> {
    String isbn = invocacion.getArgument(0);
    return catalogoDePrueba.containsKey(isbn)
            ? Optional.of(catalogoDePrueba.get(isbn))
            : Optional.empty();
});

// Sintaxis when: la habitual
when(materiales.findByIsbn("x")).thenReturn(Optional.empty());

// Sintaxis do: equivalente, pero el método se nombra al final
doReturn(Optional.empty()).when(materiales).findByIsbn("x");

// NO COMPILA: avisar() devuelve void, no hay nada que pasar a when()
when(avisos.avisar(marta, "mensaje")).thenThrow(new RuntimeException());

// CORRECTO
doThrow(new ServicioAvisosException("SMTP caído"))
        .when(avisos).avisar(any(Empleado.class), anyString());

// Y para que un void no haga nada (es el comportamiento por defecto,
// pero explicitarlo a veces aclara la intención)
doNothing().when(avisos).avisar(any(), anyString());

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

// MAL: when() LLAMA DE VERDAD a get(0) sobre una lista vacía
// -> IndexOutOfBoundsException antes de programar nada
when(espia.get(0)).thenReturn("Java Efectivo");

// BIEN: do... NO invoca el método real
doReturn("Java Efectivo").when(espia).get(0);

when(materiales.findByIsbn(anyString())).thenReturn(Optional.of(libro));
// Más adelante, cambiar el comportamiento:
doReturn(Optional.empty()).when(materiales).findByIsbn("978-9999999999");

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

@Test
void devolverConRetrasoRegistraLaMultaYAvisaAlEmpleado() {

    Prestamo vencido = prestamoVencidoHace(10);
    when(prestamos.findById(1L)).thenReturn(Optional.of(vencido));

    gestor.devolver(1L);

    // Se guardó el préstamo actualizado
    verify(prestamos).save(vencido);

    // Se avisó al empleado
    verify(avisos).avisar(eq(vencido.getEmpleado()), contains("multa"));
}

verify(avisos, times(1)).avisar(any(), anyString());        // exactamente 1 (por defecto)
verify(avisos, times(3)).avisar(any(), anyString());        // exactamente 3
verify(avisos, never()).avisar(any(), anyString());         // NUNCA
verify(avisos, atLeastOnce()).avisar(any(), anyString());   // 1 o más
verify(avisos, atLeast(2)).avisar(any(), anyString());      // 2 o más
verify(avisos, atMost(5)).avisar(any(), anyString());       // 5 o menos
verify(avisos, only()).avisar(any(), anyString());          // esta llamada Y NINGUNA OTRA

verifyNoInteractions(avisos);                    // el mock no se usó en absoluto
verifyNoMoreInteractions(prestamos);             // no hubo más llamadas de las verificadas

@Test
void unPrestamoDevueltoEnPlazoNoGeneraAviso() {
    when(prestamos.findById(1L)).thenReturn(Optional.of(prestamoEnPlazo()));

    gestor.devolver(1L);

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

@Test
void seDecrementaElStockAntesDeGuardarElPrestamo() {

    InOrder orden = inOrder(materiales, prestamos, avisos);

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

    orden.verify(materiales).findByIsbn("978-0000000001");
    orden.verify(prestamos).save(any(Prestamo.class));
    orden.verify(avisos).avisar(any(), anyString());
}

gestor.consultar("978-0000000001");

verify(materiales).findByIsbn("978-0000000001");
verifyNoMoreInteractions(materiales);   // no se llamó a nada más

// MAL: verificar una consulta
verify(materiales).findByIsbn("978-0000000001");
verify(prestamos).countByEmpleadoAndEstado(marta, EstadoPrestamo.ACTIVO);

// BIEN: verificar un comando
verify(avisos).avisar(marta, "Tu préstamo de Java Efectivo vence en 2 días");

when(materiales.findByIsbn(anyString())).thenReturn(Optional.of(libro));

verify(avisos).avisar(any(Empleado.class), contains("vence"));

// argThat: condiciones arbitrarias
verify(prestamos).save(argThat(p ->
        p.getEstado() == EstadoPrestamo.ACTIVO
        && p.getFechaVencimiento().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.

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

// También correcto: ningún matcher
verify(avisos).avisar(marta, "Tu préstamo vence en 2 días");

// También correcto: todos matchers
verify(avisos).avisar(any(Empleado.class), anyString());

@ExtendWith(MockitoExtension.class)
class ServicioAvisosVencimientoTest {

    @Mock private PrestamoRepository prestamos;
    @Mock private ServicioAvisos avisos;

    @Captor private ArgumentCaptor<String> capturadorMensaje;
    @Captor private ArgumentCaptor<Empleado> capturadorEmpleado;

    @Test
    void elMensajeDeAvisoIncluyeElTituloYLosDiasRestantes() {

        Prestamo prestamo = prestamoQueVence(HOY.plusDays(2), marta(), "Java Efectivo");
        when(prestamos.buscarActivos()).thenReturn(List.of(prestamo));

        servicio.enviarAvisosDelDia();

        // Capturar los argumentos REALES de la llamada
        verify(avisos).avisar(capturadorEmpleado.capture(), capturadorMensaje.capture());

        assertThat(capturadorEmpleado.getValue().getCorreo())
                .isEqualTo("[email protected]");
        assertThat(capturadorMensaje.getValue())
                .contains("Java Efectivo")
                .contains("2 días")
                .doesNotContain("null");        // el clásico bug de concatenación
    }
}

@Test
void seAvisaAcadaEmpleadoConPrestamoProximoAVencer() {

    when(prestamos.buscarActivos()).thenReturn(List.of(
            prestamoQueVence(HOY.plusDays(2), marta(), "Java Efectivo"),
            prestamoQueVence(HOY.plusDays(2), diego(), "Patrones de Diseño"),
            prestamoQueVence(HOY.plusDays(9), nuria(), "Refactorización")));   // aún no toca

    servicio.enviarAvisosDelDia();

    verify(avisos, times(2)).avisar(capturadorEmpleado.capture(), capturadorMensaje.capture());

    assertThat(capturadorEmpleado.getAllValues())
            .extracting(Empleado::getCorreo)
            .containsExactly("[email protected]",
                             "[email protected]");

    assertThat(capturadorMensaje.getAllValues())
            .allSatisfy(mensaje -> assertThat(mensaje).contains("2 días"));
}

@ExtendWith(MockitoExtension.class)
class CalculadoraMultasTest {

    @Spy private CalculadoraMultas calculadora =
            new CalculadoraMultas(propiedadesDePrueba(), RELOJ_FIJO);

    @Test
    void ejemplo() {
        // Comportamiento REAL por defecto
        assertThat(calculadora.calcular(prestamoConRetraso(5))).isEqualByComparingTo("2.50");

        // Sustituir SOLO un método (nota: do... obligatorio, apartado 10)
        doReturn(new BigDecimal("999.99")).when(calculadora).calcular(any());
        assertThat(calculadora.calcular(prestamoConRetraso(5))).isEqualByComparingTo("999.99");
    }
}

// TRAMPA: el espía es una COPIA, no el objeto original
List<String> original = new ArrayList<>();
List<String> espia = spy(original);

espia.add("Java Efectivo");
assertThat(espia).hasSize(1);       // ok
assertThat(original).isEmpty();     // ¡el original NO cambió!

// TRAMPA: las llamadas internas NO pasan por el espía
// Es exactamente el problema del proxy de 11-02 §26.
// Si metodoA() llama a this.metodoB(), sustituir metodoB no afecta a metodoA.

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

        // dentro de este bloque, LocalDate.now() devuelve la fecha fija
        assertThat(LocalDate.now()).isEqualTo(LocalDate.of(2026, 3, 20));
    }
    // fuera, comportamiento normal
}

// Opción A: mockStatic. Funciona, y arrastra problemas.
try (MockedStatic<LocalDate> f = mockStatic(LocalDate.class)) {
    f.when(LocalDate::now).thenReturn(LocalDate.of(2026, 3, 20));
    assertThat(calculadora.calcular(prestamo)).isEqualByComparingTo("2.50");
}

// Opción B: Clock inyectado. El diseño elimina la necesidad del mock.
var calculadora = new CalculadoraMultas(propiedades, Clock.fixed(...));
assertThat(calculadora.calcular(prestamo)).isEqualByComparingTo("2.50");

@Mock private HttpClient http;

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

@Test
void prestar() {
    when(materiales.findByIsbn("978-0000000001")).thenReturn(Optional.of(libro));
    when(empleados.findByCorreo("[email protected]")).thenReturn(Optional.of(marta));
    when(prestamos.countByEmpleadoAndEstado(marta, ACTIVO)).thenReturn(0L);
    when(propiedades.prestamo()).thenReturn(new Prestamo(15, 3));
    when(calculadora.calcular(any())).thenReturn(BigDecimal.ZERO);
    when(prestamos.save(any())).thenReturn(prestamoGuardado);

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

    verify(materiales).findByIsbn("978-0000000001");
    verify(empleados).findByCorreo("[email protected]");
    verify(prestamos).countByEmpleadoAndEstado(marta, ACTIVO);
    verify(prestamos).save(any());
    verify(avisos).avisar(any(), anyString());
    verifyNoMoreInteractions(materiales, empleados, prestamos, avisos);
}

@Test
void prestarCreaUnPrestamoActivoConVencimientoAQuinceDias() {

    when(materiales.findByIsbn("978-0000000001")).thenReturn(Optional.of(libro));
    when(empleados.findByCorreo("[email protected]")).thenReturn(Optional.of(marta));
    when(prestamos.save(any(Prestamo.class))).thenAnswer(inv -> inv.getArgument(0));

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

    // COMPORTAMIENTO: qué se produjo
    assertThat(prestamo)
            .satisfies(p -> {
                assertThat(p.getMaterial()).isEqualTo(libro);
                assertThat(p.getEmpleado()).isEqualTo(marta);
                assertThat(p.getEstado()).isEqualTo(EstadoPrestamo.ACTIVO);
                assertThat(p.getFechaVencimiento()).isEqualTo(LocalDate.of(2026, 4, 4));
            });

    // EFECTOS observables (comandos)
    verify(prestamos).save(prestamo);
    verify(avisos).avisar(eq(marta), contains("Java Efectivo"));
}

@Test
void devolverConRetrasoRegistraLaMulta_interaccion() {

    Prestamo vencido = prestamoVencidoHace(10);
    when(prestamos.findById(1L)).thenReturn(Optional.of(vencido));
    when(calculadora.calcular(vencido)).thenReturn(new BigDecimal("5.00"));

    gestor.devolver(1L);

    verify(calculadora).calcular(vencido);
    verify(multas).registrar(eq(vencido), eq(new BigDecimal("5.00")));
}

@Test
void devolverConRetrasoRegistraLaMulta_estado() {

    // Colaboradores REALES para lo que es barato y determinista
    var calculadora = new CalculadoraMultas(propiedadesDePrueba(), RELOJ_FIJO);
    var multasEnMemoria = new RegistroMultasEnMemoria();          // fake
    var gestor = new GestorPrestamos(prestamos, calculadora, multasEnMemoria, avisos, RELOJ_FIJO);

    Prestamo vencido = prestamoVencidoHace(10);
    when(prestamos.findById(1L)).thenReturn(Optional.of(vencido));

    gestor.devolver(1L);

    // Se comprueba el ESTADO resultante
    assertThat(multasEnMemoria.deEmpleado(vencido.getEmpleado()))
            .singleElement()
            .satisfies(multa -> {
                assertThat(multa.importe()).isEqualByComparingTo("5.00");
                assertThat(multa.prestamo()).isEqualTo(vencido);
            });

    assertThat(vencido.getEstado()).isEqualTo(EstadoPrestamo.DEVUELTO);
}

// Sin Clock: hace falta mockear un método estático
try (MockedStatic<LocalDate> f = mockStatic(LocalDate.class)) {
    f.when(LocalDate::now).thenReturn(LocalDate.of(2026, 3, 20));
    // ... prueba lenta, frágil y con riesgo de contaminación
}

// Con Clock inyectado: NO hace falta ningún mock
var calculadora = new CalculadoraMultas(propiedades, Clock.fixed(...));

@Test
void elAvisoContieneTodosLosDatosDelPrestamo() {

    when(prestamos.buscarActivos()).thenReturn(List.of(prestamoDeMarta(), prestamoDeDiego()));

    servicio.enviarAvisosDelDia();

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

    // AssertJ sobre lo capturado: expresivo y con buenos mensajes de error
    assertThat(captor.getAllValues())
            .hasSize(2)
            .extracting(Aviso::destinatario, Aviso::asunto)
            .containsExactly(
                    tuple("[email protected]",  "Tu préstamo vence en 2 días"),
                    tuple("[email protected]","Tu préstamo vence en 2 días"));

    assertThat(captor.getAllValues())
            .allSatisfy(aviso -> {
                assertThat(aviso.cuerpo()).doesNotContain("null");
                assertThat(aviso.destinatario()).endsWith("@nexussoftware.com");
            });
}

when(prestamos.save(any())).thenThrow(new DataAccessResourceFailureException("Sin conexión"));

assertThatThrownBy(() -> gestor.prestar("978-0000000001", "[email protected]"))
        .isInstanceOf(BiblioTechException.class)                  // se traduce la excepción
        .hasCauseInstanceOf(DataAccessResourceFailureException.class)
        .hasMessageContaining("978-0000000001");

package com.nexussoftware.bibliotech.servicio;

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("GestorPrestamos")
class GestorPrestamosTest {

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

    @Mock private MaterialRepository materiales;
    @Mock private EmpleadoRepository empleados;
    @Mock private PrestamoRepository prestamos;
    @Mock private ServicioAvisos avisos;

    private GestorPrestamos gestor;
    private Material libro;
    private Empleado marta;

    @BeforeEach
    void preparar() {
        // Propiedades y calculadora REALES: son baratas, deterministas y sin efectos
        var propiedades = new PropiedadesBiblioTech(
                "BiblioTech",
                new PropiedadesBiblioTech.Prestamo(15, 3),
                new PropiedadesBiblioTech.Multa(new BigDecimal("0.50"), new BigDecimal("20.00")),
                new PropiedadesBiblioTech.Reserva(3));
        var calculadora = new CalculadoraMultas(propiedades, RELOJ);

        gestor = new GestorPrestamos(materiales, empleados, prestamos, calculadora,
                                     avisos, propiedades, RELOJ);

        libro = new Libro("978-0000000001", "Java Efectivo", 3, "J. Bloch");
        marta = new Empleado("[email protected]", "Marta Ruiz");
    }

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

        @Test
        @DisplayName("crea un préstamo activo con vencimiento a 15 días")
        void creaPrestamoCorrecto() {
            when(materiales.findByIsbn("978-0000000001")).thenReturn(Optional.of(libro));
            when(empleados.findByCorreo(marta.getCorreo())).thenReturn(Optional.of(marta));
            when(prestamos.save(any(Prestamo.class))).thenAnswer(inv -> inv.getArgument(0));

            Prestamo prestamo = gestor.prestar("978-0000000001", marta.getCorreo());

            assertThat(prestamo.getMaterial()).isEqualTo(libro);
            assertThat(prestamo.getEmpleado()).isEqualTo(marta);
            assertThat(prestamo.getEstado()).isEqualTo(EstadoPrestamo.ACTIVO);
            assertThat(prestamo.getFechaPrestamo()).isEqualTo(HOY);
            assertThat(prestamo.getFechaVencimiento()).isEqualTo(HOY.plusDays(15));
        }

        @Test
        @DisplayName("decrementa los ejemplares disponibles del material")
        void decrementaEjemplares() {
            when(materiales.findByIsbn("978-0000000001")).thenReturn(Optional.of(libro));
            when(empleados.findByCorreo(marta.getCorreo())).thenReturn(Optional.of(marta));
            when(prestamos.save(any(Prestamo.class))).thenAnswer(inv -> inv.getArgument(0));

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

            assertThat(libro.getEjemplaresDisponibles()).isEqualTo(2);   // estado real
        }

        @Test
        @DisplayName("falla si el material no existe, y no guarda nada")
        void materialInexistente() {
            when(materiales.findByIsbn("978-9999999999")).thenReturn(Optional.empty());

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

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

        @Test
        @DisplayName("falla si el material no tiene ejemplares disponibles")
        void sinEjemplares() {
            Material agotado = new Libro("978-0000000003", "Refactorización", 0, "M. Fowler");
            when(materiales.findByIsbn("978-0000000003")).thenReturn(Optional.of(agotado));
            when(empleados.findByCorreo(marta.getCorreo())).thenReturn(Optional.of(marta));

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

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

        @Test
        @DisplayName("falla si el empleado ha alcanzado el límite de 3 préstamos")
        void limiteAlcanzado() {
            when(materiales.findByIsbn("978-0000000001")).thenReturn(Optional.of(libro));
            when(empleados.findByCorreo(marta.getCorreo())).thenReturn(Optional.of(marta));
            when(prestamos.countByEmpleadoAndEstado(marta, EstadoPrestamo.ACTIVO))
                    .thenReturn(3L);

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

            verify(prestamos, never()).save(any());
            assertThat(libro.getEjemplaresDisponibles()).isEqualTo(3);   // sin efectos
        }
    }

    @Nested
    @DisplayName("ante fallos de infraestructura")
    class Fallos {

        @Test
        @DisplayName("si el guardado falla, no se avisa a nadie")
        void fallaElGuardado() {
            when(materiales.findByIsbn("978-0000000001")).thenReturn(Optional.of(libro));
            when(empleados.findByCorreo(marta.getCorreo())).thenReturn(Optional.of(marta));
            when(prestamos.save(any()))
                    .thenThrow(new DataAccessResourceFailureException("Conexión perdida"));

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

            verifyNoInteractions(avisos);   // requisito: no se notifica lo no persistido
        }

        @Test
        @DisplayName("reintenta ante un conflicto de concurrencia y acaba con éxito")
        void reintentaAnteConflicto() {
            when(materiales.findByIsbn("978-0000000001")).thenReturn(Optional.of(libro));
            when(empleados.findByCorreo(marta.getCorreo())).thenReturn(Optional.of(marta));
            when(prestamos.save(any()))
                    .thenThrow(new OptimisticLockingFailureException("versión obsoleta"))
                    .thenAnswer(inv -> inv.getArgument(0));   // segunda vez, éxito

            Resultado<Prestamo> resultado =
                    gestor.prestarConReintento("978-0000000001", marta.getCorreo());

            assertThat(resultado.esExito()).isTrue();
            verify(prestamos, times(2)).save(any());   // se intentó dos veces
        }
    }
}

@ExtendWith(MockitoExtension.class)
@DisplayName("Avisos de vencimiento")
class ServicioAvisosVencimientoTest {

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

    @Mock private PrestamoRepository prestamos;
    @Mock private ServicioAvisos avisos;

    @Captor private ArgumentCaptor<Empleado> capturadorEmpleado;
    @Captor private ArgumentCaptor<String> capturadorMensaje;

    private ServicioAvisosVencimiento servicio;

    @BeforeEach
    void preparar() {
        servicio = new ServicioAvisosVencimiento(prestamos, avisos, propiedadesConAntelacion(2), RELOJ);
    }

    @Test
    @DisplayName("el mensaje incluye el título del material y los días restantes")
    void contenidoDelMensaje() {
        when(prestamos.buscarActivos()).thenReturn(List.of(
                prestamo("Java Efectivo", marta(), HOY.plusDays(2))));

        servicio.enviarAvisosDelDia();

        verify(avisos).avisar(capturadorEmpleado.capture(), capturadorMensaje.capture());

        assertThat(capturadorEmpleado.getValue().getCorreo())
                .isEqualTo("[email protected]");

        assertThat(capturadorMensaje.getValue())
                .contains("Java Efectivo")
                .contains("2 días")
                .doesNotContain("null")          // bug clásico de concatenación
                .doesNotContain("@{");           // plantilla sin sustituir
    }

    @Test
    @DisplayName("avisa solo a los empleados cuyo préstamo vence en exactamente 2 días")
    void ventanaDeAviso() {
        when(prestamos.buscarActivos()).thenReturn(List.of(
                prestamo("Java Efectivo",      marta(), HOY.plusDays(2)),   // SÍ
                prestamo("Patrones de Diseño", diego(), HOY.plusDays(2)),   // SÍ
                prestamo("Refactorización",    nuria(), HOY.plusDays(1)),   // no
                prestamo("Java Efectivo",      nuria(), HOY.plusDays(3)),   // no
                prestamo("Refactorización",    diego(), HOY.minusDays(5))));// no

        servicio.enviarAvisosDelDia();

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

        assertThat(capturadorEmpleado.getAllValues())
                .extracting(Empleado::getCorreo)
                .containsExactly("[email protected]",
                                 "[email protected]");
    }

    @Test
    @DisplayName("un canal caído no impide los avisos restantes")
    void unFalloNoDetieneElResto() {
        when(prestamos.buscarActivos()).thenReturn(List.of(
                prestamo("Java Efectivo",      marta(), HOY.plusDays(2)),
                prestamo("Patrones de Diseño", diego(), HOY.plusDays(2)),
                prestamo("Refactorización",    nuria(), HOY.plusDays(2))));

        // El segundo aviso falla
        doNothing()
                .doThrow(new ServicioAvisosException("SMTP no responde"))
                .doNothing()
                .when(avisos).avisar(any(), anyString());

        int enviados = servicio.enviarAvisosDelDia();

        assertThat(enviados).isEqualTo(2);                       // 3 intentos, 2 con éxito
        verify(avisos, times(3)).avisar(any(), anyString());     // se intentaron los 3
    }
}

package com.nexussoftware.bibliotech.red;

// Interfaz PROPIA que expresa lo que el dominio necesita
public interface PasarelaMetadatos {
    Optional<MetadatosLibro> buscarPorIsbn(String isbn);
}

// Implementación real, que sí usa HttpClient
@Component
public class PasarelaMetadatosHttp implements PasarelaMetadatos {

    private final HttpClient http;
    private final String urlBase;

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

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

@Service
public class EnriquecedorCatalogo {

    private final PasarelaMetadatos pasarela;     // la INTERFAZ, no HttpClient
    private final MaterialRepository materiales;

    public EnriquecedorCatalogo(PasarelaMetadatos pasarela, MaterialRepository materiales) {
        this.pasarela = pasarela;
        this.materiales = materiales;
    }

    public int enriquecerCatalogo() {
        int enriquecidos = 0;
        for (Material material : materiales.findByAutorIsNull()) {
            try {
                Optional<MetadatosLibro> metadatos = pasarela.buscarPorIsbn(material.getIsbn());
                if (metadatos.isPresent()) {
                    material.completarCon(metadatos.get());
                    materiales.save(material);
                    enriquecidos++;
                }
            } catch (PasarelaNoDisponibleException e) {
                log.warn("No se pudo enriquecer {}: {}", material.getIsbn(), e.getMessage());
                // continúa con el siguiente
            }
        }
        return enriquecidos;
    }
}

@ExtendWith(MockitoExtension.class)
@DisplayName("Enriquecimiento del catálogo")
class EnriquecedorCatalogoTest {

    @Mock private PasarelaMetadatos pasarela;
    @Mock private MaterialRepository materiales;

    private EnriquecedorCatalogo enriquecedor;

    @BeforeEach
    void preparar() { enriquecedor = new EnriquecedorCatalogo(pasarela, materiales); }

    @Test
    @DisplayName("completa el autor de los materiales que lo tienen vacío")
    void completaLosDatos() {
        Material sinAutor = new Libro("978-0000000001", "Java Efectivo", 3, null);
        when(materiales.findByAutorIsNull()).thenReturn(List.of(sinAutor));
        when(pasarela.buscarPorIsbn("978-0000000001"))
                .thenReturn(Optional.of(new MetadatosLibro("Joshua Bloch", 2018, "Addison-Wesley")));

        int enriquecidos = enriquecedor.enriquecerCatalogo();

        assertThat(enriquecidos).isEqualTo(1);
        assertThat(sinAutor.getAutor()).isEqualTo("Joshua Bloch");
        verify(materiales).save(sinAutor);
    }

    @Test
    @DisplayName("no guarda nada si la API no conoce el ISBN")
    void isbnDesconocido() {
        Material sinAutor = new Libro("978-0000000099", "Título raro", 1, null);
        when(materiales.findByAutorIsNull()).thenReturn(List.of(sinAutor));
        when(pasarela.buscarPorIsbn(anyString())).thenReturn(Optional.empty());

        assertThat(enriquecedor.enriquecerCatalogo()).isZero();
        verify(materiales, never()).save(any());
    }

    @Test
    @DisplayName("si la API está caída, continúa con el resto del catálogo")
    void apiCaidaParcialmente() {
        Material uno = new Libro("978-0000000001", "Java Efectivo", 3, null);
        Material dos = new Libro("978-0000000002", "Patrones de Diseño", 2, null);
        when(materiales.findByAutorIsNull()).thenReturn(List.of(uno, dos));

        when(pasarela.buscarPorIsbn("978-0000000001"))
                .thenThrow(new PasarelaNoDisponibleException("504 Gateway Timeout"));
        when(pasarela.buscarPorIsbn("978-0000000002"))
                .thenReturn(Optional.of(new MetadatosLibro("GoF", 1994, "Addison-Wesley")));

        assertThat(enriquecedor.enriquecerCatalogo()).isEqualTo(1);
        assertThat(dos.getAutor()).isEqualTo("GoF");
        verify(materiales, times(1)).save(dos);
    }

    @Test
    @DisplayName("no llama a la API si no hay materiales incompletos")
    void catalogoCompleto() {
        when(materiales.findByAutorIsNull()).thenReturn(List.of());

        assertThat(enriquecedor.enriquecerCatalogo()).isZero();
        verifyNoInteractions(pasarela);      // ni una petición innecesaria
    }
}

@SpringBootTest
@ActiveProfiles("test")
class GestorPrestamosIT {          // sufijo IT: la ejecuta failsafe (11-05)

    @Autowired private GestorPrestamos gestor;
    @Autowired private MaterialRepository materiales;

    // Sustituye el bean real en el contexto de Spring por un mock
    @MockitoBean private ServicioAvisos avisos;

    @Test
    void prestarPersisteYAvisa() {
        materiales.save(new Libro("978-0000000001", "Java Efectivo", 3, "J. Bloch"));

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

        assertThat(prestamo.getId()).isNotNull();      // se persistió de verdad
        verify(avisos).avisar(any(), contains("Java Efectivo"));   // no se envió correo real
    }
}

@DataJpaTest                       // solo JPA: repositorios, EntityManager, BD embebida
@Tag("integracion")
class PrestamoRepositoryIT {

    @Autowired private PrestamoRepository repositorio;
    @Autowired private TestEntityManager em;

    @Test
    @DisplayName("encuentra los préstamos vencidos sin devolver, con sus relaciones cargadas")
    void encuentraVencidos() {
        Material libro = em.persist(new Libro("978-0000000001", "Java Efectivo", 3, "J. Bloch"));
        Empleado marta = em.persist(new Empleado("[email protected]", "Marta Ruiz"));

        em.persist(new Prestamo(libro, marta, LocalDate.of(2026, 3, 1), LocalDate.of(2026, 3, 10)));
        em.persist(new Prestamo(libro, marta, LocalDate.of(2026, 3, 1), LocalDate.of(2026, 4, 10)));
        em.flush();
        em.clear();                // vacía el contexto: fuerza a leer de la BD de verdad

        List<Prestamo> vencidos = repositorio.vencidos(LocalDate.of(2026, 3, 20));

        assertThat(vencidos).hasSize(1);
        // El JOIN FETCH de 11-03 funciona: no hay LazyInitializationException
        assertThat(vencidos.get(0).getMaterial().getTitulo()).isEqualTo("Java Efectivo");
    }
}

@SpringBootTest
@Testcontainers
class PrestamoRepositoryPostgresIT {

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

    @Autowired private PrestamoRepository repositorio;

    @Test
    void funcionaContraPostgresDeVerdad() {
        // Se ejecuta contra PostgreSQL 16 real, arrancado y destruido por la prueba
    }
}

@Test
void coberturaAlta() {
    when(materiales.findByIsbn(anyString())).thenReturn(Optional.of(libro));
    when(empleados.findByCorreo(anyString())).thenReturn(Optional.of(marta));
    when(prestamos.save(any())).thenReturn(prestamo);

    gestor.prestar("978-0000000001", "[email protected]");
    // Ni una aserción. Cobertura del método: 100 %. Valor: cero.
}

@ExtendWith(MockitoExtension.class)
class ProcesadorReservasTest {

    @Mock private ReservaRepository reservas;
    @Mock private GestorPrestamos gestor;
    @Mock private PropiedadesBiblioTech propiedades;
    @Mock private PropiedadesBiblioTech.Reserva propiedadesReserva;
    @Mock private Clock reloj;
    @Mock private Reserva reserva;
    @Mock private Material material;

    @InjectMocks private ProcesadorReservas procesador;

    @Test
    void test() {
        when(propiedades.reserva()).thenReturn(propiedadesReserva);
        when(propiedadesReserva.diasCaducidad()).thenReturn(3);
        when(reloj.instant()).thenReturn(Instant.parse("2026-03-20T10:00:00Z"));
        when(reloj.getZone()).thenReturn(ZoneId.of("Europe/Madrid"));
        when(reservas.pendientes()).thenReturn(List.of(reserva));
        when(reserva.getFechaSolicitud()).thenReturn(LocalDate.of(2026, 3, 10));
        when(reserva.getMaterial()).thenReturn(material);
        when(material.getIsbn()).thenReturn("978-0000000001");
        when(gestor.hayDisponible(anyString())).thenReturn(false);

        procesador.procesarPendientes();

        verify(propiedades).reserva();
        verify(propiedadesReserva).diasCaducidad();
        verify(reservas).pendientes();
        verify(reserva).getFechaSolicitud();
        verify(reservas).caducar(reserva);
        verifyNoMoreInteractions(reservas, gestor, propiedades);
    }
}

@Service
public class GestorDevoluciones {

    private final PrestamoRepository prestamos;
    private final CalculadoraMultas calculadora;
    private final RegistroMultas multas;
    private final ProcesadorReservas reservas;
    private final ServicioAvisos avisos;
    private final Clock reloj;

    @Transactional
    public ResultadoDevolucion devolver(Long prestamoId) {

        Prestamo prestamo = prestamos.findById(prestamoId)
                .orElseThrow(() -> new PrestamoNoEncontradoException(prestamoId));

        if (prestamo.getFechaDevolucion().isPresent()) {
            throw new PrestamoYaDevueltoException(prestamoId);
        }

        LocalDate hoy = LocalDate.now(reloj);
        BigDecimal multa = calculadora.calcular(prestamo);

        prestamo.devolver(hoy);
        prestamo.getMaterial().devolverUnEjemplar();
        prestamos.save(prestamo);

        if (multa.compareTo(BigDecimal.ZERO) > 0) {
            multas.registrar(prestamo, multa);
            avisos.avisar(prestamo.getEmpleado(),
                    "Se ha registrado una multa de " + multa + " € por la devolución tardía de "
                    + prestamo.getMaterial().getTitulo());
        }

        Optional<Reserva> siguiente = reservas.siguienteDe(prestamo.getMaterial());
        siguiente.ifPresent(r -> {
            r.avisar(reloj);
            avisos.avisar(r.getEmpleado(),
                    "Ya está disponible el material que reservaste: "
                    + prestamo.getMaterial().getTitulo());
        });

        return new ResultadoDevolucion(prestamo, multa, siguiente.isPresent());
    }
}

// 1. Sin dobles: todo real
var calculadora = new CalculadoraMultas(propiedadesDePrueba(), Clock.fixed(...));
assertThat(calculadora.calcular(prestamoConRetraso(200))).isEqualByComparingTo("20.00");

// 2. Mock para verificar el comando
verify(avisos).avisar(eq(bibliotecarioResponsable), contains("último ejemplar"));

// 3. Stub para la consulta, verify(never) para la ausencia de comando
when(prestamos.countByEmpleadoAndEstado(marta, ACTIVO)).thenReturn(3L);
assertThatThrownBy(() -> gestor.prestar(...)).isInstanceOf(LimitePrestamosException.class);
verify(prestamos, never()).save(any());

// 4. Fake: coherencia entre consultas, gratis
var repositorio = new RepositorioPrestamosEnMemoria();
repositorio.save(prestamoDe(marta, "978-0000000001"));
repositorio.save(prestamoDe(marta, "978-0000000002"));
repositorio.save(prestamoDe(diego, "978-0000000001"));

var estadisticas = new EstadisticasBiblioTech(repositorio);
assertThat(estadisticas.materialMasPrestado()).contains("978-0000000001");
assertThat(estadisticas.prestamosPorEmpleado()).containsEntry("Marta Ruiz", 2L);

// 5. thenThrow: el escenario imposible de reproducir
when(pasarela.buscarPorIsbn("978-0000000001"))
        .thenThrow(new PasarelaNoDisponibleException("503 Service Unavailable"));

// 6. Captor para el contenido de la auditoría
verify(registro).anotar(captorEntrada.capture());
assertThat(captorEntrada.getValue())
        .extracting(EntradaAuditoria::operacion, EntradaAuditoria::isbn)
        .containsExactly("PRESTAMO", "978-0000000001");

// 7. Reloj fijo REAL, no mock de Clock
var procesador = new ProcesadorReservas(repositorio, gestor, propiedades,
                                        Clock.fixed(Instant.parse("2026-03-20T10:00:00Z"), MADRID));

@ExtendWith(MockitoExtension.class)
@DisplayName("ProcesadorReservas")
class ProcesadorReservasTest {

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

    @Mock private ReservaRepository reservas;      // colaborador externo: mock
    @Mock private GestorPrestamos gestor;          // colaborador con efectos: mock

    private ProcesadorReservas procesador;
    private Material libro;
    private Empleado marta;

    @BeforeEach
    void preparar() {
        // Objetos REALES: records de configuración, reloj fijo y entidades de dominio
        var propiedades = new PropiedadesBiblioTech(
                "BiblioTech",
                new PropiedadesBiblioTech.Prestamo(15, 3),
                new PropiedadesBiblioTech.Multa(new BigDecimal("0.50"), new BigDecimal("20.00")),
                new PropiedadesBiblioTech.Reserva(3));       // 3 días de caducidad

        // Construcción explícita, no @InjectMocks
        procesador = new ProcesadorReservas(reservas, gestor, propiedades, RELOJ);

        libro = new Libro("978-0000000001", "Java Efectivo", 0, "J. Bloch");
        marta = new Empleado("[email protected]", "Marta Ruiz");
    }

    @Test
    @DisplayName("caduca las reservas solicitadas hace más de 3 días")
    void caducaLasReservasAntiguas() {
        // Solicitada el 10 -> caducaba el 13 -> hoy es 20: caducada
        Reserva antigua = new Reserva(libro, marta, LocalDate.of(2026, 3, 10), 3);
        when(reservas.pendientes()).thenReturn(List.of(antigua));

        procesador.procesarPendientes();

        verify(reservas).caducar(antigua);                       // COMANDO: se verifica
        assertThat(antigua.getEstado()).isEqualTo(EstadoReserva.CADUCADA);   // ESTADO real
        verify(gestor, never()).prestar(anyString(), anyString());
    }

    @Test
    @DisplayName("no caduca una reserva dentro del plazo de 3 días")
    void noCaducaLasRecientes() {
        // Solicitada el 18 -> caduca el 21 -> hoy es 20: todavía vigente
        Reserva reciente = new Reserva(libro, marta, LocalDate.of(2026, 3, 18), 3);
        when(reservas.pendientes()).thenReturn(List.of(reciente));
        when(gestor.hayDisponible("978-0000000001")).thenReturn(false);

        procesador.procesarPendientes();

        verify(reservas, never()).caducar(any());
        assertThat(reciente.getEstado()).isEqualTo(EstadoReserva.PENDIENTE);
    }

    @Test
    @DisplayName("presta y completa la reserva cuando hay ejemplar disponible")
    void completaLaReservaSiHayEjemplar() {
        Reserva vigente = new Reserva(libro, marta, LocalDate.of(2026, 3, 18), 3);
        when(reservas.pendientes()).thenReturn(List.of(vigente));
        when(gestor.hayDisponible("978-0000000001")).thenReturn(true);

        procesador.procesarPendientes();

        verify(gestor).prestar("978-0000000001", marta.getCorreo());   // COMANDO
        verify(reservas).completar(vigente);                            // COMANDO
        verify(reservas, never()).caducar(any());
    }

    @Test
    @DisplayName("el día exacto de caducidad la reserva todavía es válida")
    void limiteDelPlazo() {
        // Solicitada el 17 -> caduca el 20 -> hoy es 20: ES el último día, aún vale
        Reserva enElLimite = new Reserva(libro, marta, LocalDate.of(2026, 3, 17), 3);
        when(reservas.pendientes()).thenReturn(List.of(enElLimite));
        when(gestor.hayDisponible(anyString())).thenReturn(false);

        procesador.procesarPendientes();

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

    @Test
    @DisplayName("no hace nada si no hay reservas pendientes")
    void sinReservas() {
        when(reservas.pendientes()).thenReturn(List.of());

        procesador.procesarPendientes();

        verifyNoInteractions(gestor);
    }
}

package com.nexussoftware.bibliotech.servicio;

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("GestorDevoluciones")
class GestorDevolucionesTest {

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

    // MOCKS: colaboradores con efectos externos o infraestructura
    @Mock private PrestamoRepository prestamos;
    @Mock private RegistroMultas multas;
    @Mock private ProcesadorReservas reservas;
    @Mock private ServicioAvisos avisos;

    @Captor private ArgumentCaptor<String> capturadorMensaje;
    @Captor private ArgumentCaptor<Empleado> capturadorEmpleado;
    @Captor private ArgumentCaptor<BigDecimal> capturadorImporte;

    private GestorDevoluciones gestor;
    private Material libro;
    private Empleado marta;
    private Empleado diego;

    @BeforeEach
    void preparar() {
        var propiedades = new PropiedadesBiblioTech(
                "BiblioTech",
                new PropiedadesBiblioTech.Prestamo(15, 3),
                new PropiedadesBiblioTech.Multa(new BigDecimal("0.50"), new BigDecimal("20.00")),
                new PropiedadesBiblioTech.Reserva(3));

        // REAL: pura, barata, determinista. Mockearla debilitaría la prueba
        var calculadora = new CalculadoraMultas(propiedades, RELOJ);

        gestor = new GestorDevoluciones(prestamos, calculadora, multas, reservas, avisos, RELOJ);

        libro  = new Libro("978-0000000001", "Java Efectivo", 2, "J. Bloch");
        marta  = new Empleado("[email protected]", "Marta Ruiz");
        diego  = new Empleado("[email protected]", "Diego Alonso");
    }

    // ============ (1) EN PLAZO ============
    @Nested
    @DisplayName("devolución en plazo")
    class EnPlazo {

        @Test
        @DisplayName("no genera multa ni aviso")
        void sinMultaNiAviso() {
            Prestamo prestamo = prestamoQueVence(HOY.plusDays(5));   // aún en plazo
            when(prestamos.findById(1L)).thenReturn(Optional.of(prestamo));
            when(reservas.siguienteDe(libro)).thenReturn(Optional.empty());

            ResultadoDevolucion resultado = gestor.devolver(1L);

            assertThat(resultado.multa()).isEqualByComparingTo("0.00");
            assertThat(resultado.hayReservaPendiente()).isFalse();
            assertThat(prestamo.getEstado()).isEqualTo(EstadoPrestamo.DEVUELTO);
            assertThat(prestamo.getFechaDevolucion()).contains(HOY);

            verify(prestamos).save(prestamo);          // COMANDO
            verifyNoInteractions(multas);              // no se registró multa
            verify(avisos, never()).avisar(any(), anyString());
        }

        // ============ (6) EJEMPLARES ============
        @Test
        @DisplayName("el material recupera un ejemplar disponible")
        void recuperaEjemplar() {
            Prestamo prestamo = prestamoQueVence(HOY.plusDays(5));
            when(prestamos.findById(1L)).thenReturn(Optional.of(prestamo));
            when(reservas.siguienteDe(libro)).thenReturn(Optional.empty());

            int antes = libro.getEjemplaresDisponibles();
            gestor.devolver(1L);

            assertThat(libro.getEjemplaresDisponibles()).isEqualTo(antes + 1);
        }
    }

    // ============ (2) CON RETRASO ============
    @Nested
    @DisplayName("devolución con retraso")
    class ConRetraso {

        @Test
        @DisplayName("registra una multa de 5,00 € por 10 días y avisa con el detalle")
        void multaDeDiezDias() {
            Prestamo prestamo = prestamoQueVence(HOY.minusDays(10));
            when(prestamos.findById(1L)).thenReturn(Optional.of(prestamo));
            when(reservas.siguienteDe(libro)).thenReturn(Optional.empty());

            ResultadoDevolucion resultado = gestor.devolver(1L);

            // La multa la calcula el código REAL: 10 días x 0,50 € = 5,00 €
            assertThat(resultado.multa()).isEqualByComparingTo("5.00");

            // COMANDO 1: registro de la multa, con captura de los argumentos reales
            verify(multas).registrar(eq(prestamo), capturadorImporte.capture());
            assertThat(capturadorImporte.getValue()).isEqualByComparingTo("5.00");

            // COMANDO 2: aviso, con el CONTENIDO verificado
            verify(avisos).avisar(capturadorEmpleado.capture(), capturadorMensaje.capture());
            assertThat(capturadorEmpleado.getValue()).isEqualTo(marta);
            assertThat(capturadorMensaje.getValue())
                    .contains("multa")
                    .contains("5.00")
                    .contains("Java Efectivo")
                    .doesNotContain("null");
        }

        @Test
        @DisplayName("la multa se limita al máximo de 20 € con retrasos muy largos")
        void multaLimitada() {
            Prestamo prestamo = prestamoQueVence(HOY.minusDays(300));
            when(prestamos.findById(1L)).thenReturn(Optional.of(prestamo));
            when(reservas.siguienteDe(libro)).thenReturn(Optional.empty());

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

    // ============ (3) CON RESERVA PENDIENTE ============
    @Nested
    @DisplayName("cuando hay una reserva pendiente del material")
    class ConReserva {

        @Test
        @DisplayName("avisa también al siguiente empleado de la cola")
        void avisaAlSiguiente() {
            Prestamo prestamo = prestamoQueVence(HOY.plusDays(5));   // en plazo: solo 1 aviso
            Reserva reservaDeDiego = new Reserva(libro, diego, HOY.minusDays(1), 3);

            when(prestamos.findById(1L)).thenReturn(Optional.of(prestamo));
            when(reservas.siguienteDe(libro)).thenReturn(Optional.of(reservaDeDiego));

            ResultadoDevolucion resultado = gestor.devolver(1L);

            assertThat(resultado.hayReservaPendiente()).isTrue();
            assertThat(reservaDeDiego.getEstado()).isEqualTo(EstadoReserva.AVISADA);
            assertThat(reservaDeDiego.getInstanteAviso()).isPresent();

            verify(avisos).avisar(capturadorEmpleado.capture(), capturadorMensaje.capture());
            assertThat(capturadorEmpleado.getValue()).isEqualTo(diego);
            assertThat(capturadorMensaje.getValue())
                    .contains("disponible")
                    .contains("Java Efectivo");
        }

        @Test
        @DisplayName("con retraso Y reserva se envían dos avisos, primero la multa")
        void dosAvisosEnOrden() {
            Prestamo prestamo = prestamoQueVence(HOY.minusDays(10));
            Reserva reservaDeDiego = new Reserva(libro, diego, HOY.minusDays(1), 3);

            when(prestamos.findById(1L)).thenReturn(Optional.of(prestamo));
            when(reservas.siguienteDe(libro)).thenReturn(Optional.of(reservaDeDiego));

            gestor.devolver(1L);

            verify(avisos, times(2))
                    .avisar(capturadorEmpleado.capture(), capturadorMensaje.capture());

            // El orden aquí SÍ es un requisito: el afectado por la multa se entera primero
            assertThat(capturadorEmpleado.getAllValues()).containsExactly(marta, diego);
            assertThat(capturadorMensaje.getAllValues().get(0)).contains("multa");
            assertThat(capturadorMensaje.getAllValues().get(1)).contains("disponible");
        }
    }

    // ============ (4) y (5) CASOS DE ERROR ============
    @Nested
    @DisplayName("casos de error")
    class Errores {

        @Test
        @DisplayName("préstamo inexistente: excepción y ningún efecto")
        void prestamoInexistente() {
            when(prestamos.findById(99L)).thenReturn(Optional.empty());

            assertThatThrownBy(() -> gestor.devolver(99L))
                    .isInstanceOf(PrestamoNoEncontradoException.class)
                    .hasMessageContaining("99");

            verify(prestamos, never()).save(any());
            verifyNoInteractions(multas, avisos, reservas);
        }

        @Test
        @DisplayName("préstamo ya devuelto: excepción y ningún efecto")
        void prestamoYaDevuelto() {
            Prestamo devuelto = prestamoQueVence(HOY.minusDays(10));
            devuelto.devolver(HOY.minusDays(5));                  // ya devuelto
            when(prestamos.findById(1L)).thenReturn(Optional.of(devuelto));

            int ejemplaresAntes = libro.getEjemplaresDisponibles();

            assertThatThrownBy(() -> gestor.devolver(1L))
                    .isInstanceOf(PrestamoYaDevueltoException.class);

            verify(prestamos, never()).save(any());
            verifyNoInteractions(multas, avisos, reservas);
            // Ningún efecto sobre el estado del material
            assertThat(libro.getEjemplaresDisponibles()).isEqualTo(ejemplaresAntes);
        }
    }

    // --- fábrica de escenarios ---
    private Prestamo prestamoQueVence(LocalDate vencimiento) {
        return new Prestamo(libro, marta, vencimiento.minusDays(15), vencimiento);
    }
}