生成テストの置き場所を分ける

最初に決めておきたいのは、生成したファイルの置き場所だ。生成テストは 下書き であり、テスト対象を直したら生成し直す。人が期待値を書き込んだファイルを上書きしてしまわないよう、置き場所を分ける。

場所中身上書き通常の gradlew test
src/test/generated/java生成テスト(*GeneratedTest.java)生成のたびに上書き実行しない(-PwithGenerated を付けたときだけ)
src/test/java人が仕上げたテスト(*Test.java)しない実行する

使い方は「生成 → 計測で確認 → 必要なテストを src/test/java にコピーして仕上げる」という流れになる。PART 02 の build.gradle に入れた次の2か所が、この運用のための設定だ。

build.gradle(抜粋)
sourceSets {
    test {
        java {
            if (project.hasProperty('withGenerated')) {
                srcDir 'src/test/generated/java'
            }
        }
    }
}

test {
    // ...
    ignoreFailures = project.hasProperty('withGenerated')
    finalizedBy jacocoTestReport
}

-PwithGenerated を付けると生成テストもコンパイル・実行し、期待値 TODO の fail() で失敗してもビルドを止めない。finalizedBy により、テストが失敗しても JaCoCo のレポートは作られる。付けなければ生成テストは存在しないのと同じになり、CI に影響しない。

テンプレート

テストクラスの形は Jinja2 のテンプレート1枚で決める。命名、コメント、Arrange-Act-Assert の区切りなど、チームの規約に合わせたいところはここを直せばよい。trim_blocks と lstrip_blocks を有効にしているので、{% for %} などの制御行は出力に空行を残さない。

testgen/templates/test_class.java.j2
package {{ package }};

{% for imp in imports %}
import {{ imp }};
{% endfor %}

/**
 * {{ target }} のテスト(testgen による自動生成:{{ generated_at }})。
 * <p>
 * 分岐の結果ごとに1ケースを生成しています。期待値は自動では決められないため、
 * 「// TODO」の箇所に手動で設定してください。設定するまで fail() で失敗します。
 */
@ExtendWith(MockitoExtension.class)
class {{ class_name }} {
{% if mocks %}

{% for d in mocks %}
    @Mock
    {{ d.type }} {{ d.name }};
{% endfor %}
{% endif %}
{% for d in clocks %}

    Clock {{ d.name }} = Clock.fixed(Instant.parse("2026-01-01T00:00:00Z"), ZoneId.of("Asia/Tokyo"));
{% endfor %}
{% for d in values %}

    // TODO: テスト用の値を設定してください(自動生成:コンストラクタ引数 {{ d.name }})
    {{ d.type }} {{ d.name }} = {{ d.value }};
{% endfor %}

    {{ target }} sut;

    @BeforeEach
    void setUp() {
        sut = new {{ target }}({{ ctor_args }});
    }
{% for m in methods %}

    @Nested
    @DisplayName("{{ m.name }}")
    class {{ m.nested }} {
{% for c in m.cases %}

        @Test
        @DisplayName("{{ c.display }}")
        void {{ c.test_name }}() {
            // 経路: {{ c.path }}
{% for t in c.input_todos %}
            // TODO: {{ t }}(自動生成)
{% endfor %}
            // Arrange
{% for line in c.arrange %}
            {{ line }}
{% endfor %}

{% if c.throws %}
            // Act & Assert
            assertThrows({{ c.throws }}.class, () -> sut.{{ m.name }}({{ c.args }}));
            // TODO: 期待値を設定してください(自動生成:{{ c.where }})
            //       現在は例外の型のみ検証しています。メッセージや状態の検証は手動で追加してください。
{% elif c.returns %}
            // Act
            {{ c.return_type }} actual = sut.{{ m.name }}({{ c.args }});

            // Assert
            // TODO: 期待値を設定してください(自動生成:{{ c.where }})
            //       コード上の戻り値: {{ c.return_hint }}
{% else %}
            // Act
            sut.{{ m.name }}({{ c.args }});

            // Assert
            // TODO: 期待値(状態の変化など)を設定してください(自動生成:{{ c.where }})
{% endif %}
{% for line in c.verifies %}
            {{ line }}
{% endfor %}
{% if c.returns and not c.throws %}
            fail("TODO: 期待値が未設定です");
{% endif %}
        }
{% endfor %}
    }
{% endfor %}
}

