@Test
void theFineIsCappedAtTheConfiguredMaximum() {
    Loan loan = loanOverdueBy(200);   // 200 days × €0.50 = €100
    assertThat(calculator.calculate(loan)).isEqualByComparingTo("20.00");
}

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

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

src/
├── main/java/com/nexussoftware/bibliotech/     <- production code
├── main/resources/                             <- application.yml
├── test/java/com/nexussoftware/bibliotech/     <- THE TESTS, same package
└── test/resources/                             <- application-test.yml, test fixtures

package com.nexussoftware.bibliotech.service;

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

@Service
public class FineCalculator {

    private final BiblioTechProperties properties;
    private final Clock clock;

    public FineCalculator(BiblioTechProperties properties, Clock clock) {
        this.properties = properties;
        this.clock = clock;
    }

    public BigDecimal calculate(Loan loan) {
        if (loan.getReturnDate().isPresent()) {
            return BigDecimal.ZERO;   // already returned: no fine
        }
        LocalDate today = LocalDate.now(clock);
        long daysLate = ChronoUnit.DAYS.between(loan.getDueDate(), today);
        if (daysLate <= 0) {
            return BigDecimal.ZERO;   // still within term
        }
        BigDecimal fine = properties.fine().eurosPerDay()
                .multiply(BigDecimal.valueOf(daysLate));
        return fine.min(properties.fine().max());
    }
}

package com.nexussoftware.bibliotech.service;

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

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

class FineCalculatorTest {

    @Test
    void aLoanFiveDaysLateGeneratesTwoEurosFifty() {

        // ARRANGE: a FIXED clock. "Today" is always 20 March 2026.
        Clock fixedClock = Clock.fixed(
                Instant.parse("2026-03-20T10:00:00Z"), ZoneId.of("Europe/Madrid"));

        BiblioTechProperties properties = testProperties(
                new BigDecimal("0.50"), new BigDecimal("20.00"));

        FineCalculator calculator = new FineCalculator(properties, fixedClock);

        // Due on the 15th -> 5 days late relative to the 20th
        Loan loan = new Loan(aBook(), anEmployee(),
                LocalDate.of(2026, 3, 1), LocalDate.of(2026, 3, 15));

        // ACT
        BigDecimal fine = calculator.calculate(loan);

        // ASSERT
        assertThat(fine).isEqualByComparingTo("2.50");
    }
}

mvn test

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

@Test
void anEmployeeCannotExceedTheLoanLimit() {

    // ARRANGE: set up the scenario
    Employee marta = new Employee("[email protected]", "Marta Ruiz");
    LoanManager manager = new LoanManager(repository, calculator, notices, properties, clock);
    manager.lend("978-0000000001", marta.getEmail());
    manager.lend("978-0000000002", marta.getEmail());
    manager.lend("978-0000000003", marta.getEmail());

    // ACT: ONE single action, the one being tested
    ThrowingCallable fourthLoan =
            () -> manager.lend("978-0000000004", marta.getEmail());

    // ASSERT: verify the result
    assertThatThrownBy(fourthLoan)
            .isInstanceOf(LoanLimitExceededException.class)
            .hasMessageContaining("[email protected]");
}

@DisplayName("Fine calculation for late returns")
class FineCalculatorTest {

    @Test
    @DisplayName("A loan 5 days late generates a fine of €2.50")
    void fineForFiveDays() { ... }

    @Test
    @DisplayName("The fine never exceeds the configured maximum (€20)")
    void fineCappedAtTheMaximum() { ... }
}

Fine calculation for late returns
  ✔ A loan 5 days late generates a fine of €2.50
  ✔ The fine never exceeds the configured maximum (€20)

assertEquals(3, manager.countActive(marta),
             "Marta should have 3 active loans after lending three materials");

assertTrue(loan.isOverdue(today),
           () -> "The loan was due on " + loan.getDueDate() + " and today is " + today);

