Unit Testing Services

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

import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.Test;

record WelcomeEmail(String to, String name) {
}

interface EmailSender {
    void send(WelcomeEmail email);
}

class RecordingEmailSender implements EmailSender {

    final List<WelcomeEmail> sent = new ArrayList<>();

    @Override
    public void send(WelcomeEmail email) {
        sent.add(email);
    }
}

class SignupService {

    private final EmailSender emails;

    SignupService(EmailSender emails) {
        this.emails = emails;
    }

    void register(String email, String name) {
        String normalised = email.trim().toLowerCase();
        emails.send(new WelcomeEmail(normalised, name.strip()));
    }
}

class SignupServiceTest {

    @Test
    void sendsTheWelcomeEmailToTheNormalisedAddress() {
        RecordingEmailSender sender = new RecordingEmailSender();
        SignupService service = new SignupService(sender);

        service.register("  [email protected] ", " Ada ");

        assertThat(sender.sent).containsExactly(new WelcomeEmail("[email protected]", "Ada"));
    }
}

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

import java.time.Clock;
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneId;
import org.junit.jupiter.api.Test;

record Subscription(String customerId, LocalDate renewsOn) {
}

class RenewalReminderPolicy {

    private final Clock clock;

    RenewalReminderPolicy(Clock clock) {
        this.clock = clock;
    }

    boolean shouldRemind(Subscription subscription) {
        LocalDate today = LocalDate.now(clock);
        return !subscription.renewsOn().isBefore(today)
                && !subscription.renewsOn().isAfter(today.plusDays(7));
    }
}

class RenewalReminderPolicyTest {

    private final Clock clock = Clock.fixed(Instant.parse("2026-05-10T23:30:00Z"), ZoneId.of("Europe/London"));
    private final RenewalReminderPolicy policy = new RenewalReminderPolicy(clock);

    @Test
    void remindsWithinTheLastWeek() {
        assertThat(policy.shouldRemind(new Subscription("c1", LocalDate.of(2026, 5, 18)))).isTrue();
    }

    @Test
    void usesTheLocalDateNotTheUtcDate() {
        // 23:30 UTC on 10 May is already 11 May in London (BST):
        // 19 May is eight days away and 10 May is in the past.
        assertThat(policy.shouldRemind(new Subscription("c2", LocalDate.of(2026, 5, 19)))).isFalse();
        assertThat(policy.shouldRemind(new Subscription("c3", LocalDate.of(2026, 5, 10)))).isFalse();
    }
}

import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.then;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

record StockReserved(String sku, int quantity) {
}

interface StockLevels {
    int available(String sku);

    void reserve(String sku, int quantity);
}

interface DomainEvents {
    void publish(Object event);
}

class OutOfStockException extends RuntimeException {
    OutOfStockException(String sku) {
        super("Not enough stock for " + sku);
    }
}

class ReservationService {

    private final StockLevels stock;
    private final DomainEvents events;

    ReservationService(StockLevels stock, DomainEvents events) {
        this.stock = stock;
        this.events = events;
    }

    void reserve(String sku, int quantity) {
        if (stock.available(sku) < quantity) {
            throw new OutOfStockException(sku);
        }
        stock.reserve(sku, quantity);
        events.publish(new StockReserved(sku, quantity));
    }
}

@ExtendWith(MockitoExtension.class)
class ReservationServiceTest {

    @Mock
    StockLevels stock;

    @Mock
    DomainEvents events;

    @InjectMocks
    ReservationService service;

    @Test
    void rejectsTheReservationAndPublishesNothing() {
        given(stock.available("SKU-1")).willReturn(2);

        assertThatThrownBy(() -> service.reserve("SKU-1", 3)).isInstanceOf(OutOfStockException.class);

        then(stock).should().available("SKU-1");
        then(stock).shouldHaveNoMoreInteractions();
        then(events).shouldHaveNoInteractions();
    }

    @Test
    void publishesAnEventAfterReserving() {
        given(stock.available("SKU-1")).willReturn(5);

        service.reserve("SKU-1", 3);

        then(stock).should().reserve("SKU-1", 3);
        then(events).should().publish(new StockReserved("SKU-1", 3));
    }
}