@Test
void laMultaSeLimitaAlMaximoConfigurado() {
    Prestamo prestamo = prestamoConRetraso(200);   // 200 días × 0,50 € = 100 €
    assertThat(calculadora.calcular(prestamo)).isEqualByComparingTo("20.00");
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.10.2</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.assertj</groupId>
    <artifactId>assertj-core</artifactId>
    <version>3.25.3</version>
    <scope>test</scope>
</dependency>

src/
├── main/java/com/nexussoftware/bibliotech/     <- código de producción
├── main/resources/                             <- application.yml
├── test/java/com/nexussoftware/bibliotech/     <- LAS PRUEBAS, mismo paquete
└── test/resources/                             <- application-test.yml, ficheros de prueba

package com.nexussoftware.bibliotech.servicio;

import java.math.BigDecimal;
import java.time.*;
import java.time.temporal.ChronoUnit;
import org.springframework.stereotype.Service;

@Service
public class CalculadoraMultas {

    private final PropiedadesBiblioTech propiedades;
    private final Clock reloj;

    public CalculadoraMultas(PropiedadesBiblioTech propiedades, Clock reloj) {
        this.propiedades = propiedades;
        this.reloj = reloj;
    }

    public BigDecimal calcular(Prestamo prestamo) {
        if (prestamo.getFechaDevolucion().isPresent()) {
            return BigDecimal.ZERO;   // ya devuelto: sin multa
        }
        LocalDate hoy = LocalDate.now(reloj);
        long diasRetraso = ChronoUnit.DAYS.between(prestamo.getFechaVencimiento(), hoy);
        if (diasRetraso <= 0) {
            return BigDecimal.ZERO;   // aún en plazo
        }
        BigDecimal multa = propiedades.multa().eurosPorDia()
                .multiply(BigDecimal.valueOf(diasRetraso));
        return multa.min(propiedades.multa().maxima());
    }
}

package com.nexussoftware.bibliotech.servicio;

import static org.assertj.core.api.Assertions.assertThat;

import java.math.BigDecimal;
import java.time.*;
import org.junit.jupiter.api.Test;

class CalculadoraMultasTest {

    @Test
    void unPrestamoConCincoDiasDeRetrasoGeneraDosEurosCincuenta() {

        // PREPARAR: un reloj FIJO. "Hoy" es siempre el 20 de marzo de 2026.
        Clock relojFijo = Clock.fixed(
                Instant.parse("2026-03-20T10:00:00Z"), ZoneId.of("Europe/Madrid"));

        PropiedadesBiblioTech propiedades = propiedadesDePrueba(
                new BigDecimal("0.50"), new BigDecimal("20.00"));

        CalculadoraMultas calculadora = new CalculadoraMultas(propiedades, relojFijo);

        // Vencía el 15 -> 5 días de retraso respecto al 20
        Prestamo prestamo = new Prestamo(unLibro(), unEmpleado(),
                LocalDate.of(2026, 3, 1), LocalDate.of(2026, 3, 15));

        // ACTUAR
        BigDecimal multa = calculadora.calcular(prestamo);

        // COMPROBAR
        assertThat(multa).isEqualByComparingTo("2.50");
    }
}

mvn test

[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO] BUILD SUCCESS

@Test
void unEmpleadoNoPuedeSuperarElLimiteDePrestamos() {

    // PREPARAR (Arrange): montar el escenario
    Empleado marta = new Empleado("[email protected]", "Marta Ruiz");
    GestorPrestamos gestor = new GestorPrestamos(repositorio, calculadora, avisos, propiedades, reloj);
    gestor.prestar("978-0000000001", marta.getCorreo());
    gestor.prestar("978-0000000002", marta.getCorreo());
    gestor.prestar("978-0000000003", marta.getCorreo());

    // ACTUAR (Act): UNA sola acción, la que se está probando
    ThrowingCallable cuartoPrestamo =
            () -> gestor.prestar("978-0000000004", marta.getCorreo());

    // COMPROBAR (Assert): verificar el resultado
    assertThatThrownBy(cuartoPrestamo)
            .isInstanceOf(LimitePrestamosException.class)
            .hasMessageContaining("[email protected]");
}

@DisplayName("Cálculo de multas por retraso")
class CalculadoraMultasTest {

    @Test
    @DisplayName("Un préstamo con 5 días de retraso genera una multa de 2,50 €")
    void multaDeCincoDias() { ... }

    @Test
    @DisplayName("La multa nunca supera el máximo configurado (20 €)")
    void multaLimitadaAlMaximo() { ... }
}

Cálculo de multas por retraso
  ✔ Un préstamo con 5 días de retraso genera una multa de 2,50 €
  ✔ La multa nunca supera el máximo configurado (20 €)

assertEquals(3, gestor.contarActivos(marta),
             "Marta debería tener 3 préstamos activos tras prestar tres materiales");

assertTrue(prestamo.estaVencido(hoy),
           () -> "El préstamo vencía el " + prestamo.getFechaVencimiento() + " y hoy es " + hoy);

@Test
void prestarUnMaterialSinEjemplaresLanzaExcepcion() {

    Material agotado = new Libro("978-0000000003", "Refactorización", 0, "M. Fowler");

    // assertThrows DEVUELVE la excepción: se puede inspeccionar
    SinEjemplaresException excepcion = assertThrows(
            SinEjemplaresException.class,
            () -> agotado.prestarUnEjemplar());

    assertEquals("978-0000000003", excepcion.getIsbn());
    assertTrue(excepcion.getMessage().contains("978-0000000003"));
}

// MAL: si NO lanza la excepción, la prueba pasa igualmente
@Test
void mal() {
    try {
        agotado.prestarUnEjemplar();
    } catch (SinEjemplaresException e) {
        assertEquals("978-0000000003", e.getIsbn());
    }
    // Si no se lanza nada, no se ejecuta ningún catch... y la prueba es verde.
}

@Test
void unPrestamoNuevoTieneLosDatosCorrectos() {

    LocalDate hoy = LocalDate.of(2026, 3, 1);
    Prestamo prestamo = new Prestamo(unLibro(), unEmpleado(), hoy, 15);

    assertAll("datos del préstamo recién creado",
            () -> assertEquals(hoy, prestamo.getFechaPrestamo()),
            () -> assertEquals(hoy.plusDays(15), prestamo.getFechaVencimiento()),
            () -> assertEquals(EstadoPrestamo.ACTIVO, prestamo.getEstado()),
            () -> assertTrue(prestamo.getFechaDevolucion().isEmpty()),
            () -> assertNotNull(prestamo.getMaterial()));
}

// JUnit
assertEquals(3, prestamos.size());

org.opentest4j.AssertionFailedError: expected: <3> but was: <2>

// AssertJ
assertThat(prestamos).hasSize(3);

Expected size: 3 but was: 2 in:
  [Prestamo{isbn='978-0000000001', empleado='Marta Ruiz', vence=2026-03-15},
   Prestamo{isbn='978-0000000002', empleado='Marta Ruiz', vence=2026-03-16}]

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

// Encadenamiento sobre colecciones
assertThat(prestamosVencidos)
        .hasSize(2)
        .extracting(Prestamo::getEmpleado)
        .extracting(Empleado::getNombre)
        .containsExactlyInAnyOrder("Marta Ruiz", "Diego Alonso");

// BigDecimal: compara VALOR, no escala. 2.50 vs 2.5 no falla.
assertThat(multa).isEqualByComparingTo("2.50");

// Optional (10-04)
assertThat(repositorio.buscarPorIsbn("978-0000000001"))
        .isPresent()
        .get()
        .extracting(Material::getTitulo)
        .isEqualTo("Java Efectivo");

// Excepciones, con más detalle
assertThatThrownBy(() -> gestor.prestar("978-9999999999", "[email protected]"))
        .isInstanceOf(MaterialNoEncontradoException.class)
        .hasMessageContaining("978-9999999999")
        .hasNoCause();

// Comparar objetos campo a campo, ignorando el id generado
assertThat(prestamoGuardado)
        .usingRecursiveComparison()
        .ignoringFields("id", "version")
        .isEqualTo(prestamoEsperado);

// Predicados sobre todos los elementos
assertThat(prestamosActivos)
        .isNotEmpty()
        .allMatch(p -> p.getFechaDevolucion().isEmpty())
        .allSatisfy(p -> assertThat(p.getFechaVencimiento()).isAfter(p.getFechaPrestamo()));

class GestorPrestamosTest {

    private Clock relojFijo;
    private CalculadoraMultas calculadora;
    private GestorPrestamos gestor;
    private Empleado marta;

    @BeforeAll
    static void prepararTodaLaClase() {
        // UNA vez, antes de todas las pruebas. static (salvo con @TestInstance PER_CLASS)
        // Para recursos caros y COMPARTIDOS: arrancar un contenedor, cargar un fichero grande.
    }

    @BeforeEach
    void prepararCadaPrueba() {
        // ANTES DE CADA prueba: estado limpio, sin contaminación entre pruebas
        relojFijo = Clock.fixed(Instant.parse("2026-03-20T10:00:00Z"), ZoneId.of("Europe/Madrid"));
        calculadora = new CalculadoraMultas(propiedadesDePrueba(), relojFijo);
        gestor = new GestorPrestamos(new RepositorioEnMemoria(), calculadora,
                                     new AvisosEnMemoria(), propiedadesDePrueba(), relojFijo);
        marta = new Empleado("[email protected]", "Marta Ruiz");
    }

    @AfterEach
    void limpiarCadaPrueba() {
        // Después de cada prueba. Con recursos gestionados, rara vez necesario.
    }

    @AfterAll
    static void limpiarTodaLaClase() {
        // Una vez, al final. Cerrar lo abierto en @BeforeAll.
    }
}

private Prestamo prestamoConRetrasoDe(int dias) {
    LocalDate hoy = LocalDate.now(relojFijo);
    return new Prestamo(unLibro(), marta, hoy.minusDays(15 + dias), hoy.minusDays(dias));
}

private Material unLibro() {
    return new Libro("978-0000000001", "Java Efectivo", 3, "J. Bloch");
}

class ContadorTest {

    private int contador = 0;   // se reinicia en CADA prueba

    @Test void primera()  { contador++; assertEquals(1, contador); }   // pasa
    @Test void segunda()  { contador++; assertEquals(1, contador); }   // TAMBIÉN pasa
}

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class CatalogoTest {

    private List<Material> catalogo;   // compartido por TODAS las pruebas

    @BeforeAll
    void cargarCatalogo() {            // ya no necesita ser static
        catalogo = cargarCatalogoGrande();
    }
}

@Test
@Disabled("Pendiente de decidir la política de multas para revistas (BIB-142)")
void multaDeRevistaEsLaMitad() { ... }

@Test
@EnabledOnOs(OS.LINUX)
void rutasDePermisosPosix() { ... }

@Test
@DisabledOnOs(OS.WINDOWS)
void enlacesSimbolicos() { ... }

@Test
@EnabledOnJre(JRE.JAVA_21)
void hilosVirtuales() { ... }                       // retoma 10-06

@Test
@EnabledIfSystemProperty(named = "pruebas.integracion", matches = "true")
void contraLaBaseDeDatosReal() { ... }

@Test
@EnabledIfEnvironmentVariable(named = "CI", matches = "true")
void soloEnIntegracionContinua() { ... }

@Test void multaDeUnDia()    { assertThat(calcular(1)).isEqualByComparingTo("0.50"); }
@Test void multaDeDosDias()  { assertThat(calcular(2)).isEqualByComparingTo("1.00"); }
@Test void multaDeCincoDias(){ assertThat(calcular(5)).isEqualByComparingTo("2.50"); }
@Test void multaDeDiezDias() { assertThat(calcular(10)).isEqualByComparingTo("5.00"); }
// ... ocho más

@ParameterizedTest(name = "{0} días de retraso -> {1} €")
@CsvSource({
        "  1,  0.50",
        "  2,  1.00",
        "  5,  2.50",
        " 10,  5.00",
        " 39, 19.50",
        " 40, 20.00",   // justo el máximo
        " 41, 20.00",   // pasado el máximo: se limita
        "200, 20.00",   // muy pasado: sigue limitado
        "  0,  0.00",   // vence hoy: sin retraso
        " -1,  0.00",   // vence mañana
        " -5,  0.00",
        "-30,  0.00"
})
void laMultaSeCalculaSegunLosDiasDeRetraso(int diasRetraso, BigDecimal multaEsperada) {
    Prestamo prestamo = prestamoConRetrasoDe(diasRetraso);
    assertThat(calculadora.calcular(prestamo)).isEqualByComparingTo(multaEsperada);
}

laMultaSeCalculaSegunLosDiasDeRetraso
  ✔ 1 días de retraso -> 0.50 €
  ✔ 5 días de retraso -> 2.50 €
  ✔ 40 días de retraso -> 20.00 €
  ✔ 41 días de retraso -> 20.00 €
  ...

// Todos los estados del enum (04-07)
@ParameterizedTest
@EnumSource(EstadoPrestamo.class)
void todoEstadoTieneDescripcionNoVacia(EstadoPrestamo estado) {
    assertThat(estado.getDescripcion()).isNotBlank();
}

// Solo algunos
@ParameterizedTest
@EnumSource(value = EstadoPrestamo.class, names = {"ACTIVO", "VENCIDO"})
void losEstadosNoFinalizadosPermitenDevolucion(EstadoPrestamo estado) {
    assertThat(estado.permiteDevolucion()).isTrue();
}

// Validación de entradas inválidas: null, vacío y basura
@ParameterizedTest
@NullAndEmptySource
@ValueSource(strings = { " ", "abc", "978", "978-000000000X", "1234567890123" })
void unIsbnInvalidoEsRechazado(String isbnInvalido) {
    assertThatThrownBy(() -> new Isbn(isbnInvalido))
            .isInstanceOf(IsbnInvalidoException.class);
}

class GestorPrestamosTest {

    // El método debe ser static (o la clase, @TestInstance(PER_CLASS))
    static Stream<Arguments> escenariosDePrestamo() {
        return Stream.of(
            Arguments.of("Empleado sin préstamos, material disponible",
                         0, 3, true,  null),
            Arguments.of("Empleado en el límite",
                         3, 3, false, LimitePrestamosException.class),
            Arguments.of("Material sin ejemplares",
                         1, 0, false, SinEjemplaresException.class),
            Arguments.of("Empleado a un préstamo del límite",
                         2, 5, true,  null)
        );
    }

    @ParameterizedTest(name = "{0}")
    @MethodSource("escenariosDePrestamo")
    void escenariosDePrestamoDeBiblioTech(String descripcion,
                                          int prestamosActivos,
                                          int ejemplaresDisponibles,
                                          boolean deberiaTenerExito,
                                          Class<? extends Exception> excepcionEsperada) {

        // PREPARAR
        Material material = new Libro("978-0000000001", "Java Efectivo",
                                      ejemplaresDisponibles, "J. Bloch");
        Empleado marta = new Empleado("[email protected]", "Marta Ruiz");
        repositorio.guardar(material);
        repositorio.guardar(marta);
        for (int i = 0; i < prestamosActivos; i++) {
            repositorio.guardarPrestamo(new Prestamo(otroLibro(i), marta, hoy(), 15));
        }

        // ACTUAR y COMPROBAR
        if (deberiaTenerExito) {
            assertThat(gestor.prestar("978-0000000001", marta.getCorreo())).isNotNull();
        } else {
            assertThatThrownBy(() -> gestor.prestar("978-0000000001", marta.getCorreo()))
                    .isInstanceOf(excepcionEsperada);
        }
    }
}

static Stream<Material> materialesDePrueba() {
    return Stream.of(
        new Libro("978-0000000001", "Java Efectivo", 3, "J. Bloch"),
        new Revista("978-0000000010", "Java Magazine", 5, 42),
        new Dvd("978-0000000020", "Curso de Java", 1, 180));
}

@ParameterizedTest
@MethodSource("materialesDePrueba")
void todoMaterialSePuedePrestarSiHayEjemplares(Material material) {
    int antes = material.getEjemplaresDisponibles();
    material.prestarUnEjemplar();
    assertThat(material.getEjemplaresDisponibles()).isEqualTo(antes - 1);
}

@DisplayName("GestorPrestamos")
class GestorPrestamosTest {

    private GestorPrestamos gestor;
    private Empleado marta;

    @BeforeEach
    void prepararComun() {
        gestor = crearGestor();
        marta = new Empleado("[email protected]", "Marta Ruiz");
    }

    @Nested
    @DisplayName("cuando el empleado no tiene préstamos activos")
    class SinPrestamosActivos {

        @Test
        @DisplayName("puede prestar un material disponible")
        void puedePrestar() {
            Prestamo prestamo = gestor.prestar("978-0000000001", marta.getCorreo());
            assertThat(prestamo).isNotNull();
        }

        @Test
        @DisplayName("la fecha de vencimiento son 15 días después")
        void vencimientoCorrecto() {
            Prestamo prestamo = gestor.prestar("978-0000000001", marta.getCorreo());
            assertThat(prestamo.getFechaVencimiento())
                    .isEqualTo(LocalDate.now(relojFijo).plusDays(15));
        }
    }

    @Nested
    @DisplayName("cuando el empleado está en el límite de préstamos")
    class EnElLimite {

        @BeforeEach
        void prestarHastaElLimite() {          // preparación PROPIA de este escenario
            gestor.prestar("978-0000000001", marta.getCorreo());
            gestor.prestar("978-0000000002", marta.getCorreo());
            gestor.prestar("978-0000000003", marta.getCorreo());
        }

        @Test
        @DisplayName("no puede prestar más")
        void noPuedePrestarMas() {
            assertThatThrownBy(() -> gestor.prestar("978-0000000004", marta.getCorreo()))
                    .isInstanceOf(LimitePrestamosException.class);
        }

        @Test
        @DisplayName("puede prestar de nuevo tras devolver uno")
        void puedeTrasDevolver() {
            gestor.devolver("978-0000000001", marta.getCorreo());
            assertThat(gestor.prestar("978-0000000004", marta.getCorreo())).isNotNull();
        }
    }
}

GestorPrestamos
  cuando el empleado no tiene préstamos activos
    ✔ puede prestar un material disponible
    ✔ la fecha de vencimiento son 15 días después
  cuando el empleado está en el límite de préstamos
    ✔ no puede prestar más
    ✔ puede prestar de nuevo tras devolver uno

@Tag("rapida")
class CalculadoraMultasTest { ... }

@Tag("lenta")
@Tag("integracion")
class PrestamoRepositoryIT { ... }

mvn test -Dgroups="rapida"                        # solo las rápidas
mvn test -DexcludedGroups="lenta,integracion"     # todo menos lo lento

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
        <excludedGroups>integracion</excludedGroups>
    </configuration>
</plugin>

class EscrituraAtomicaTest {

    @TempDir
    Path directorioTemporal;   // JUnit lo crea antes y lo BORRA después, solo

    @Test
    void escribeElFicheroCompletoONoLoEscribe() throws IOException {

        Path destino = directorioTemporal.resolve("catalogo.csv");
        EscrituraAtomica escritura = new EscrituraAtomica();

        escritura.escribir(destino, List.of(
                "isbn;titulo;ejemplares",
                "978-0000000001;Java Efectivo;3"));

        assertThat(destino).exists();
        assertThat(Files.readAllLines(destino, StandardCharsets.UTF_8))
                .containsExactly(
                        "isbn;titulo;ejemplares",
                        "978-0000000001;Java Efectivo;3");
    }

    @Test
    void noDejaFicherosTemporalesTrasUnaEscrituraCorrecta() throws IOException {
        Path destino = directorioTemporal.resolve("catalogo.csv");
        new EscrituraAtomica().escribir(destino, List.of("linea"));

        try (Stream<Path> ficheros = Files.list(directorioTemporal)) {
            assertThat(ficheros).containsExactly(destino);   // ni .tmp ni .bak
        }
    }

    @Test
    void elFicheroOriginalSobreviveSiLaEscrituraFalla() throws IOException {
        Path destino = directorioTemporal.resolve("catalogo.csv");
        Files.writeString(destino, "contenido original", StandardCharsets.UTF_8);

        assertThatThrownBy(() -> new EscrituraAtomica().escribir(destino, lineasQueFallan()))
                .isInstanceOf(PersistenciaException.class);

        // La garantía de la escritura atómica: el original intacto
        assertThat(Files.readString(destino, StandardCharsets.UTF_8))
                .isEqualTo("contenido original");
    }
}

// NO TESTEABLE: crea sus dependencias
public class GestorPrestamos {
    private final Repositorio repo = new RepositorioJpa();   // necesita base de datos
    private final ServicioAvisos avisos = new AvisosSmtp();  // necesita servidor SMTP
}

// TESTEABLE: las recibe
public class GestorPrestamos {
    public GestorPrestamos(Repositorio repo, ServicioAvisos avisos) { ... }
}

// Pura: se prueba con una línea
public static BigDecimal calcularMulta(long diasRetraso, BigDecimal porDia, BigDecimal maxima) {
    if (diasRetraso <= 0) return BigDecimal.ZERO;
    return porDia.multiply(BigDecimal.valueOf(diasRetraso)).min(maxima);
}

// MAL: busca su estado en un lugar global
public BigDecimal calcular(Prestamo p) {
    BigDecimal porDia = ReglasNegocio.multaPorDia();   // static: no se puede sustituir
    LocalDate hoy = LocalDate.now();                   // reloj del sistema
    ...
}

// BIEN: lo recibe
public BigDecimal calcular(Prestamo p) {
    BigDecimal porDia = propiedades.multa().eurosPorDia();   // inyectado
    LocalDate hoy = LocalDate.now(reloj);                    // inyectado
    ...
}

public BigDecimal calcular(Prestamo prestamo) {
    LocalDate hoy = LocalDate.now();   // el reloj del SISTEMA
    ...
}

public BigDecimal calcular(Prestamo prestamo) {
    LocalDate hoy = LocalDate.now(reloj);   // el reloj INYECTADO
    ...
}

class CalculadoraMultasTest {

    // "Hoy" es SIEMPRE el 20 de marzo de 2026. En cualquier máquina, cualquier día.
    private static final Clock RELOJ_FIJO = Clock.fixed(
            Instant.parse("2026-03-20T10:00:00Z"), ZoneId.of("Europe/Madrid"));

    private CalculadoraMultas calculadora;

    @BeforeEach
    void preparar() {
        calculadora = new CalculadoraMultas(propiedadesDePrueba(), RELOJ_FIJO);
    }

    @Test
    void unPrestamoVencidoHaceCincoDiasGeneraDosEurosCincuenta() {
        Prestamo prestamo = prestamoQueVencioEl(LocalDate.of(2026, 3, 15));
        assertThat(calculadora.calcular(prestamo)).isEqualByComparingTo("2.50");
    }

    @Test
    void unPrestamoQueVenceHoyNoGeneraMulta() {
        Prestamo prestamo = prestamoQueVencioEl(LocalDate.of(2026, 3, 20));
        assertThat(calculadora.calcular(prestamo)).isEqualByComparingTo("0.00");
    }

    @Test
    void unPrestamoQueVenceMananaNoGeneraMulta() {
        Prestamo prestamo = prestamoQueVencioEl(LocalDate.of(2026, 3, 21));
        assertThat(calculadora.calcular(prestamo)).isEqualByComparingTo("0.00");
    }
}

@Test
void laMultaCreceUnEuroMedioPorCadaDiaQuePasa() {

    LocalDate vencimiento = LocalDate.of(2026, 3, 15);
    Prestamo prestamo = prestamoQueVencioEl(vencimiento);

    // Día 16: 1 día de retraso
    var dia16 = new CalculadoraMultas(propiedades, relojEn(LocalDate.of(2026, 3, 16)));
    assertThat(dia16.calcular(prestamo)).isEqualByComparingTo("0.50");

    // Día 20: 5 días
    var dia20 = new CalculadoraMultas(propiedades, relojEn(LocalDate.of(2026, 3, 20)));
    assertThat(dia20.calcular(prestamo)).isEqualByComparingTo("2.50");

    // Día 100: limitado al máximo
    var dia100 = new CalculadoraMultas(propiedades, relojEn(LocalDate.of(2026, 6, 23)));
    assertThat(dia100.calcular(prestamo)).isEqualByComparingTo("20.00");
}

private static Clock relojEn(LocalDate fecha) {
    return Clock.fixed(fecha.atStartOfDay(ZoneId.of("Europe/Madrid")).toInstant(),
                       ZoneId.of("Europe/Madrid"));
}

// NO SE PUEDE PROBAR
public class CalculadoraMultas {
    public static BigDecimal calcular(Prestamo p) {
        BigDecimal porDia = ReglasNegocio.multaPorDia();   // static: no se sustituye
        LocalDate hoy = LocalDate.now();                   // reloj del sistema
        ...
    }
}

// NO SE PUEDE PROBAR SIN RED
public class EnriquecedorCatalogo {
    public Material enriquecer(Material material) {
        ClienteMetadatos cliente = new ClienteMetadatos();   // llama a una API real
        return cliente.enriquecer(material);
    }
}

public void procesar(Prestamo p) {
    calcular(p);
    enviarCorreo(p);                    // envía un correo DE VERDAD
    System.out.println("Procesado");    // no se puede comprobar
    ficheroLog.append(...);             // escribe en disco
}

// FRÁGIL: comprueba CÓMO se hace
verify(repositorio).findById(1L);
verify(repositorio).save(any());
verify(calculadora).calcular(any());
// Si mañana se usa findByIsbn, la prueba falla aunque el resultado sea idéntico.

// ROBUSTA: comprueba QUÉ resultado se obtiene
assertThat(gestor.prestar("978-0000000001", "[email protected]"))
        .extracting(Prestamo::getFechaVencimiento)
        .isEqualTo(LocalDate.of(2026, 3, 16));

// MAL
servicio.procesarAsincrono();
Thread.sleep(1000);              // ¿y si tarda 1100 ms en la integración continua?
assertThat(resultado).isNotNull();

@Test
void pruebaDePrestamo() {
    Prestamo p = gestor.prestar("978-0000000001", "[email protected]");
    assertNotNull(p);       // ¿y qué? No comprueba ninguna regla
}

// Inútil: si la fórmula está mal, la prueba está mal igual
BigDecimal esperado = porDia.multiply(BigDecimal.valueOf(dias)).min(maxima);
assertThat(calculadora.calcular(prestamo)).isEqualByComparingTo(esperado);

@Test
void elCatalogoConcurrenteSoportaCienHilosSimultaneos() throws Exception {

    CatalogoConcurrente catalogo = new CatalogoConcurrente();
    int hilos = 100, operaciones = 1000;

    try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {   // 10-06
        CountDownLatch listos = new CountDownLatch(hilos);
        CountDownLatch salida = new CountDownLatch(1);

        for (int i = 0; i < hilos; i++) {
            executor.submit(() -> {
                listos.countDown();
                salida.await();                    // todos empiezan A LA VEZ
                for (int j = 0; j < operaciones; j++) catalogo.incrementarConsultas();
                return null;
            });
        }
        listos.await(5, TimeUnit.SECONDS);
        salida.countDown();                        // disparo simultáneo
    }   // el cierre del executor espera a que terminen

    assertThat(catalogo.getConsultas()).isEqualTo((long) hilos * operaciones);
}

mvn test                                     # compila y ejecuta las pruebas unitarias
mvn test -Dtest=CalculadoraMultasTest        # solo una clase
mvn test -Dtest=CalculadoraMultasTest#multa* # solo métodos que empiecen por "multa"
mvn test -Dgroups="rapida"                   # solo las etiquetadas
mvn verify                                   # unitarias + integración (failsafe)
mvn package -DskipTests                      # empaqueta SIN ejecutar pruebas

[ERROR] Failures:
[ERROR]   CalculadoraMultasTest.laMultaSeLimitaAlMaximo:47
           expected: 20.00 but was: 100.00
[INFO] Tests run: 24, Failures: 1, Errors: 0, Skipped: 0
[INFO] BUILD FAILURE

@Test
void cobertura100() {
    calculadora.calcular(prestamo);   // se ejecuta... y no se comprueba nada
}

@SpringBootTest
class BiblioTechApplicationTests {

    @Autowired
    private GestorPrestamos gestor;

    @Test
    void elContextoSeCargaCorrectamente() {
        assertThat(gestor).isNotNull();
    }
}

@DataJpaTest
class PrestamoRepositoryTest {

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

    @Test
    void encuentraLosPrestamosVencidosSinDevolver() {
        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.flush();

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

        assertThat(vencidos).hasSize(1)
                .first().extracting(p -> p.getMaterial().getTitulo())
                .isEqualTo("Java Efectivo");
    }
}

src/test/java/com/nexussoftware/bibliotech/
├── dominio/
│   ├── PrestamoTest.java              <- reglas de vencimiento y devolución
│   ├── MaterialTest.java              <- ejemplares disponibles
│   └── IsbnTest.java                  <- validación
├── servicio/
│   ├── CalculadoraMultasTest.java     <- multas, con Clock fijo
│   └── GestorPrestamosTest.java       <- límite de préstamos
├── persistencia/
│   └── EscrituraAtomicaTest.java      <- @TempDir
└── BiblioTechApplicationTests.java    <- @SpringBootTest: carga del contexto

package com.nexussoftware.bibliotech.servicio;

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

import java.math.BigDecimal;
import java.time.*;
import org.junit.jupiter.api.*;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

@DisplayName("Cálculo de multas de BiblioTech")
class CalculadoraMultasTest {

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

    private CalculadoraMultas calculadora;
    private Empleado marta;
    private Material libro;

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

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

    @Nested
    @DisplayName("cuando el préstamo sigue en plazo")
    class EnPlazo {

        @Test
        @DisplayName("no hay multa si vence dentro de una semana")
        void sinMultaSiVenceEnUnaSemana() {
            assertThat(calculadora.calcular(prestamoQueVence(HOY.plusDays(7))))
                    .isEqualByComparingTo("0.00");
        }

        @Test
        @DisplayName("no hay multa el mismo día del vencimiento")
        void sinMultaElDiaDelVencimiento() {
            assertThat(calculadora.calcular(prestamoQueVence(HOY)))
                    .isEqualByComparingTo("0.00");
        }
    }

    @Nested
    @DisplayName("cuando el préstamo está vencido")
    class Vencido {

        @ParameterizedTest(name = "{0} días de retraso -> {1} €")
        @CsvSource({
                "  1,  0.50", "  2,  1.00", "  5,  2.50", " 10,  5.00",
                " 39, 19.50", " 40, 20.00", " 41, 20.00", "200, 20.00"
        })
        @DisplayName("la multa es 0,50 € por día hasta el máximo de 20 €")
        void multaPorDiasDeRetraso(int dias, BigDecimal esperada) {
            assertThat(calculadora.calcular(prestamoQueVence(HOY.minusDays(dias))))
                    .isEqualByComparingTo(esperada);
        }

        @Test
        @DisplayName("la multa nunca supera el máximo configurado")
        void nuncaSuperaElMaximo() {
            assertThat(calculadora.calcular(prestamoQueVence(HOY.minusYears(2))))
                    .isEqualByComparingTo("20.00");
        }
    }

    @Nested
    @DisplayName("cuando el préstamo ya se devolvió")
    class Devuelto {

        @Test
        @DisplayName("no hay multa aunque se devolviera tarde")
        void sinMultaTrasLaDevolucion() {
            Prestamo prestamo = prestamoQueVence(HOY.minusDays(30));
            prestamo.devolver(HOY.minusDays(10));

            assertThat(calculadora.calcular(prestamo)).isEqualByComparingTo("0.00");
        }
    }

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

mvn test

[INFO] Running com.nexussoftware.bibliotech.servicio.CalculadoraMultasTest
[INFO] Tests run: 12, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.089 s
[INFO] Running com.nexussoftware.bibliotech.dominio.PrestamoTest
[INFO] Tests run: 8, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.021 s
...
[INFO] Tests run: 41, Failures: 0, Errors: 0, Skipped: 0
[INFO] BUILD SUCCESS
[INFO] Total time: 6.412 s

@Entity
public class Prestamo {

    @Id @GeneratedValue private Long id;
    @ManyToOne(fetch = FetchType.LAZY) private Material material;
    @ManyToOne(fetch = FetchType.LAZY) private Empleado empleado;
    private LocalDate fechaPrestamo;
    private LocalDate fechaVencimiento;
    private LocalDate fechaDevolucion;
    @Enumerated(EnumType.STRING) private EstadoPrestamo estado;

    public Prestamo(Material material, Empleado empleado, LocalDate fechaPrestamo, int dias) {
        this.material = material;
        this.empleado = empleado;
        this.fechaPrestamo = fechaPrestamo;
        this.fechaVencimiento = fechaPrestamo.plusDays(dias);
        this.estado = EstadoPrestamo.ACTIVO;
    }

    public boolean estaVencido(LocalDate hoy) {
        return fechaDevolucion == null && hoy.isAfter(fechaVencimiento);
    }

    public void devolver(LocalDate fecha) {
        if (fechaDevolucion != null) {
            throw new PrestamoYaDevueltoException(id);
        }
        if (fecha.isBefore(fechaPrestamo)) {
            throw new FechaInvalidaException("No se puede devolver antes de prestar");
        }
        this.fechaDevolucion = fecha;
        this.estado = EstadoPrestamo.DEVUELTO;
    }

    public Optional<LocalDate> getFechaDevolucion() {
        return Optional.ofNullable(fechaDevolucion);
    }
}

public class ServicioAvisosVencimiento {

    public int enviarAvisosDelDia() {
        int enviados = 0;
        LocalDate hoy = LocalDate.now();

        RepositorioPrestamos repositorio = new RepositorioPrestamosJpa();
        List<Prestamo> prestamos = repositorio.buscarTodos();

        for (Prestamo p : prestamos) {
            long dias = ChronoUnit.DAYS.between(hoy, p.getFechaVencimiento());
            if (dias == Integer.parseInt(ReglasNegocio.get("aviso.dias.antelacion", "2"))) {
                ClienteCorreo correo = new ClienteCorreo("smtp.nexussoftware.com", 587);
                correo.enviar(p.getEmpleado().getCorreo(),
                              "Tu préstamo de " + p.getMaterial().getTitulo() + " vence pronto");
                System.out.println("Aviso enviado a " + p.getEmpleado().getCorreo());
                enviados++;
            }
        }
        return enviados;
    }
}

public class GestorRenovaciones {

    private static final int MAX_RENOVACIONES = 2;
    private final Clock reloj;

    public GestorRenovaciones(Clock reloj) { this.reloj = reloj; }

    public LocalDate renovar(Prestamo prestamo, int dias) {
        if (prestamo.getRenovaciones() >= MAX_RENOVACIONES) {
            throw new LimiteRenovacionesException(prestamo.getId());
        }
        if (prestamo.getFechaDevolucion().isPresent()) {
            throw new PrestamoYaDevueltoException(prestamo.getId());
        }

        LocalDate hoy = LocalDate.now(reloj);
        LocalDate nuevaFecha = prestamo.getFechaVencimiento().plusDays(dias);

        if (nuevaFecha.isBefore(hoy)) {
            nuevaFecha = hoy;
        }

        prestamo.actualizarVencimiento(nuevaFecha);
        prestamo.incrementarRenovaciones();
        return nuevaFecha;
    }
}

package com.nexussoftware.bibliotech.dominio;

import static org.assertj.core.api.Assertions.*;
import static org.junit.jupiter.api.Assertions.assertAll;

import java.time.LocalDate;
import org.junit.jupiter.api.*;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

@DisplayName("Préstamo")
class PrestamoTest {

    private static final LocalDate FECHA_PRESTAMO = LocalDate.of(2026, 3, 1);
    private static final int DIAS = 15;
    private static final LocalDate VENCIMIENTO = LocalDate.of(2026, 3, 16);

    private Material libro;
    private Empleado marta;
    private Prestamo prestamo;

    @BeforeEach
    void preparar() {
        libro = new Libro("978-0000000001", "Java Efectivo", 3, "J. Bloch");
        marta = new Empleado("[email protected]", "Marta Ruiz");
        prestamo = new Prestamo(libro, marta, FECHA_PRESTAMO, DIAS);
    }

    @Nested
    @DisplayName("recién creado")
    class RecienCreado {

        @Test
        @DisplayName("(1) tiene todos los datos correctos")
        void datosCorrectos() {
            assertAll("datos del préstamo",
                    () -> assertThat(prestamo.getMaterial()).isEqualTo(libro),
                    () -> assertThat(prestamo.getEmpleado()).isEqualTo(marta),
                    () -> assertThat(prestamo.getFechaPrestamo()).isEqualTo(FECHA_PRESTAMO),
                    () -> assertThat(prestamo.getFechaVencimiento()).isEqualTo(VENCIMIENTO),
                    () -> assertThat(prestamo.getEstado()).isEqualTo(EstadoPrestamo.ACTIVO),
                    () -> assertThat(prestamo.getFechaDevolucion()).isEmpty());
        }
    }

    @Nested
    @DisplayName("comprobación de vencimiento")
    class Vencimiento {

        // (2) cinco casos, incluidos los límites
        @ParameterizedTest(name = "el {0} -> vencido = {1}")
        @CsvSource({
                "2026-03-01, false",   // el día del préstamo
                "2026-03-15, false",   // víspera del vencimiento
                "2026-03-16, false",   // LÍMITE: el mismo día NO está vencido
                "2026-03-17, true",    // LÍMITE: el día siguiente SÍ
                "2026-04-30, true",    // mucho después
                "2027-01-01, true"
        })
        void estaVencidoSegunLaFecha(LocalDate hoy, boolean esperado) {
            assertThat(prestamo.estaVencido(hoy)).isEqualTo(esperado);
        }
    }

    @Nested
    @DisplayName("al devolver")
    class Devolucion {

        @Test
        @DisplayName("(3) registra la fecha y cambia el estado")
        void devolucionCorrecta() {
            LocalDate fechaDevolucion = LocalDate.of(2026, 3, 10);

            prestamo.devolver(fechaDevolucion);

            assertAll(
                    () -> assertThat(prestamo.getFechaDevolucion()).contains(fechaDevolucion),
                    () -> assertThat(prestamo.getEstado()).isEqualTo(EstadoPrestamo.DEVUELTO));
        }

        @Test
        @DisplayName("(4) devolver dos veces lanza PrestamoYaDevueltoException")
        void noSePuedeDevolverDosVeces() {
            prestamo.devolver(LocalDate.of(2026, 3, 10));

            assertThatThrownBy(() -> prestamo.devolver(LocalDate.of(2026, 3, 11)))
                    .isInstanceOf(PrestamoYaDevueltoException.class);
        }

        @Test
        @DisplayName("(5) devolver antes de prestar lanza FechaInvalidaException")
        void noSePuedeDevolverAntesDePrestar() {
            assertThatThrownBy(() -> prestamo.devolver(FECHA_PRESTAMO.minusDays(1)))
                    .isInstanceOf(FechaInvalidaException.class)
                    .hasMessageContaining("antes de prestar");
        }

        @Test
        @DisplayName("(6) un préstamo devuelto nunca está vencido, aunque se devolviera tarde")
        void devueltoNuncaEstaVencido() {
            prestamo.devolver(LocalDate.of(2026, 4, 30));   // 45 días tarde

            assertThat(prestamo.estaVencido(LocalDate.of(2027, 1, 1))).isFalse();
        }
    }
}

package com.nexussoftware.bibliotech.servicio;

import java.time.Clock;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.List;
import org.slf4j.*;
import org.springframework.stereotype.Service;

@Service
public class ServicioAvisosVencimiento {

    private static final Logger log = LoggerFactory.getLogger(ServicioAvisosVencimiento.class);

    private final RepositorioPrestamos repositorio;    // interfaz
    private final ServicioAvisos avisos;               // interfaz
    private final PropiedadesBiblioTech propiedades;   // configuración inyectada
    private final Clock reloj;                         // tiempo controlable

    public ServicioAvisosVencimiento(RepositorioPrestamos repositorio,
                                     ServicioAvisos avisos,
                                     PropiedadesBiblioTech propiedades,
                                     Clock reloj) {
        this.repositorio = repositorio;
        this.avisos = avisos;
        this.propiedades = propiedades;
        this.reloj = reloj;
    }

    public int enviarAvisosDelDia() {
        LocalDate hoy = LocalDate.now(reloj);
        int diasAntelacion = propiedades.aviso().diasAntelacion();

        List<Prestamo> aAvisar = repositorio.buscarActivos().stream()
                .filter(p -> ChronoUnit.DAYS.between(hoy, p.getFechaVencimiento()) == diasAntelacion)
                .toList();

        aAvisar.forEach(p -> {
            avisos.avisar(p.getEmpleado(),
                    "Tu préstamo de " + p.getMaterial().getTitulo() + " vence pronto");
            log.info("Aviso enviado a {}", p.getEmpleado().getCorreo());
        });

        return aAvisar.size();
    }
}

package com.nexussoftware.bibliotech.servicio;

import static org.assertj.core.api.Assertions.assertThat;

import java.time.*;
import java.util.*;
import org.junit.jupiter.api.*;

@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);

    // Doble de prueba tipo FAKE: implementación real, pero en memoria
    static class RepositorioEnMemoria implements RepositorioPrestamos {
        private final List<Prestamo> prestamos = new ArrayList<>();
        void anadir(Prestamo p) { prestamos.add(p); }
        @Override public List<Prestamo> buscarActivos() { return List.copyOf(prestamos); }
    }

    // Doble tipo SPY casero: registra lo que se le pide
    static class AvisosRegistrados implements ServicioAvisos {
        final List<String> destinatarios = new ArrayList<>();
        final List<String> mensajes = new ArrayList<>();
        @Override public void avisar(Empleado destinatario, String mensaje) {
            destinatarios.add(destinatario.getCorreo());
            mensajes.add(mensaje);
        }
    }

    private RepositorioEnMemoria repositorio;
    private AvisosRegistrados avisos;
    private ServicioAvisosVencimiento servicio;

    @BeforeEach
    void preparar() {
        repositorio = new RepositorioEnMemoria();
        avisos = new AvisosRegistrados();

        var propiedades = propiedadesConAntelacionDe(2);   // avisar 2 días antes
        servicio = new ServicioAvisosVencimiento(repositorio, avisos, propiedades, RELOJ);
    }

    @Test
    @DisplayName("avisa cuando faltan exactamente los días configurados")
    void avisaConLaAntelacionConfigurada() {
        repositorio.anadir(prestamoQueVence(HOY.plusDays(2), "[email protected]"));

        int enviados = servicio.enviarAvisosDelDia();

        assertThat(enviados).isEqualTo(1);
        assertThat(avisos.destinatarios).containsExactly("[email protected]");
        assertThat(avisos.mensajes).first().asString().contains("Java Efectivo");
    }

    @Test
    @DisplayName("no avisa si faltan más o menos días de los configurados")
    void noAvisaFueraDeLaVentana() {
        repositorio.anadir(prestamoQueVence(HOY.plusDays(1), "[email protected]"));  // 1 día
        repositorio.anadir(prestamoQueVence(HOY.plusDays(3), "[email protected]"));  // 3 días
        repositorio.anadir(prestamoQueVence(HOY,             "[email protected]"));  // hoy
        repositorio.anadir(prestamoQueVence(HOY.minusDays(5),"[email protected]"));  // vencido

        int enviados = servicio.enviarAvisosDelDia();

        assertThat(enviados).isZero();
        assertThat(avisos.destinatarios).isEmpty();
    }

    @Test
    @DisplayName("cuenta correctamente los avisos enviados")
    void cuentaLosAvisos() {
        repositorio.anadir(prestamoQueVence(HOY.plusDays(2), "[email protected]"));
        repositorio.anadir(prestamoQueVence(HOY.plusDays(2), "[email protected]"));
        repositorio.anadir(prestamoQueVence(HOY.plusDays(2), "[email protected]"));
        repositorio.anadir(prestamoQueVence(HOY.plusDays(9), "[email protected]"));

        assertThat(servicio.enviarAvisosDelDia()).isEqualTo(3);
        assertThat(avisos.destinatarios).containsExactlyInAnyOrder(
                "[email protected]",
                "[email protected]",
                "[email protected]");
    }

    private Prestamo prestamoQueVence(LocalDate vencimiento, String correo) {
        return new Prestamo(
                new Libro("978-0000000001", "Java Efectivo", 3, "J. Bloch"),
                new Empleado(correo, "Empleado de prueba"),
                vencimiento.minusDays(15), vencimiento);
    }
}