@Test
void lendingAMaterialWithNoCopiesThrowsAnException() {

    Material soldOut = new Book("978-0000000003", "Refactoring", 0, "M. Fowler");

    // assertThrows RETURNS the exception: it can be inspected
    NoCopiesAvailableException exception = assertThrows(
            NoCopiesAvailableException.class,
            () -> soldOut.lendOneCopy());

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

// BAD: if the exception is NOT thrown, the test passes anyway
@Test
void bad() {
    try {
        soldOut.lendOneCopy();
    } catch (NoCopiesAvailableException e) {
        assertEquals("978-0000000003", e.getIsbn());
    }
    // If nothing is thrown, no catch runs... and the test is green.
}

@Test
void aNewLoanHasTheCorrectData() {

    LocalDate today = LocalDate.of(2026, 3, 1);
    Loan loan = new Loan(aBook(), anEmployee(), today, 15);

    assertAll("data of the newly created loan",
            () -> assertEquals(today, loan.getLoanDate()),
            () -> assertEquals(today.plusDays(15), loan.getDueDate()),
            () -> assertEquals(LoanStatus.ACTIVE, loan.getStatus()),
            () -> assertTrue(loan.getReturnDate().isEmpty()),
            () -> assertNotNull(loan.getMaterial()));
}

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

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

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

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

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

// Chaining over collections
assertThat(overdueLoans)
        .hasSize(2)
        .extracting(Loan::getEmployee)
        .extracting(Employee::getName)
        .containsExactlyInAnyOrder("Marta Ruiz", "Diego Alonso");

// BigDecimal: it compares VALUE, not scale. 2.50 vs 2.5 does not fail.
assertThat(fine).isEqualByComparingTo("2.50");

// Optional (10-04)
assertThat(repository.findByIsbn("978-0000000001"))
        .isPresent()
        .get()
        .extracting(Material::getTitle)
        .isEqualTo("Effective Java");

// Exceptions, in more detail
assertThatThrownBy(() -> manager.lend("978-9999999999", "[email protected]"))
        .isInstanceOf(MaterialNotFoundException.class)
        .hasMessageContaining("978-9999999999")
        .hasNoCause();

// Comparing objects field by field, ignoring the generated id
assertThat(savedLoan)
        .usingRecursiveComparison()
        .ignoringFields("id", "version")
        .isEqualTo(expectedLoan);

// Predicates over every element
assertThat(activeLoans)
        .isNotEmpty()
        .allMatch(l -> l.getReturnDate().isEmpty())
        .allSatisfy(l -> assertThat(l.getDueDate()).isAfter(l.getLoanDate()));

class LoanManagerTest {

    private Clock fixedClock;
    private FineCalculator calculator;
    private LoanManager manager;
    private Employee marta;

    @BeforeAll
    static void prepareTheWholeClass() {
        // ONCE, before every test. static (except with @TestInstance PER_CLASS)
        // For expensive and SHARED resources: starting a container, loading a big file.
    }

    @BeforeEach
    void prepareEachTest() {
        // BEFORE EACH test: a clean state, no contamination between tests
        fixedClock = Clock.fixed(Instant.parse("2026-03-20T10:00:00Z"), ZoneId.of("Europe/Madrid"));
        calculator = new FineCalculator(testProperties(), fixedClock);
        manager = new LoanManager(new InMemoryRepository(), calculator,
                                  new InMemoryNotices(), testProperties(), fixedClock);
        marta = new Employee("[email protected]", "Marta Ruiz");
    }

    @AfterEach
    void cleanUpEachTest() {
        // After each test. With managed resources, rarely necessary.
    }

    @AfterAll
    static void cleanUpTheWholeClass() {
        // Once, at the end. Close whatever @BeforeAll opened.
    }
}

private Loan loanOverdueBy(int days) {
    LocalDate today = LocalDate.now(fixedClock);
    return new Loan(aBook(), marta, today.minusDays(15 + days), today.minusDays(days));
}

private Material aBook() {
    return new Book("978-0000000001", "Effective Java", 3, "J. Bloch");
}

class CounterTest {

    private int counter = 0;   // reset on EVERY test

    @Test void first()   { counter++; assertEquals(1, counter); }   // passes
    @Test void second()  { counter++; assertEquals(1, counter); }   // ALSO passes
}

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

    private List<Material> catalogue;   // shared by ALL the tests

    @BeforeAll
    void loadCatalogue() {              // no longer needs to be static
        catalogue = loadLargeCatalogue();
    }
}

@Test
@Disabled("Pending a decision on the fine policy for magazines (BIB-142)")
void theMagazineFineIsHalf() { ... }

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

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

@Test
@EnabledOnJre(JRE.JAVA_21)
void virtualThreads() { ... }                       // picks up 10-06

@Test
@EnabledIfSystemProperty(named = "integration.tests", matches = "true")
void againstTheRealDatabase() { ... }

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

@Test void fineForOneDay()   { assertThat(calculate(1)).isEqualByComparingTo("0.50"); }
@Test void fineForTwoDays()  { assertThat(calculate(2)).isEqualByComparingTo("1.00"); }
@Test void fineForFiveDays() { assertThat(calculate(5)).isEqualByComparingTo("2.50"); }
@Test void fineForTenDays()  { assertThat(calculate(10)).isEqualByComparingTo("5.00"); }
// ... eight more

@ParameterizedTest(name = "{0} days late -> €{1}")
@CsvSource({
        "  1,  0.50",
        "  2,  1.00",
        "  5,  2.50",
        " 10,  5.00",
        " 39, 19.50",
        " 40, 20.00",   // exactly the maximum
        " 41, 20.00",   // past the maximum: capped
        "200, 20.00",   // far past it: still capped
        "  0,  0.00",   // due today: not late
        " -1,  0.00",   // due tomorrow
        " -5,  0.00",
        "-30,  0.00"
})
void theFineIsCalculatedFromTheDaysLate(int daysLate, BigDecimal expectedFine) {
    Loan loan = loanOverdueBy(daysLate);
    assertThat(calculator.calculate(loan)).isEqualByComparingTo(expectedFine);
}

theFineIsCalculatedFromTheDaysLate
  ✔ 1 days late -> €0.50
  ✔ 5 days late -> €2.50
  ✔ 40 days late -> €20.00
  ✔ 41 days late -> €20.00
  ...

// Every state of the enum (04-07)
@ParameterizedTest
@EnumSource(LoanStatus.class)
void everyStatusHasANonBlankDescription(LoanStatus status) {
    assertThat(status.getDescription()).isNotBlank();
}

