何をモックにし、何をモックにしないか
判定の材料にするのは コンストラクタの引数 だ。依存性注入(DI)で作られるクラスは、外部とやり取りする相手をコンストラクタで受け取る。Spring の @Service でも、手で new するクラスでも同じだ。引数の型ごとに、テストでの扱いを次の3つに分ける。
| 扱い | 対象 | テストでの書き方 | 理由 |
|---|---|---|---|
| MOCK | interface、プロジェクト外の型、プロジェクト内の普通のクラス | @Mock | DB・API・メールなど、外とつながる協力者。戻り値で分岐を操作したい |
| FIXED_CLOCK | java.time.Clock | Clock.fixed(...) | モックにすると instant() と getZone() の両方のスタブが必要になる。固定時刻を渡すほうが簡単で確実 |
| VALUE | String・数値・真偽値、record、enum | 値をそのまま渡す(TODO 付き) | 設定値やデータ。モックにする意味がない |
「プロジェクト内の普通のクラスもモックにする」のは、コンストラクタで受け取る時点で、それが 協力者(別の責務を持つクラス)だからだ。一方、メソッドの中で new Order(...) のように作る値のクラスや、モックが返す Order は実物を使う。値のクラスまでモックにすると、getStatus() のような getter をすべてスタブすることになる。そうなると、テストは実装をなぞるだけになってしまう。
型の一覧を作る:project_index.py
「引数の型が interface かどうか」「モックのメソッドの戻り値は何か」「record の構成要素は何か」を知るために、まず src/main/java 全体の型を一覧にする。tree-sitter シリーズ PART 05 の宣言の集め方を、テスト生成に必要な項目に絞って作り直した。
"""src/main/java 配下を読み、型ごとの情報(種類・フィールド・コンストラクタ・メソッド・enum 定数)を集める"""
from dataclasses import dataclass, field
from pathlib import Path
from ts_common import parse_file, text
TYPE_NODES = {"class_declaration": "class", "interface_declaration": "interface",
"enum_declaration": "enum", "record_declaration": "record"}
@dataclass
class TypeInfo:
name: str
kind: str # class / interface / enum / record
package: str
path: str
superclass: str | None = None
fields: dict = field(default_factory=dict) # 名前 -> 型
constructors: list = field(default_factory=list) # [[(型, 名前), ...], ...]
methods: dict = field(default_factory=dict) # 名前 -> 戻り値の型
method_params: dict = field(default_factory=dict) # 名前 -> [(型, 名前)]
components: list = field(default_factory=list) # record の [(型, 名前)]
constants: list = field(default_factory=list) # enum 定数
node: object = None
@property
def is_exception(self):
return bool(self.superclass) and self.superclass.endswith(("Exception", "Error"))
def params_of(params_node):
"""formal_parameters ノードから [(型, 名前)] を作る"""
result = []
for p in params_node.named_children:
if p.type == "formal_parameter":
result.append((text(p.child_by_field_name("type")), text(p.child_by_field_name("name"))))
return result
def collect_type(node, package, path):
info = TypeInfo(text(node.child_by_field_name("name")), TYPE_NODES[node.type], package, str(path), node=node)
sc = node.child_by_field_name("superclass")
if sc is not None:
info.superclass = text(sc.named_children[0])
if info.kind == "record":
info.components = params_of(node.child_by_field_name("parameters"))
for t, n in info.components:
info.methods[n] = t # record はアクセサーを持つ
body = node.child_by_field_name("body")
for child in body.named_children:
if child.type == "field_declaration":
ftype = text(child.child_by_field_name("type"))
for d in child.children_by_field_name("declarator"):
info.fields[text(d.child_by_field_name("name"))] = ftype
elif child.type == "constructor_declaration":
info.constructors.append(params_of(child.child_by_field_name("parameters")))
elif child.type == "method_declaration":
mname = text(child.child_by_field_name("name"))
info.methods[mname] = text(child.child_by_field_name("type"))
info.method_params[mname] = params_of(child.child_by_field_name("parameters"))
elif child.type == "enum_body_declarations":
for c in child.named_children:
if c.type == "method_declaration":
info.methods[text(c.child_by_field_name("name"))] = text(c.child_by_field_name("type"))
elif child.type == "enum_constant":
info.constants.append(text(child.child_by_field_name("name")))
return info
def build_index(src_root):
"""型名 -> TypeInfo の辞書を返す(同名の型は先勝ち)"""
index = {}
for path in sorted(Path(src_root).rglob("*.java")):
_, tree = parse_file(path)
package = ""
for child in tree.root_node.named_children:
if child.type == "package_declaration":
package = text(child.named_children[0])
elif child.type in TYPE_NODES:
info = collect_type(child, package, path)
index.setdefault(info.name, info)
return index
if __name__ == "__main__":
import sys
for name, t in build_index(sys.argv[1]).items():
extra = t.constants or t.components or t.constructors
print(f"{t.kind:9} {name:20} {extra}")python project_index.py ../src/main/javaclass MailException [[('String', 'message')]]
interface MailSender []
class Order [[('String', 'customerId'), ('LocalDateTime', 'orderedAt')]]
record OrderLine [('String', 'itemCode'), ('int', 'quantity'), ('int', 'unitPrice')]
interface OrderRepository []
class OrderService [[('OrderRepository', 'orderRepository'), ('StockClient', 'stockClient'), ('MailSender', 'mailSender'), ('Clock', 'clock')]]
enum OrderStatus ['NEW', 'PAID', 'SHIPPED', 'CANCELLED']
class OutOfStockException [[('String', 'itemCode')]]
interface StockClient []3列目は、enum なら定数、record なら構成要素、クラスならコンストラクタの引数だ。interface の行は空だが、methods と method_params にはメソッドの戻り値と引数が入っている。たとえば OrderRepository は {'save': 'Order', 'findById': 'Optional<Order>'} になる。
ℹ️ 型は名前だけで照合する
tree-sitter は型を解決しないので、別のパッケージに同じ名前のクラスがあると区別できない(setdefault で先に見つかったほうを使う)。テスト対象と同じモジュールの中で名前が重なることは少ないので、ここでは割り切っている。
外部依存を分類する:deps.py
"""テスト対象クラスの外部依存を見つけ、テストでの扱い(MOCK / FIXED_CLOCK / VALUE)を決める"""
import re
import sys
from dataclasses import dataclass
from project_index import build_index
# 外部と通信する役割を表す名前の接尾辞(メソッド内で new していたら警告する)
MOCK_SUFFIXES = ("Repository", "Dao", "Client", "Gateway", "Sender", "Api")
# 時刻・乱数など、呼ぶたびに結果が変わる static 呼び出し
NONDETERMINISTIC = [
(r"\b(LocalDate|LocalDateTime|LocalTime|ZonedDateTime|OffsetDateTime|Instant)\.now\(\s*\)",
"引数なしの now() は現在時刻に依存する。Clock を注入して now(clock) にする"),
(r"\bSystem\.currentTimeMillis\(\)", "現在時刻に依存する。Clock を注入して clock.millis() にする"),
(r"\bnew\s+Random\(\s*\)|\bMath\.random\(\)", "乱数に依存する。RandomGenerator を注入する"),
(r"\bUUID\.randomUUID\(\)", "毎回違う値になる。ID の採番を別クラスに切り出して注入する"),
]
@dataclass
class Dependency:
name: str # フィールド名
type: str
handling: str # MOCK / FIXED_CLOCK / VALUE
reason: str
def classify(dep_type, index):
base = dep_type.split("<")[0]
if base == "Clock":
return "FIXED_CLOCK", "Clock はモックせず Clock.fixed で固定する"
if base in ("String", "int", "long", "boolean", "double", "Integer", "Long", "Boolean"):
return "VALUE", "設定値として値を渡す"
info = index.get(base)
if info is None:
return "MOCK", "プロジェクト外の型(ライブラリなど)はモックにする"
if info.kind in ("record", "enum"):
return "VALUE", f"{info.kind} は値なので実物を使う"
if info.kind == "interface":
return "MOCK", "interface はモックにする"
return "MOCK", "コンストラクタで受け取るクラスは協力者とみなしてモックにする"
def find_dependencies(target, index):
"""コンストラクタ引数を外部依存とみなす(コンストラクタが複数なら引数が最多のもの)"""
info = index[target]
if not info.constructors:
return [Dependency(n, t, *classify(t, index)) for n, t in info.fields.items()]
params = max(info.constructors, key=len)
return [Dependency(n, t, *classify(t, index)) for t, n in params]
def find_warnings(target, index):
"""モックで差し替えられない書き方を、行番号付きで返す"""
info = index[target]
warnings = []
lines = info.node.text.decode("utf-8").splitlines()
offset = info.node.start_point[0] + 1
for i, line in enumerate(lines):
for pattern, advice in NONDETERMINISTIC:
if re.search(pattern, line):
warnings.append((offset + i, line.strip(), advice))
for m in re.finditer(r"\bnew\s+([A-Z]\w*)\s*\(", line):
name = m.group(1)
if name.endswith(MOCK_SUFFIXES):
warnings.append((offset + i, line.strip(),
f"{name} をメソッド内で new している。コンストラクタで受け取る形にする"))
for m in re.finditer(r"\b([A-Z]\w*)\.([a-z]\w*)\(", line):
cls = m.group(1)
if cls in index and cls.endswith(MOCK_SUFFIXES):
warnings.append((offset + i, line.strip(),
f"{cls}.{m.group(2)}() は static 呼び出し。インスタンスにして注入する"))
return warnings
if __name__ == "__main__":
src_root, target = sys.argv[1], sys.argv[2]
index = build_index(src_root)
for d in find_dependencies(target, index):
print(f"{d.handling:12} {d.type:16} {d.name:16} {d.reason}")
for line, code, advice in find_warnings(target, index):
print(f"WARN L{line}: {code}\n → {advice}")python deps.py ../src/main/java OrderServiceMOCK OrderRepository orderRepository interface はモックにする
MOCK StockClient stockClient interface はモックにする
MOCK MailSender mailSender interface はモックにする
FIXED_CLOCK Clock clock Clock はモックせず Clock.fixed で固定するPART 02 で手書きしたテストと同じ扱いになった。コンストラクタが複数あるときは、引数がいちばん多いものを使う(DI で使われるのはたいていそれだ)。コンストラクタがないクラスは、フィールドを依存とみなす。
モックに差し替えられない書き方
ルールが成り立つのは、協力者をコンストラクタで受け取っている場合だけだ。古いコードでは、次のようにメソッドの中で直接作ったり、static メソッドを呼んだりしていることが多い。
package com.example.legacy;
import java.time.LocalDateTime;
public class LegacyOrderService {
public String reserve(String itemCode, int quantity) {
StockApiClient client = new StockApiClient();
if (client.getStock(itemCode) < quantity) {
return "NG";
}
AuditLogDao.write("reserved " + itemCode + " at " + LocalDateTime.now());
return "OK";
}
}このクラスにはコンストラクタ引数がないので、モックにできるものが見つからない。代わりに find_warnings がソースの行を正規表現で調べ、差し替えられない書き方を報告する。
python deps.py ../src/main/java LegacyOrderServiceWARN L8: StockApiClient client = new StockApiClient();
→ StockApiClient をメソッド内で new している。コンストラクタで受け取る形にする
WARN L12: AuditLogDao.write("reserved " + itemCode + " at " + LocalDateTime.now());
→ 引数なしの now() は現在時刻に依存する。Clock を注入して now(clock) にする
WARN L12: AuditLogDao.write("reserved " + itemCode + " at " + LocalDateTime.now());
→ AuditLogDao.write() は static 呼び出し。インスタンスにして注入する警告を無視してテストを生成すると、どうなるか。PART 06 で作るジェネレーターにかけると、主経路のテストは次のようになる。
@Test
@DisplayName("主経路(各分岐の通常側)")
void reserve_mainPath() {
// 経路: B1 false?
// Arrange
String itemCode = "itemCode-1";
int quantity = 1;
// Act
String actual = sut.reserve(itemCode, quantity);
// Assert
// TODO: 期待値を設定してください(自動生成:主経路)
// コード上の戻り値: "OK"
fail("TODO: 期待値が未設定です");経路の B1 false? の「?」は、条件 client.getStock(itemCode) < quantity の値を入力から決められなかったという印だ。client はメソッドの中で作られるローカル変数で、モックではないからだ。実行すると、本物の StockApiClient が呼ばれる(題材では、本番の API につながる代わりに例外を投げるようにしてある)。
reserve ✔
├─ 主経路(各分岐の通常側) ✘ 本番の在庫APIに接続する
└─ [B1] if (client.getStock(itemCode) < quantity) → true ✘ 本番の在庫APIに接続する
=> java.lang.UnsupportedOperationException: 本番の在庫APIに接続する
com.example.legacy.StockApiClient.getStock(StockApiClient.java:5)
com.example.legacy.LegacyOrderService.reserve(LegacyOrderService.java:9)期待値の TODO にたどり着く前に、外部への接続で失敗した。テストの自動生成は テストしやすい設計であることを前提にしている。警告が出たら、生成の前にリファクタリングするのが近道だ。
リファクタリングして生成し直す
警告の指示どおりに直す。StockApiClient はコンストラクタで受け取り、static の AuditLogDao.write は薄いラッパー(AuditLogger)で包んで注入する。時刻は Clock から取る。
package com.example.legacy;
import java.time.Clock;
import java.time.LocalDateTime;
public class ReserveService {
private final StockApiClient client;
private final AuditLogger auditLogger;
private final Clock clock;
public ReserveService(StockApiClient client, AuditLogger auditLogger, Clock clock) {
this.client = client;
this.auditLogger = auditLogger;
this.clock = clock;
}
public String reserve(String itemCode, int quantity) {
if (client.getStock(itemCode) < quantity) {
return "NG";
}
auditLogger.write("reserved " + itemCode + " at " + LocalDateTime.now(clock));
return "OK";
}
}MOCK StockApiClient client コンストラクタで受け取るクラスは協力者とみなしてモックにする
MOCK AuditLogger auditLogger コンストラクタで受け取るクラスは協力者とみなしてモックにする
FIXED_CLOCK Clock clock Clock はモックせず Clock.fixed で固定する警告は消え、2つの協力者はモック、時刻は固定になった。生成されたテストの冒頭と主経路は次のとおり。
@ExtendWith(MockitoExtension.class)
class ReserveServiceGeneratedTest {
@Mock
StockApiClient client;
@Mock
AuditLogger auditLogger;
Clock clock = Clock.fixed(Instant.parse("2026-01-01T00:00:00Z"), ZoneId.of("Asia/Tokyo"));
ReserveService sut;
@BeforeEach
void setUp() {
sut = new ReserveService(client, auditLogger, clock);
}
@Nested
@DisplayName("reserve")
class Reserve {
@Test
@DisplayName("主経路(各分岐の通常側)")
void reserve_mainPath() {
// 経路: B1 false
// Arrange
String itemCode = "itemCode-1";
int quantity = 1;
when(client.getStock("itemCode-1")).thenReturn(1);
// Act
String actual = sut.reserve(itemCode, quantity);
// Assert
// TODO: 期待値を設定してください(自動生成:主経路)
// コード上の戻り値: "OK"
verify(auditLogger).write(anyString());
fail("TODO: 期待値が未設定です");
}在庫 API のモックが 1(数量と同じ)を返すようにスタブされ、主経路は確実に B1 の false 側を通る。もう1本のテスト(B1 → true)では、スタブの値が 0 になる。実行すると、2本とも失敗理由は「TODO: 期待値が未設定です」だけになった。外部への接続はもう起きない。
mockStatic・mockConstruction を使わない理由
Mockito には、static メソッドをモックにする mockStatic と、new で作られるオブジェクトを差し替える mockConstruction がある(Mockito 5 では既定で使える)。リファクタリングできない古いコードでは助けになるが、本シリーズのジェネレーターでは出力しない。
try (MockedConstruction<StockApiClient> mocked = mockConstruction(StockApiClient.class,
(mock, context) -> when(mock.getStock("itemCode-1")).thenReturn(0));
MockedStatic<AuditLogDao> dao = mockStatic(AuditLogDao.class)) {
assertEquals("NG", sut.reserve("itemCode-1", 1));
dao.verifyNoInteractions();
}- 有効範囲の管理が必要:try-with-resources で閉じ忘れると、ほかのテストにも影響する
- 設計の問題を隠す:テストが書けてしまうので、依存を注入する形に直す動機がなくなる
- 生成の規則が複雑になる:どの
newを差し替え、どれを実物にするかを、名前だけでは判断できない
警告の出たクラスは、生成の前にリファクタリングするか、手で mockConstruction を使ったテストを書く。どちらを選ぶかは、そのクラスを今後も変更するかどうかで決めるとよい。