# Las 10 pruebas más lentas del proyecto
./mvnw test -Dsurefire.reportFormat=plain
grep -h "Time elapsed" target/surefire-reports/*.txt | sort -t: -k2 -rn | head -10

@Test
void laSuiteDeDominioEsRapida() {
    long inicio = System.nanoTime();
    // ejecutar el conjunto de pruebas de dominio…
    long ms = (System.nanoTime() - inicio) / 1_000_000;
    assertThat(ms)
        .as("Las pruebas de dominio deben seguir siendo rápidas")
        .isLessThan(5_000);
}

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-testcontainers</artifactId>
  <scope>test</scope>
</dependency>
<dependency>
  <groupId>org.testcontainers</groupId>
  <artifactId>postgresql</artifactId>
  <scope>test</scope>
</dependency>
<dependency>
  <groupId>org.testcontainers</groupId>
  <artifactId>junit-jupiter</artifactId>
  <scope>test</scope>
</dependency>

/**
 * Clase base de las pruebas de integración.
 *
 * El contenedor es static: se crea UNA VEZ para toda la ejecución
 * y lo comparten todas las clases que heredan. Sin static, se
 * levantaría un PostgreSQL por clase de prueba (30 s cada uno).
 */
@Testcontainers
public abstract class PruebaConPostgres {

    @Container
    @ServiceConnection            // Spring Boot 3.1+: configura el DataSource solo
    static final PostgreSQLContainer<?> POSTGRES =
            new PostgreSQLContainer<>("postgres:16-alpine")
                    .withDatabaseName("bibliotech_test")
                    .withUsername("test")
                    .withPassword("test")
                    .withReuse(true);      // reutiliza el contenedor entre ejecuciones locales
}

@DynamicPropertySource
static void propiedades(DynamicPropertyRegistry registro) {
    registro.add("spring.datasource.url", POSTGRES::getJdbcUrl);
    registro.add("spring.datasource.username", POSTGRES::getUsername);
    registro.add("spring.datasource.password", POSTGRES::getPassword);
}

@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)   // ¡no sustituyas por H2!
@Tag("integracion")
class PrestamoRepositoryIT extends PruebaConPostgres {

    @Autowired PrestamoRepository repositorio;
    @Autowired TestEntityManager em;

    @Test
    void encuentraLosPrestamosVencidosOrdenadosPorAntiguedad() {
        Empleado marta = em.persist(unEmpleado("Marta Ruiz"));
        Material java = em.persist(unLibro("978-0000000001", "Java Efectivo"));

        em.persist(unPrestamo(java, marta).conVencimiento(LocalDate.of(2026, 3, 1)));   // vencido
        em.persist(unPrestamo(java, marta).conVencimiento(LocalDate.of(2026, 3, 10)));  // vencido
        em.persist(unPrestamo(java, marta).conVencimiento(LocalDate.of(2026, 9, 1)));   // vigente
        em.flush();

        List<Prestamo> vencidos = repositorio.vencidosAntesDe(LocalDate.of(2026, 8, 5));

        assertThat(vencidos)
                .hasSize(2)
                .extracting(Prestamo::getFechaVencimiento)
                .containsExactly(LocalDate.of(2026, 3, 1), LocalDate.of(2026, 3, 10));
    }

    @Test
    void laBusquedaIgnoraMayusculasYAcentosComoEnProduccion() {
        em.persist(unLibro("978-0000000003", "Refactorización"));
        em.flush();

        // Esto usa unaccent() de PostgreSQL: en H2 sería IMPOSIBLE de probar
        assertThat(repositorio.buscarPorTitulo("refactorizacion")).hasSize(1);
        assertThat(repositorio.buscarPorTitulo("REFACTORIZACIÓN")).hasSize(1);
    }

    @Test
    void detectaElConflictoDeBloqueoOptimista() {
        Prestamo p = em.persistFlushFind(unPrestamo());
        em.detach(p);

        // Simular una modificación concurrente por otra transacción
        em.getEntityManager()
          .createNativeQuery("update prestamo set version = version + 1 where id = :id")
          .setParameter("id", p.getId())
          .executeUpdate();

        p.renovar(7);

        assertThatThrownBy(() -> { repositorio.save(p); em.flush(); })
                .isInstanceOf(OptimisticLockingFailureException.class);
    }
}

# ~/.testcontainers.properties — reutilizar contenedores entre ejecuciones locales
testcontainers.reuse.enable=true

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-surefire-plugin</artifactId>
      <configuration>
        <excludedGroups>integracion</excludedGroups>   <!-- por si alguna Test lleva @Tag -->
        <includes>
          <include>**/*Test.java</include>
        </includes>
      </configuration>
    </plugin>

    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-failsafe-plugin</artifactId>
      <configuration>
        <includes>
          <include>**/*IT.java</include>
        </includes>
      </configuration>
      <executions>
        <execution>
          <goals>
            <goal>integration-test</goal>
            <goal>verify</goal>            <!-- verify es quien FALLA la construcción -->
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

./mvnw test                    # solo unitarias: ~20 s
./mvnw verify                  # unitarias + integración: ~3 min
./mvnw verify -DskipITs        # saltarse las de integración
./mvnw test -Dgroups=rapidas    # solo las etiquetadas

@Tag("integracion")
@Tag("lento")
class ImportacionMasivaIT extends PruebaConPostgres { … }

# src/test/resources/junit-platform.properties
junit.jupiter.execution.parallel.enabled=true
junit.jupiter.execution.parallel.mode.default=concurrent
junit.jupiter.execution.parallel.config.strategy=dynamic
junit.jupiter.execution.parallel.config.dynamic.factor=1.0