// Only some of them
@ParameterizedTest
@EnumSource(value = LoanStatus.class, names = {"ACTIVE", "OVERDUE"})
void unfinishedStatusesAllowReturning(LoanStatus status) {
    assertThat(status.allowsReturn()).isTrue();
}

// Validating invalid input: null, empty and rubbish
@ParameterizedTest
@NullAndEmptySource
@ValueSource(strings = { " ", "abc", "978", "978-000000000X", "1234567890123" })
void anInvalidIsbnIsRejected(String invalidIsbn) {
    assertThatThrownBy(() -> new Isbn(invalidIsbn))
            .isInstanceOf(InvalidIsbnException.class);
}

class LoanManagerTest {

    // The method must be static (or the class, @TestInstance(PER_CLASS))
    static Stream<Arguments> loanScenarios() {
        return Stream.of(
            Arguments.of("Employee with no loans, material available",
                         0, 3, true,  null),
            Arguments.of("Employee at the limit",
                         3, 3, false, LoanLimitExceededException.class),
            Arguments.of("Material with no copies",
                         1, 0, false, NoCopiesAvailableException.class),
            Arguments.of("Employee one loan short of the limit",
                         2, 5, true,  null)
        );
    }

    @ParameterizedTest(name = "{0}")
    @MethodSource("loanScenarios")
    void biblioTechLoanScenarios(String description,
                                 int activeLoans,
                                 int availableCopies,
                                 boolean shouldSucceed,
                                 Class<? extends Exception> expectedException) {

        // ARRANGE
        Material material = new Book("978-0000000001", "Effective Java",
                                     availableCopies, "J. Bloch");
        Employee marta = new Employee("[email protected]", "Marta Ruiz");
        repository.save(material);
        repository.save(marta);
        for (int i = 0; i < activeLoans; i++) {
            repository.saveLoan(new Loan(anotherBook(i), marta, today(), 15));
        }

        // ACT and ASSERT
        if (shouldSucceed) {
            assertThat(manager.lend("978-0000000001", marta.getEmail())).isNotNull();
        } else {
            assertThatThrownBy(() -> manager.lend("978-0000000001", marta.getEmail()))
                    .isInstanceOf(expectedException);
        }
    }
}

static Stream<Material> testMaterials() {
    return Stream.of(
        new Book("978-0000000001", "Effective Java", 3, "J. Bloch"),
        new Magazine("978-0000000010", "Java Magazine", 5, 42),
        new Dvd("978-0000000020", "Java Course", 1, 180));
}

@ParameterizedTest
@MethodSource("testMaterials")
void everyMaterialCanBeLentIfThereAreCopies(Material material) {
    int before = material.getAvailableCopies();
    material.lendOneCopy();
    assertThat(material.getAvailableCopies()).isEqualTo(before - 1);
}

@DisplayName("LoanManager")
class LoanManagerTest {

    private LoanManager manager;
    private Employee marta;

    @BeforeEach
    void commonSetup() {
        manager = createManager();
        marta = new Employee("[email protected]", "Marta Ruiz");
    }

    @Nested
    @DisplayName("when the employee has no active loans")
    class WithNoActiveLoans {

        @Test
        @DisplayName("can lend an available material")
        void canLend() {
            Loan loan = manager.lend("978-0000000001", marta.getEmail());
            assertThat(loan).isNotNull();
        }

        @Test
        @DisplayName("the due date is 15 days later")
        void correctDueDate() {
            Loan loan = manager.lend("978-0000000001", marta.getEmail());
            assertThat(loan.getDueDate())
                    .isEqualTo(LocalDate.now(fixedClock).plusDays(15));
        }
    }

    @Nested
    @DisplayName("when the employee is at the loan limit")
    class AtTheLimit {

        @BeforeEach
        void lendUpToTheLimit() {              // setup OF ITS OWN for this scenario
            manager.lend("978-0000000001", marta.getEmail());
            manager.lend("978-0000000002", marta.getEmail());
            manager.lend("978-0000000003", marta.getEmail());
        }

        @Test
        @DisplayName("cannot lend any more")
        void cannotLendAnyMore() {
            assertThatThrownBy(() -> manager.lend("978-0000000004", marta.getEmail()))
                    .isInstanceOf(LoanLimitExceededException.class);
        }

        @Test
        @DisplayName("can lend again after returning one")
        void canLendAfterReturning() {
            manager.returnItem("978-0000000001", marta.getEmail());
            assertThat(manager.lend("978-0000000004", marta.getEmail())).isNotNull();
        }
    }
}

LoanManager
  when the employee has no active loans
    ✔ can lend an available material
    ✔ the due date is 15 days later
  when the employee is at the loan limit
    ✔ cannot lend any more
    ✔ can lend again after returning one

@Tag("fast")
class FineCalculatorTest { ... }

@Tag("slow")
@Tag("integration")
class LoanRepositoryIT { ... }

mvn test -Dgroups="fast"                      # only the fast ones
mvn test -DexcludedGroups="slow,integration"  # everything except the slow stuff

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

class AtomicWriteTest {

    @TempDir
    Path tempDir;              // JUnit creates it beforehand and DELETES it afterwards, alone