テストメソッドの最後は、戻り値の有無と例外で3通りに分かれる。

  • 例外で終わる経路:assertThrows で例外の型だけを確かめる。fail() は入れない(型の確認は、コードから決まる事実なので)。メッセージや状態の確認は TODO にする
  • 値を返す経路:戻り値を actual に受け、TODO に「コード上の戻り値」をヒントとして書き、最後に fail()
  • void のメソッド:状態の変化を確かめる TODO だけを書く

生成スクリプト

testgen/gen_tests.py
"""Java クラスを解析し、C1(分岐網羅)を狙う JUnit 5 + Mockito のテストクラスを生成する

使い方:
  python gen_tests.py <src/main/java> <クラス名> <出力先の test ソースルート>
"""
import datetime
import re
import sys
from pathlib import Path
from jinja2 import Environment, FileSystemLoader
from cases import Planner
from deps import find_dependencies, find_warnings
from project_index import build_index
from ts_common import text

MATCHERS = {"String": "anyString()", "int": "anyInt()", "Integer": "anyInt()", "long": "anyLong()",
            "Long": "anyLong()", "boolean": "anyBoolean()", "double": "anyDouble()"}


def matcher(typ):
    base = typ.split("<")[0]
    return MATCHERS.get(base, f"any({base}.class)" if "<" not in typ else "any()")


def call_args(planner, case, call, param_types):
    """引数を Java の式にする。1つでも決まらなければ、全部をマッチャーにそろえる"""
    values = [planner.render(a, case) for a in call.args]
    if all(v is not None for v in values):
        return ", ".join(values)
    return ", ".join(f"eq({v})" if v is not None else matcher(t)
                     for v, (t, _) in zip(values, param_types))


def drop_unused_samples(arrange, sample_vars):
    """どこからも使われていないサンプル変数の宣言(と setter)を取り除く"""
    changed = True
    while changed:
        changed = False
        for var in sample_vars:
            own = [l for l in arrange if l.startswith(f"{var}.") or re.match(rf"\w+ {var} = ", l)]
            others = [l for l in arrange if l not in own]
            if own and not any(re.search(rf"\b{var}\b", l) for l in others):
                arrange = others
                changed = True
    return arrange