<plugin>
  <groupId>org.jacoco</groupId>
  <artifactId>jacoco-maven-plugin</artifactId>
  <version>0.8.12</version>
  <executions>
    <!-- 1. Instrumentar antes de las pruebas unitarias -->
    <execution>
      <id>preparar-agente</id>
      <goals><goal>prepare-agent</goal></goals>
    </execution>

    <!-- 2. Generar el informe tras las pruebas -->
    <execution>
      <id>informe</id>
      <phase>verify</phase>
      <goals><goal>report</goal></goals>
    </execution>

    <!-- 3. Comprobar umbrales: si no se cumplen, la construcción FALLA -->
    <execution>
      <id>comprobar-umbrales</id>
      <phase>verify</phase>
      <goals><goal>check</goal></goals>
      <configuration>
        <rules>
          <rule>
            <element>BUNDLE</element>
            <limits>
              <limit>
                <counter>INSTRUCTION</counter>
                <value>COVEREDRATIO</value>
                <minimum>0.75</minimum>
              </limit>
              <limit>
                <counter>BRANCH</counter>          <!-- la métrica que de verdad importa -->
                <value>COVEREDRATIO</value>
                <minimum>0.70</minimum>
              </limit>
            </limits>
          </rule>
          <!-- El dominio es lógica pura: se exige más -->
          <rule>
            <element>PACKAGE</element>
            <includes><include>com.nexussoftware.bibliotech.dominio.*</include></includes>
            <limits>
              <limit>
                <counter>BRANCH</counter>
                <value>COVEREDRATIO</value>
                <minimum>0.90</minimum>
              </limit>
            </limits>
          </rule>
        </rules>
      </configuration>
    </execution>
  </executions>

  <configuration>
    <excludes>
      <!-- Excluir lo que no tiene lógica que probar -->
      <exclude>**/dto/**</exclude>
      <exclude>**/*Application.class</exclude>
      <exclude>**/config/**</exclude>
      <exclude>**/generated/**</exclude>
    </excludes>
  </configuration>
</plugin>

./mvnw verify
# El informe navegable, con el código coloreado línea a línea:
open target/site/jacoco/index.html

public Dinero calcularMulta(Prestamo prestamo, LocalDate hoy) {
    long dias = ChronoUnit.DAYS.between(prestamo.getFechaVencimiento(), hoy);
    if (dias <= 0) {
        return Dinero.CERO;
    }
    Dinero multa = prestamo.multaPorDia().por(dias);
    return multa.esMayorQue(MAXIMO) ? MAXIMO : multa;
}

@Test
void calculaLaMultaDeDiezDias() {
    assertThat(calculadora.calcularMulta(prestamoVencidoHace(10), HOY))
            .isEqualTo(Dinero.euros("5.00"));
}

@Test
void calculaLaMulta() {
    // Ejecuta TODO el método: cobertura de líneas del 100 %
    calculadora.calcularMulta(unPrestamoVencidoHace(10), HOY);
    // Y NO COMPRUEBA NADA.
}

<plugin>
  <groupId>org.pitest</groupId>
  <artifactId>pitest-maven</artifactId>
  <version>1.16.1</version>
  <dependencies>
    <dependency>
      <groupId>org.pitest</groupId>
      <artifactId>pitest-junit5-plugin</artifactId>
      <version>1.2.1</version>
    </dependency>
  </dependencies>
  <configuration>
    <targetClasses>
      <param>com.nexussoftware.bibliotech.dominio.*</param>   <!-- donde está la lógica -->
    </targetClasses>
    <targetTests>
      <param>com.nexussoftware.bibliotech.dominio.*Test</param>
    </targetTests>
    <mutationThreshold>70</mutationThreshold>
    <timestampedReports>false</timestampedReports>
  </configuration>
</plugin>

./mvnw org.pitest:pitest-maven:mutationCoverage
open target/pit-reports/index.html

public Dinero calcularMulta(Prestamo prestamo, LocalDate hoy) {
    long dias = ChronoUnit.DAYS.between(prestamo.getFechaVencimiento(), hoy);
    if (dias <= 0) {                                    // ← el punto crítico
        return Dinero.CERO;
    }
    Dinero multa = prestamo.multaPorDia().por(dias);
    return multa.esMayorQue(MAXIMO) ? MAXIMO : multa;
}

@Test void sinRetrasoNoHayMulta()      { assertThat(calcular(-3)).isEqualTo(Dinero.CERO); }
@Test void conDiezDiasSonCincoEuros()  { assertThat(calcular(10)).isEqualTo(Dinero.euros("5.00")); }
@Test void nuncaSuperaElMaximo()       { assertThat(calcular(100)).isEqualTo(Dinero.euros("20.00")); }

CalculadoraMultas.java
  L.4   changed conditional boundary → SURVIVED    (dias <= 0  →  dias < 0)
  L.8   changed conditional boundary → KILLED
  L.7   Replaced long multiplication with division → KILLED

@ParameterizedTest
@CsvSource({
    "-1, 0.00",     // un día antes de vencer
    " 0, 0.00",     // EL DÍA DEL VENCIMIENTO: la frontera
    " 1, 0.50",     // un día de retraso
    "39, 19.50",    // justo por debajo del máximo
    "40, 20.00",    // exactamente el máximo
    "41, 20.00"     // por encima: se aplica el tope
})
void calculaLaMultaEnLasFronteras(int diasDeRetraso, String multaEsperada) {
    assertThat(calcular(diasDeRetraso)).isEqualTo(Dinero.euros(multaEsperada));
}

<plugin>
  <groupId>com.github.spotbugs</groupId>
  <artifactId>spotbugs-maven-plugin</artifactId>
  <version>4.8.6.4</version>
  <configuration>
    <effort>Max</effort>
    <threshold>Medium</threshold>
    <failOnError>true</failOnError>
    <excludeFilterFile>config/spotbugs-exclusiones.xml</excludeFilterFile>
    <plugins>
      <plugin>
        <groupId>com.h3xstream.findsecbugs</groupId>     <!-- análisis de seguridad -->
        <artifactId>findsecbugs-plugin</artifactId>
        <version>1.13.0</version>
      </plugin>
    </plugins>
  </configuration>
  <executions>
    <execution><phase>verify</phase><goals><goal>check</goal></goals></execution>
  </executions>
</plugin>

// SpotBugs: DM_DEFAULT_ENCODING — depende de la codificación de la plataforma
Files.readString(ruta);                          // MAL
Files.readString(ruta, StandardCharsets.UTF_8);  // BIEN

// SpotBugs: ES_COMPARING_STRINGS_WITH_EQ
if (estado == "ACTIVO")           // MAL: compara referencias
if ("ACTIVO".equals(estado))      // BIEN

// SpotBugs: EI_EXPOSE_REP — se expone la representación interna
public List<Prestamo> getPrestamos() { return prestamos; }             // MAL: mutable
public List<Prestamo> getPrestamos() { return List.copyOf(prestamos); } // BIEN

// FindSecBugs: SQL_INJECTION_JPA
em.createQuery("select m from Material m where m.titulo like '%" + texto + "%'");   // MAL
em.createQuery("select m from Material m where m.titulo like :t").setParameter("t", …); // BIEN

./mvnw verify sonar:sonar \
  -Dsonar.projectKey=nexussoftware_bibliotech \
  -Dsonar.host.url=https://sonarcloud.io \
  -Dsonar.token=$SONAR_TOKEN

./mvnw spotless:apply     # formatea (en local, o como enganche de pre-commit)
./mvnw spotless:check     # falla si no está formateado (en CI)

// DEUDA: la búsqueda recorre todo el catálogo en memoria porque son ~3.000 materiales.
// Con más de 50.000 habrá que pasar a búsqueda a texto completo de PostgreSQL.
// Decidido conscientemente el 2026-08-05 — ver docs/adr/0007-busqueda-en-memoria.md

// ANTES: 40 líneas, tres responsabilidades entremezcladas
public ResultadoImportacion importar(Path fichero) {
    List<String> lineas = Files.readAllLines(fichero, UTF_8);
    List<Material> materiales = new ArrayList<>();
    List<String> errores = new ArrayList<>();

    for (int i = 1; i < lineas.size(); i++) {
        String[] campos = lineas.get(i).split(";");
        if (campos.length < 4) { errores.add("Línea " + i + ": campos insuficientes"); continue; }
        if (!campos[0].matches("97[89]-\\d{10}")) { errores.add("Línea " + i + ": ISBN inválido"); continue; }
        // … 20 líneas más de conversión y validación
    }
    // … guardado y resumen
}

// DESPUÉS: el método principal cuenta la historia; los detalles están un nivel más abajo
public ResultadoImportacion importar(Path fichero) throws IOException {
    List<LineaCsv> lineas = leerLineas(fichero);
    ResultadoParseo parseo = parsear(lineas);
    List<Material> guardados = guardar(parseo.validos());
    return new ResultadoImportacion(guardados.size(), parseo.errores());
}

private ResultadoParseo parsear(List<LineaCsv> lineas) {
    List<Material> validos = new ArrayList<>();
    List<ErrorImportacion> errores = new ArrayList<>();
    for (LineaCsv linea : lineas) {
        parsearLinea(linea).ifPresentOrElse(validos::add, () -> errores.add(errorDe(linea)));
    }
    return new ResultadoParseo(validos, errores);
}

// ANTES: Prestamo mezcla su identidad con el cálculo de multas
public class Prestamo {
    public Dinero calcularMulta(LocalDate hoy) {
        long dias = ChronoUnit.DAYS.between(fechaVencimiento, hoy);
        if (dias <= 0) return Dinero.CERO;
        Dinero base = material.multaPorDia().por(dias);
        if (empleado.antiguedadEnMeses() < 6) base = base.multiplicarPor(0.5);
        if (empleado.esDireccion()) return Dinero.CERO;
        return base.esMayorQue(MAXIMO) ? MAXIMO : base;
    }
}

// DESPUÉS: la política de multas es un concepto propio, con sus propias pruebas
public class PoliticaMultas {
    private final List<ReglaTarifa> reglas;     // Estrategia (12-02)

    public Dinero calcular(Prestamo prestamo, LocalDate hoy) { … }
}

public class Prestamo {
    public Dinero multaAcumulada(LocalDate hoy, PoliticaMultas politica) {
        return politica.calcular(this, hoy);
    }
}

// ANTES
public int diasDePrestamo(Material m) {
    switch (m.getTipo()) {
        case LIBRO: return 15;
        case REVISTA: return 7;
        case DVD: return 3;
        default: throw new IllegalStateException();
    }
}

// DESPUÉS: cada tipo responde por sí mismo
public abstract class Material {
    public abstract int diasDePrestamoPorDefecto();
}

class RecargoPorDanoTest {

    @Test
    void unMaterialSinDanoNoTieneRecargo() {
        var calculadora = new CalculadoraRecargos();
        var material = unLibro("978-0000000001").conValor(Dinero.euros("45.00"));

        Dinero recargo = calculadora.calcular(material, EstadoDevolucion.SIN_DANO);

        assertThat(recargo).isEqualTo(Dinero.CERO);
    }
}

public enum EstadoDevolucion { SIN_DANO }

public class CalculadoraRecargos {
    public Dinero calcular(Material material, EstadoDevolucion estado) {
        return Dinero.CERO;      // sí, esto es hacer trampa. Y es correcto en TDD.
    }
}

@Test
void unDanoLeveSuponeElVeintePorCientoDelValor() {
    var material = unLibro("978-0000000001").conValor(Dinero.euros("45.00"));

    Dinero recargo = calculadora.calcular(material, EstadoDevolucion.LEVE);

    assertThat(recargo).isEqualTo(Dinero.euros("9.00"));      // 45 × 0,20
}

public enum EstadoDevolucion { SIN_DANO, LEVE }

public class CalculadoraRecargos {
    public Dinero calcular(Material material, EstadoDevolucion estado) {
        if (estado == EstadoDevolucion.SIN_DANO) return Dinero.CERO;
        return material.getValor().multiplicarPor(new BigDecimal("0.20"));
    }
}

@ParameterizedTest
@CsvSource({
    "SIN_DANO,       0.00",
    "LEVE,           9.00",
    "GRAVE,         27.00",
    "IRRECUPERABLE, 45.00"
})
void elRecargoDependeDelEstadoDeDevolucion(EstadoDevolucion estado, String esperado) {
    var material = unLibro("978-0000000001").conValor(Dinero.euros("45.00"));
    assertThat(calculadora.calcular(material, estado)).isEqualTo(Dinero.euros(esperado));
}

public Dinero calcular(Material material, EstadoDevolucion estado) {
    BigDecimal porcentaje = switch (estado) {
        case SIN_DANO -> BigDecimal.ZERO;
        case LEVE -> new BigDecimal("0.20");
        case GRAVE -> new BigDecimal("0.60");
        case IRRECUPERABLE -> BigDecimal.ONE;
    };
    return material.getValor().multiplicarPor(porcentaje);
}

public enum EstadoDevolucion {
    SIN_DANO(BigDecimal.ZERO),
    LEVE(new BigDecimal("0.20")),
    GRAVE(new BigDecimal("0.60")),
    IRRECUPERABLE(BigDecimal.ONE);

    private final BigDecimal porcentajeRecargo;

    EstadoDevolucion(BigDecimal porcentajeRecargo) {
        this.porcentajeRecargo = porcentajeRecargo;
    }

    public BigDecimal porcentajeRecargo() { return porcentajeRecargo; }
    public boolean exigeRetirarDelCatalogo() { return this == IRRECUPERABLE; }
}

public class CalculadoraRecargos {
    public Dinero calcular(Material material, EstadoDevolucion estado) {
        return material.getValor().multiplicarPor(estado.porcentajeRecargo());
    }
}

@Test
void elTotalDeMultaYRecargoNoSuperaElValorDelMaterial() {
    var material = unLibro("978-0000000001").conValor(Dinero.euros("45.00"));
    var prestamo = unPrestamoDe(material).vencidoHace(200);   // multa enorme

    Dinero total = calculadora.totalACobrar(prestamo, EstadoDevolucion.GRAVE, HOY);

    // multa (tope 20 €) + recargo (27 €) = 47 €, pero el material vale 45 €
    assertThat(total).isEqualTo(Dinero.euros("45.00"));
}

public Dinero totalACobrar(Prestamo prestamo, EstadoDevolucion estado, LocalDate hoy) {
    Dinero multa = politicaMultas.calcular(prestamo, hoy);
    Dinero recargo = calcular(prestamo.getMaterial(), estado);
    Dinero total = multa.mas(recargo);
    Dinero valorMaterial = prestamo.getMaterial().getValor();
    return total.esMayorQue(valorMaterial) ? valorMaterial : total;
}

@Test
void unMaterialIrrecuperableSeRetiraDelCatalogo() {
    var material = unLibro("978-0000000001").conValor(Dinero.euros("45.00"));
    var prestamo = unPrestamoDe(material);

    servicio.registrarDevolucion(prestamo.getId(), EstadoDevolucion.IRRECUPERABLE, HOY);

    assertThat(material.estaRetirado()).isTrue();
    verify(catalogo).retirar(material.getIsbn(), MotivoRetirada.DANADO);
}

@Test
void unMaterialConDanoGraveSigueEnElCatalogo() {
    var material = unLibro("978-0000000001");
    servicio.registrarDevolucion(unPrestamoDe(material).getId(), EstadoDevolucion.GRAVE, HOY);

    assertThat(material.estaRetirado()).isFalse();
    verifyNoInteractions(catalogo);
}

@Transactional
public ResultadoDevolucion registrarDevolucion(Long idPrestamo, EstadoDevolucion estado, LocalDate fecha) {
    Prestamo prestamo = repositorio.buscarPorId(idPrestamo)
            .orElseThrow(() -> new PrestamoNoEncontradoException(idPrestamo));

    prestamo.registrarDevolucion(fecha);
    Dinero total = calculadora.totalACobrar(prestamo, estado, fecha);

    if (estado.exigeRetirarDelCatalogo()) {
        catalogo.retirar(prestamo.getIsbn(), MotivoRetirada.DANADO);
    }
    eventos.publicar(new MaterialDevuelto(prestamo.getId(), estado, total));   // Observador
    return new ResultadoDevolucion(prestamo.getId(), fecha, total, estado);
}

./mvnw org.pitest:pitest-maven:mutationCoverage \
    -DtargetClasses=com.nexussoftware.bibliotech.dominio.prestamos.*

CalculadoraRecargos    : 100% mutación (8/8 mutantes eliminados)
EstadoDevolucion       : 100% mutación (4/4)

## Revisión de código — BiblioTech

### Corrección
- [ ] ¿Hace lo que dice la descripción del PR?
- [ ] ¿Se manejan los casos límite (vacío, nulo, cero, negativo, máximo)?
- [ ] ¿Las excepciones se capturan en el nivel correcto (06-07)?
- [ ] ¿Hay condiciones de carrera si esto se ejecuta en paralelo?

### Arquitectura
- [ ] ¿Está en el módulo correcto (dominio / aplicación / infraestructura)?
- [ ] ¿El dominio sigue sin importar Spring ni JPA?
- [ ] ¿Se exponen entidades JPA en la API? (no se debe)
- [ ] ¿La transacción está en el caso de uso, no en el controlador?

### Pruebas
- [ ] ¿Hay pruebas del camino feliz Y de los errores?
- [ ] ¿Las pruebas tienen aserciones significativas?
- [ ] ¿Están en el nivel más bajo posible?
- [ ] ¿Se usa `Clock` inyectable en lugar de `LocalDate.now()`?

### Seguridad (12-07)
- [ ] ¿Se valida toda entrada externa?
- [ ] ¿Hay secretos, tokens o datos personales en el código o en el log?
- [ ] ¿Las consultas usan parámetros, nunca concatenación?

### Legibilidad
- [ ] ¿Los nombres describen la intención?
- [ ] ¿Algún método supera las 30 líneas o la complejidad 10?
- [ ] ¿Los comentarios explican el «por qué», no el «qué»?

# .github/workflows/ci.yml
name: CI

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

# Cancela ejecuciones anteriores del mismo PR: no tiene sentido probar código ya obsoleto
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

env:
  JAVA_VERSION: '21'

jobs:

  # ---------------------------------------------------------------
  # Trabajo 1: rápido. Da respuesta en menos de 3 minutos.
  # ---------------------------------------------------------------
  verificacion-rapida:
    name: Compilación, formato y pruebas unitarias
    runs-on: ubuntu-latest
    timeout-minutes: 10

    steps:
      - uses: actions/checkout@v4

      - name: Configurar JDK ${{ env.JAVA_VERSION }}
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: temurin
          cache: maven              # cachea ~/.m2: ahorra 1-2 minutos por ejecución

      - name: Verificar formato
        run: ./mvnw -B spotless:check

      - name: Compilar
        run: ./mvnw -B clean compile

      - name: Pruebas unitarias
        run: ./mvnw -B test

      - name: Publicar resultados de las pruebas
        uses: mikepenz/action-junit-report@v4
        if: always()                # también cuando fallan: es cuando más se necesita
        with:
          report_paths: '**/target/surefire-reports/TEST-*.xml'
          check_name: 'Pruebas unitarias'

  # ---------------------------------------------------------------
  # Trabajo 2: lento. Testcontainers, cobertura y análisis estático.
  # ---------------------------------------------------------------
  verificacion-completa:
    name: Integración, cobertura y análisis
    runs-on: ubuntu-latest
    needs: verificacion-rapida      # no gastes 10 minutos si no compila
    timeout-minutes: 25

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0            # Sonar necesita el historial para el "código nuevo"

      - uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: temurin
          cache: maven

      # Docker ya está disponible en ubuntu-latest: Testcontainers funciona sin más

      - name: Pruebas de integración y cobertura
        run: ./mvnw -B verify
        env:
          TESTCONTAINERS_RYUK_DISABLED: 'false'

      - name: Comprobar umbrales de cobertura
        run: ./mvnw -B jacoco:check

      - name: Publicar cobertura en el PR
        uses: madrapps/[email protected]
        if: github.event_name == 'pull_request'
        with:
          paths: '**/target/site/jacoco/jacoco.xml'
          token: ${{ secrets.GITHUB_TOKEN }}
          min-coverage-overall: 75
          min-coverage-changed-files: 80    # el código NUEVO, más exigente
          title: 'Informe de cobertura'

      - name: Análisis estático
        run: ./mvnw -B spotbugs:check

      - name: Guardar informes
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: informes
          path: |
            **/target/site/jacoco/
            **/target/spotbugsXml.xml
          retention-days: 7

  # ---------------------------------------------------------------
  # Trabajo 3: solo en main. Pruebas de mutación, que son lentas.
  # ---------------------------------------------------------------
  mutacion:
    name: Pruebas de mutación
    runs-on: ubuntu-latest
    needs: verificacion-completa
    if: github.ref == 'refs/heads/main'
    timeout-minutes: 30

    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: temurin
          cache: maven

      - name: PIT sobre el dominio
        run: ./mvnw -B -pl bibliotech-dominio org.pitest:pitest-maven:mutationCoverage

      - uses: actions/upload-artifact@v4
        with:
          name: informe-mutacion
          path: '**/target/pit-reports/'