    @Test
    void writesTheWholeFileOrDoesNotWriteIt() throws IOException {

        Path target = tempDir.resolve("catalogue.csv");
        AtomicWrite atomicWrite = new AtomicWrite();

        atomicWrite.write(target, List.of(
                "isbn;title;copies",
                "978-0000000001;Effective Java;3"));

        assertThat(target).exists();
        assertThat(Files.readAllLines(target, StandardCharsets.UTF_8))
                .containsExactly(
                        "isbn;title;copies",
                        "978-0000000001;Effective Java;3");
    }

    @Test
    void leavesNoTemporaryFilesAfterACorrectWrite() throws IOException {
        Path target = tempDir.resolve("catalogue.csv");
        new AtomicWrite().write(target, List.of("line"));

        try (Stream<Path> files = Files.list(tempDir)) {
            assertThat(files).containsExactly(target);   // no .tmp, no .bak
        }
    }

    @Test
    void theOriginalFileSurvivesIfTheWriteFails() throws IOException {
        Path target = tempDir.resolve("catalogue.csv");
        Files.writeString(target, "original content", StandardCharsets.UTF_8);

        assertThatThrownBy(() -> new AtomicWrite().write(target, linesThatFail()))
                .isInstanceOf(PersistenceException.class);

        // The guarantee of the atomic write: the original is untouched
        assertThat(Files.readString(target, StandardCharsets.UTF_8))
                .isEqualTo("original content");
    }
}

// NOT TESTABLE: it creates its dependencies
public class LoanManager {
    private final LoanRepository repo = new JpaLoanRepository();  // needs a database
    private final NoticeService notices = new SmtpNoticeService(); // needs an SMTP server
}

// TESTABLE: it receives them
public class LoanManager {
    public LoanManager(LoanRepository repo, NoticeService notices) { ... }
}

// Pure: tested in one line
public static BigDecimal calculateFine(long daysLate, BigDecimal perDay, BigDecimal max) {
    if (daysLate <= 0) return BigDecimal.ZERO;
    return perDay.multiply(BigDecimal.valueOf(daysLate)).min(max);
}

// BAD: it looks its state up in a global place
public BigDecimal calculate(Loan l) {
    BigDecimal perDay = BusinessRules.finePerDay();    // static: cannot be replaced
    LocalDate today = LocalDate.now();                 // the system clock
    ...
}

// GOOD: it receives it
public BigDecimal calculate(Loan l) {
    BigDecimal perDay = properties.fine().eurosPerDay();     // injected
    LocalDate today = LocalDate.now(clock);                  // injected
    ...
}

public BigDecimal calculate(Loan loan) {
    LocalDate today = LocalDate.now();   // the SYSTEM clock
    ...
}

public BigDecimal calculate(Loan loan) {
    LocalDate today = LocalDate.now(clock);   // the INJECTED clock
    ...
}

class FineCalculatorTest {

    // "Today" is ALWAYS 20 March 2026. On any machine, on any day.
    private static final Clock FIXED_CLOCK = Clock.fixed(
            Instant.parse("2026-03-20T10:00:00Z"), ZoneId.of("Europe/Madrid"));

    private FineCalculator calculator;

    @BeforeEach
    void setUp() {
        calculator = new FineCalculator(testProperties(), FIXED_CLOCK);
    }

    @Test
    void aLoanThatFellDueFiveDaysAgoGeneratesTwoEurosFifty() {
        Loan loan = loanThatWasDueOn(LocalDate.of(2026, 3, 15));
        assertThat(calculator.calculate(loan)).isEqualByComparingTo("2.50");
    }

    @Test
    void aLoanThatFallsDueTodayGeneratesNoFine() {
        Loan loan = loanThatWasDueOn(LocalDate.of(2026, 3, 20));
        assertThat(calculator.calculate(loan)).isEqualByComparingTo("0.00");
    }

    @Test
    void aLoanThatFallsDueTomorrowGeneratesNoFine() {
        Loan loan = loanThatWasDueOn(LocalDate.of(2026, 3, 21));
        assertThat(calculator.calculate(loan)).isEqualByComparingTo("0.00");
    }
}

@Test
void theFineGrowsByFiftyCentsForEveryDayThatPasses() {

    LocalDate dueDate = LocalDate.of(2026, 3, 15);
    Loan loan = loanThatWasDueOn(dueDate);

    // Day 16: 1 day late
    var day16 = new FineCalculator(properties, clockAt(LocalDate.of(2026, 3, 16)));
    assertThat(day16.calculate(loan)).isEqualByComparingTo("0.50");

    // Day 20: 5 days
    var day20 = new FineCalculator(properties, clockAt(LocalDate.of(2026, 3, 20)));
    assertThat(day20.calculate(loan)).isEqualByComparingTo("2.50");

    // Day 100: capped at the maximum
    var day100 = new FineCalculator(properties, clockAt(LocalDate.of(2026, 6, 23)));
    assertThat(day100.calculate(loan)).isEqualByComparingTo("20.00");
}

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

// CANNOT BE TESTED
public class FineCalculator {
    public static BigDecimal calculate(Loan l) {
        BigDecimal perDay = BusinessRules.finePerDay();    // static: not replaceable
        LocalDate today = LocalDate.now();                 // the system clock
        ...
    }
}

// CANNOT BE TESTED WITHOUT A NETWORK
public class CatalogEnricher {
    public Material enrich(Material material) {
        MetadataClient client = new MetadataClient();        // calls a real API
        return client.enrich(material);
    }
}

