Chapter 13 Companion: Code, Explanations and Solutions

bash scripts/pipeline.sh
mvn --batch-mode verify

=== STAGE: 1 compile
=== PASSED: 1 compile (4 s)
=== STAGE: 2 unit tests and architecture checks
[INFO] Tests run: 203, Failures: 0, Errors: 0, Skipped: 0
=== PASSED: 2 unit tests and architecture checks (13 s)
=== STAGE: 3 integration tests (real file, real HTTP client, local stub service)
[INFO] Tests run: 26, Failures: 0, Errors: 0, Skipped: 0
=== PASSED: 3 integration tests (real file, real HTTP client, local stub service) (6 s)
=== STAGE: 4 end-to-end journeys (separate process)
[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0
=== PASSED: 4 end-to-end journeys (separate process) (6 s)
=== STAGE: 5 package
=== PASSED: 5 package (4 s)
PIPELINE PASSED

Visitors enabled: false
Student B1: Confirmed: R1 for B1 on CAM1 [2026-10-20, 2026-10-22).
Visitor V1: Rejected: visitor reservations are not enabled.
Visitor V2: Rejected: visitor reservations are not enabled.
Unknown U9: Rejected: borrower not found or inactive.
Outage BROKEN: Unavailable: Borrower directory unavailable
Reservations: 1
Notices: 1

Visitors enabled: true
Student B1: Confirmed: R1 for B1 on CAM1 [2026-10-20, 2026-10-22).
Visitor V1: Confirmed: R2 for V1 on CAM2 [2026-10-20, 2026-10-22).
Visitor V2: Rejected: no valid sponsor approval.
Unknown U9: Rejected: borrower not found or inactive.
Outage BROKEN: Unavailable: Borrower directory unavailable
Reservations: 2
Notices: 2

mvn --batch-mode test -DexcludedGroups=integration,e2e     # stage 2: unit tests and architecture checks
mvn --batch-mode test -Dgroups=integration                 # stage 3
mvn --batch-mode test -Dgroups=e2e                         # stage 4
mvn --batch-mode test -Dtest=VisitorAcceptanceTest         # one class

RELEASE_LABEL=v1 bash scripts/simulate-release.sh
RELEASE_LABEL=v2 bash scripts/simulate-release.sh
bash scripts/simulate-release.sh rollback

package edu.se506.lending.domain;



public enum BorrowerCategory {
    STUDENT, STAFF, VISITOR
}

package edu.se506.lending.domain;

/**
 * Illustrative teaching rule for visiting researchers (change request CR-12): fewer than three
 * retained reservations, and one to three calendar days. It decides count and duration only;
 * sponsor approval is checked elsewhere, because this contract has no identity, item or clock.
 */
public final class VisitorReservationRules implements BorrowingPolicy {
    @Override
    public boolean mayRequest(int activeReservations, int requestedDays) {
        return activeReservations >= 0
                && activeReservations < 3
                && requestedDays >= 1
                && requestedDays <= 3;
    }
}

package edu.se506.lending.domain;

/** A sponsor's decision on one request. Any other word in the register is a data error. */
public enum ApprovalStatus {
    APPROVED, DENIED
}

package edu.se506.lending.domain;

import java.time.Instant;
import java.time.LocalDate;
import java.util.Objects;

/**
 * A trusted sponsor decision for one exact request: borrower, item and half-open loan period.
 * The record is valid for requests made at or after {@code validFrom} and strictly before
 * {@code validUntil}. The loan period itself need not lie inside that window.
 */
public record ApprovalRecord(String borrowerId, String itemId, LocalDate start, LocalDate endExclusive,
                             String sponsorId, ApprovalStatus status, Instant validFrom, Instant validUntil) {

    public ApprovalRecord {
        requireText(borrowerId, "borrowerId");
        requireText(itemId, "itemId");
        requireText(sponsorId, "sponsorId");
        Objects.requireNonNull(start, "start");
        Objects.requireNonNull(endExclusive, "endExclusive");
        Objects.requireNonNull(status, "status");
        Objects.requireNonNull(validFrom, "validFrom");
        Objects.requireNonNull(validUntil, "validUntil");
        if (!start.isBefore(endExclusive)) {
            throw new IllegalArgumentException("Loan period must end after it starts.");
        }
        if (!validFrom.isBefore(validUntil)) {
            throw new IllegalArgumentException("Validity must end after it starts.");
        }
    }

    /** True only for the exact borrower, item and period; approval for anything else is not enough. */
    public boolean matches(String borrower, String item, LocalDate periodStart, LocalDate periodEnd) {
        return borrowerId.equals(borrower) && itemId.equals(item)
                && start.equals(periodStart) && endExclusive.equals(periodEnd);
    }

    /** Equality at the start of the window is valid; equality at its end is not. */
    public boolean validAt(Instant now) {
        Objects.requireNonNull(now, "now");
        return !now.isBefore(validFrom) && now.isBefore(validUntil);
    }

    public boolean approvesAt(Instant now) {
        return status == ApprovalStatus.APPROVED && validAt(now);
    }

    private static void requireText(String value, String name) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException(name + " must not be blank.");
        }
    }
}