// MAL: prueba CÓMO se hace. Refactorizar la rompe aunque el comportamiento no cambie.
@Test
void usaElRepositorioParaBuscar() {
    servicio.buscarPorIsbn(isbn);
    verify(repositorio).findByIsbn(isbn);      // ¿y si mañana usa una caché?
}

// BIEN: prueba QUÉ hace. Sobrevive a cualquier refactor interno.
@Test
void devuelveElMaterialCuandoExiste() {
    when(repositorio.findByIsbn(isbn)).thenReturn(Optional.of(javaEfectivo));

    Optional<Material> resultado = servicio.buscarPorIsbn(isbn);

    assertThat(resultado).contains(javaEfectivo);
}

// FRÁGIL: falla el 1 de enero, o si la prueba corre a medianoche
@Test
void elPrestamoVenceEnQuinceDias() {
    Prestamo p = gestor.prestar(isbn, 1L, 15);
    assertThat(p.getFechaVencimiento()).isEqualTo(LocalDate.now().plusDays(15));
}

// ROBUSTA: el tiempo es una dependencia como cualquier otra
@Test
void elPrestamoVenceEnQuinceDias() {
    var reloj = Clock.fixed(Instant.parse("2026-08-05T10:00:00Z"), ZoneId.of("Europe/Madrid"));
    var gestor = new GestorPrestamos(repositorio, notificador, reloj);

    Prestamo p = gestor.prestar(isbn, 1L, 15);

    assertThat(p.getFechaVencimiento()).isEqualTo(LocalDate.of(2026, 8, 20));
}

