生成テストの置き場所を分ける
最初に決めておきたいのは、生成したファイルの置き場所だ。生成テストは 下書き であり、テスト対象を直したら生成し直す。人が期待値を書き込んだファイルを上書きしてしまわないよう、置き場所を分ける。
| 場所 | 中身 | 上書き | 通常の gradlew test |
|---|---|---|---|
src/test/generated/java | 生成テスト(*GeneratedTest.java) | 生成のたびに上書き | 実行しない(-PwithGenerated を付けたときだけ) |
src/test/java | 人が仕上げたテスト(*Test.java) | しない | 実行する |
使い方は「生成 → 計測で確認 → 必要なテストを src/test/java にコピーして仕上げる」という流れになる。PART 02 の build.gradle に入れた次の2か所が、この運用のための設定だ。
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 %} などの制御行は出力に空行を残さない。
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 だけを書く
生成スクリプト
"""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 は付けない |
| 戻り値を使わない・void | orderRepository.save(order); | verify(orderRepository).save(...) |
| 例外を投げさせる | catch の経路 | void なら doThrow(...).when(...)、そうでなければ thenThrow |
| メソッド内にあるが、この経路では呼ばれない | 入力チェックで弾いたときの save | verify(..., 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 で、ほかのどの行からも参照されないサンプルの宣言を取り除く。残しても動くが、読む人を迷わせる。
生成結果
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本を見てみる。
@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("[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 の全体を表示する
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 で実行する
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 SUCCESSFUL11件中6件が失敗したが、失敗の理由はすべて fail("TODO: 期待値が未設定です") だった。Mockito の UnnecessaryStubbingException(使われないスタブ)も、WantedButNotInvoked(verify の不一致)も1件も出ていない。スタブと verify が、実際の経路と一致している ということだ。成功した5件は、例外で終わる経路のテスト(型だけを確認)だ。
⚠️ 例外のテストは「成功」していても仕上がっていない
例外の経路のテストには fail() を入れていないので、TODO が残ったままでも成功する。仕上げたテストに TODO が残っていないかは、PART 07 で CI のチェックに入れる((自動生成 という文字列を検索するだけでよい)。
✅ 次の記事では…
PART 07 では、生成テストを JaCoCo で計測し、未達の分岐を分岐表・生成テストと突き合わせて、どのテストを直せばよいかを一覧にする。