package edu.se506.lending.application.port;

import edu.se506.lending.domain.ApprovalRecord;
import java.time.LocalDate;
import java.util.Optional;

/**
 * Finds the sponsor approval recorded for one exact request. Empty means that no record exists
 * for it. A source that cannot give a trustworthy answer (unreadable, malformed, ambiguous) must
 * throw {@link ApprovalSourceException}, never return empty.
 */
@FunctionalInterface
public interface ApprovalSource {
    Optional<ApprovalRecord> find(String borrowerId, String itemId, LocalDate start, LocalDate endExclusive);
}

package edu.se506.lending.application.port;

/** The approval register could not be read or trusted. This is not a sponsor's rejection. */
public final class ApprovalSourceException extends RuntimeException {
    private static final long serialVersionUID = 1L;

    public ApprovalSourceException(String message) { super(message); }
    public ApprovalSourceException(String message, Throwable cause) { super(message, cause); }
}

package edu.se506.lending.application;

import edu.se506.lending.application.port.ApprovalSource;
import edu.se506.lending.domain.ApprovalRecord;
import java.time.Clock;
import java.time.Instant;
import java.time.LocalDate;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;

/**
 * The extra checks for a visiting researcher, kept apart from the count and duration policy: the
 * feature flag, the item allowlist and a matching sponsor approval that is valid at one request-time
 * instant. It returns a rejection text, or empty when the request may go on to the coordinator.
 * An unreadable or untrustworthy approval register is not a rejection: the exception from the
 * source is not caught here, so no reservation can follow it.
 */
public final class VisitorGate {
    public static final String DISABLED = "Rejected: visitor reservations are not enabled.";
    public static final String ITEM_NOT_ALLOWED = "Rejected: item not available to visitors.";
    public static final String NOT_APPROVED = "Rejected: no valid sponsor approval.";

    private static final Set<String> ALLOWED_ITEMS = Set.of("CAM1", "CAM2");

    private final ApprovalSource source;
    private final Clock clock;
    private final boolean enabled;

    public VisitorGate(ApprovalSource source, Clock clock, boolean enabled) {
        this.source = Objects.requireNonNull(source, "source");
        this.clock = Objects.requireNonNull(clock, "clock");
        this.enabled = enabled;
    }

    /** A gate for applications that have not enabled visitors: the approval source is never read. */
    public static VisitorGate disabled() {
        return new VisitorGate((borrowerId, itemId, start, end) -> {
            throw new IllegalStateException("The approval source must not be read while visitors are disabled.");
        }, Clock.systemUTC(), false);
    }

    public Optional<String> rejection(String borrowerId, String itemId, LocalDate start, int days) {
        if (!enabled) {
            return Optional.of(DISABLED);
        }
        if (!ALLOWED_ITEMS.contains(itemId)) {
            return Optional.of(ITEM_NOT_ALLOWED);
        }
        if (days < 1) {
            return Optional.empty();      // there is no period to look up; the policy rejects it
        }
        Instant now = clock.instant();    // one request-time instant for the whole decision
        LocalDate endExclusive = start.plusDays(days);
        Optional<ApprovalRecord> record = source.find(borrowerId, itemId, start, endExclusive);
        // The source should return only the exact request, but approval for anything else is never enough.
        if (record.isEmpty() || !record.get().matches(borrowerId, itemId, start, endExclusive)
                || !record.get().approvesAt(now)) {
            return Optional.of(NOT_APPROVED);
        }
        return Optional.empty();
    }
}

