fleetd/bridged/src/test/java/dev/ltms/fleet/msg/FakeLeadChannel.java

package dev.ltms.fleet.msg;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * Hermetic stand-in for {@link LeadChannel}: an in-memory mailbox that records what was published
 * and what was acked, with no broker anywhere.
 *
 * <p>Its whole point is that {@link LeadMailbox} — the production implementation — owns a live AMQP
 * connection, so every test of the code AROUND it would otherwise need a broker and end up tagged
 * {@code contract}. The broker round trip is covered once, by {@code LeadMailboxTest}; the routing
 * ({@code FleetMcp}) and the delivery ({@link LeadCoordLoop}) are covered here.
 *
 * <p>Thread-safe: {@link LeadCoordLoop} calls it from its own scheduler thread while a test reads
 * the recorded lists.
 */
public final class FakeLeadChannel implements LeadChannel {

    private final String selfCoordId;
    private final List<LeadMessage> held = Collections.synchronizedList(new ArrayList<>());
    private final List<LeadMessage> published = Collections.synchronizedList(new ArrayList<>());
    private final List<String> acked = Collections.synchronizedList(new ArrayList<>());
    /** When set, every {@link #publish} throws it — the unroutable/nacked/timed-out peer. */
    private volatile IllegalStateException publishFailure;

    public FakeLeadChannel(String selfCoordId) {
        this.selfCoordId = selfCoordId;
    }

    /** Make every publish fail as an unreachable peer would. */
    public FakeLeadChannel failPublishWith(String message) {
        this.publishFailure = new IllegalStateException(message);
        return this;
    }

    /** Put a message in this mailbox as if a peer had sent it. */
    public FakeLeadChannel hold(LeadMessage m) {
        held.add(m);
        return this;
    }

    @Override
    public void publish(String toCoordId, LeadMessage m) {
        if (publishFailure != null) {
            throw publishFailure;
        }
        published.add(m);
    }

    @Override
    public List<LeadMessage> peek() {
        return List.copyOf(held);
    }

    @Override
    public void ack(String msgId) {
        held.removeIf(m -> m.msgId().equals(msgId));
        acked.add(msgId);
    }

    @Override
    public String selfCoordId() {
        return selfCoordId;
    }

    public List<LeadMessage> published() {
        return List.copyOf(published);
    }

    public List<String> acked() {
        return List.copyOf(acked);
    }
}