public void process(Loan l) {
    calculate(l);
    sendEmail(l);                       // sends a REAL email
    System.out.println("Processed");     // cannot be checked
    logFile.append(...);                 // writes to disk
}

// BRITTLE: it checks HOW it is done
verify(repository).findById(1L);
verify(repository).save(any());
verify(calculator).calculate(any());
// If tomorrow findByIsbn is used, the test fails even though the result is identical.

// ROBUST: it checks WHAT result is obtained
assertThat(manager.lend("978-0000000001", "[email protected]"))
        .extracting(Loan::getDueDate)
        .isEqualTo(LocalDate.of(2026, 3, 16));

// BAD
service.processAsynchronously();
Thread.sleep(1000);              // what if it takes 1100 ms in continuous integration?
assertThat(result).isNotNull();

@Test
void loanTest() {
    Loan l = manager.lend("978-0000000001", "[email protected]");
    assertNotNull(l);       // so what? It checks no rule at all
}

// Useless: if the formula is wrong, the test is wrong in the same way
BigDecimal expected = perDay.multiply(BigDecimal.valueOf(days)).min(max);
assertThat(calculator.calculate(loan)).isEqualByComparingTo(expected);

@Test
void theConcurrentCatalogHandlesAHundredSimultaneousThreads() throws Exception {

    ConcurrentCatalog catalogue = new ConcurrentCatalog();
    int threads = 100, operations = 1000;

    try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {   // 10-06
        CountDownLatch ready = new CountDownLatch(threads);
        CountDownLatch start = new CountDownLatch(1);

        for (int i = 0; i < threads; i++) {
            executor.submit(() -> {
                ready.countDown();
                start.await();                     // they all begin AT ONCE
                for (int j = 0; j < operations; j++) catalogue.incrementQueries();
                return null;
            });
        }
        ready.await(5, TimeUnit.SECONDS);
        start.countDown();                         // simultaneous starting gun
    }   // closing the executor waits for them to finish

    assertThat(catalogue.getQueries()).isEqualTo((long) threads * operations);
}

mvn test                                # compiles and runs the unit tests
mvn test -Dtest=FineCalculatorTest      # only one class
mvn test -Dtest=FineCalculatorTest#the* # only methods starting with "the"
mvn test -Dgroups="fast"                # only the tagged ones
mvn verify                              # unit + integration (failsafe)
mvn package -DskipTests                 # packages WITHOUT running tests

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

@Test
void coverage100() {
    calculator.calculate(loan);   // it runs... and nothing is checked
}

@SpringBootTest
class BiblioTechApplicationTests {

    @Autowired
    private LoanManager manager;

    @Test
    void theContextLoadsCorrectly() {
        assertThat(manager).isNotNull();
    }
}

@DataJpaTest
class LoanRepositoryTest {

    @Autowired private LoanRepository repository;
    @Autowired private TestEntityManager em;

    @Test
    void findsTheOverdueLoansThatAreStillOut() {
        Material book = em.persist(new Book("978-0000000001", "Effective Java", 3, "J. Bloch"));
        Employee marta = em.persist(new Employee("[email protected]", "Marta Ruiz"));
        em.persist(new Loan(book, marta,
                LocalDate.of(2026, 3, 1), LocalDate.of(2026, 3, 10)));
        em.flush();

        List<Loan> overdue = repository.overdue(LocalDate.of(2026, 3, 20));

        assertThat(overdue).hasSize(1)
                .first().extracting(l -> l.getMaterial().getTitle())
                .isEqualTo("Effective Java");
    }
}

src/test/java/com/nexussoftware/bibliotech/
├── domain/
│   ├── LoanTest.java                  <- due-date and return rules
│   ├── MaterialTest.java              <- available copies
│   └── IsbnTest.java                  <- validation
├── service/
│   ├── FineCalculatorTest.java        <- fines, with a fixed Clock
│   └── LoanManagerTest.java           <- loan limit
├── persistence/
│   └── AtomicWriteTest.java           <- @TempDir
└── BiblioTechApplicationTests.java    <- @SpringBootTest: context loading

package com.nexussoftware.bibliotech.service;

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

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

@DisplayName("BiblioTech fine calculation")
class FineCalculatorTest {

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

    private FineCalculator calculator;
    private Employee marta;
    private Material book;

    @BeforeEach
    void setUp() {
        var properties = new BiblioTechProperties(
                "BiblioTech - Nexus Software",
                new BiblioTechProperties.Loan(15, 3),
                new BiblioTechProperties.Fine(new BigDecimal("0.50"), new BigDecimal("20.00")),
                new BiblioTechProperties.Reservation(3));

        calculator = new FineCalculator(properties, FIXED_CLOCK);
        marta = new Employee("[email protected]", "Marta Ruiz");
        book = new Book("978-0000000001", "Effective Java", 3, "J. Bloch");
    }

    @Nested
    @DisplayName("when the loan is still within term")
    class WithinTerm {

        @Test
        @DisplayName("there is no fine if it falls due within a week")
        void noFineIfDueInAWeek() {
            assertThat(calculator.calculate(loanDueOn(TODAY.plusDays(7))))
                    .isEqualByComparingTo("0.00");
        }