package edu.se506.lending.application;

import edu.se506.lending.application.port.BorrowerDirectory;
import edu.se506.lending.application.port.DirectoryException;
import edu.se506.lending.domain.Borrower;
import edu.se506.lending.domain.BorrowerCategory;

import java.time.LocalDate;
import java.util.Objects;
import java.util.Optional;

/** Directory-backed entry point; this does not authenticate the caller. */
public final class DirectoryReservationService {
    private final BorrowerDirectory directory;
    private final ReservationCoordinator coordinator;
    private final VisitorGate visitorGate;

    public DirectoryReservationService(BorrowerDirectory directory,
                                       ReservationCoordinator coordinator) {
        this(directory, coordinator, VisitorGate.disabled());
    }

    public DirectoryReservationService(BorrowerDirectory directory,
                                       ReservationCoordinator coordinator,
                                       VisitorGate visitorGate) {
        this.directory = Objects.requireNonNull(directory, "directory");
        this.coordinator = Objects.requireNonNull(coordinator, "coordinator");
        this.visitorGate = Objects.requireNonNull(visitorGate, "visitorGate");
    }

    public String reserve(String borrowerId, String itemId, LocalDate start, int days) {
        if (borrowerId == null || borrowerId.isBlank() || itemId == null || itemId.isBlank()) {
            throw new IllegalArgumentException("Identifiers must not be blank.");
        }
        Objects.requireNonNull(start, "start");
        var found = directory.find(borrowerId);
        if (found.isEmpty()) return "Rejected: borrower not found or inactive.";
        Borrower borrower = found.get();
        if (!borrowerId.equals(borrower.id())) {
            throw new DirectoryException("Directory returned a different borrower");
        }
        if (borrower.category() == BorrowerCategory.VISITOR) {
            Optional<String> rejection = visitorGate.rejection(borrower.id(), itemId, start, days);
            if (rejection.isPresent()) return rejection.get();
        }
        return coordinator.reserve(borrower.id(), itemId, start, days, borrower.category());
    }
}

package edu.se506.lending.infrastructure.approvals;

import edu.se506.lending.application.port.ApprovalSource;
import edu.se506.lending.application.port.ApprovalSourceException;
import edu.se506.lending.domain.ApprovalRecord;
import edu.se506.lending.domain.ApprovalStatus;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Instant;
import java.time.LocalDate;
import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;

/**
 * Reads the sponsor-approval register: a local UTF-8 tab-separated file with exactly eight columns
 * (borrowerId, itemId, start, endExclusive, sponsorId, status, validFrom, validUntil) and a header.
 * The file is read afresh on every call and is rejected as a whole if any row is invalid or if two
 * rows share a request key. It is a trusted, sequential fixture, not a concurrent approval database.
 */
public final class FileApprovalSource implements ApprovalSource {
    static final String HEADER =
            "borrowerId\titemId\tstart\tendExclusive\tsponsorId\tstatus\tvalidFrom\tvalidUntil";

    private final Path file;

    public FileApprovalSource(Path file) {
        this.file = Objects.requireNonNull(file, "file");
    }

    @Override
    public Optional<ApprovalRecord> find(String borrowerId, String itemId, LocalDate start, LocalDate endExclusive) {
        List<ApprovalRecord> records = readAll();
        for (ApprovalRecord record : records) {
            if (record.matches(borrowerId, itemId, start, endExclusive)) {
                return Optional.of(record);
            }
        }
        return Optional.empty();
    }