def build_case(planner, case, info_index, mocks):
    arrange, verifies = [], []
    for s in case.samples.values():
        args = ", ".join(s.args.values())
        arrange.append(f"{s.type} {s.var} = new {s.type}({args});")
        for setter, value in s.setters.items():
            arrange.append(f"{s.var}.{setter}({value});")
    for name, value in case.params.items():
        arrange.append(f"{case.param_types[name]} {name} = {value};")

    reached = set()
    for call in case.calls:
        ptypes = info_index[mocks[call.mock].split("<")[0]].method_params.get(call.method, [])
        args = call_args(planner, case, call, ptypes)
        reached.add((call.mock, call.method))
        if call.throw and call.ret == "void":
            arrange.append(f"doThrow({call.throw}).when({call.mock}).{call.method}({args});")
        elif call.throw:
            arrange.append(f"when({call.mock}.{call.method}({args})).thenThrow({call.throw});")
        elif call.stub is not None:
            arrange.append(f"when({call.mock}.{call.method}({args})).thenReturn({call.stub});")
        if call.stub is None:                # スタブしていない呼び出しは verify で確かめる
            verifies.append(f"verify({call.mock}).{call.method}({args});")
    for mock, method in planner.all_call_sites():
        if (mock, method) not in reached:
            ptypes = info_index[mocks[mock].split("<")[0]].method_params.get(method, [])
            verifies.append(f"verify({mock}, never()).{method}({', '.join(matcher(t) for t, _ in ptypes)});")

    arrange = drop_unused_samples(arrange, list(case.samples))
    if verifies and any(o.endswith("?") for _, o in case.path):     # 経路が確定しないなら verify は参考扱い
        verifies = ["// TODO: 「?」の分岐は入力から結果を決められないため、次の verify は確認してから有効にしてください"] + \
                   [f"// {v}" for v in verifies]
    path = " → ".join(f"{b} {o}" for b, o in case.path) or "(分岐なし)"
    if case.target:
        bid, label, kind, cond, line, detail = case.target
        display = f"[{bid}] {kind} {cond} → {label}" + (f"({detail})" if detail else "")
        where = f"{bid} {kind} {cond} → {label}/L{line}"
        suffix = re.sub(r"\W", "_", {"0回": "zero", "1回以上": "loop", "catch": "catch"}.get(label, label))
        test_name = f"{case.method}_{bid}_{suffix}"
    else:
        display = "主経路(各分岐の通常側)"
        where = "主経路"
        test_name = f"{case.method}_mainPath"
    kind, value = case.end
    return {
        "display": display.replace('"', '\\"'), "test_name": test_name, "path": path,
        "where": where, "input_todos": case.todos, "arrange": arrange, "verifies": verifies,
        "args": ", ".join(case.params), "throws": value if kind == "throw" else None,
        "returns": kind == "return" and value is not None, "return_hint": value,
    }


def value_literal(typ, name, index):
    """コンストラクタで受け取る値(設定値・record・enum)の仮の値"""
    simple = {"String": f'"{name}-1"', "int": "1", "Integer": "1", "long": "1L", "Long": "1L",
              "boolean": "false", "Boolean": "false", "double": "1.0"}
    if typ in simple:
        return simple[typ]
    info = index.get(typ)
    if info and info.kind == "enum":
        return f"{typ}.{info.constants[0]}"
    if info and info.kind == "record":
        return f"new {typ}({', '.join(value_literal(t, n, index) for t, n in info.components)})"
    return "null"


def is_public(node):
    return any(c.type == "modifiers" and "public" in text(c).split() for c in node.children)


def generate(src_root, target, out_root):
    index = build_index(src_root)
    info = index[target]
    deps = find_dependencies(target, index)
    mocks = {d.name: d.type for d in deps if d.handling == "MOCK"}
    methods, notes = [], []
    body = info.node.child_by_field_name("body")
    for node in body.named_children:
        if node.type != "method_declaration" or not is_public(node):
            continue
        planner = Planner(node, deps, index)
        cases = planner.plan()
        notes += [f"{planner.node.child_by_field_name('name').text.decode()}: {n}" for n in planner.notes]
        rtype = text(node.child_by_field_name("type"))
        built = [build_case(planner, c, index, mocks) for c in cases]
        seen = {}
        for b in built:                      # 同じ名前になったら連番を付ける
            seen[b["test_name"]] = seen.get(b["test_name"], 0) + 1
            if seen[b["test_name"]] > 1:
                b["test_name"] += f"_{seen[b['test_name']]}"
            b["return_type"] = rtype
        name = text(node.child_by_field_name("name"))
        methods.append({"name": name, "nested": name[0].upper() + name[1:], "cases": built})

    imports = sorted({
        "org.junit.jupiter.api.BeforeEach", "org.junit.jupiter.api.DisplayName",
        "org.junit.jupiter.api.Nested", "org.junit.jupiter.api.Test",
        "org.junit.jupiter.api.extension.ExtendWith", "org.mockito.Mock",
        "org.mockito.junit.jupiter.MockitoExtension", "java.util.List", "java.util.Optional",
        "java.time.LocalDateTime"} | ({"java.time.Clock", "java.time.Instant", "java.time.ZoneId"}
                                       if any(d.handling == "FIXED_CLOCK" for d in deps) else set()))
    imports += ["static org.junit.jupiter.api.Assertions.*",
                "static org.mockito.ArgumentMatchers.*", "static org.mockito.Mockito.*"]
    env = Environment(loader=FileSystemLoader(Path(__file__).parent / "templates"),
                      trim_blocks=True, lstrip_blocks=True, keep_trailing_newline=True)
    code = env.get_template("test_class.java.j2").render(
        package=info.package, imports=imports, target=target, class_name=f"{target}GeneratedTest",
        generated_at=datetime.date.today().isoformat(),
        mocks=[d for d in deps if d.handling == "MOCK"],
        clocks=[d for d in deps if d.handling == "FIXED_CLOCK"],
        values=[{"type": d.type, "name": d.name, "value": value_literal(d.type, d.name, index)}
                for d in deps if d.handling == "VALUE"],
        ctor_args=", ".join(d.name for d in deps), methods=methods)
    out = Path(out_root, *info.package.split("."), f"{target}GeneratedTest.java")
    out.parent.mkdir(parents=True, exist_ok=True)
    out.write_text(code, encoding="utf-8")

    count = sum(len(m["cases"]) for m in methods)
    print(f"生成: {out}({len(methods)} メソッド / {count} ケース)")
    for n in notes:
        print(f"NOTE {n}")
    for line, code_line, advice in find_warnings(target, index):
        print(f"WARN L{line}: {code_line}\n     → {advice}")


