題材:外部とやり取りする注文サービス

題材は、注文を受け付けて取り消す OrderService だ。tree-sitter シリーズ PART 04 の注文サービスを、テストの題材向けに作り直した。外部とのやり取りはすべてコンストラクタで受け取る形にしてある。

ファイル種類役割テストでの扱い
OrderServiceclassテスト対象実物(sut)
OrderRepositoryinterface注文の保存・検索(DB)モック
StockClientinterface在庫管理システム(外部 API)モック
MailSenderinterface受付メールの送信モック
ClockJDK現在時刻Clock.fixed で固定
Order / OrderLine / OrderStatusclass / record / enum注文・明細・状態実物
OutOfStockException / MailException例外在庫不足・送信失敗実物
src/main/java/com/example/order/OrderService.java
package com.example.order;

import java.time.Clock;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

public class OrderService {

    private final OrderRepository orderRepository;
    private final StockClient stockClient;
    private final MailSender mailSender;
    private final Clock clock;

    public OrderService(OrderRepository orderRepository, StockClient stockClient,
                        MailSender mailSender, Clock clock) {
        this.orderRepository = orderRepository;
        this.stockClient = stockClient;
        this.mailSender = mailSender;
        this.clock = clock;
    }

    public Order placeOrder(String customerId, List<OrderLine> lines) {
        if (customerId == null || customerId.isBlank()) {
            throw new IllegalArgumentException("customerId is required");
        }
        if (lines.isEmpty()) {
            throw new IllegalArgumentException("lines is empty");
        }
        Order order = new Order(customerId, LocalDateTime.now(clock));
        for (OrderLine line : lines) {
            int stock = stockClient.getStock(line.itemCode());
            if (stock < line.quantity()) {
                throw new OutOfStockException(line.itemCode());
            }
            order.addLine(line);
        }
        order.setDiscountRate(order.total() >= 10000 ? 0.05 : 0.0);
        orderRepository.save(order);
        try {
            mailSender.send(customerId, "ご注文を受け付けました");
        } catch (MailException e) {
            order.markMailFailed();
        }
        return order;
    }

    public boolean cancelOrder(long orderId) {
        Optional<Order> found = orderRepository.findById(orderId);
        if (found.isEmpty()) {
            return false;
        }
        Order order = found.get();
        switch (order.getStatus()) {
            case NEW, PAID -> order.setStatus(OrderStatus.CANCELLED);
            case SHIPPED -> throw new IllegalStateException("発送済みの注文は取り消せません");
            default -> {
                return false;
            }
        }
        orderRepository.save(order);
        return true;
    }
}

値のクラスも載せておく。OrderLine は record、Order は状態を持つ普通のクラスだ。

OrderLine.java
package com.example.order;

public record OrderLine(String itemCode, int quantity, int unitPrice) {
    public int amount() {
        return quantity * unitPrice;
    }
}
Order.java
package com.example.order;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

public class Order {
    private final String customerId;
    private final LocalDateTime orderedAt;
    private final List<OrderLine> lines = new ArrayList<>();
    private OrderStatus status = OrderStatus.NEW;
    private double discountRate;
    private boolean mailFailed;

    public Order(String customerId, LocalDateTime orderedAt) {
        this.customerId = customerId;
        this.orderedAt = orderedAt;
    }

    public void addLine(OrderLine line) { lines.add(line); }
    public int total() { return lines.stream().mapToInt(OrderLine::amount).sum(); }

    public String getCustomerId() { return customerId; }
    public LocalDateTime getOrderedAt() { return orderedAt; }
    public List<OrderLine> getLines() { return List.copyOf(lines); }
    public OrderStatus getStatus() { return status; }
    public void setStatus(OrderStatus status) { this.status = status; }
    public double getDiscountRate() { return discountRate; }
    public void setDiscountRate(double discountRate) { this.discountRate = discountRate; }
    public boolean isMailFailed() { return mailFailed; }
    public void markMailFailed() { this.mailFailed = true; }
}