    private List<ApprovalRecord> readAll() {
        List<String> lines;
        try {
            lines = Files.readAllLines(file, StandardCharsets.UTF_8);
        } catch (IOException failure) {
            throw new ApprovalSourceException("Approval register cannot be read: " + file.getFileName(), failure);
        }
        if (lines.isEmpty() || !HEADER.equals(lines.get(0))) {
            throw new ApprovalSourceException("Approval register has no valid header row.");
        }
        List<ApprovalRecord> records = new ArrayList<>();
        Set<String> keys = new HashSet<>();
        for (int i = 1; i < lines.size(); i++) {
            int row = i + 1;
            ApprovalRecord record = parse(lines.get(i), row);
            String key = record.borrowerId() + "|" + record.itemId() + "|" + record.start() + "|" + record.endExclusive();
            if (!keys.add(key)) {
                throw new ApprovalSourceException("Duplicate approval request key at row " + row + ".");
            }
            records.add(record);
        }
        return List.copyOf(records);
    }

    private static ApprovalRecord parse(String line, int row) {
        String[] columns = line.split("\t", -1);
        if (columns.length != 8) {
            throw new ApprovalSourceException("Row " + row + " has " + columns.length + " columns, not 8.");
        }
        try {
            return new ApprovalRecord(columns[0], columns[1], LocalDate.parse(columns[2]), LocalDate.parse(columns[3]),
                    columns[4], status(columns[5], row), Instant.parse(columns[6]), Instant.parse(columns[7]));
        } catch (DateTimeParseException | IllegalArgumentException bad) {
            throw new ApprovalSourceException("Row " + row + " is not a valid approval record.", bad);
        }
    }

    private static ApprovalStatus status(String text, int row) {
        return switch (text) {
            case "APPROVED" -> ApprovalStatus.APPROVED;
            case "DENIED" -> ApprovalStatus.DENIED;
            default -> throw new ApprovalSourceException("Row " + row + " has an unknown status.");
        };
    }
}

package edu.se506.lending.infrastructure.directory;

/** Illustrative provider contract, not an actual university API. See HttpLegacyDirectoryClient for a network client. */
@FunctionalInterface
public interface LegacyDirectoryClient {
    // null means no row; codes are exact and case-sensitive.
    Person lookup(String key);

    record Person(String key, String kind, String status) { }

    final class Failure extends RuntimeException {
        private static final long serialVersionUID = 1L;

        public Failure(String message) { super(message); }
        public Failure(String message, Throwable cause) { super(message, cause); }
    }
}

package edu.se506.lending.infrastructure.directory;

import edu.se506.lending.application.port.BorrowerDirectory;
import edu.se506.lending.application.port.DirectoryException;
import edu.se506.lending.domain.Borrower;
import edu.se506.lending.domain.BorrowerCategory;

import java.util.Objects;
import java.util.Optional;

public final class LegacyDirectoryAdapter implements BorrowerDirectory {
    private final LegacyDirectoryClient client;

    public LegacyDirectoryAdapter(LegacyDirectoryClient client) {
        this.client = Objects.requireNonNull(client, "client");
    }

    @Override
    public Optional<Borrower> find(String borrowerId) {
        if (borrowerId == null || borrowerId.isBlank()) {
            throw new IllegalArgumentException("Borrower id required");
        }
        LegacyDirectoryClient.Person row;
        try {
            row = client.lookup(borrowerId);
        } catch (LegacyDirectoryClient.Failure failure) {
            throw new DirectoryException("Borrower directory unavailable", failure);
        }
        if (row == null) return Optional.empty();
        if (!borrowerId.equals(row.key())) throw new DirectoryException("Mismatched borrower id");
        BorrowerCategory category;
        if ("S".equals(row.kind())) category = BorrowerCategory.STUDENT;
        else if ("T".equals(row.kind())) category = BorrowerCategory.STAFF;
        else if ("V".equals(row.kind())) category = BorrowerCategory.VISITOR;
        else throw new DirectoryException("Unsupported borrower category");
        if ("N".equals(row.status())) return Optional.empty();
        if (!"Y".equals(row.status())) throw new DirectoryException("Unsupported borrower status");
        return Optional.of(new Borrower(row.key(), category));
    }
}

package edu.se506.lending.infrastructure.directory;

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * Asks a directory service over HTTP: {@code GET <base>/borrowers/<key>}. A 200 response carries one
 * line, the provider's kind and status separated by a tab. A 404 means there is no such row. Everything
 * else is a failure: a timeout, a refused connection, any other status and a body that is not exactly
 * two fields. Policy: one attempt, a bounded wait, no retry and no fallback answer. The wait bounds the
 * whole lookup, including the time to receive the body: the request timeout of the JDK client is not
 * documented to cover the body, and a server that sends its headers and then stalls would otherwise hold
 * the caller for as long as it likes. A caller that cannot get an answer must fail, because an outage
 * must never look like a missing borrower.
 */