if __name__ == "__main__":
    generate(*sys.argv[1:4])

ポイントを4つ説明する。

テストの名前

テスト対象のメソッドごとに @Nested クラスを作り、テストメソッドは メソッド名_分岐ID_結果 と名付ける(例:placeOrder_B4_true、cancelOrder_B2_SHIPPED)。名前が重なったら _2 を付ける。@DisplayName には分岐の種類・条件式・結果をそのまま書く。テストレポートを見ただけで、どの分岐のテストかがわかるようにするためだ。分岐 ID を名前に入れておくと、PART 07 で JaCoCo の結果と突き合わせるときの鍵にもなる。

スタブと verify の出し分け

モック呼び出しは、戻り値を使うかどうかで扱いを分ける。

呼び出し例出力
戻り値を使うint stock = stockClient.getStock(...)when(...).thenReturn(...)。strict stubs が「使われたこと」を保証するので verify は付けない
戻り値を使わない・voidorderRepository.save(order);verify(orderRepository).save(...)
例外を投げさせるcatch の経路void なら doThrow(...).when(...)、そうでなければ thenThrow
メソッド内にあるが、この経路では呼ばれない入力チェックで弾いたときの saveverify(..., never())

マッチャーと eq() をそろえる

Mockito では、1つの呼び出しの引数に any() などのマッチャーと生の値を混ぜることはできない。引数がすべて決まっていれば send("customerId-1", "ご注文を受け付けました") のように生の値を書き、1つでも決まらなければ全部をマッチャーにそろえる。決まっている値は eq(...) で包む(例:verify(ledger).add(eq("memberId-1"), anyInt()))。マッチャーの種類は、モックの interface から取った引数の型で選ぶ。

使わないサンプルは消す

lines を List.of() にしたケースでは、既定値として作った orderLine が不要になる。drop_unused_samples で、ほかのどの行からも参照されないサンプルの宣言を取り除く。残しても動くが、読む人を迷わせる。

生成結果

PowerShell / bash
cd testgen
python gen_tests.py ../src/main/java OrderService ../src/test/generated/java
実行結果
生成: ../src/test/generated/java/com/example/order/OrderServiceGeneratedTest.java(2 メソッド / 11 ケース)
NOTE placeOrder: B3(L31)の 0回 は到達できません(前の判定で空のときは抜けるため)

生成は 0.1 秒ほどで終わる。出力された265行のうち、主経路・在庫不足・メール送信失敗の3本を見てみる。