        @Test
        @DisplayName("there is no fine on the due date itself")
        void noFineOnTheDueDate() {
            assertThat(calculator.calculate(loanDueOn(TODAY)))
                    .isEqualByComparingTo("0.00");
        }
    }

    @Nested
    @DisplayName("when the loan is overdue")
    class Overdue {

        @ParameterizedTest(name = "{0} days late -> €{1}")
        @CsvSource({
                "  1,  0.50", "  2,  1.00", "  5,  2.50", " 10,  5.00",
                " 39, 19.50", " 40, 20.00", " 41, 20.00", "200, 20.00"
        })
        @DisplayName("the fine is €0.50 per day up to the €20 maximum")
        void fineByDaysLate(int days, BigDecimal expected) {
            assertThat(calculator.calculate(loanDueOn(TODAY.minusDays(days))))
                    .isEqualByComparingTo(expected);
        }

        @Test
        @DisplayName("the fine never exceeds the configured maximum")
        void neverExceedsTheMaximum() {
            assertThat(calculator.calculate(loanDueOn(TODAY.minusYears(2))))
                    .isEqualByComparingTo("20.00");
        }
    }

    @Nested
    @DisplayName("when the loan has already been returned")
    class Returned {

        @Test
        @DisplayName("there is no fine even if it was returned late")
        void noFineAfterTheReturn() {
            Loan loan = loanDueOn(TODAY.minusDays(30));
            loan.returnItem(TODAY.minusDays(10));

            assertThat(calculator.calculate(loan)).isEqualByComparingTo("0.00");
        }
    }

    // --- scenario factories ---
    private Loan loanDueOn(LocalDate dueDate) {
        return new Loan(book, marta, dueDate.minusDays(15), dueDate);
    }
}

mvn test

[INFO] Running com.nexussoftware.bibliotech.service.FineCalculatorTest
[INFO] Tests run: 12, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.089 s
[INFO] Running com.nexussoftware.bibliotech.domain.LoanTest
[INFO] Tests run: 8, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.021 s
...
[INFO] Tests run: 41, Failures: 0, Errors: 0, Skipped: 0
[INFO] BUILD SUCCESS
[INFO] Total time: 6.412 s

@Entity
public class Loan {

    @Id @GeneratedValue private Long id;
    @ManyToOne(fetch = FetchType.LAZY) private Material material;
    @ManyToOne(fetch = FetchType.LAZY) private Employee employee;
    private LocalDate loanDate;
    private LocalDate dueDate;
    private LocalDate returnDate;
    @Enumerated(EnumType.STRING) private LoanStatus status;

    public Loan(Material material, Employee employee, LocalDate loanDate, int days) {
        this.material = material;
        this.employee = employee;
        this.loanDate = loanDate;
        this.dueDate = loanDate.plusDays(days);
        this.status = LoanStatus.ACTIVE;
    }

    public boolean isOverdue(LocalDate today) {
        return returnDate == null && today.isAfter(dueDate);
    }

    public void returnItem(LocalDate date) {
        if (returnDate != null) {
            throw new LoanAlreadyReturnedException(id);
        }
        if (date.isBefore(loanDate)) {
            throw new InvalidDateException("Cannot return before lending");
        }
        this.returnDate = date;
        this.status = LoanStatus.RETURNED;
    }

    public Optional<LocalDate> getReturnDate() {
        return Optional.ofNullable(returnDate);
    }
}

public class DueDateNoticeService {

    public int sendTodaysNotices() {
        int sent = 0;
        LocalDate today = LocalDate.now();

        LoanRepository repository = new JpaLoanRepository();
        List<Loan> loans = repository.findAll();

        for (Loan l : loans) {
            long days = ChronoUnit.DAYS.between(today, l.getDueDate());
            if (days == Integer.parseInt(BusinessRules.get("notice.days.ahead", "2"))) {
                EmailClient email = new EmailClient("smtp.nexussoftware.com", 587);
                email.send(l.getEmployee().getEmail(),
                           "Your loan of " + l.getMaterial().getTitle() + " is due soon");
                System.out.println("Notice sent to " + l.getEmployee().getEmail());
                sent++;
            }
        }
        return sent;
    }
}

public class RenewalManager {

    private static final int MAX_RENEWALS = 2;
    private final Clock clock;

    public RenewalManager(Clock clock) { this.clock = clock; }

    public LocalDate renew(Loan loan, int days) {
        if (loan.getRenewals() >= MAX_RENEWALS) {
            throw new RenewalLimitExceededException(loan.getId());
        }
        if (loan.getReturnDate().isPresent()) {
            throw new LoanAlreadyReturnedException(loan.getId());
        }

        LocalDate today = LocalDate.now(clock);
        LocalDate newDueDate = loan.getDueDate().plusDays(days);

        if (newDueDate.isBefore(today)) {
            newDueDate = today;
        }

        loan.updateDueDate(newDueDate);
        loan.incrementRenewals();
        return newDueDate;
    }
}

package com.nexussoftware.bibliotech.domain;

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

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

@DisplayName("Loan")
class LoanTest {

    private static final LocalDate LOAN_DATE = LocalDate.of(2026, 3, 1);
    private static final int DAYS = 15;
    private static final LocalDate DUE_DATE = LocalDate.of(2026, 3, 16);