public final class HttpLegacyDirectoryClient implements LegacyDirectoryClient {
    private final HttpClient http;
    private final URI base;
    private final Duration requestTimeout;

    public HttpLegacyDirectoryClient(URI base, Duration connectTimeout, Duration requestTimeout) {
        this.base = Objects.requireNonNull(base, "base");
        this.requestTimeout = Objects.requireNonNull(requestTimeout, "requestTimeout");
        this.http = HttpClient.newBuilder()
                .connectTimeout(Objects.requireNonNull(connectTimeout, "connectTimeout"))
                .build();
    }

    @Override
    public Person lookup(String key) {
        URI uri = URI.create(base.toString().replaceAll("/+$", "") + "/borrowers/"
                + URLEncoder.encode(key, StandardCharsets.UTF_8));
        HttpRequest request = HttpRequest.newBuilder(uri).timeout(requestTimeout).GET().build();
        CompletableFuture<HttpResponse<String>> pending =
                http.sendAsync(request, HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
        HttpResponse<String> response;
        try {
            response = pending.get(requestTimeout.toNanos(), TimeUnit.NANOSECONDS);
        } catch (TimeoutException late) {
            pending.cancel(true);   // asks the client to drop the exchange; the caller does not wait for it
            throw new Failure("Directory did not answer within " + requestTimeout.toMillis() + " ms.", late);
        } catch (InterruptedException interrupted) {
            pending.cancel(true);
            Thread.currentThread().interrupt();
            throw new Failure("Directory request was interrupted.", interrupted);
        } catch (ExecutionException failed) {
            Throwable cause = failed.getCause() == null ? failed : failed.getCause();
            throw new Failure("Directory unavailable: " + cause.getClass().getSimpleName(), cause);
        }
        if (response.statusCode() == 404) {
            return null;
        }
        if (response.statusCode() != 200) {
            throw new Failure("Directory answered with status " + response.statusCode() + ".");
        }
        String[] fields = response.body().strip().split("\t", -1);
        if (fields.length != 2) {
            throw new Failure("Directory answered with a malformed row.");
        }
        return new Person(key, fields[0], fields[1]);
    }
}

package edu.se506.lending.bootstrap;

import edu.se506.lending.application.ConfirmationFormatter;
import edu.se506.lending.application.ReservationCoordinator;
import edu.se506.lending.application.port.NotificationSender;
import edu.se506.lending.domain.BorrowerCategory;
import edu.se506.lending.domain.ReservationRules;
import edu.se506.lending.domain.StaffReservationRules;
import edu.se506.lending.domain.VisitorReservationRules;
import edu.se506.lending.infrastructure.notification.ConsoleNotificationSender;
import edu.se506.lending.infrastructure.persistence.InMemoryReservationRepository;

import java.time.LocalDate;
import java.util.Map;

public final class ReservationApplication {
    private ReservationApplication() { }

    public static ReservationCoordinator create(NotificationSender sender) {
        return new ReservationCoordinator(
                Map.of(BorrowerCategory.STUDENT, new ReservationRules(),
                       BorrowerCategory.STAFF, new StaffReservationRules(),
                       BorrowerCategory.VISITOR, new VisitorReservationRules()),
                new ConfirmationFormatter(), sender, new InMemoryReservationRepository());
    }