// FRÁGIL: 500 ms puede no bastar en una máquina cargada, y sobra en una rápida
@Test
void laImportacionAsincronaTermina() throws Exception {
    servicio.importarAsincrono(fichero);
    Thread.sleep(500);
    assertThat(repositorio.count()).isEqualTo(100);
}

// ROBUSTA: espera a la CONDICIÓN, no a un tiempo
@Test
void laImportacionAsincronaTermina() {
    servicio.importarAsincrono(fichero);

    await().atMost(Duration.ofSeconds(5))
           .pollInterval(Duration.ofMillis(50))
           .untilAsserted(() -> assertThat(repositorio.count()).isEqualTo(100));
}

class ProcesadorReservasTest {

    ProcesadorReservas procesador = new ProcesadorReservas(
            new RepositorioReservasEnMemoria(), new NotificadorFalso());

    @Test
    void testReservar() {
        procesador.reservar("978-0000000001", 1L);
    }

    @Test
    void testCancelar() throws Exception {
        Reserva r = procesador.reservar("978-0000000001", 1L);
        procesador.cancelar(r.getId());
        assertNotNull(r);
    }

    @Test
    void testCaducidad() throws Exception {
        Reserva r = procesador.reservar("978-0000000001", 1L);
        Thread.sleep(1000);
        procesador.caducarVencidas();
        assertTrue(true);
    }