    private Material book;
    private Employee marta;
    private Loan loan;

    @BeforeEach
    void setUp() {
        book = new Book("978-0000000001", "Effective Java", 3, "J. Bloch");
        marta = new Employee("[email protected]", "Marta Ruiz");
        loan = new Loan(book, marta, LOAN_DATE, DAYS);
    }

    @Nested
    @DisplayName("newly created")
    class NewlyCreated {

        @Test
        @DisplayName("(1) has all the correct data")
        void correctData() {
            assertAll("loan data",
                    () -> assertThat(loan.getMaterial()).isEqualTo(book),
                    () -> assertThat(loan.getEmployee()).isEqualTo(marta),
                    () -> assertThat(loan.getLoanDate()).isEqualTo(LOAN_DATE),
                    () -> assertThat(loan.getDueDate()).isEqualTo(DUE_DATE),
                    () -> assertThat(loan.getStatus()).isEqualTo(LoanStatus.ACTIVE),
                    () -> assertThat(loan.getReturnDate()).isEmpty());
        }
    }

    @Nested
    @DisplayName("overdue check")
    class DueDate {

        // (2) five cases, including the edges
        @ParameterizedTest(name = "on {0} -> overdue = {1}")
        @CsvSource({
                "2026-03-01, false",   // the day of the loan
                "2026-03-15, false",   // the eve of the due date
                "2026-03-16, false",   // EDGE: the day itself is NOT overdue
                "2026-03-17, true",    // EDGE: the following day IS
                "2026-04-30, true",    // much later
                "2027-01-01, true"
        })
        void isOverdueDependingOnTheDate(LocalDate today, boolean expected) {
            assertThat(loan.isOverdue(today)).isEqualTo(expected);
        }
    }

    @Nested
    @DisplayName("on return")
    class Returning {

        @Test
        @DisplayName("(3) records the date and changes the status")
        void correctReturn() {
            LocalDate returnDate = LocalDate.of(2026, 3, 10);

            loan.returnItem(returnDate);

            assertAll(
                    () -> assertThat(loan.getReturnDate()).contains(returnDate),
                    () -> assertThat(loan.getStatus()).isEqualTo(LoanStatus.RETURNED));
        }

        @Test
        @DisplayName("(4) returning twice throws LoanAlreadyReturnedException")
        void cannotReturnTwice() {
            loan.returnItem(LocalDate.of(2026, 3, 10));

            assertThatThrownBy(() -> loan.returnItem(LocalDate.of(2026, 3, 11)))
                    .isInstanceOf(LoanAlreadyReturnedException.class);
        }

        @Test
        @DisplayName("(5) returning before lending throws InvalidDateException")
        void cannotReturnBeforeLending() {
            assertThatThrownBy(() -> loan.returnItem(LOAN_DATE.minusDays(1)))
                    .isInstanceOf(InvalidDateException.class)
                    .hasMessageContaining("before lending");
        }

        @Test
        @DisplayName("(6) a returned loan is never overdue, even if it was returned late")
        void returnedIsNeverOverdue() {
            loan.returnItem(LocalDate.of(2026, 4, 30));   // 45 days late

            assertThat(loan.isOverdue(LocalDate.of(2027, 1, 1))).isFalse();
        }
    }
}

package com.nexussoftware.bibliotech.service;

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

@Service
public class DueDateNoticeService {

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

    private final LoanRepository repository;           // interface
    private final NoticeService notices;               // interface
    private final BiblioTechProperties properties;     // injected configuration
    private final Clock clock;                         // controllable time

    public DueDateNoticeService(LoanRepository repository,
                                NoticeService notices,
                                BiblioTechProperties properties,
                                Clock clock) {
        this.repository = repository;
        this.notices = notices;
        this.properties = properties;
        this.clock = clock;
    }

    public int sendTodaysNotices() {
        LocalDate today = LocalDate.now(clock);
        int daysAhead = properties.notice().daysAhead();

        List<Loan> toNotify = repository.findActive().stream()
                .filter(l -> ChronoUnit.DAYS.between(today, l.getDueDate()) == daysAhead)
                .toList();

        toNotify.forEach(l -> {
            notices.notify(l.getEmployee(),
                    "Your loan of " + l.getMaterial().getTitle() + " is due soon");
            log.info("Notice sent to {}", l.getEmployee().getEmail());
        });

        return toNotify.size();
    }
}

package com.nexussoftware.bibliotech.service;

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

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

@DisplayName("Due-date notices")
class DueDateNoticeServiceTest {

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

    // FAKE test double: a real implementation, but in memory
    static class InMemoryLoanRepository implements LoanRepository {
        private final List<Loan> loans = new ArrayList<>();
        void add(Loan l) { loans.add(l); }
        @Override public List<Loan> findActive() { return List.copyOf(loans); }
    }

    // Home-made SPY double: it records what it is asked to do
    static class RecordingNotices implements NoticeService {
        final List<String> recipients = new ArrayList<>();
        final List<String> messages = new ArrayList<>();
        @Override public void notify(Employee recipient, String message) {
            recipients.add(recipient.getEmail());
            messages.add(message);
        }
    }

    private InMemoryLoanRepository repository;
    private RecordingNotices notices;
    private DueDateNoticeService service;