OrderServiceGeneratedTest.java(主経路)
        @Test
        @DisplayName("主経路(各分岐の通常側)")
        void placeOrder_mainPath() {
            // 経路: B1 false → B2 false → B3 1回以上 → B4 false → B5 false → B6 例外なし
            // Arrange
            OrderLine orderLine = new OrderLine("itemCode-1", 1, 1);
            String customerId = "customerId-1";
            List<OrderLine> lines = List.of(orderLine);
            when(stockClient.getStock("itemCode-1")).thenReturn(1);

            // Act
            Order actual = sut.placeOrder(customerId, lines);

            // Assert
            // TODO: 期待値を設定してください(自動生成:主経路)
            //       コード上の戻り値: order
            verify(orderRepository).save(any(Order.class));
            verify(mailSender).send("customerId-1", "ご注文を受け付けました");
            fail("TODO: 期待値が未設定です");
        }
OrderServiceGeneratedTest.java(B4 在庫不足・B5 TODO・B6 メール送信失敗)
        @Test
        @DisplayName("[B4] if (stock < line.quantity()) → true")
        void placeOrder_B4_true() {
            // 経路: B1 false → B2 false → B3 1回以上 → B4 true
            // Arrange
            OrderLine orderLine = new OrderLine("itemCode-1", 1, 1);
            String customerId = "customerId-1";
            List<OrderLine> lines = List.of(orderLine);
            when(stockClient.getStock("itemCode-1")).thenReturn(0);

            // Act & Assert
            assertThrows(OutOfStockException.class, () -> sut.placeOrder(customerId, lines));
            // TODO: 期待値を設定してください(自動生成:B4 if (stock < line.quantity()) → true/L33)
            //       現在は例外の型のみ検証しています。メッセージや状態の検証は手動で追加してください。
            verify(orderRepository, never()).save(any(Order.class));
            verify(mailSender, never()).send(anyString(), anyString());
        }

        @Test
        @DisplayName("[B5] ternary order.total() >= 10000 → true")
        void placeOrder_B5_true() {
            // 経路: B1 false → B2 false → B3 1回以上 → B4 false → B5 true
            // TODO: B5 の条件 `order.total() >= 10000` を true にする入力値を設定してください(自動生成)
            // Arrange
            OrderLine orderLine = new OrderLine("itemCode-1", 1, 1);
            String customerId = "customerId-1";
            List<OrderLine> lines = List.of(orderLine);
            when(stockClient.getStock("itemCode-1")).thenReturn(1);

            // Act
            Order actual = sut.placeOrder(customerId, lines);

            // Assert
            // TODO: 期待値を設定してください(自動生成:B5 ternary order.total() >= 10000 → true/L38)
            //       コード上の戻り値: order
            verify(orderRepository).save(any(Order.class));
            verify(mailSender).send("customerId-1", "ご注文を受け付けました");
            fail("TODO: 期待値が未設定です");
        }

        @Test
        @DisplayName("[B6] catch MailException → catch")
        void placeOrder_B6_catch() {
            // 経路: B1 false → B2 false → B3 1回以上 → B4 false → B5 false → B6 catch
            // Arrange
            OrderLine orderLine = new OrderLine("itemCode-1", 1, 1);
            String customerId = "customerId-1";
            List<OrderLine> lines = List.of(orderLine);
            when(stockClient.getStock("itemCode-1")).thenReturn(1);
            doThrow(new MailException("test")).when(mailSender).send("customerId-1", "ご注文を受け付けました");

            // Act
            Order actual = sut.placeOrder(customerId, lines);

            // Assert
            // TODO: 期待値を設定してください(自動生成:B6 catch MailException → catch/L42)
            //       コード上の戻り値: order
            verify(orderRepository).save(any(Order.class));
            verify(mailSender).send("customerId-1", "ご注文を受け付けました");
            fail("TODO: 期待値が未設定です");
        }

B4 では在庫 API のスタブが 0(数量 1 − 1)になり、save と send には never() が付いた。B5 では、PART 05 で決められなかった条件が「入力値の TODO」として先頭に書かれている。B6 では、send が void なので doThrow の形になっている。