    @Test
    void testFechaLimite() {
        Reserva r = procesador.reservar("978-0000000001", 1L);
        assertEquals(LocalDate.now().plusDays(2), r.getFechaLimite());
    }
}

@DisplayName("Procesador de reservas")
class ProcesadorReservasTest {

    // Reloj FIJO: elimina toda dependencia del momento de ejecución
    private static final Instant AHORA = Instant.parse("2026-08-05T10:00:00Z");
    private static final ZoneId MADRID = ZoneId.of("Europe/Madrid");

    private RepositorioReservasEnMemoria repositorio;
    private NotificadorEspia notificador;
    private MutableClock reloj;                  // reloj avanzable, sin Thread.sleep
    private ProcesadorReservas procesador;

    @BeforeEach
    void preparar() {
        // Estado NUEVO en cada prueba: sin contaminación entre ellas
        repositorio = new RepositorioReservasEnMemoria();
        notificador = new NotificadorEspia();
        reloj = MutableClock.de(AHORA, MADRID);
        procesador = new ProcesadorReservas(repositorio, notificador, reloj);
    }

    @Nested
    @DisplayName("Al crear una reserva")
    class AlReservar {

        @Test
        @DisplayName("queda pendiente y en la cola del material")
        void quedaPendienteYEnLaCola() {
            Reserva reserva = procesador.reservar(ISBN_JAVA, MARTA);

            assertThat(reserva.getEstado()).isEqualTo(EstadoReserva.PENDIENTE);
            assertThat(reserva.getMaterialIsbn()).isEqualTo(ISBN_JAVA);
            assertThat(reserva.getIdEmpleado()).isEqualTo(MARTA);
            assertThat(reserva.getFechaSolicitud()).isEqualTo(AHORA);
            assertThat(repositorio.pendientesDe(ISBN_JAVA)).containsExactly(reserva);
        }

        @Test
        @DisplayName("respeta el orden de llegada en la cola")
        void respetaElOrdenDeLlegada() {
            Reserva primera = procesador.reservar(ISBN_JAVA, MARTA);
            reloj.avanzar(Duration.ofMinutes(5));
            Reserva segunda = procesador.reservar(ISBN_JAVA, DIEGO);

            assertThat(repositorio.pendientesDe(ISBN_JAVA))
                    .containsExactly(primera, segunda);      // el orden importa
        }

        @Test
        @DisplayName("rechaza una segunda reserva del mismo empleado y material")
        void rechazaReservaDuplicada() {
            procesador.reservar(ISBN_JAVA, MARTA);

            assertThatThrownBy(() -> procesador.reservar(ISBN_JAVA, MARTA))
                    .isInstanceOf(ReservaDuplicadaException.class)
                    .hasMessageContaining(ISBN_JAVA.valor());

            assertThat(repositorio.pendientesDe(ISBN_JAVA)).hasSize(1);
        }