    @BeforeEach
    void setUp() {
        repository = new InMemoryLoanRepository();
        notices = new RecordingNotices();

        var properties = propertiesWithDaysAhead(2);   // notify 2 days in advance
        service = new DueDateNoticeService(repository, notices, properties, CLOCK);
    }

    @Test
    @DisplayName("notifies when exactly the configured number of days remain")
    void notifiesWithTheConfiguredLeadTime() {
        repository.add(loanDueOn(TODAY.plusDays(2), "[email protected]"));

        int sent = service.sendTodaysNotices();

        assertThat(sent).isEqualTo(1);
        assertThat(notices.recipients).containsExactly("[email protected]");
        assertThat(notices.messages).first().asString().contains("Effective Java");
    }

    @Test
    @DisplayName("does not notify if more or fewer days remain than configured")
    void doesNotNotifyOutsideTheWindow() {
        repository.add(loanDueOn(TODAY.plusDays(1), "[email protected]"));   // 1 day
        repository.add(loanDueOn(TODAY.plusDays(3), "[email protected]"));   // 3 days
        repository.add(loanDueOn(TODAY,             "[email protected]"));   // today
        repository.add(loanDueOn(TODAY.minusDays(5),"[email protected]"));   // overdue

        int sent = service.sendTodaysNotices();

        assertThat(sent).isZero();
        assertThat(notices.recipients).isEmpty();
    }

    @Test
    @DisplayName("counts the notices sent correctly")
    void countsTheNotices() {
        repository.add(loanDueOn(TODAY.plusDays(2), "[email protected]"));
        repository.add(loanDueOn(TODAY.plusDays(2), "[email protected]"));
        repository.add(loanDueOn(TODAY.plusDays(2), "[email protected]"));
        repository.add(loanDueOn(TODAY.plusDays(9), "[email protected]"));

        assertThat(service.sendTodaysNotices()).isEqualTo(3);
        assertThat(notices.recipients).containsExactlyInAnyOrder(
                "[email protected]",
                "[email protected]",
                "[email protected]");
    }

    private Loan loanDueOn(LocalDate dueDate, String email) {
        return new Loan(
                new Book("978-0000000001", "Effective Java", 3, "J. Bloch"),
                new Employee(email, "Test employee"),
                dueDate.minusDays(15), dueDate);
    }
}

package com.nexussoftware.bibliotech.service;

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

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

@DisplayName("Loan renewal")
class RenewalManagerTest {

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

    private RenewalManager manager;

    @BeforeEach
    void setUp() { manager = new RenewalManager(CLOCK); }

    @Test
    @DisplayName("renewing adds the days to the due date")
    void renewingAddsDays() {
        Loan loan = loanDueOn(TODAY.plusDays(3));                // due on the 23rd

        LocalDate newDueDate = manager.renew(loan, 15);

        assertThat(newDueDate).isEqualTo(LocalDate.of(2026, 4, 7));   // 23 + 15
        assertThat(loan.getRenewals()).isEqualTo(1);
    }

    @Test
    @DisplayName("a loan cannot be renewed more than twice")
    void renewalLimit() {
        Loan loan = loanDueOn(TODAY.plusDays(3));
        manager.renew(loan, 15);
        manager.renew(loan, 15);

        assertThatThrownBy(() -> manager.renew(loan, 15))
                .isInstanceOf(RenewalLimitExceededException.class);
    }

    @Test
    @DisplayName("a loan that has already been returned cannot be renewed")
    void aReturnedLoanIsNotRenewed() {
        Loan loan = loanDueOn(TODAY.plusDays(3));
        loan.returnItem(TODAY.minusDays(1));

        assertThatThrownBy(() -> manager.renew(loan, 15))
                .isInstanceOf(LoanAlreadyReturnedException.class);
    }

    // ===== THE TEST THAT REVEALS THE BUG =====
    @Test
    @DisplayName("renewing a long-overdue loan must add the days from TODAY, not from the past")
    void renewingALongOverdueLoan() {
        // Marta had a loan that fell due 60 days ago (on 19 January)
        Loan loan = loanDueOn(TODAY.minusDays(60));

        LocalDate newDueDate = manager.renew(loan, 15);

        // Expected by the business: today (20 March) + 15 days = 4 April
        assertThat(newDueDate).isEqualTo(LocalDate.of(2026, 4, 4));
    }
}

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

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

if (newDueDate.isBefore(today)) {  // 3 February is before 20 March -> true
    newDueDate = today;            // it stays at TODAY!
}

public LocalDate renew(Loan loan, int days) {
    if (loan.getRenewals() >= MAX_RENEWALS) {
        throw new RenewalLimitExceededException(loan.getId());
    }
    if (loan.getReturnDate().isPresent()) {
        throw new LoanAlreadyReturnedException(loan.getId());
    }

    LocalDate today = LocalDate.now(clock);

    // A renewal always counts from the LATER of today and the current due
    // date. That guarantees that `days` full days of usable loan time are ALWAYS
    // added, whether the loan is within term or overdue.
    LocalDate base = loan.getDueDate().isAfter(today)
            ? loan.getDueDate()
            : today;

    LocalDate newDueDate = base.plusDays(days);

    loan.updateDueDate(newDueDate);
    loan.incrementRenewals();
    return newDueDate;
}