OrderServiceGeneratedTest.java の全体を表示する
OrderServiceGeneratedTest.java
package com.example.order;

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.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;

/**
 * OrderService のテスト(testgen による自動生成:2026-11-06)。
 * <p>
 * 分岐の結果ごとに1ケースを生成しています。期待値は自動では決められないため、
 * 「// TODO」の箇所に手動で設定してください。設定するまで fail() で失敗します。
 */
@ExtendWith(MockitoExtension.class)
class OrderServiceGeneratedTest {

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

    Clock clock = Clock.fixed(Instant.parse("2026-01-01T00:00:00Z"), ZoneId.of("Asia/Tokyo"));

    OrderService sut;

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

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

        @Test
        @DisplayName("主経路(各分岐の通常側)")
        void placeOrder_mainPath() {
            // 経路: B1 false → B2 false → B3 1回以上 → B4 false → B5 false → B6 例外なし
            // Arrange
            OrderLine orderLine = new OrderLine("itemCode-1", 1, 1);
            String customerId = "customerId-1";
            List<OrderLine> lines = List.of(orderLine);
            when(stockClient.getStock("itemCode-1")).thenReturn(1);

            // Act
            Order actual = sut.placeOrder(customerId, lines);

            // Assert
            // TODO: 期待値を設定してください(自動生成:主経路)
            //       コード上の戻り値: order
            verify(orderRepository).save(any(Order.class));
            verify(mailSender).send("customerId-1", "ご注文を受け付けました");
            fail("TODO: 期待値が未設定です");
        }

        @Test
        @DisplayName("[B1] if (customerId == null || customerId.isBlank()) → true(customerId == null が true)")
        void placeOrder_B1_true() {
            // 経路: B1 true
            // Arrange
            OrderLine orderLine = new OrderLine("itemCode-1", 1, 1);
            String customerId = null;
            List<OrderLine> lines = List.of(orderLine);

            // Act & Assert
            assertThrows(IllegalArgumentException.class, () -> sut.placeOrder(customerId, lines));
            // TODO: 期待値を設定してください(自動生成:B1 if (customerId == null || customerId.isBlank()) → true/L24)
            //       現在は例外の型のみ検証しています。メッセージや状態の検証は手動で追加してください。
            verify(stockClient, never()).getStock(anyString());
            verify(orderRepository, never()).save(any(Order.class));
            verify(mailSender, never()).send(anyString(), anyString());
        }

        @Test
        @DisplayName("[B1] if (customerId == null || customerId.isBlank()) → true(customerId == null が false、customerId.isBlank() が true)")
        void placeOrder_B1_true_2() {
            // 経路: B1 true
            // Arrange
            OrderLine orderLine = new OrderLine("itemCode-1", 1, 1);
            String customerId = " ";
            List<OrderLine> lines = List.of(orderLine);

            // Act & Assert
            assertThrows(IllegalArgumentException.class, () -> sut.placeOrder(customerId, lines));
            // TODO: 期待値を設定してください(自動生成:B1 if (customerId == null || customerId.isBlank()) → true/L24)
            //       現在は例外の型のみ検証しています。メッセージや状態の検証は手動で追加してください。
            verify(stockClient, never()).getStock(anyString());
            verify(orderRepository, never()).save(any(Order.class));
            verify(mailSender, never()).send(anyString(), anyString());
        }

        @Test
        @DisplayName("[B2] if (lines.isEmpty()) → true")
        void placeOrder_B2_true() {
            // 経路: B1 false → B2 true
            // Arrange
            String customerId = "customerId-1";
            List<OrderLine> lines = List.of();

            // Act & Assert
            assertThrows(IllegalArgumentException.class, () -> sut.placeOrder(customerId, lines));
            // TODO: 期待値を設定してください(自動生成:B2 if (lines.isEmpty()) → true/L27)
            //       現在は例外の型のみ検証しています。メッセージや状態の検証は手動で追加してください。
            verify(stockClient, never()).getStock(anyString());
            verify(orderRepository, never()).save(any(Order.class));
            verify(mailSender, never()).send(anyString(), anyString());
        }

