テストコード設計パターンで可読性と保守性を上げる方法

import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.List;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

class OrderServiceTest {

    record OrderItem(String productName, int quantity, BigDecimal unitPrice) {}
    record Order(String customerName, LocalDate orderDate, List<OrderItem> items, Order.Status status) {
        enum Status { PENDING, CONFIRMED, SHIPPED, CANCELLED }
        BigDecimal totalAmount() {
            return items.stream().map(i -> i.unitPrice().multiply(BigDecimal.valueOf(i.quantity())))
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        }
    }

    // --- TestDataBuilder パターン ---
    static class OrderBuilder {
        private String customerName = "テスト株式会社";
        private LocalDate orderDate = LocalDate.of(2025, 4, 1);
        private List<OrderItem> items = List.of(new OrderItem("コピー用紙", 10, new BigDecimal("500")));
        private Order.Status status = Order.Status.PENDING;
        OrderBuilder customerName(String v) { this.customerName = v; return this; }
        OrderBuilder items(List<OrderItem> v) { this.items = v; return this; }
        OrderBuilder status(Order.Status v) { this.status = v; return this; }
        Order build() { return new Order(customerName, orderDate, items, status); }
    }

    // --- Object Mother パターン ---
    static class OrderMother {
        static Order pendingOrder() { return new OrderBuilder().build(); }
        static Order confirmedOrder() { return new OrderBuilder().status(Order.Status.CONFIRMED).build(); }
        static Order highValueOrder() {
            return new OrderBuilder().customerName("大口商事")
                .items(List.of(new OrderItem("サーバー", 2, new BigDecimal("500000")))).build();
        }
    }

    static class OrderService {
        Order confirm(Order order) {
            if (order.status() != Order.Status.PENDING)
                throw new IllegalStateException("確定できるのは PENDING 状態の注文のみです");
            return new Order(order.customerName(), order.orderDate(), order.items(), Order.Status.CONFIRMED);
        }
        boolean requiresApproval(Order order) {
            return order.totalAmount().compareTo(new BigDecimal("100000")) > 0;
        }
    }

    private OrderService service;
    @BeforeEach void setUp() { service = new OrderService(); }

    @Nested @DisplayName("注文確定")
    class ConfirmTests {
        @Test @DisplayName("PENDING を確定すると CONFIRMED になる")
        void confirmPending() {
            Order confirmed = service.confirm(OrderMother.pendingOrder());
            assertEquals(Order.Status.CONFIRMED, confirmed.status());
        }
        @Test @DisplayName("CONFIRMED 済みの再確定は例外")
        void confirmAgainThrows() {
            assertThrows(IllegalStateException.class, () -> service.confirm(OrderMother.confirmedOrder()));
        }
    }

    @Nested @DisplayName("承認要否")
    class ApprovalTests {
        @Test @DisplayName("高額注文は承認が必要")
        void highValue() { assertTrue(service.requiresApproval(OrderMother.highValueOrder())); }
        @Test @DisplayName("少額注文は承認不要")
        void lowValue() { assertFalse(service.requiresApproval(OrderMother.pendingOrder())); }
    }
}