    public static void main(String[] args) {
        ConfirmationFormatter noticeFormat = new ConfirmationFormatter();
        NotificationSender sender = new ConsoleNotificationSender(System.out, noticeFormat);
        ReservationCoordinator coordinator = create(sender);
        String result = coordinator.reserve("B1", "CAM1", LocalDate.of(2026, 10, 20), 2);
        System.out.println("Result: " + result);
    }
}

package edu.se506.lending.bootstrap;

import edu.se506.lending.application.DirectoryReservationService;
import edu.se506.lending.application.ReservationCoordinator;
import edu.se506.lending.application.VisitorGate;
import edu.se506.lending.application.port.ApprovalSourceException;
import edu.se506.lending.application.port.DirectoryException;
import edu.se506.lending.infrastructure.approvals.FileApprovalSource;
import edu.se506.lending.infrastructure.directory.HttpLegacyDirectoryClient;
import edu.se506.lending.infrastructure.directory.LegacyDirectoryAdapter;
import edu.se506.lending.infrastructure.notification.RecordingNotificationSender;
import java.net.URI;
import java.nio.file.Path;
import java.time.Clock;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneOffset;

/**
 * The runnable system for Chapter 13: a directory service reached over HTTP, a sponsor-approval file
 * and one feature flag. Settings are system properties so that a test can start it as a separate process:
 * lending.directory.url (required), lending.approvals.file (required), lending.visitors (default false),
 * lending.now (an ISO instant, default the system clock) and lending.directory.timeout.millis (default 1000).
 */
public final class Chapter13Demo {
    public static void main(String[] args) {
        URI directoryUrl = URI.create(required("lending.directory.url"));
        Path approvals = Path.of(required("lending.approvals.file"));
        boolean visitorsEnabled = Boolean.parseBoolean(System.getProperty("lending.visitors", "false"));
        String now = System.getProperty("lending.now");
        Clock clock = now == null ? Clock.systemUTC() : Clock.fixed(Instant.parse(now), ZoneOffset.UTC);
        long timeoutMillis = Long.parseLong(System.getProperty("lending.directory.timeout.millis", "1000"));

        var sender = new RecordingNotificationSender();
        ReservationCoordinator coordinator = ReservationApplication.create(sender);
        var directory = new LegacyDirectoryAdapter(new HttpLegacyDirectoryClient(
                directoryUrl, Duration.ofMillis(timeoutMillis), Duration.ofMillis(timeoutMillis)));
        var gate = new VisitorGate(new FileApprovalSource(approvals), clock, visitorsEnabled);
        var service = new DirectoryReservationService(directory, coordinator, gate);

        LocalDate start = LocalDate.of(2026, 10, 20);
        System.out.println("Visitors enabled: " + visitorsEnabled);
        attempt("Student B1", service, "B1", "CAM1", start, 2);
        attempt("Visitor V1", service, "V1", "CAM2", start, 2);
        attempt("Visitor V2", service, "V2", "CAM2", start, 2);
        attempt("Unknown U9", service, "U9", "MIC1", start, 1);
        attempt("Outage BROKEN", service, "BROKEN", "MIC1", start, 1);
        System.out.println("Reservations: " + coordinator.reservations().size());
        System.out.println("Notices: " + sender.received().size());
    }

    private static void attempt(String label, DirectoryReservationService service,
                                String borrower, String item, LocalDate start, int days) {
        String outcome;
        try {
            outcome = service.reserve(borrower, item, start, days);
        } catch (DirectoryException failure) {
            outcome = "Unavailable: " + failure.getMessage();
        } catch (ApprovalSourceException failure) {
            outcome = "Approval register unavailable: " + failure.getMessage();
        }
        System.out.println(label + ": " + outcome);
    }

    private static String required(String property) {
        String value = System.getProperty(property);
        if (value == null || value.isBlank()) {
            throw new IllegalStateException("Missing system property " + property);
        }
        return value;
    }
}

package edu.se506.lending.visitor;

import static org.junit.jupiter.api.Assertions.*;

import edu.se506.lending.domain.ApprovalRecord;
import edu.se506.lending.domain.ApprovalStatus;
import edu.se506.lending.domain.VisitorReservationRules;
import java.time.Instant;
import java.time.LocalDate;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

/** Unit tests for the visitor count and duration rule and for the approval record's own rules. */
class VisitorRulesTest {
    private static final LocalDate START = LocalDate.of(2026, 10, 20);
    private static final Instant FROM = Instant.parse("2026-10-18T00:00:00Z");
    private static final Instant UNTIL = Instant.parse("2026-10-20T00:00:00Z");

    private static ApprovalRecord record(ApprovalStatus status) {
        return new ApprovalRecord("V1", "CAM1", START, START.plusDays(2), "S1", status, FROM, UNTIL);
    }