package com.nexussoftware.bibliotech.servicio;

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

import java.time.*;
import org.junit.jupiter.api.*;

@DisplayName("Renovación de préstamos")
class GestorRenovacionesTest {

    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);

    private GestorRenovaciones gestor;

    @BeforeEach
    void preparar() { gestor = new GestorRenovaciones(RELOJ); }

    @Test
    @DisplayName("renovar añade los días a la fecha de vencimiento")
    void renovarAnadeDias() {
        Prestamo prestamo = prestamoQueVence(HOY.plusDays(3));   // vence el 23

        LocalDate nueva = gestor.renovar(prestamo, 15);

        assertThat(nueva).isEqualTo(LocalDate.of(2026, 4, 7));   // 23 + 15
        assertThat(prestamo.getRenovaciones()).isEqualTo(1);
    }

    @Test
    @DisplayName("no se puede renovar más de dos veces")
    void limiteDeRenovaciones() {
        Prestamo prestamo = prestamoQueVence(HOY.plusDays(3));
        gestor.renovar(prestamo, 15);
        gestor.renovar(prestamo, 15);

        assertThatThrownBy(() -> gestor.renovar(prestamo, 15))
                .isInstanceOf(LimiteRenovacionesException.class);
    }

    @Test
    @DisplayName("no se puede renovar un préstamo ya devuelto")
    void noSeRenuevaUnDevuelto() {
        Prestamo prestamo = prestamoQueVence(HOY.plusDays(3));
        prestamo.devolver(HOY.minusDays(1));

        assertThatThrownBy(() -> gestor.renovar(prestamo, 15))
                .isInstanceOf(PrestamoYaDevueltoException.class);
    }

    // ===== LA PRUEBA QUE REVELA EL BUG =====
    @Test
    @DisplayName("renovar un préstamo muy vencido debe añadir los días desde HOY, no desde el pasado")
    void renovarUnPrestamoMuyVencido() {
        // Marta tenía un préstamo que venció hace 60 días (el 19 de enero)
        Prestamo prestamo = prestamoQueVence(HOY.minusDays(60));

        LocalDate nueva = gestor.renovar(prestamo, 15);

        // Esperado por negocio: hoy (20 de marzo) + 15 días = 4 de abril
        assertThat(nueva).isEqualTo(LocalDate.of(2026, 4, 4));
    }
}

