# Les 10 proves més lentes del projecte
./mvnw test -Dsurefire.reportFormat=plain
grep -h "Time elapsed" target/surefire-reports/*.txt | sort -t: -k2 -rn | head -10

@Test
void laSuiteDeDominiEsRapida() {
    long inici = System.nanoTime();
    // executar el conjunt de proves de domini…
    long ms = (System.nanoTime() - inici) / 1_000_000;
    assertThat(ms)
        .as("Les proves de domini han de continuar sent rapides")
        .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>

/**
 * Classe base de les proves d'integracio.
 *
 * El contenidor es static: es crea UNA VEGADA per a tota l'execucio
 * i el comparteixen totes les classes que n'hereten. Sense static,
 * s'aixecaria un PostgreSQL per classe de prova (30 s cadascun).
 */
@Testcontainers
public abstract class ProvaAmbPostgres {

    @Container
    @ServiceConnection            // Spring Boot 3.1+: configura el DataSource sol
    static final PostgreSQLContainer<?> POSTGRES =
            new PostgreSQLContainer<>("postgres:16-alpine")
                    .withDatabaseName("bibliotech_test")
                    .withUsername("test")
                    .withPassword("test")
                    .withReuse(true);      // reutilitza el contenidor entre execucions locals
}

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

@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)   // no substitueixis per H2!
@Tag("integracio")
class PrestecRepositoryIT extends ProvaAmbPostgres {

    @Autowired PrestecRepository repositori;
    @Autowired TestEntityManager em;

    @Test
    void trobaElsPrestecsVencutsOrdenatsPerAntiguitat() {
        Empleat marta = em.persist(unEmpleat("Marta Ruiz"));
        Material java = em.persist(unLlibre("978-0000000001", "Java Eficac"));

        em.persist(unPrestec(java, marta).ambVenciment(LocalDate.of(2026, 3, 1)));   // vencut
        em.persist(unPrestec(java, marta).ambVenciment(LocalDate.of(2026, 3, 10)));  // vencut
        em.persist(unPrestec(java, marta).ambVenciment(LocalDate.of(2026, 9, 1)));   // vigent
        em.flush();

        List<Prestec> vencuts = repositori.vencutsAbansDe(LocalDate.of(2026, 8, 5));

        assertThat(vencuts)
                .hasSize(2)
                .extracting(Prestec::getDataVenciment)
                .containsExactly(LocalDate.of(2026, 3, 1), LocalDate.of(2026, 3, 10));
    }

    @Test
    void laCercaIgnoraMajusculesIAccentsComAProduccio() {
        em.persist(unLlibre("978-0000000003", "Refactoritzacio"));
        em.flush();

        // Aixo fa servir unaccent() de PostgreSQL: a H2 seria IMPOSSIBLE de provar
        assertThat(repositori.cercarPerTitol("refactoritzacio")).hasSize(1);
        assertThat(repositori.cercarPerTitol("REFACTORITZACIÓ")).hasSize(1);
    }