残りのファイル(OrderStatus は NEW, PAID, SHIPPED, CANCELLED の enum、OrderRepository は save と Optional<Order> findById(long)、StockClient は int getStock(String)、MailSender は void send(String, String) を持つ interface)は短いので省略する。

判定を数える

テストを書く前に、通すべき判定と結果を書き出す。PART 03 ではこの作業を自動にする。

メソッド行判定通すべき結果入力の作り方
placeOrder24customerId == null || customerId.isBlank()true(null / 空白)・false引数
27lines.isEmpty()true・false引数
31for (OrderLine line : lines)1回以上(0回は到達不能)引数
33stock < line.quantity()true・false在庫 API のモックの戻り値
38order.total() >= 10000 ? 0.05 : 0.0true・false明細の単価 × 数量
42catch (MailException e)例外なし・例外ありメール送信のモックに例外を投げさせる
cancelOrder50found.isEmpty()true・falseRepository のモックの戻り値
54switch (order.getStatus())NEW / PAID・SHIPPED・それ以外モックが返す Order の状態

注目したいのは for の「0回」だ。直前の lines.isEmpty() で空のリストは弾かれるため、ループを0回で抜ける経路は通れない。このような 到達できない分岐 も、ジェネレーターは見分けられる必要がある。

Gradle の設定

JUnit 5・Mockito・JaCoCo を使う build.gradle は次のとおり。生成テスト用の設定(withGenerated)も先に入れておくが、意味は PART 06 で説明する。