Expected: 2026-04-04
Actual:   2026-03-20

LocalDate hoy = LocalDate.of(2026, 3, 20);
LocalDate nuevaFecha = LocalDate.of(2026, 1, 19).plusDays(15);   // = 2026-02-03

if (nuevaFecha.isBefore(hoy)) {    // 3 de febrero es anterior al 20 de marzo -> true
    nuevaFecha = hoy;              // ¡se queda en HOY!
}

public LocalDate renovar(Prestamo prestamo, int dias) {
    if (prestamo.getRenovaciones() >= MAX_RENOVACIONES) {
        throw new LimiteRenovacionesException(prestamo.getId());
    }
    if (prestamo.getFechaDevolucion().isPresent()) {
        throw new PrestamoYaDevueltoException(prestamo.getId());
    }

    LocalDate hoy = LocalDate.now(reloj);

    // La renovación siempre cuenta desde la fecha MÁS TARDÍA entre hoy y el
    // vencimiento actual. Así se garantiza que SIEMPRE se añaden `dias` completos
    // de préstamo útil, tanto si el préstamo está en plazo como si está vencido.
    LocalDate base = prestamo.getFechaVencimiento().isAfter(hoy)
            ? prestamo.getFechaVencimiento()
            : hoy;

    LocalDate nuevaFecha = base.plusDays(dias);

    prestamo.actualizarVencimiento(nuevaFecha);
    prestamo.incrementarRenovaciones();
    return nuevaFecha;
}