    @Test
    void detectaElConflicteDeBloqueigOptimista() {
        Prestec p = em.persistFlushFind(unPrestec());
        em.detach(p);

        // Simular una modificacio concurrent per part d'una altra transaccio
        em.getEntityManager()
          .createNativeQuery("update prestecs set version = version + 1 where id = :id")
          .setParameter("id", p.getId())
          .executeUpdate();

        p.renovar(7);

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

# ~/.testcontainers.properties — reutilitzar contenidors entre execucions locals
testcontainers.reuse.enable=true

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-surefire-plugin</artifactId>
      <configuration>
        <excludedGroups>integracio</excludedGroups>   <!-- per si alguna Test porta @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 qui FA FALLAR la construccio -->
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

./mvnw test                    # només unitàries: ~20 s
./mvnw verify                  # unitàries + integració: ~3 min
./mvnw verify -DskipITs        # saltar-se les d'integració
./mvnw test -Dgroups=rapida    # només les etiquetades

@Tag("integracio")
@Tag("lenta")
class ImportacioMassivaIT extends ProvaAmbPostgres { … }

# 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 abans de les proves unitaries -->
    <execution>
      <id>preparar-agent</id>
      <goals><goal>prepare-agent</goal></goals>
    </execution>

    <!-- 2. Generar l'informe despres de les proves -->
    <execution>
      <id>informe</id>
      <phase>verify</phase>
      <goals><goal>report</goal></goals>
    </execution>

    <!-- 3. Comprovar llindars: si no es compleixen, la construccio FALLA -->
    <execution>
      <id>comprovar-llindars</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 metrica que de debo importa -->
                <value>COVEREDRATIO</value>
                <minimum>0.70</minimum>
              </limit>
            </limits>
          </rule>
          <!-- El domini es logica pura: se n'exigeix mes -->
          <rule>
            <element>PACKAGE</element>
            <includes><include>com.nexussoftware.bibliotech.domini.*</include></includes>
            <limits>
              <limit>
                <counter>BRANCH</counter>
                <value>COVEREDRATIO</value>
                <minimum>0.90</minimum>
              </limit>
            </limits>
          </rule>
        </rules>
      </configuration>
    </execution>
  </executions>

  <configuration>
    <excludes>
      <!-- Excloure el que no te logica per provar -->
      <exclude>**/dto/**</exclude>
      <exclude>**/*Application.class</exclude>
      <exclude>**/config/**</exclude>
      <exclude>**/generated/**</exclude>
    </excludes>
  </configuration>
</plugin>

./mvnw verify
# L'informe navegable, amb el codi acolorit línia a línia:
open target/site/jacoco/index.html

public Diner calcularMulta(Prestec prestec, LocalDate avui) {
    long dies = ChronoUnit.DAYS.between(prestec.getDataVenciment(), avui);
    if (dies <= 0) {
        return Diner.ZERO;
    }
    Diner multa = prestec.multaPerDia().per(dies);
    return multa.esMesGranQue(MAXIM) ? MAXIM : multa;
}

@Test
void calculaLaMultaDeDeuDies() {
    assertThat(calculadora.calcularMulta(prestecVencutFa(10), AVUI))
            .isEqualTo(Diner.euros("5.00"));
}

@Test
void calculaLaMulta() {
    // Executa TOT el metode: cobertura de linies del 100 %
    calculadora.calcularMulta(unPrestecVencutFa(10), AVUI);
    // I NO COMPROVA RES.
}

<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.domini.*</param>   <!-- on hi ha la logica -->
    </targetClasses>
    <targetTests>
      <param>com.nexussoftware.bibliotech.domini.*Test</param>
    </targetTests>
    <mutationThreshold>70</mutationThreshold>
    <timestampedReports>false</timestampedReports>
  </configuration>
</plugin>

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

public Diner calcularMulta(Prestec prestec, LocalDate avui) {
    long dies = ChronoUnit.DAYS.between(prestec.getDataVenciment(), avui);
    if (dies <= 0) {                                    // ← el punt critic
        return Diner.ZERO;
    }
    Diner multa = prestec.multaPerDia().per(dies);
    return multa.esMesGranQue(MAXIM) ? MAXIM : multa;
}

@Test void senseRetardNoHiHaMulta()    { assertThat(calcular(-3)).isEqualTo(Diner.ZERO); }
@Test void ambDeuDiesSonCincEuros()    { assertThat(calcular(10)).isEqualTo(Diner.euros("5.00")); }
@Test void maiNoSuperaElMaxim()        { assertThat(calcular(100)).isEqualTo(Diner.euros("20.00")); }

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

@ParameterizedTest
@CsvSource({
    "-1, 0.00",     // un dia abans de vencer
    " 0, 0.00",     // EL DIA DEL VENCIMENT: la frontera
    " 1, 0.50",     // un dia de retard
    "39, 19.50",    // just per sota del maxim
    "40, 20.00",    // exactament el maxim
    "41, 20.00"     // per sobre: aplica el sostre
})
void calculaLaMultaEnLesFronteres(int diesDeRetard, String multaEsperada) {
    assertThat(calcular(diesDeRetard)).isEqualTo(Diner.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-exclusions.xml</excludeFilterFile>
    <plugins>
      <plugin>
        <groupId>com.h3xstream.findsecbugs</groupId>     <!-- analisi de seguretat -->
        <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 — depen de la codificacio de la plataforma
Files.readString(cami);                          // MALAMENT
Files.readString(cami, StandardCharsets.UTF_8);  // BE

// SpotBugs: ES_COMPARING_STRINGS_WITH_EQ
if (estat == "ACTIU")             // MALAMENT: compara referencies
if ("ACTIU".equals(estat))        // BE

// SpotBugs: EI_EXPOSE_REP — s'exposa la representacio interna
public List<Prestec> getPrestecs() { return prestecs; }             // MALAMENT: mutable
public List<Prestec> getPrestecs() { return List.copyOf(prestecs); } // BE

// FindSecBugs: SQL_INJECTION_JPA
em.createQuery("select m from Material m where m.titol like '%" + text + "%'");   // MALAMENT
em.createQuery("select m from Material m where m.titol like :t").setParameter("t", …); // BE

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

./mvnw spotless:apply     # formata (en local, o com a enganxall de pre-commit)
./mvnw spotless:check     # falla si no està formatat (a CI)

// DEUTE: la cerca recorre tot el cataleg en memoria perque son ~3.000 materials.
// Amb mes de 50.000 caldra passar a cerca a text complet de PostgreSQL.
// Decidit conscientment el 2026-08-05 — veure docs/adr/0007-cerca-en-memoria.md

// ABANS: 40 linies, tres responsabilitats entremesclades
public ResultatImportacio importar(Path fitxer) {
    List<String> linies = Files.readAllLines(fitxer, UTF_8);
    List<Material> materials = new ArrayList<>();
    List<String> errors = new ArrayList<>();

    for (int i = 1; i < linies.size(); i++) {
        String[] camps = linies.get(i).split(";");
        if (camps.length < 4) { errors.add("Linia " + i + ": camps insuficients"); continue; }
        if (!camps[0].matches("97[89]-\\d{10}")) { errors.add("Linia " + i + ": ISBN invalid"); continue; }
        // … 20 linies mes de conversio i validacio
    }
    // … desat i resum
}

// DESPRES: el metode principal explica la historia; els detalls son un nivell mes avall
public ResultatImportacio importar(Path fitxer) throws IOException {
    List<LiniaCsv> linies = llegirLinies(fitxer);
    ResultatParseig parseig = parsejar(linies);
    List<Material> desats = desar(parseig.valids());
    return new ResultatImportacio(desats.size(), parseig.errors());
}

private ResultatParseig parsejar(List<LiniaCsv> linies) {
    List<Material> valids = new ArrayList<>();
    List<ErrorImportacio> errors = new ArrayList<>();
    for (LiniaCsv linia : linies) {
        parsejarLinia(linia).ifPresentOrElse(valids::add, () -> errors.add(errorDe(linia)));
    }
    return new ResultatParseig(valids, errors);
}

// ABANS: Prestec barreja la seva identitat amb el calcul de multes
public class Prestec {
    public Diner calcularMulta(LocalDate avui) {
        long dies = ChronoUnit.DAYS.between(dataVenciment, avui);
        if (dies <= 0) return Diner.ZERO;
        Diner base = material.multaPerDia().per(dies);
        if (empleat.antiguitatEnMesos() < 6) base = base.multiplicarPer(0.5);
        if (empleat.esDireccio()) return Diner.ZERO;
        return base.esMesGranQue(MAXIM) ? MAXIM : base;
    }
}

// DESPRES: la politica de multes es un concepte propi, amb les seves propies proves
public class PoliticaMultes {
    private final List<ReglaTarifa> regles;     // Estrategia (12-02)

    public Diner calcular(Prestec prestec, LocalDate avui) { … }
}

public class Prestec {
    public Diner multaAcumulada(LocalDate avui, PoliticaMultes politica) {
        return politica.calcular(this, avui);
    }
}

// ABANS
public int diesDePrestec(Material m) {
    switch (m.getTipus()) {
        case LLIBRE: return 15;
        case REVISTA: return 7;
        case DVD: return 3;
        default: throw new IllegalStateException();
    }
}

// DESPRES: cada tipus respon per si mateix
public abstract class Material {
    public abstract int diesDePrestecPerDefecte();
}

class RecarrecPerDanyTest {

    @Test
    void unMaterialSenseDanyNoTeRecarrec() {
        var calculadora = new CalculadoraRecarrecs();
        var material = unLlibre("978-0000000001").ambValor(Diner.euros("45.00"));

        Diner recarrec = calculadora.calcular(material, EstatDevolucio.SENSE_DANY);

        assertThat(recarrec).isEqualTo(Diner.ZERO);
    }
}

public enum EstatDevolucio { SENSE_DANY }

public class CalculadoraRecarrecs {
    public Diner calcular(Material material, EstatDevolucio estat) {
        return Diner.ZERO;      // si, aixo es fer trampa. I es correcte en TDD.
    }
}

@Test
void unDanyLleuSuposaElVintPerCentDelValor() {
    var material = unLlibre("978-0000000001").ambValor(Diner.euros("45.00"));

    Diner recarrec = calculadora.calcular(material, EstatDevolucio.LLEU);

    assertThat(recarrec).isEqualTo(Diner.euros("9.00"));      // 45 x 0,20
}

public enum EstatDevolucio { SENSE_DANY, LLEU }

public class CalculadoraRecarrecs {
    public Diner calcular(Material material, EstatDevolucio estat) {
        if (estat == EstatDevolucio.SENSE_DANY) return Diner.ZERO;
        return material.getValor().multiplicarPer(new BigDecimal("0.20"));
    }
}

@ParameterizedTest
@CsvSource({
    "SENSE_DANY,     0.00",
    "LLEU,           9.00",
    "GREU,          27.00",
    "IRRECUPERABLE, 45.00"
})
void elRecarrecDepenDelEstatDeDevolucio(EstatDevolucio estat, String esperat) {
    var material = unLlibre("978-0000000001").ambValor(Diner.euros("45.00"));
    assertThat(calculadora.calcular(material, estat)).isEqualTo(Diner.euros(esperat));
}

public Diner calcular(Material material, EstatDevolucio estat) {
    BigDecimal percentatge = switch (estat) {
        case SENSE_DANY -> BigDecimal.ZERO;
        case LLEU -> new BigDecimal("0.20");
        case GREU -> new BigDecimal("0.60");
        case IRRECUPERABLE -> BigDecimal.ONE;
    };
    return material.getValor().multiplicarPer(percentatge);
}

public enum EstatDevolucio {
    SENSE_DANY(BigDecimal.ZERO),
    LLEU(new BigDecimal("0.20")),
    GREU(new BigDecimal("0.60")),
    IRRECUPERABLE(BigDecimal.ONE);

    private final BigDecimal percentatgeRecarrec;

    EstatDevolucio(BigDecimal percentatgeRecarrec) {
        this.percentatgeRecarrec = percentatgeRecarrec;
    }

    public BigDecimal percentatgeRecarrec() { return percentatgeRecarrec; }
    public boolean exigeixRetirarDelCataleg() { return this == IRRECUPERABLE; }
}

public class CalculadoraRecarrecs {
    public Diner calcular(Material material, EstatDevolucio estat) {
        return material.getValor().multiplicarPer(estat.percentatgeRecarrec());
    }
}

@Test
void elTotalDeMultaIRecarrecNoSuperaElValorDelMaterial() {
    var material = unLlibre("978-0000000001").ambValor(Diner.euros("45.00"));
    var prestec = unPrestecDe(material).vencutFa(200);   // multa enorme

    Diner total = calculadora.totalACobrar(prestec, EstatDevolucio.GREU, AVUI);

    // multa (sostre 20 EUR) + recarrec (27 EUR) = 47 EUR, pero el material val 45 EUR
    assertThat(total).isEqualTo(Diner.euros("45.00"));
}

public Diner totalACobrar(Prestec prestec, EstatDevolucio estat, LocalDate avui) {
    Diner multa = politicaMultes.calcular(prestec, avui);
    Diner recarrec = calcular(prestec.getMaterial(), estat);
    Diner total = multa.mes(recarrec);
    Diner valorMaterial = prestec.getMaterial().getValor();
    return total.esMesGranQue(valorMaterial) ? valorMaterial : total;
}

@Test
void unMaterialIrrecuperableEsRetiraDelCataleg() {
    var material = unLlibre("978-0000000001").ambValor(Diner.euros("45.00"));
    var prestec = unPrestecDe(material);

    servei.registrarDevolucio(prestec.getId(), EstatDevolucio.IRRECUPERABLE, AVUI);

    assertThat(material.estaRetirat()).isTrue();
    verify(cataleg).retirar(material.getIsbn(), MotiuRetirada.DANYAT);
}

@Test
void unMaterialAmbDanyGreuSegueixAlCataleg() {
    var material = unLlibre("978-0000000001");
    servei.registrarDevolucio(unPrestecDe(material).getId(), EstatDevolucio.GREU, AVUI);

    assertThat(material.estaRetirat()).isFalse();
    verifyNoInteractions(cataleg);
}

@Transactional
public ResultatDevolucio registrarDevolucio(Long idPrestec, EstatDevolucio estat, LocalDate data) {
    Prestec prestec = repositori.cercarPerId(idPrestec)
            .orElseThrow(() -> new PrestecNoTrobatException(idPrestec));

    prestec.registrarDevolucio(data);
    Diner total = calculadora.totalACobrar(prestec, estat, data);

    if (estat.exigeixRetirarDelCataleg()) {
        cataleg.retirar(prestec.getIsbn(), MotiuRetirada.DANYAT);
    }
    esdeveniments.publicar(new MaterialRetornat(prestec.getId(), estat, total));   // Observador
    return new ResultatDevolucio(prestec.getId(), data, total, estat);
}

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

CalculadoraRecarrecs   : 100% mutació (8/8 mutants eliminats)
EstatDevolucio         : 100% mutació (4/4)

## Revisió de codi — BiblioTech

### Correcció
- [ ] Fa el que diu la descripció del PR?
- [ ] Es gestionen els casos límit (buit, nul, zero, negatiu, màxim)?
- [ ] Les excepcions es capturen al nivell correcte (06-07)?
- [ ] Hi ha condicions de cursa si això s'executa en paral·lel?

### Arquitectura
- [ ] És al mòdul correcte (domini / aplicació / infraestructura)?
- [ ] El domini continua sense importar Spring ni JPA?
- [ ] S'exposen entitats JPA a l'API? (no s'ha de fer)
- [ ] La transacció és al cas d'ús, no al controlador?

### Proves
- [ ] Hi ha proves del camí feliç I dels errors?
- [ ] Les proves tenen assercions significatives?
- [ ] Són al nivell més baix possible?
- [ ] Es fa servir `Clock` injectable en lloc de `LocalDate.now()`?

### Seguretat (12-07)
- [ ] Es valida tota entrada externa?
- [ ] Hi ha secrets, tokens o dades personals al codi o al registre?
- [ ] Les consultes fan servir paràmetres, mai concatenació?

### Llegibilitat
- [ ] Els noms descriuen la intenció?
- [ ] Algun mètode supera les 30 línies o la complexitat 10?
- [ ] Els comentaris expliquen el «per què», no el «què»?

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

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

# Cancel·la execucions anteriors del mateix PR: no té sentit provar codi ja obsolet
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

env:
  JAVA_VERSION: '21'

jobs:

  # ---------------------------------------------------------------
  # Treball 1: ràpid. Dona resposta en menys de 3 minuts.
  # ---------------------------------------------------------------
  verificacio-rapida:
    name: Compilació, format i proves unitàries
    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              # posa ~/.m2 a la memòria cau: estalvia 1-2 minuts per execució

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

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

      - name: Proves unitàries
        run: ./mvnw -B test

      - name: Publicar resultats de les proves
        uses: mikepenz/action-junit-report@v4
        if: always()                # també quan fallen: és quan més es necessita
        with:
          report_paths: '**/target/surefire-reports/TEST-*.xml'
          check_name: 'Proves unitaries'

  # ---------------------------------------------------------------
  # Treball 2: lent. Testcontainers, cobertura i anàlisi estàtica.
  # ---------------------------------------------------------------
  verificacio-completa:
    name: Integració, cobertura i anàlisi
    runs-on: ubuntu-latest
    needs: verificacio-rapida       # no gastis 10 minuts si no compila
    timeout-minutes: 25

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0            # Sonar necessita l'històric per al "codi nou"

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

      # Docker ja està disponible a ubuntu-latest: Testcontainers funciona sense més

      - name: Proves d'integració i cobertura
        run: ./mvnw -B verify
        env:
          TESTCONTAINERS_RYUK_DISABLED: 'false'

      - name: Comprovar llindars de cobertura
        run: ./mvnw -B jacoco:check

      - name: Publicar cobertura al 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 codi NOU, més exigent
          title: 'Informe de cobertura'

      - name: Anàlisi estàtica
        run: ./mvnw -B spotbugs:check

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

  # ---------------------------------------------------------------
  # Treball 3: només a main. Proves de mutació, que són lentes.
  # ---------------------------------------------------------------
  mutacio:
    name: Proves de mutació
    runs-on: ubuntu-latest
    needs: verificacio-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 domini
        run: ./mvnw -B -pl bibliotech-domini org.pitest:pitest-maven:mutationCoverage

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

// MALAMENT: prova COM es fa. Refactoritzar la trenca encara que el comportament no canvii.
@Test
void faServirElRepositoriPerCercar() {
    servei.cercarPerIsbn(isbn);
    verify(repositori).findByIsbn(isbn);      // i si dema fa servir una memoria cau?
}

// BE: prova QUE fa. Sobreviu a qualsevol refactor intern.
@Test
void retornaElMaterialQuanExisteix() {
    when(repositori.findByIsbn(isbn)).thenReturn(Optional.of(javaEficac));

    Optional<Material> resultat = servei.cercarPerIsbn(isbn);

    assertThat(resultat).contains(javaEficac);
}

// FRAGIL: falla l'1 de gener, o si la prova corre a mitjanit
@Test
void elPrestecVenceEnQuinzeDies() {
    Prestec p = gestor.prestar(isbn, 1L, 15);
    assertThat(p.getDataVenciment()).isEqualTo(LocalDate.now().plusDays(15));
}

// ROBUSTA: el temps es una dependencia com qualsevol altra
@Test
void elPrestecVenceEnQuinzeDies() {
    var rellotge = Clock.fixed(Instant.parse("2026-08-05T10:00:00Z"), ZoneId.of("Europe/Madrid"));
    var gestor = new GestorPrestecs(repositori, notificador, rellotge);

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

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

// FRAGIL: 500 ms pot no bastar en una maquina carregada, i sobra en una de rapida
@Test
void laImportacioAsincronaAcaba() throws Exception {
    servei.importarAsincron(fitxer);
    Thread.sleep(500);
    assertThat(repositori.count()).isEqualTo(100);
}

// ROBUSTA: espera a la CONDICIO, no a un temps
@Test
void laImportacioAsincronaAcaba() {
    servei.importarAsincron(fitxer);

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

class ProcessadorReservesTest {

    ProcessadorReserves processador = new ProcessadorReserves(
            new RepositoriReservesEnMemoria(), new NotificadorFals());

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

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

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

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

@DisplayName("Processador de reserves")
class ProcessadorReservesTest {

    // Rellotge FIX: elimina tota dependencia del moment d'execucio
    private static final Instant ARA = Instant.parse("2026-08-05T10:00:00Z");
    private static final ZoneId MADRID = ZoneId.of("Europe/Madrid");

    private RepositoriReservesEnMemoria repositori;
    private NotificadorEspia notificador;
    private RellotgeMutable rellotge;            // rellotge avancable, sense Thread.sleep
    private ProcessadorReserves processador;

    @BeforeEach
    void preparar() {
        // Estat NOU a cada prova: sense contaminacio entre elles
        repositori = new RepositoriReservesEnMemoria();
        notificador = new NotificadorEspia();
        rellotge = RellotgeMutable.de(ARA, MADRID);
        processador = new ProcessadorReserves(repositori, notificador, rellotge);
    }

    @Nested
    @DisplayName("En crear una reserva")
    class EnReservar {

        @Test
        @DisplayName("queda pendent i a la cua del material")
        void quedaPendentIALaCua() {
            Reserva reserva = processador.reservar(ISBN_JAVA, MARTA);

            assertThat(reserva.getEstat()).isEqualTo(EstatReserva.PENDENT);
            assertThat(reserva.getMaterialIsbn()).isEqualTo(ISBN_JAVA);
            assertThat(reserva.getIdEmpleat()).isEqualTo(MARTA);
            assertThat(reserva.getDataSollicitud()).isEqualTo(ARA);
            assertThat(repositori.pendentsDe(ISBN_JAVA)).containsExactly(reserva);
        }

        @Test
        @DisplayName("respecta l'ordre d'arribada a la cua")
        void respectaLOrdreDArribada() {
            Reserva primera = processador.reservar(ISBN_JAVA, MARTA);
            rellotge.avancar(Duration.ofMinutes(5));
            Reserva segona = processador.reservar(ISBN_JAVA, DIEGO);

            assertThat(repositori.pendentsDe(ISBN_JAVA))
                    .containsExactly(primera, segona);       // l'ordre importa
        }

        @Test
        @DisplayName("rebutja una segona reserva del mateix empleat i material")
        void rebutjaReservaDuplicada() {
            processador.reservar(ISBN_JAVA, MARTA);

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

            assertThat(repositori.pendentsDe(ISBN_JAVA)).hasSize(1);
        }

        @Test
        @DisplayName("rebutja reservar un material inexistent")
        void rebutjaMaterialInexistent() {
            assertThatThrownBy(() -> processador.reservar(ISBN_INEXISTENT, MARTA))
                    .isInstanceOf(MaterialNoTrobatException.class);
        }
    }

    @Nested
    @DisplayName("En cancel·lar")
    class EnCancellar {

        @Test
        @DisplayName("la reserva passa a CANCELLADA i surt de la cua")
        void passaACancelladaISurtDeLaCua() {
            Reserva reserva = processador.reservar(ISBN_JAVA, MARTA);

            processador.cancellar(reserva.getId());

            assertThat(repositori.perId(reserva.getId()))
                    .get()
                    .extracting(Reserva::getEstat)
                    .isEqualTo(EstatReserva.CANCELLADA);
            assertThat(repositori.pendentsDe(ISBN_JAVA)).isEmpty();
        }

        @Test
        @DisplayName("cancel·lar dues vegades llança TransicioInvalidaException")
        void cancellarDuesVegadesFalla() {
            Reserva reserva = processador.reservar(ISBN_JAVA, MARTA);
            processador.cancellar(reserva.getId());

            assertThatThrownBy(() -> processador.cancellar(reserva.getId()))
                    .isInstanceOf(TransicioInvalidaException.class);
        }

        @Test
        @DisplayName("cancel·lar una reserva inexistent llança ReservaNoTrobadaException")
        void reservaInexistent() {
            assertThatThrownBy(() -> processador.cancellar(9999L))
                    .isInstanceOf(ReservaNoTrobadaException.class);
        }
    }

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

        @Test
        @DisplayName("una reserva disponible caduca a les 48 hores exactes")
        void caducaALes48Hores() {
            Reserva reserva = processador.reservar(ISBN_JAVA, MARTA);
            processador.assignarExemplar(reserva.getId());

            rellotge.avancar(Duration.ofHours(48));       // sense Thread.sleep!
            int caducades = processador.caducarVencudes();

            assertThat(caducades).isEqualTo(1);
            assertThat(repositori.perId(reserva.getId()))
                    .get().extracting(Reserva::getEstat)
                    .isEqualTo(EstatReserva.CADUCADA);
        }

        @Test
        @DisplayName("a les 47 hores i 59 minuts encara NO caduca")
        void noCaducaAbansDHora() {
            Reserva reserva = processador.reservar(ISBN_JAVA, MARTA);
            processador.assignarExemplar(reserva.getId());

            rellotge.avancar(Duration.ofHours(47).plusMinutes(59));
            int caducades = processador.caducarVencudes();

            assertThat(caducades).isZero();               // LA FRONTERA
            assertThat(repositori.perId(reserva.getId()))
                    .get().extracting(Reserva::getEstat)
                    .isEqualTo(EstatReserva.DISPONIBLE);
        }

        @Test
        @DisplayName("les reserves pendents no caduquen: no tenen data límit")
        void lesPendentsNoCaduquen() {
            processador.reservar(ISBN_JAVA, MARTA);       // PENDENT, sense exemplar assignat

            rellotge.avancar(Duration.ofDays(30));

            assertThat(processador.caducarVencudes()).isZero();
        }

        @Test
        @DisplayName("en caducar s'avisa l'empleat i s'activa la següent de la cua")
        void avisaIActivaLaSeguent() {
            Reserva deMarta = processador.reservar(ISBN_JAVA, MARTA);
            Reserva deDiego = processador.reservar(ISBN_JAVA, DIEGO);
            processador.assignarExemplar(deMarta.getId());

            rellotge.avancar(Duration.ofHours(48));
            processador.caducarVencudes();

            assertThat(notificador.avisosEnviats())
                    .extracting(Avis::tipus)
                    .containsExactly(TipusAvis.RESERVA_CADUCADA, TipusAvis.RESERVA_DISPONIBLE);
            assertThat(repositori.perId(deDiego.getId()))
                    .get().extracting(Reserva::getEstat)
                    .isEqualTo(EstatReserva.DISPONIBLE);
        }
    }

    @Nested
    @DisplayName("Data límit de recollida")
    class DataLimit {

        @Test
        @DisplayName("es fixa a 48 hores des de l'assignació de l'exemplar")
        void aLes48HoresDesDeLAssignacio() {
            Reserva reserva = processador.reservar(ISBN_JAVA, MARTA);
            rellotge.avancar(Duration.ofDays(3));         // l'assignacio arriba dies despres
            processador.assignarExemplar(reserva.getId());

            // Data ABSOLUTA calculada des del rellotge fix: mai no depen d'"avui"
            assertThat(repositori.perId(reserva.getId()))
                    .get().extracting(Reserva::getDataLimitRecollida)
                    .isEqualTo(ARA.plus(Duration.ofDays(3)).plus(Duration.ofHours(48)));
        }

        @Test
        @DisplayName("una reserva pendent no té data límit")
        void lesPendentsNoTenenDataLimit() {
            Reserva reserva = processador.reservar(ISBN_JAVA, MARTA);
            assertThat(reserva.getDataLimitRecollida()).isNull();
        }
    }
}

/** Clock mutable per a proves: permet avancar el temps sense esperar. */
public class RellotgeMutable extends Clock {

    private Instant instant;
    private final ZoneId zona;

    private RellotgeMutable(Instant instant, ZoneId zona) {
        this.instant = instant;
        this.zona = zona;
    }

    public static RellotgeMutable de(Instant instant, ZoneId zona) {
        return new RellotgeMutable(instant, zona);
    }

    public void avancar(Duration durada) { this.instant = instant.plus(durada); }

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

@Test
void unEmpleatSenseProjecteCriticNoPotUsarPrioritat() {
    Empleat diego = unEmpleat("Diego Alonso").senseProjectesCritics();

    assertThatThrownBy(() -> servei.prestarAmbPrioritat(ISBN_JAVA, diego.getId()))
            .isInstanceOf(SensePrioritatDisponibleException.class)
            .hasMessageContaining("no te cap projecte critic actiu");
}

public Prestec prestarAmbPrioritat(Isbn isbn, Long idEmpleat) {
    Empleat empleat = empleats.cercarPerId(idEmpleat).orElseThrow(…);
    if (!empleat.teProjecteCriticActiu()) {
        throw new SensePrioritatDisponibleException(
                "L'empleat %s no te cap projecte critic actiu."
                        .formatted(empleat.getNom()));
    }
    return null;   // el minim perque la prova passi
}

@Test
void siElMaterialEstaLliureEsFaUnPrestecNormalSenseConsumirPrioritat() {
    Empleat marta = unEmpleat("Marta Ruiz").ambProjecteCritic();
    materialLliure(ISBN_JAVA);

    Prestec prestec = servei.prestarAmbPrioritat(ISBN_JAVA, marta.getId());

    assertThat(prestec.esPrioritari()).isFalse();
    assertThat(marta.prioritatsEnUs()).isZero();         // la prioritat NO es va gastar
}

public Prestec prestarAmbPrioritat(Isbn isbn, Long idEmpleat) {
    Empleat empleat = …;
    verificarTeProjecteCritic(empleat);

    Material material = materials.cercarPerIsbn(isbn).orElseThrow(…);
    if (material.teUnitatsLliures()) {
        return gestorPrestecs.prestar(isbn, idEmpleat, null);   // prestec normal
    }
    return null;
}

@Test
void marcaElPrestecEnCursPerADevolucioUrgentEnQuarantaVuitHores() {
    Empleat marta = unEmpleat("Marta Ruiz").ambProjecteCritic();
    Prestec enCurs = prestecActiuDe(ISBN_JAVA, DIEGO);
    materialSenseUnitatsLliures(ISBN_JAVA);

    servei.prestarAmbPrioritat(ISBN_JAVA, marta.getId());

    assertThat(enCurs.esUrgent()).isTrue();
    assertThat(enCurs.getDataVenciment())
            .isEqualTo(LocalDate.now(rellotge).plusDays(2));
}

@Test
void avisaLEmpleatQueTeElMaterial() {
    Empleat marta = unEmpleat("Marta Ruiz").ambProjecteCritic();
    prestecActiuDe(ISBN_JAVA, DIEGO);
    materialSenseUnitatsLliures(ISBN_JAVA);

    servei.prestarAmbPrioritat(ISBN_JAVA, marta.getId());

    assertThat(notificador.avisosEnviats())
            .singleElement()
            .satisfies(a -> {
                assertThat(a.tipus()).isEqualTo(TipusAvis.DEVOLUCIO_URGENT);
                assertThat(a.destinatari()).isEqualTo(DIEGO.getCorreu());
            });
}

public Prestec prestarAmbPrioritat(Isbn isbn, Long idEmpleat) {
    Empleat empleat = …;
    verificarTeProjecteCritic(empleat);

    Material material = …;
    if (material.teUnitatsLliures()) {
        return gestorPrestecs.prestar(isbn, idEmpleat, null);
    }

    Prestec enCurs = prestecs.actiuDe(isbn).orElseThrow(…);
    enCurs.marcarUrgent(LocalDate.now(rellotge).plusDays(2));
    notificador.notificar(Avis.devolucioUrgent(enCurs));

    return Prestec.prioritariEnEspera(material, empleat, LocalDate.now(rellotge));
}

@Test
void unEmpleatNoPotTenirDuesPrioritatsSimultanies() {
    Empleat marta = unEmpleat("Marta Ruiz").ambProjecteCritic().ambPrioritatEnUs();
    materialSenseUnitatsLliures(ISBN_JAVA);

    assertThatThrownBy(() -> servei.prestarAmbPrioritat(ISBN_JAVA, marta.getId()))
            .isInstanceOf(PrioritatJaEnUsException.class);
}

@Test
void noEsPotUsarPrioritatSobreUnMaterialJaMarcatComAUrgent() {
    Empleat marta = unEmpleat("Marta Ruiz").ambProjecteCritic();
    prestecActiuDe(ISBN_JAVA, DIEGO).jaMarcatUrgent();
    materialSenseUnitatsLliures(ISBN_JAVA);

    assertThatThrownBy(() -> servei.prestarAmbPrioritat(ISBN_JAVA, marta.getId()))
            .isInstanceOf(MaterialJaUrgentException.class)
            .hasMessageContaining("ja te una devolucio urgent en curs");
}

@Service
public class ServeiPrestecPrioritari {

    private final List<VerificacioPrioritat> verificacions;     // Cadena de responsabilitat
    private final Clock rellotge;

    @Transactional
    public Prestec prestarAmbPrioritat(Isbn isbn, Long idEmpleat) {
        ContextPrioritat ctx = construirContext(isbn, idEmpleat);

        // Si el material esta lliure, no hi ha res a verificar: prestec normal
        if (ctx.material().teUnitatsLliures()) {
            return gestorPrestecs.prestar(isbn, idEmpleat, null);
        }

        // Cada verificacio llanca la seva propia excepcio especifica
        verificacions.forEach(v -> v.verificar(ctx));

        return activarPrioritat(ctx);
    }

    private Prestec activarPrioritat(ContextPrioritat ctx) {
        LocalDate limit = LocalDate.now(rellotge).plusDays(2);
        ctx.prestecEnCurs().marcarUrgent(limit);
        ctx.empleat().consumirPrioritat();
        notificador.notificar(Avis.devolucioUrgent(ctx.prestecEnCurs(), limit));
        esdeveniments.publicar(new PrioritatActivada(ctx.isbn(), ctx.empleat().getId(), limit));
        return Prestec.prioritariEnEspera(ctx.material(), ctx.empleat(), LocalDate.now(rellotge));
    }
}

@Component @Order(10)
class VerificarProjecteCritic implements VerificacioPrioritat {
    public void verificar(ContextPrioritat ctx) {
        if (!ctx.empleat().teProjecteCriticActiu()) {
            throw new SensePrioritatDisponibleException(ctx.empleat().getNom());
        }
    }
}

@Component @Order(20)
class VerificarPrioritatDisponible implements VerificacioPrioritat {
    public void verificar(ContextPrioritat ctx) {
        if (ctx.empleat().prioritatsEnUs() >= 1) {
            throw new PrioritatJaEnUsException(ctx.empleat().getNom());
        }
    }
}

@Component @Order(30)
class VerificarMaterialNoUrgent implements VerificacioPrioritat {
    public void verificar(ContextPrioritat ctx) {
        if (ctx.prestecEnCurs().esUrgent()) {
            throw new MaterialJaUrgentException(ctx.isbn());
        }
    }
}

@Test
void despresDUsarLaPrioritatLEmpleatNoPotUsarNeUnaAltra() {
    Empleat marta = unEmpleat("Marta Ruiz").ambProjecteCritic();
    materialSenseUnitatsLliures(ISBN_JAVA);
    materialSenseUnitatsLliures(ISBN_PATRONS);

    servei.prestarAmbPrioritat(ISBN_JAVA, marta.getId());

    assertThatThrownBy(() -> servei.prestarAmbPrioritat(ISBN_PATRONS, marta.getId()))
            .isInstanceOf(PrioritatJaEnUsException.class);
}

@Test
void publicaLEsdevenimentDePrioritatActivada() {
    Empleat marta = unEmpleat("Marta Ruiz").ambProjecteCritic();
    prestecActiuDe(ISBN_JAVA, DIEGO);
    materialSenseUnitatsLliures(ISBN_JAVA);

    servei.prestarAmbPrioritat(ISBN_JAVA, marta.getId());

    assertThat(esdeveniments.publicats())
            .singleElement(as(InstanceOfAssertFactories.type(PrioritatActivada.class)))
            .satisfies(e -> {
                assertThat(e.isbn()).isEqualTo(ISBN_JAVA);
                assertThat(e.dataLimit()).isEqualTo(LocalDate.of(2026, 8, 7));   // data EXACTA
            });
}

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

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
  schedule:
    - cron: '0 4 * * 1'        # dilluns a les 04:00 UTC: proves de mutació

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

permissions:
  contents: read
  pull-requests: write         # necessari per comentar al PR
  checks: write

jobs:

  # =====================================================================
  # 1. RÀPID — resposta en menys de 3 minuts
  # =====================================================================
  rapid:
    name: Format i proves unitàries
    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 format
        run: ./mvnw -B --no-transfer-progress spotless:check

      - name: Compilar i proves unitàries
        run: ./mvnw -B --no-transfer-progress test

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

  # =====================================================================
  # 2. MATRIU — Java 21 (producció) i Java 23 (detecció primerenca)
  # =====================================================================
  compatibilitat:
    name: Java ${{ matrix.java }}
    runs-on: ubuntu-latest
    needs: rapid
    timeout-minutes: 15

    strategy:
      fail-fast: false            # que una fallada a 23 no cancel·li la 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: Proves unitàries
        run: ./mvnw -B --no-transfer-progress test
        # Java 23 és informatiu: no ha de bloquejar la fusió
        continue-on-error: ${{ matrix.java == '23' }}

  # =====================================================================
  # 3. COMPLET — integració amb Testcontainers, cobertura i anàlisi
  # =====================================================================
  complet:
    name: Integració, cobertura i anàlisi
    runs-on: ubuntu-latest
    needs: rapid
    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

      # Precarregar la imatge: evita que la primera prova carregui amb els 30 s de descàrrega
      - name: Precarregar imatge de PostgreSQL
        run: docker pull postgres:16-alpine

      - name: Proves d'integració i cobertura
        run: ./mvnw -B --no-transfer-progress verify
        env:
          TESTCONTAINERS_REUSE_ENABLE: 'false'      # a CI, contenidors nets

      - name: Comentar la cobertura al 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                      # actualitza en lloc d'acumular comentaris
          pass-emoji: '✅'
          fail-emoji: '❌'

      - name: Comprovar llindars de cobertura
        run: ./mvnw -B jacoco:check

      - name: Anàlisi estàtica (SpotBugs + FindSecBugs)
        run: ./mvnw -B spotbugs:check

      - name: Regles d'arquitectura (ArchUnit)
        run: ./mvnw -B test -Dtest='ReglesArquitecturaTest'

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

      - name: Resum a la pestanya de l'execució
        if: always()
        run: |
          echo "## Resum de qualitat" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          echo "| Comprovacio | Resultat |" >> $GITHUB_STEP_SUMMARY
          echo "|---|---|" >> $GITHUB_STEP_SUMMARY
          echo "| Proves unitaries | ${{ needs.rapid.result }} |" >> $GITHUB_STEP_SUMMARY
          echo "| Integracio | ${{ job.status }} |" >> $GITHUB_STEP_SUMMARY

  # =====================================================================
  # 4. MUTACIÓ — només els dilluns i a main. És lenta.
  # =====================================================================
  mutacio:
    name: Proves de mutació (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 domini
        run: |
          ./mvnw -B -pl bibliotech-domini \
            org.pitest:pitest-maven:mutationCoverage \
            -DmutationThreshold=70

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

      - name: Obrir incidència si baixa del llindar
        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 mutacio del domini ha baixat del 70 %',
              body: 'Revisa l informe de PIT als artefactes de l execucio ' +
                    context.runId + '. Hi ha mutants supervivents: les assercions ' +
                    'd alguna prova no detecten canvis al codi.',
              labels: ['qualitat', 'proves']
            })