        @Test
        @DisplayName("[B4] if (stock < line.quantity()) → true")
        void placeOrder_B4_true() {
            // 経路: B1 false → B2 false → B3 1回以上 → B4 true
            // Arrange
            OrderLine orderLine = new OrderLine("itemCode-1", 1, 1);
            String customerId = "customerId-1";
            List<OrderLine> lines = List.of(orderLine);
            when(stockClient.getStock("itemCode-1")).thenReturn(0);

            // Act & Assert
            assertThrows(OutOfStockException.class, () -> sut.placeOrder(customerId, lines));
            // TODO: 期待値を設定してください(自動生成:B4 if (stock < line.quantity()) → true/L33)
            //       現在は例外の型のみ検証しています。メッセージや状態の検証は手動で追加してください。
            verify(orderRepository, never()).save(any(Order.class));
            verify(mailSender, never()).send(anyString(), anyString());
        }

        @Test
        @DisplayName("[B5] ternary order.total() >= 10000 → true")
        void placeOrder_B5_true() {
            // 経路: B1 false → B2 false → B3 1回以上 → B4 false → B5 true
            // TODO: B5 の条件 `order.total() >= 10000` を true にする入力値を設定してください(自動生成)
            // Arrange
            OrderLine orderLine = new OrderLine("itemCode-1", 1, 1);
            String customerId = "customerId-1";
            List<OrderLine> lines = List.of(orderLine);
            when(stockClient.getStock("itemCode-1")).thenReturn(1);

            // Act
            Order actual = sut.placeOrder(customerId, lines);

            // Assert
            // TODO: 期待値を設定してください(自動生成:B5 ternary order.total() >= 10000 → true/L38)
            //       コード上の戻り値: order
            verify(orderRepository).save(any(Order.class));
            verify(mailSender).send("customerId-1", "ご注文を受け付けました");
            fail("TODO: 期待値が未設定です");
        }

