何をモックにし、何をモックにしないか

判定の材料にするのは コンストラクタの引数 だ。依存性注入(DI)で作られるクラスは、外部とやり取りする相手をコンストラクタで受け取る。Spring の @Service でも、手で new するクラスでも同じだ。引数の型ごとに、テストでの扱いを次の3つに分ける。

扱い対象テストでの書き方理由
MOCKinterface、プロジェクト外の型、プロジェクト内の普通のクラス@MockDB・API・メールなど、外とつながる協力者。戻り値で分岐を操作したい
FIXED_CLOCKjava.time.ClockClock.fixed(...)モックにすると instant() と getZone() の両方のスタブが必要になる。固定時刻を渡すほうが簡単で確実
VALUEString・数値・真偽値、record、enum値をそのまま渡す(TODO 付き)設定値やデータ。モックにする意味がない

「プロジェクト内の普通のクラスもモックにする」のは、コンストラクタで受け取る時点で、それが 協力者(別の責務を持つクラス)だからだ。一方、メソッドの中で new Order(...) のように作る値のクラスや、モックが返す Order は実物を使う。値のクラスまでモックにすると、getStatus() のような getter をすべてスタブすることになる。そうなると、テストは実装をなぞるだけになってしまう。

型の一覧を作る:project_index.py

「引数の型が interface かどうか」「モックのメソッドの戻り値は何か」「record の構成要素は何か」を知るために、まず src/main/java 全体の型を一覧にする。tree-sitter シリーズ PART 05 の宣言の集め方を、テスト生成に必要な項目に絞って作り直した。

testgen/project_index.py
"""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}")
PowerShell / bash
python project_index.py ../src/main/java
実行結果(OrderService のパッケージ)
class     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

testgen/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}")
PowerShell / bash
python deps.py ../src/main/java OrderService
実行結果
MOCK         OrderRepository  orderRepository  interface はモックにする
MOCK         StockClient      stockClient      interface はモックにする
MOCK         MailSender       mailSender       interface はモックにする
FIXED_CLOCK  Clock            clock            Clock はモックせず Clock.fixed で固定する

PART 02 で手書きしたテストと同じ扱いになった。コンストラクタが複数あるときは、引数がいちばん多いものを使う(DI で使われるのはたいていそれだ)。コンストラクタがないクラスは、フィールドを依存とみなす。

モックに差し替えられない書き方

ルールが成り立つのは、協力者をコンストラクタで受け取っている場合だけだ。古いコードでは、次のようにメソッドの中で直接作ったり、static メソッドを呼んだりしていることが多い。

LegacyOrderService.java
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 がソースの行を正規表現で調べ、差し替えられない書き方を報告する。

PowerShell / bash
python deps.py ../src/main/java LegacyOrderService
実行結果
WARN 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 で作るジェネレーターにかけると、主経路のテストは次のようになる。

LegacyOrderServiceGeneratedTest.java(抜粋)

        @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 につながる代わりに例外を投げるようにしてある)。

実行結果(JUnit Console Launcher、抜粋)
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 から取る。

ReserveService.java(リファクタリング後)
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";
    }
}
deps.py の実行結果
MOCK         StockApiClient   client           コンストラクタで受け取るクラスは協力者とみなしてモックにする
MOCK         AuditLogger      auditLogger      コンストラクタで受け取るクラスは協力者とみなしてモックにする
FIXED_CLOCK  Clock            clock            Clock はモックせず Clock.fixed で固定する

警告は消え、2つの協力者はモック、時刻は固定になった。生成されたテストの冒頭と主経路は次のとおり。

ReserveServiceGeneratedTest.java(抜粋)
@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 では既定で使える)。リファクタリングできない古いコードでは助けになるが、本シリーズのジェネレーターでは出力しない。

参考:mockConstruction と mockStatic(ジェネレーターは出力しない)
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 を使ったテストを書く。どちらを選ぶかは、そのクラスを今後も変更するかどうかで決めるとよい。

✅ 次の記事では…

PART 05 では、ここで決めたモックの戻り値と引数を使って、分岐の結果ごとに「その結果になる入力」を組み立てる。

→ PART 05 — 分岐条件から入力値とスタブを決めるへ