build.gradle
plugins {
    id 'java'
    id 'jacoco'
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

repositories {
    mavenCentral()
}

configurations {
    mockitoAgent
}

dependencies {
    testImplementation platform('org.junit:junit-bom:5.14.2')
    testImplementation 'org.junit.jupiter:junit-jupiter'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
    testImplementation 'org.mockito:mockito-core:5.23.0'
    testImplementation 'org.mockito:mockito-junit-jupiter:5.23.0'
    mockitoAgent('org.mockito:mockito-core:5.23.0') { transitive = false }
}

// 生成テスト(src/test/generated/java)は -PwithGenerated を付けたときだけ実行する
sourceSets {
    test {
        java {
            if (project.hasProperty('withGenerated')) {
                srcDir 'src/test/generated/java'
            }
        }
    }
}

jacoco {
    toolVersion = '0.8.14'
}

test {
    useJUnitPlatform()
    jvmArgs += "-javaagent:${configurations.mockitoAgent.asPath}"
    // 生成テストは期待値が TODO のため失敗する。計測だけしたいので失敗で止めない
    ignoreFailures = project.hasProperty('withGenerated')
    finalizedBy jacocoTestReport
}

jacocoTestReport {
    reports {
        xml.required = true
        html.required = true
    }
}

ℹ️ mockitoAgent について

Mockito 5 は、final クラスもモックにできる inline 方式が既定になっている。JDK 21 以降では、実行中にエージェントを読み込むと警告が出る(将来は禁止される予定)。そのため Mockito の公式ドキュメントでは、-javaagent でテスト起動時に読み込む設定を勧めている。上の configurations { mockitoAgent } と jvmArgs の2か所がそれにあたる。

手書きのテスト

テストは @Nested でメソッドごとにまとめ、@DisplayName に何を確かめるかを日本語で書く。外部依存は @Mock にし、Clock だけは固定の時刻を渡す。

src/test/java/com/example/order/OrderServiceHandTest.java
package com.example.order;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;

import java.time.Clock;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.EnumSource;
import org.junit.jupiter.params.provider.NullSource;
import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
class OrderServiceHandTest {

    @Mock OrderRepository orderRepository;
    @Mock StockClient stockClient;
    @Mock MailSender mailSender;

    Clock clock = Clock.fixed(Instant.parse("2026-11-06T01:00:00Z"), ZoneId.of("Asia/Tokyo"));
    OrderService sut;

    @BeforeEach
    void setUp() {
        sut = new OrderService(orderRepository, stockClient, mailSender, clock);
    }

    @Nested
    @DisplayName("placeOrder")
    class PlaceOrder {

        @ParameterizedTest
        @NullSource
        @ValueSource(strings = {"", "  "})
        @DisplayName("顧客IDが未指定なら IllegalArgumentException")
        void customerIdMissing(String customerId) {
            List<OrderLine> lines = List.of(new OrderLine("A001", 1, 500));
            assertThrows(IllegalArgumentException.class, () -> sut.placeOrder(customerId, lines));
            verifyNoInteractions(stockClient, orderRepository, mailSender);
        }

        @Test
        @DisplayName("明細が空なら IllegalArgumentException")
        void linesEmpty() {
            assertThrows(IllegalArgumentException.class, () -> sut.placeOrder("C001", List.of()));
            verifyNoInteractions(stockClient, orderRepository, mailSender);
        }

        @Test
        @DisplayName("在庫が数量より少なければ OutOfStockException、保存しない")
        void outOfStock() {
            when(stockClient.getStock("A001")).thenReturn(1);
            List<OrderLine> lines = List.of(new OrderLine("A001", 2, 500));
            assertThrows(OutOfStockException.class, () -> sut.placeOrder("C001", lines));
            verify(orderRepository, never()).save(any());
        }

        @Test
        @DisplayName("在庫が数量ちょうどなら受注でき、合計1万円未満は割引なし")
        void stockJustEnough_noDiscount() {
            when(stockClient.getStock("A001")).thenReturn(2);
            Order order = sut.placeOrder("C001", List.of(new OrderLine("A001", 2, 4999)));
            assertEquals(9998, order.total());
            assertEquals(0.0, order.getDiscountRate());
            assertEquals(LocalDateTime.of(2026, 11, 6, 10, 0), order.getOrderedAt());
            assertFalse(order.isMailFailed());
            verify(orderRepository).save(order);
            verify(mailSender).send("C001", "ご注文を受け付けました");
        }

        @Test
        @DisplayName("合計1万円ちょうどなら5%割引")
        void discount() {
            when(stockClient.getStock("A001")).thenReturn(10);
            Order order = sut.placeOrder("C001", List.of(new OrderLine("A001", 2, 5000)));
            assertEquals(0.05, order.getDiscountRate());
        }

        @Test
        @DisplayName("メール送信に失敗しても受注は成功し、失敗フラグが立つ")
        void mailFailed() {
            when(stockClient.getStock("A001")).thenReturn(5);
            doThrow(new MailException("SMTP error")).when(mailSender).send(anyString(), anyString());
            Order order = sut.placeOrder("C001", List.of(new OrderLine("A001", 1, 500)));
            assertTrue(order.isMailFailed());
            verify(orderRepository).save(order);
        }
    }

    @Nested
    @DisplayName("cancelOrder")
    class CancelOrder {

        @Test
        @DisplayName("注文が見つからなければ false")
        void notFound() {
            when(orderRepository.findById(1L)).thenReturn(Optional.empty());
            assertFalse(sut.cancelOrder(1L));
            verify(orderRepository, never()).save(any());
        }

        @ParameterizedTest
        @EnumSource(value = OrderStatus.class, names = {"NEW", "PAID"})
        @DisplayName("NEW・PAID は取り消せる")
        void cancellable(OrderStatus status) {
            Order order = orderWith(status);
            when(orderRepository.findById(1L)).thenReturn(Optional.of(order));
            assertTrue(sut.cancelOrder(1L));
            assertEquals(OrderStatus.CANCELLED, order.getStatus());
            verify(orderRepository).save(order);
        }

        @Test
        @DisplayName("発送済みは IllegalStateException")
        void shipped() {
            when(orderRepository.findById(1L)).thenReturn(Optional.of(orderWith(OrderStatus.SHIPPED)));
            assertThrows(IllegalStateException.class, () -> sut.cancelOrder(1L));
            verify(orderRepository, never()).save(any());
        }

        @Test
        @DisplayName("取消済みは false")
        void alreadyCancelled() {
            when(orderRepository.findById(1L)).thenReturn(Optional.of(orderWith(OrderStatus.CANCELLED)));
            assertFalse(sut.cancelOrder(1L));
            verify(orderRepository, never()).save(any());
        }

        private Order orderWith(OrderStatus status) {
            Order order = new Order("C001", LocalDateTime.of(2026, 11, 1, 9, 0));
            order.setStatus(status);
            return order;
        }
    }
}

人が書くときに自然とやっている工夫を、あとで比べられるように書き出しておく。

  • 境界値を選んでいる:在庫は「1少ない(1 < 2)」と「ちょうど(2 = 2)」、合計は「9,998 円」と「10,000 円ちょうど」
  • まとめられるものはまとめている:顧客 ID の未指定は null・""・" " の3つをパラメータ化テストにしている
  • 呼ばれないことも確かめている:入力チェックで弾いたときは verifyNoInteractions、在庫不足のときは save が呼ばれないこと
  • 時刻を固定している:2026-11-06T01:00:00Z を東京時間で渡し、受注日時が 10:00 になることを確かめている
  • 期待値は仕様から書いている:「1 万円以上で 5% 割引」「発送済みは取り消せない」を確かめている

実行結果:分岐 17/17

PowerShell / bash
gradlew test

テストは 13 件(パラメータ化テストを展開した数)がすべて成功した。build/reports/jacoco/test/jacocoTestReport.xml から、OrderService の分岐のある行だけを抜き出すと次のようになる(mb = 未達の分岐数、cb = 通った分岐数)。

jacocoTestReport.xml から抜粋(OrderService.java)
行  mb  cb  ソース
24   0   4  if (customerId == null || customerId.isBlank()) {
27   0   2  if (lines.isEmpty()) {
31   0   2  for (OrderLine line : lines) {
33   0   2  if (stock < line.quantity()) {
38   0   2  order.setDiscountRate(order.total() >= 10000 ? 0.05 : 0.0);
50   0   2  if (found.isEmpty()) {
54   0   3  switch (order.getStatus()) {

合計: 分岐 17/17(100%)、行 34/34(100%)

24 行目の || は 4、54 行目の switch は 3 と数えられている。一方、catch の行は分岐として数えられていない。前の表で数えた「判定の結果」とは数え方が違うが、ここでは 100% になったことだけ確認しておき、詳しい比較は PART 07 で行う。

生成ツールに必要な情報

手で書いた結果から逆算すると、ジェネレーターが知っていなければならない情報は次のとおりだ。

必要な情報テストのどこで使うか扱う回
判定の位置・種類・条件式・結果ごとに抜けるかケースの数と @DisplayNamePART 03
コンストラクタ引数と、その型が interface かどうか@Mock と new OrderService(...)PART 04
モックのメソッドの戻り値の型・引数の型when(...).thenReturn(...)、any(...)PART 04・05
record の構成要素、クラスのコンストラクタ、enum の定数テストデータの組み立てPART 05
条件式の左右の値がどこから来るか(引数・モック・定数)境界値の決定PART 05
例外クラスのコンストラクタdoThrow(new MailException(...))PART 05

逆に、ジェネレーターに まねできない こともはっきりした。「9,998 円と 10,000 円で境界を挟む」のは、order.total() が単価 × 数量の合計だと理解しているからできることだ。「メール送信に失敗しても受注は成功する」という期待値も、仕様を知らなければ書けない。前者は入力値の TODO、後者は期待値の TODO として、人に任せることになる。

✅ 次の記事では…

PART 03 では、tree-sitter で OrderService の判定を自動で集め、ここで手作業で数えた分岐を「分岐表」として出力する。

→ PART 03 — 分岐の抽出へ