        @Test
        @DisplayName("rechaza reservar un material inexistente")
        void rechazaMaterialInexistente() {
            assertThatThrownBy(() -> procesador.reservar(ISBN_INEXISTENTE, MARTA))
                    .isInstanceOf(MaterialNoEncontradoException.class);
        }
    }

    @Nested
    @DisplayName("Al cancelar")
    class AlCancelar {

        @Test
        @DisplayName("la reserva pasa a CANCELADA y sale de la cola")
        void pasaACanceladaYSaleDeLaCola() {
            Reserva reserva = procesador.reservar(ISBN_JAVA, MARTA);

            procesador.cancelar(reserva.getId());

            assertThat(repositorio.porId(reserva.getId()))
                    .get()
                    .extracting(Reserva::getEstado)
                    .isEqualTo(EstadoReserva.CANCELADA);
            assertThat(repositorio.pendientesDe(ISBN_JAVA)).isEmpty();
        }

        @Test
        @DisplayName("cancelar dos veces lanza TransicionInvalidaException")
        void cancelarDosVecesFalla() {
            Reserva reserva = procesador.reservar(ISBN_JAVA, MARTA);
            procesador.cancelar(reserva.getId());

            assertThatThrownBy(() -> procesador.cancelar(reserva.getId()))
                    .isInstanceOf(TransicionInvalidaException.class);
        }

        @Test
        @DisplayName("cancelar una reserva inexistente lanza ReservaNoEncontradaException")
        void reservaInexistente() {
            assertThatThrownBy(() -> procesador.cancelar(9999L))
                    .isInstanceOf(ReservaNoEncontradaException.class);
        }
    }

    @Nested
    @DisplayName("Caducidad")
    class Caducidad {

        @Test
        @DisplayName("una reserva disponible caduca a las 48 horas exactas")
        void caducaALas48Horas() {
            Reserva reserva = procesador.reservar(ISBN_JAVA, MARTA);
            procesador.asignarEjemplar(reserva.getId());

            reloj.avanzar(Duration.ofHours(48));          // ¡sin Thread.sleep!
            int caducadas = procesador.caducarVencidas();

            assertThat(caducadas).isEqualTo(1);
            assertThat(repositorio.porId(reserva.getId()))
                    .get().extracting(Reserva::getEstado)
                    .isEqualTo(EstadoReserva.CADUCADA);
        }

        @Test
        @DisplayName("a las 47 horas y 59 minutos todavía NO caduca")
        void noCaducaAntesDeTiempo() {
            Reserva reserva = procesador.reservar(ISBN_JAVA, MARTA);
            procesador.asignarEjemplar(reserva.getId());

            reloj.avanzar(Duration.ofHours(47).plusMinutes(59));
            int caducadas = procesador.caducarVencidas();

            assertThat(caducadas).isZero();               // LA FRONTERA
            assertThat(repositorio.porId(reserva.getId()))
                    .get().extracting(Reserva::getEstado)
                    .isEqualTo(EstadoReserva.DISPONIBLE);
        }

        @Test
        @DisplayName("las reservas pendientes no caducan: no tienen fecha límite")
        void lasPendientesNoCaducan() {
            procesador.reservar(ISBN_JAVA, MARTA);        // PENDIENTE, sin ejemplar asignado

            reloj.avanzar(Duration.ofDays(30));

            assertThat(procesador.caducarVencidas()).isZero();
        }

        @Test
        @DisplayName("al caducar se notifica al empleado y se activa la siguiente de la cola")
        void notificaYActivaLaSiguiente() {
            Reserva deMarta = procesador.reservar(ISBN_JAVA, MARTA);
            Reserva deDiego = procesador.reservar(ISBN_JAVA, DIEGO);
            procesador.asignarEjemplar(deMarta.getId());

            reloj.avanzar(Duration.ofHours(48));
            procesador.caducarVencidas();

            assertThat(notificador.avisosEnviados())
                    .extracting(Aviso::tipo)
                    .containsExactly(TipoAviso.RESERVA_CADUCADA, TipoAviso.RESERVA_DISPONIBLE);
            assertThat(repositorio.porId(deDiego.getId()))
                    .get().extracting(Reserva::getEstado)
                    .isEqualTo(EstadoReserva.DISPONIBLE);
        }
    }

    @Nested
    @DisplayName("Fecha límite de recogida")
    class FechaLimite {

        @Test
        @DisplayName("se fija a 48 horas desde la asignación del ejemplar")
        void aLas48HorasDesdeLaAsignacion() {
            Reserva reserva = procesador.reservar(ISBN_JAVA, MARTA);
            reloj.avanzar(Duration.ofDays(3));            // la asignación llega días después
            procesador.asignarEjemplar(reserva.getId());

            // Fecha ABSOLUTA calculada desde el reloj fijo: nunca depende de "hoy"
            assertThat(repositorio.porId(reserva.getId()))
                    .get().extracting(Reserva::getFechaLimiteRecogida)
                    .isEqualTo(AHORA.plus(Duration.ofDays(3)).plus(Duration.ofHours(48)));
        }

        @Test
        @DisplayName("una reserva pendiente no tiene fecha límite")
        void lasPendientesNoTienenFechaLimite() {
            Reserva reserva = procesador.reservar(ISBN_JAVA, MARTA);
            assertThat(reserva.getFechaLimiteRecogida()).isNull();
        }
    }
}

/** Clock mutable para pruebas: permite avanzar el tiempo sin esperar. */
public class MutableClock extends Clock {

    private Instant instante;
    private final ZoneId zona;

    private MutableClock(Instant instante, ZoneId zona) {
        this.instante = instante;
        this.zona = zona;
    }

    public static MutableClock de(Instant instante, ZoneId zona) {
        return new MutableClock(instante, zona);
    }

    public void avanzar(Duration duracion) { this.instante = instante.plus(duracion); }

    @Override public Instant instant() { return instante; }
    @Override public ZoneId getZone() { return zona; }
    @Override public Clock withZone(ZoneId z) { return new MutableClock(instante, z); }
}

@Test
void unEmpleadoSinProyectoCriticoNoPuedeUsarPrioridad() {
    Empleado diego = unEmpleado("Diego Alonso").sinProyectosCriticos();

    assertThatThrownBy(() -> servicio.prestarConPrioridad(ISBN_JAVA, diego.getId()))
            .isInstanceOf(SinPrioridadDisponibleException.class)
            .hasMessageContaining("no tiene ningún proyecto crítico activo");
}

public Prestamo prestarConPrioridad(Isbn isbn, Long idEmpleado) {
    Empleado empleado = empleados.buscarPorId(idEmpleado).orElseThrow(…);
    if (!empleado.tieneProyectoCriticoActivo()) {
        throw new SinPrioridadDisponibleException(
                "El empleado %s no tiene ningún proyecto crítico activo."
                        .formatted(empleado.getNombre()));
    }
    return null;   // lo mínimo para que la prueba pase
}