    @ParameterizedTest
    @CsvSource({"0,1,true", "2,3,true", "0,2,true", "3,1,false", "0,4,false", "0,0,false", "-1,1,false", "0,-1,false"})
    void countAndDurationBoundaries(int count, int days, boolean expected) {
        assertEquals(expected, new VisitorReservationRules().mayRequest(count, days));
    }

    @Test void equalityAtTheStartOfTheWindowIsValidAndAtTheEndIsNot() {
        ApprovalRecord approved = record(ApprovalStatus.APPROVED);
        assertTrue(approved.validAt(FROM));
        assertTrue(approved.validAt(UNTIL.minusSeconds(1)));
        assertFalse(approved.validAt(UNTIL));
        assertFalse(approved.validAt(FROM.minusSeconds(1)));
    }

    @Test void onlyAnApprovedStatusApprovesAndOnlyInsideTheWindow() {
        Instant inside = Instant.parse("2026-10-19T12:00:00Z");
        assertTrue(record(ApprovalStatus.APPROVED).approvesAt(inside));
        assertFalse(record(ApprovalStatus.DENIED).approvesAt(inside));
        assertFalse(record(ApprovalStatus.APPROVED).approvesAt(UNTIL));
    }

    @Test void aRecordMatchesOnlyTheExactBorrowerItemAndPeriod() {
        ApprovalRecord approved = record(ApprovalStatus.APPROVED);
        LocalDate end = START.plusDays(2);
        assertTrue(approved.matches("V1", "CAM1", START, end));
        assertFalse(approved.matches("V2", "CAM1", START, end));
        assertFalse(approved.matches("V1", "CAM2", START, end));
        assertFalse(approved.matches("V1", "CAM1", START.plusDays(1), end));
        assertFalse(approved.matches("V1", "CAM1", START, end.plusDays(1)));
    }

    @Test void anInvalidRecordCannotBeBuilt() {
        assertThrows(IllegalArgumentException.class, () ->
                new ApprovalRecord("V1", "CAM1", START, START.plusDays(2), " ", ApprovalStatus.APPROVED, FROM, UNTIL));
        assertThrows(IllegalArgumentException.class, () ->
                new ApprovalRecord("V1", "CAM1", START, START, "S1", ApprovalStatus.APPROVED, FROM, UNTIL));
        assertThrows(IllegalArgumentException.class, () ->
                new ApprovalRecord("V1", "CAM1", START, START.plusDays(2), "S1", ApprovalStatus.APPROVED, UNTIL, UNTIL));
        assertThrows(NullPointerException.class, () ->
                new ApprovalRecord("V1", "CAM1", START, START.plusDays(2), "S1", null, FROM, UNTIL));
    }
}

package edu.se506.lending.visitor;

import static org.junit.jupiter.api.Assertions.*;

import edu.se506.lending.application.VisitorGate;
import edu.se506.lending.application.port.ApprovalSource;
import edu.se506.lending.application.port.ApprovalSourceException;
import edu.se506.lending.domain.ApprovalRecord;
import edu.se506.lending.domain.ApprovalStatus;
import java.time.Clock;
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.jupiter.api.Test;

/** Unit tests for the visitor gate with a controlled approval source and clock. */
class VisitorGateTest {
    private static final LocalDate START = LocalDate.of(2026, 10, 20);
    private static final Instant FROM = Instant.parse("2026-10-18T00:00:00Z");
    private static final Instant UNTIL = Instant.parse("2026-10-20T00:00:00Z");
    private static final Instant NOW = Instant.parse("2026-10-19T12:00:00Z");

    private final AtomicInteger reads = new AtomicInteger();

    private ApprovalSource sourceOf(ApprovalRecord record) {
        return (borrower, item, start, end) -> {
            reads.incrementAndGet();
            return Optional.ofNullable(record);
        };
    }

    private static ApprovalRecord record(ApprovalStatus status) {
        return new ApprovalRecord("V1", "CAM1", START, START.plusDays(2), "S1", status, FROM, UNTIL);
    }

    private VisitorGate gate(ApprovalRecord record, Instant now, boolean enabled) {
        return new VisitorGate(sourceOf(record), Clock.fixed(now, ZoneOffset.UTC), enabled);
    }