        @Test
        @DisplayName("[B6] catch MailException → catch")
        void placeOrder_B6_catch() {
            // 経路: B1 false → B2 false → B3 1回以上 → B4 false → B5 false → B6 catch
            // Arrange
            OrderLine orderLine = new OrderLine("itemCode-1", 1, 1);
            String customerId = "customerId-1";
            List<OrderLine> lines = List.of(orderLine);
            when(stockClient.getStock("itemCode-1")).thenReturn(1);
            doThrow(new MailException("test")).when(mailSender).send("customerId-1", "ご注文を受け付けました");

            // Act
            Order actual = sut.placeOrder(customerId, lines);

            // Assert
            // TODO: 期待値を設定してください(自動生成:B6 catch MailException → catch/L42)
            //       コード上の戻り値: order
            verify(orderRepository).save(any(Order.class));
            verify(mailSender).send("customerId-1", "ご注文を受け付けました");
            fail("TODO: 期待値が未設定です");
        }
    }

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

        @Test
        @DisplayName("主経路(各分岐の通常側)")
        void cancelOrder_mainPath() {
            // 経路: B1 false → B2 NEW,PAID
            // Arrange
            Order order = new Order("customerId-1", LocalDateTime.of(2026, 1, 1, 9, 0));
            order.setStatus(OrderStatus.NEW);
            long orderId = 1L;
            when(orderRepository.findById(1L)).thenReturn(Optional.of(order));

            // Act
            boolean actual = sut.cancelOrder(orderId);

            // Assert
            // TODO: 期待値を設定してください(自動生成:主経路)
            //       コード上の戻り値: true
            verify(orderRepository).save(order);
            fail("TODO: 期待値が未設定です");
        }

        @Test
        @DisplayName("[B1] if (found.isEmpty()) → true")
        void cancelOrder_B1_true() {
            // 経路: B1 true
            // Arrange
            long orderId = 1L;
            when(orderRepository.findById(1L)).thenReturn(Optional.empty());

            // Act
            boolean actual = sut.cancelOrder(orderId);

            // Assert
            // TODO: 期待値を設定してください(自動生成:B1 if (found.isEmpty()) → true/L50)
            //       コード上の戻り値: false
            verify(orderRepository, never()).save(any(Order.class));
            fail("TODO: 期待値が未設定です");
        }

        @Test
        @DisplayName("[B2] switch (order.getStatus()) → SHIPPED")
        void cancelOrder_B2_SHIPPED() {
            // 経路: B1 false → B2 SHIPPED
            // Arrange
            Order order = new Order("customerId-1", LocalDateTime.of(2026, 1, 1, 9, 0));
            order.setStatus(OrderStatus.SHIPPED);
            long orderId = 1L;
            when(orderRepository.findById(1L)).thenReturn(Optional.of(order));

            // Act & Assert
            assertThrows(IllegalStateException.class, () -> sut.cancelOrder(orderId));
            // TODO: 期待値を設定してください(自動生成:B2 switch (order.getStatus()) → SHIPPED/L54)
            //       現在は例外の型のみ検証しています。メッセージや状態の検証は手動で追加してください。
            verify(orderRepository, never()).save(any(Order.class));
        }

        @Test
        @DisplayName("[B2] switch (order.getStatus()) → default")
        void cancelOrder_B2_default() {
            // 経路: B1 false → B2 default
            // Arrange
            Order order = new Order("customerId-1", LocalDateTime.of(2026, 1, 1, 9, 0));
            order.setStatus(OrderStatus.CANCELLED);
            long orderId = 1L;
            when(orderRepository.findById(1L)).thenReturn(Optional.of(order));

            // Act
            boolean actual = sut.cancelOrder(orderId);

            // Assert
            // TODO: 期待値を設定してください(自動生成:B2 switch (order.getStatus()) → default/L54)
            //       コード上の戻り値: false
            verify(orderRepository, never()).save(any(Order.class));
            fail("TODO: 期待値が未設定です");
        }
    }
}

Gradle で実行する

PowerShell / bash
gradlew test -PwithGenerated --tests "*OrderServiceGeneratedTest*"
実行結果(抜粋)
OrderServiceGeneratedTest > cancelOrder > 主経路(各分岐の通常側) FAILED
    org.opentest4j.AssertionFailedError at OrderServiceGeneratedTest.java:207
OrderServiceGeneratedTest > cancelOrder > [B1] if (found.isEmpty()) → true FAILED
OrderServiceGeneratedTest > cancelOrder > [B2] switch (order.getStatus()) → default FAILED
OrderServiceGeneratedTest > placeOrder > [B5] ternary order.total() >= 10000 → true FAILED
OrderServiceGeneratedTest > placeOrder > 主経路(各分岐の通常側) FAILED
OrderServiceGeneratedTest > placeOrder > [B6] catch MailException → catch FAILED
11 tests completed, 6 failed
There were failing tests. See the report at: file:///.../build/reports/tests/test/index.html
BUILD SUCCESSFUL

11件中6件が失敗したが、失敗の理由はすべて fail("TODO: 期待値が未設定です") だった。Mockito の UnnecessaryStubbingException(使われないスタブ)も、WantedButNotInvoked(verify の不一致)も1件も出ていない。スタブと verify が、実際の経路と一致している ということだ。成功した5件は、例外で終わる経路のテスト(型だけを確認)だ。

⚠️ 例外のテストは「成功」していても仕上がっていない

例外の経路のテストには fail() を入れていないので、TODO が残ったままでも成功する。仕上げたテストに TODO が残っていないかは、PART 07 で CI のチェックに入れる((自動生成 という文字列を検索するだけでよい)。

✅ 次の記事では…

PART 07 では、生成テストを JaCoCo で計測し、未達の分岐を分岐表・生成テストと突き合わせて、どのテストを直せばよいかを一覧にする。

→ PART 07 — JaCoCoで検証するへ