@Test
void siElMaterialEstaLibreSeHaceUnPrestamoNormalSinConsumirPrioridad() {
    Empleado marta = unEmpleado("Marta Ruiz").conProyectoCritico();
    materialLibre(ISBN_JAVA);

    Prestamo prestamo = servicio.prestarConPrioridad(ISBN_JAVA, marta.getId());

    assertThat(prestamo.esPrioritario()).isFalse();
    assertThat(marta.prioridadesEnUso()).isZero();       // la prioridad NO se gastó
}

public Prestamo prestarConPrioridad(Isbn isbn, Long idEmpleado) {
    Empleado empleado = …;
    verificarTieneProyectoCritico(empleado);

    Material material = materiales.buscarPorIsbn(isbn).orElseThrow(…);
    if (material.tieneUnidadesLibres()) {
        return gestorPrestamos.prestar(isbn, idEmpleado, null);   // préstamo normal
    }
    return null;
}

@Test
void marcaElPrestamoEnCursoParaDevolucionUrgenteEnCuarentaYOchoHoras() {
    Empleado marta = unEmpleado("Marta Ruiz").conProyectoCritico();
    Prestamo enCurso = prestamoActivoDe(ISBN_JAVA, DIEGO);
    materialSinUnidadesLibres(ISBN_JAVA);

    servicio.prestarConPrioridad(ISBN_JAVA, marta.getId());

    assertThat(enCurso.esUrgente()).isTrue();
    assertThat(enCurso.getFechaVencimiento())
            .isEqualTo(LocalDate.now(reloj).plusDays(2));
}

@Test
void avisaAlEmpleadoQueTieneElMaterial() {
    Empleado marta = unEmpleado("Marta Ruiz").conProyectoCritico();
    prestamoActivoDe(ISBN_JAVA, DIEGO);
    materialSinUnidadesLibres(ISBN_JAVA);

    servicio.prestarConPrioridad(ISBN_JAVA, marta.getId());

    assertThat(notificador.avisosEnviados())
            .singleElement()
            .satisfies(a -> {
                assertThat(a.tipo()).isEqualTo(TipoAviso.DEVOLUCION_URGENTE);
                assertThat(a.destinatario()).isEqualTo(DIEGO.getCorreo());
            });
}

public Prestamo prestarConPrioridad(Isbn isbn, Long idEmpleado) {
    Empleado empleado = …;
    verificarTieneProyectoCritico(empleado);

    Material material = …;
    if (material.tieneUnidadesLibres()) {
        return gestorPrestamos.prestar(isbn, idEmpleado, null);
    }

    Prestamo enCurso = prestamos.activoDe(isbn).orElseThrow(…);
    enCurso.marcarUrgente(LocalDate.now(reloj).plusDays(2));
    notificador.notificar(Aviso.devolucionUrgente(enCurso));

    return Prestamo.prioritarioEnEspera(material, empleado, LocalDate.now(reloj));
}

@Test
void unEmpleadoNoPuedeTenerDosPrioridadesSimultaneas() {
    Empleado marta = unEmpleado("Marta Ruiz").conProyectoCritico().conPrioridadEnUso();
    materialSinUnidadesLibres(ISBN_JAVA);

    assertThatThrownBy(() -> servicio.prestarConPrioridad(ISBN_JAVA, marta.getId()))
            .isInstanceOf(PrioridadYaEnUsoException.class);
}

@Test
void noSePuedeUsarPrioridadSobreUnMaterialYaMarcadoComoUrgente() {
    Empleado marta = unEmpleado("Marta Ruiz").conProyectoCritico();
    prestamoActivoDe(ISBN_JAVA, DIEGO).yaMarcadoUrgente();
    materialSinUnidadesLibres(ISBN_JAVA);

    assertThatThrownBy(() -> servicio.prestarConPrioridad(ISBN_JAVA, marta.getId()))
            .isInstanceOf(MaterialYaUrgenteException.class)
            .hasMessageContaining("ya tiene una devolución urgente en curso");
}

@Service
public class ServicioPrestamoPrioritario {

    private final List<VerificacionPrioridad> verificaciones;   // Cadena de responsabilidad
    private final Clock reloj;

    @Transactional
    public Prestamo prestarConPrioridad(Isbn isbn, Long idEmpleado) {
        ContextoPrioridad ctx = construirContexto(isbn, idEmpleado);

        // Si el material está libre, no hay nada que verificar: préstamo normal
        if (ctx.material().tieneUnidadesLibres()) {
            return gestorPrestamos.prestar(isbn, idEmpleado, null);
        }

        // Cada verificación lanza su propia excepción específica
        verificaciones.forEach(v -> v.verificar(ctx));

        return activarPrioridad(ctx);
    }

    private Prestamo activarPrioridad(ContextoPrioridad ctx) {
        LocalDate limite = LocalDate.now(reloj).plusDays(2);
        ctx.prestamoEnCurso().marcarUrgente(limite);
        ctx.empleado().consumirPrioridad();
        notificador.notificar(Aviso.devolucionUrgente(ctx.prestamoEnCurso(), limite));
        eventos.publicar(new PrioridadActivada(ctx.isbn(), ctx.empleado().getId(), limite));
        return Prestamo.prioritarioEnEspera(ctx.material(), ctx.empleado(), LocalDate.now(reloj));
    }
}

@Component @Order(10)
class VerificarProyectoCritico implements VerificacionPrioridad {
    public void verificar(ContextoPrioridad ctx) {
        if (!ctx.empleado().tieneProyectoCriticoActivo()) {
            throw new SinPrioridadDisponibleException(ctx.empleado().getNombre());
        }
    }
}

@Component @Order(20)
class VerificarPrioridadDisponible implements VerificacionPrioridad {
    public void verificar(ContextoPrioridad ctx) {
        if (ctx.empleado().prioridadesEnUso() >= 1) {
            throw new PrioridadYaEnUsoException(ctx.empleado().getNombre());
        }
    }
}

@Component @Order(30)
class VerificarMaterialNoUrgente implements VerificacionPrioridad {
    public void verificar(ContextoPrioridad ctx) {
        if (ctx.prestamoEnCurso().esUrgente()) {
            throw new MaterialYaUrgenteException(ctx.isbn());
        }
    }
}