    @Test void aMatchingApprovedRecordInsideItsWindowLetsTheRequestContinue() {
        assertEquals(Optional.empty(), gate(record(ApprovalStatus.APPROVED), NOW, true).rejection("V1", "CAM1", START, 2));
        assertEquals(1, reads.get());
    }

    @Test void aDisabledGateRejectsWithoutReadingTheSource() {
        assertEquals(Optional.of(VisitorGate.DISABLED),
                gate(record(ApprovalStatus.APPROVED), NOW, false).rejection("V1", "CAM1", START, 2));
        assertEquals(0, reads.get());
    }

    @Test void anItemOutsideTheAllowlistIsRejectedWithoutReadingTheSource() {
        assertEquals(Optional.of(VisitorGate.ITEM_NOT_ALLOWED),
                gate(record(ApprovalStatus.APPROVED), NOW, true).rejection("V1", "MIC1", START, 2));
        assertEquals(0, reads.get());
    }

    @Test void aNonPositiveDurationIsLeftToThePolicyWithoutReadingTheSource() {
        VisitorGate gate = gate(record(ApprovalStatus.APPROVED), NOW, true);
        assertEquals(Optional.empty(), gate.rejection("V1", "CAM1", START, 0));
        assertEquals(Optional.empty(), gate.rejection("V1", "CAM1", START, -2));
        assertEquals(0, reads.get());
    }

    @Test void aMissingOrDeniedRecordIsAnExpectedRejection() {
        assertEquals(Optional.of(VisitorGate.NOT_APPROVED), gate(null, NOW, true).rejection("V1", "CAM1", START, 2));
        assertEquals(Optional.of(VisitorGate.NOT_APPROVED),
                gate(record(ApprovalStatus.DENIED), NOW, true).rejection("V1", "CAM1", START, 2));
    }

    @Test void theWindowIncludesItsStartAndExcludesItsEnd() {
        ApprovalRecord approved = record(ApprovalStatus.APPROVED);
        assertEquals(Optional.empty(), gate(approved, FROM, true).rejection("V1", "CAM1", START, 2));
        assertEquals(Optional.of(VisitorGate.NOT_APPROVED), gate(approved, UNTIL, true).rejection("V1", "CAM1", START, 2));
        assertEquals(Optional.of(VisitorGate.NOT_APPROVED),
                gate(approved, FROM.minusSeconds(1), true).rejection("V1", "CAM1", START, 2));
    }

    @Test void aSourceThatReturnsADifferentRequestDoesNotApprove() {
        ApprovalRecord other = new ApprovalRecord("V2", "CAM1", START, START.plusDays(2), "S1",
                ApprovalStatus.APPROVED, FROM, UNTIL);
        assertEquals(Optional.of(VisitorGate.NOT_APPROVED), gate(other, NOW, true).rejection("V1", "CAM1", START, 2));
    }

    @Test void anOperationalFailureOfTheSourceIsNotCaught() {
        ApprovalSourceException failure = new ApprovalSourceException("register unreadable");
        VisitorGate gate = new VisitorGate((b, i, s, e) -> { throw failure; }, Clock.fixed(NOW, ZoneOffset.UTC), true);
        assertSame(failure, assertThrows(ApprovalSourceException.class, () -> gate.rejection("V1", "CAM1", START, 2)));
    }

    @Test void oneRequestReadsTheClockOnce() {
        AtomicInteger instants = new AtomicInteger();
        Clock counting = new Clock() {
            @Override public ZoneId getZone() { return ZoneOffset.UTC; }
            @Override public Clock withZone(ZoneId zone) { return this; }
            @Override public Instant instant() { instants.incrementAndGet(); return NOW; }
        };
        new VisitorGate(sourceOf(record(ApprovalStatus.APPROVED)), counting, true).rejection("V1", "CAM1", START, 2);
        assertEquals(1, instants.get());
    }

    @Test void theDisabledFactoryNeverReadsASource() {
        assertEquals(Optional.of(VisitorGate.DISABLED), VisitorGate.disabled().rejection("V1", "CAM1", START, 2));
    }
}