@Test
void trasUsarLaPrioridadElEmpleadoNoPuedeUsarOtra() {
    Empleado marta = unEmpleado("Marta Ruiz").conProyectoCritico();
    materialSinUnidadesLibres(ISBN_JAVA);
    materialSinUnidadesLibres(ISBN_PATRONES);

    servicio.prestarConPrioridad(ISBN_JAVA, marta.getId());

    assertThatThrownBy(() -> servicio.prestarConPrioridad(ISBN_PATRONES, marta.getId()))
            .isInstanceOf(PrioridadYaEnUsoException.class);
}

@Test
void publicaElEventoDePrioridadActivada() {
    Empleado marta = unEmpleado("Marta Ruiz").conProyectoCritico();
    prestamoActivoDe(ISBN_JAVA, DIEGO);
    materialSinUnidadesLibres(ISBN_JAVA);

    servicio.prestarConPrioridad(ISBN_JAVA, marta.getId());

    assertThat(eventos.publicados())
            .singleElement(as(InstanceOfAssertFactories.type(PrioridadActivada.class)))
            .satisfies(e -> {
                assertThat(e.isbn()).isEqualTo(ISBN_JAVA);
                assertThat(e.fechaLimite()).isEqualTo(LocalDate.of(2026, 8, 7));   // fecha EXACTA
            });
}

# .github/workflows/ci.yml
name: CI

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
  schedule:
    - cron: '0 4 * * 1'        # lunes a las 04:00 UTC: pruebas de mutación

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

permissions:
  contents: read
  pull-requests: write         # necesario para comentar en el PR
  checks: write

jobs:

  # =====================================================================
  # 1. RÁPIDO — respuesta en menos de 3 minutos
  # =====================================================================
  rapido:
    name: Formato y pruebas unitarias
    runs-on: ubuntu-latest
    timeout-minutes: 8

    steps:
      - uses: actions/checkout@v4

      - name: Configurar JDK 21
        uses: actions/setup-java@v4
        with:
          java-version: '21'
          distribution: temurin
          cache: maven

      - name: Verificar formato
        run: ./mvnw -B --no-transfer-progress spotless:check

      - name: Compilar y pruebas unitarias
        run: ./mvnw -B --no-transfer-progress test

      - name: Publicar resultados
        uses: mikepenz/action-junit-report@v4
        if: always()
        with:
          report_paths: '**/target/surefire-reports/TEST-*.xml'
          check_name: 'Pruebas unitarias'
          detailed_summary: true

  # =====================================================================
  # 2. MATRIZ — Java 21 (producción) y Java 23 (detección temprana)
  # =====================================================================
  compatibilidad:
    name: Java ${{ matrix.java }}
    runs-on: ubuntu-latest
    needs: rapido
    timeout-minutes: 15

    strategy:
      fail-fast: false            # que un fallo en 23 no cancele el de 21
      matrix:
        java: ['21', '23']

    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.java }}
          distribution: temurin
          cache: maven

      - name: Pruebas unitarias
        run: ./mvnw -B --no-transfer-progress test
        # Java 23 es informativo: no debe bloquear la fusión
        continue-on-error: ${{ matrix.java == '23' }}

  # =====================================================================
  # 3. COMPLETO — integración con Testcontainers, cobertura y análisis
  # =====================================================================
  completo:
    name: Integración, cobertura y análisis
    runs-on: ubuntu-latest
    needs: rapido
    timeout-minutes: 25

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - uses: actions/setup-java@v4
        with:
          java-version: '21'
          distribution: temurin
          cache: maven

      # Precargar la imagen: evita que el primer test cargue con los 30 s de descarga
      - name: Precargar imagen de PostgreSQL
        run: docker pull postgres:16-alpine

      - name: Pruebas de integración y cobertura
        run: ./mvnw -B --no-transfer-progress verify
        env:
          TESTCONTAINERS_REUSE_ENABLE: 'false'      # en CI, contenedores limpios

      - name: Comentar la cobertura en el PR
        uses: madrapps/[email protected]
        if: github.event_name == 'pull_request'
        with:
          paths: '**/target/site/jacoco/jacoco.xml'
          token: ${{ secrets.GITHUB_TOKEN }}
          min-coverage-overall: 75
          min-coverage-changed-files: 80
          title: '📊 Cobertura'
          update-comment: true                      # actualiza en vez de acumular comentarios
          pass-emoji: '✅'
          fail-emoji: '❌'

      - name: Comprobar umbrales de cobertura
        run: ./mvnw -B jacoco:check

      - name: Análisis estático (SpotBugs + FindSecBugs)
        run: ./mvnw -B spotbugs:check

      - name: Reglas de arquitectura (ArchUnit)
        run: ./mvnw -B test -Dtest='ReglasDeArquitecturaTest'

      - name: Guardar informes
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: informes-calidad
          path: |
            **/target/site/jacoco/
            **/target/spotbugsXml.xml
            **/target/failsafe-reports/
          retention-days: 14

      - name: Resumen en la pestaña de la ejecución
        if: always()
        run: |
          echo "## Resumen de calidad" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          echo "| Comprobación | Resultado |" >> $GITHUB_STEP_SUMMARY
          echo "|---|---|" >> $GITHUB_STEP_SUMMARY
          echo "| Pruebas unitarias | ${{ needs.rapido.result }} |" >> $GITHUB_STEP_SUMMARY
          echo "| Integración | ${{ job.status }} |" >> $GITHUB_STEP_SUMMARY

  # =====================================================================
  # 4. MUTACIÓN — solo los lunes y en main. Es lenta.
  # =====================================================================
  mutacion:
    name: Pruebas de mutación (PIT)
    runs-on: ubuntu-latest
    if: github.event_name == 'schedule' || github.ref == 'refs/heads/main'
    timeout-minutes: 40

    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          java-version: '21'
          distribution: temurin
          cache: maven

      - name: PIT sobre el dominio
        run: |
          ./mvnw -B -pl bibliotech-dominio \
            org.pitest:pitest-maven:mutationCoverage \
            -DmutationThreshold=70

      - uses: actions/upload-artifact@v4
        if: always()
        with:
          name: informe-mutacion
          path: '**/target/pit-reports/'
          retention-days: 30

      - name: Abrir incidencia si baja del umbral
        if: failure()
        uses: actions/github-script@v7
        with:
          script: |
            github.rest.issues.create({
              owner: context.repo.owner,
              repo: context.repo.repo,
              title: '⚠️ La cobertura de mutación del dominio bajó del 70 %',
              body: 'Revisa el informe de PIT en los artefactos de la ejecución ' +
                    context.runId + '. Hay mutantes supervivientes: las aserciones ' +
                    'de alguna prueba no detectan cambios en el código.',
              labels: ['calidad', 'pruebas']
            })