Rustの単体テストで外部APIやデータベースを安全に模擬するモックライブラリの活用法

Rustの単体テストで外部APIやデータベースを安全に模擬するモックライブラリの活用法を解説したアイキャッチ プログラミング言語

Rustで堅牢なアプリケーションを構築する際、単体テストの品質は開発速度と信頼性を大きく左右します。
特に外部APIやデータベースに依存するコードのテストは、ネットワークの遅延や接続断、本番データへの意図しない書き込みといったリスクを伴うため、そのまま実行するのは賢明ではありません。
そこで重要になるのが、依存関係を安全に模擬するモックライブラリの活用です。

Rustのエコシステムには、mockallやwiremock、httpmockといった成熟したクレートが存在します。
これらを適切に使い分けることで、テストの決定性と実行速度を両立できます。
例えば、トレイトベースの依存注入にはmockallが強力です。
一方、HTTPレベルの振る舞いを検証したい場合はwiremockやhttpmockが適しています。
データベース層では、リポジトリパターンとモックを組み合わせるのが定石です。

  • 外部APIのモックでは、ステータスコードやレスポンスボディ、遅延を柔軟に設定できるか確認する
  • データベースのモックでは、トランザクションやロールバックの挙動を再現できるかが鍵になる
  • モックは本番コードの設計を映す鏡であり、過剰なモックは結合度の高さを示すサインとなり得る

本記事では、実際のコード例を交えながら、mockallとwiremockを中心に、非同期処理やエラーハンドリングを含めた実践的な活用法を解説します。
モックを「テストのための一時しのぎ」ではなく、設計改善のフィードバック源として捉える視点も共有します。
読者の皆さんが、外部依存に怯えることなく、自信を持ってリファクタリングできるようになることを目指します。

  1. Rustの単体テストにおける外部依存の課題とモックの必要性
    1. 外部依存がテストにもたらす本質的な問題
    2. モックという抽象化が解決するもの
    3. モックがない場合に起きる設計の劣化
    4. Rustにおけるモックの位置づけ
  2. Rustで使える主要モックライブラリの比較と選定基準
    1. トレイトモックの標準的選択肢、mockall
    2. HTTPモックの2大選択肢、wiremockとmockito
    3. 選定の判断基準
  3. mockallでトレイトをモック化する基本パターン
    1. トレイトの定義とautomock属性
    2. ジェネリクスを活用した依存注入
    3. 複数のメソッドを持つトレイトのモック
    4. ライフタイムと参照を扱う際の注意点
    5. モックしにくいケースへの対処
  4. mockallのexpectationsと戻り値設定をマスターする
    1. expectationsの基本構造
    2. 呼び出し回数の制御
    3. 引数のマッチング
    4. 戻り値とエラーの注入
    5. 順序の検証とシーケンス
    6. expectationsをテストの仕様として捉える
  5. wiremockとhttpmockで外部APIをシミュレートする方法
    1. wiremockの基本構造
    2. リクエストマッチングの詳細
    3. エラー系のシミュレーション
    4. httpmockの特徴と使い方
    5. 両者の使い分け
  6. データベースアクセスをモックして安全にテストする設計手法
    1. リポジトリパターンによる抽象化
    2. トランザクション境界の扱い
    3. インメモリデータベースという選択肢
    4. SQLをモックすべきかという問い
    5. N+1問題とモックの限界
    6. テストデータの整合性を保つ
  7. 非同期処理とエラーハンドリングを含むモックテストの実践
    1. 非同期テストの基本構造
    2. 非同期モックのexpectation設定
    3. タイムアウトと遅延のシミュレーション
    4. エラー伝播の検証
    5. 並行処理とモックのスレッド安全性
    6. エラーハンドリングをテストの中心に据える
  8. モックの過剰使用を避けるための設計原則とリファクタリング指針
    1. モックすべき境界とそうでない境界
    2. テストが実装に結合する兆候
    3. 古典学派とロンドン学派の視点
    4. モックが複雑化したときのリファクタリング
    5. テストのピラミッドとモックの位置づけ
    6. モックを設計のフィードバック源にする
  9. まとめ:Rustのモックライブラリを活用して信頼性の高いテストを実現しよう
    1. 各手法の役割の再確認
    2. テストの階層とモックの位置づけ
    3. 設計のフィードバック源としてのモック
    4. エラー系の検証を怠らない
    5. 最後に

Rustの単体テストにおける外部依存の課題とモックの必要性

Rustの単体テストで外部APIやデータベースへの依存が引き起こす課題を図解したアイキャッチ

Rustは所有権と型システムによって多くのバグをコンパイル時に排除できる言語ですが、それでも外部APIやデータベースへの依存を持つコードのテストは別問題です。
コンパイラはネットワークの到達性やデータベースの状態までは保証してくれません。
ここでは、なぜ外部依存がテストを難しくするのか、そしてモックという手法がなぜ必要になるのかを論理的に整理します。

外部依存がテストにもたらす本質的な問題

単体テストの目的は、ある関数やメソッドの論理が正しいかを、他の要素から切り離して検証することです。
ところが外部APIを呼び出すコードをそのままテストすると、テストの結果が自分のコードではなく外部サービスの状態に左右されます。
これはテストの決定性を損なう典型例です。

  • ネットワーク障害やタイムアウトにより、コードが正しくてもテストが失敗する
  • 外部APIのレート制限や認証トークンの期限切れで、再現性が失われる
  • 本番データベースに対してテストを実行すると、意図しない書き込みや削除が発生する
  • レスポンスの内容が時刻や乱数に依存し、同じ入力でも結果が変わる

これらはすべて、テストが検証したい対象と、検証を妨げる要因が混ざっていることに起因します。
単体テストは本来、入力に対する自分のコードの振る舞いだけを評価すべきです。
外部要因を排除できなければ、失敗の原因が自分のコードにあるのか外部にあるのかを切り分けられません。

モックという抽象化が解決するもの

モックとは、外部依存の振る舞いを模擬する代替オブジェクトのことです。
テスト対象のコードが依存するインターフェースを差し替え、あらかじめ決めた戻り値やエラーを返すように制御します。
これにより、テストは外部環境から完全に独立します。

モックの本質は、依存関係をインターフェースとして抽象化し、その実装をテスト時に置き換える点にあります。
Rustではトレイトがこの抽象化の役割を担います。
関数が具体的な型ではなくトレイトに依存していれば、本番では実際のHTTPクライアントを、テストではモックを注入できます。
これは依存性逆転の原則そのものです。

観点 実依存を使うテスト モックを使うテスト
決定性 外部状態に依存し不安定 常に同じ結果を再現
実行速度 ネットワーク待ちで遅い ミリ秒単位で高速
安全性 本番データを汚染し得る 副作用が発生しない
障害再現 エラー系の再現が困難 任意のエラーを注入可能

この表が示すとおり、モックは単にテストを速くするだけでなく、エラー系の網羅や安全性の確保といった品質面でも本質的な価値を持ちます。

モックがない場合に起きる設計の劣化

興味深いのは、モックしにくいコードは往々にして設計が悪いという相関です。
外部APIを関数内部で直接生成していたり、グローバルなシングルトン経由でデータベースにアクセスしていたりする場合、テスト時に差し替える手段がありません。
これはテストの問題であると同時に、結合度が高く変更に弱い設計の証拠でもあります。

つまりモックの必要性を検討することは、テスト戦略を立てることにとどまらず、依存関係を見直すリファクタリングの機会でもあります。
テスタビリティは設計品質の指標になり得ます。
逆に言えば、モックを導入しようとして困難を感じたなら、それは依存の持ち方そのものを見直すサインです。

Rustにおけるモックの位置づけ

RustにはJavaのようなリフレクションベースのモックフレームワークが標準では存在しません。
代わりに、トレイトとマクロを組み合わせたクレートが広く使われています。
静的な型付けを活かし、コンパイル時にモックの整合性を検査できる点はRustの強みです。
動的型付け言語のモックが実行時にしか誤りを検出できないのに対し、Rustでは型の不一致をビルド段階で弾けます。

この特性により、Rustのモックはテストの信頼性を高めつつ、本番コードのインターフェース設計を強制する効果も持ちます。
次章以降では、具体的なライブラリとその活用法を見ていきます。

Rustで使える主要モックライブラリの比較と選定基準

Rustのモックライブラリmockallやwiremockやhttpmockを比較した一覧のアイキャッチ

Rustのモックライブラリは、大きく分けて2つのカテゴリに分類できます。
第一はトレイトベースのモックを生成するもの、第二はHTTP通信そのものをシミュレートするものです。
前者の代表格がmockallであり、後者にはwiremockやmockitoが該当します。
この分類を理解することが、適切な選定の出発点となります。

トレイトモックの標準的選択肢、mockall

mockallはRustにおけるトレイトベースのモックライブラリとして最も成熟しており、広く採用されています。
#[automock]属性をトレイトに付与するだけで、テスト用のモック実装を自動生成できます。

#[cfg_attr(test, automock)]
trait Database {
    fn get_user(&self, id: u32) -> Option<String>;
}

この簡潔さがmockallの最大の強みです。
依存するコードが具体的な型ではなくトレイトに依存していれば、テスト時にMockDatabaseを注入するだけで外部依存を完全に排除できます。
expect_*メソッドによる呼び出し回数や引数の検証も直感的です。

ただし、mockallが対象とするのはあくまでトレイトです。
自由関数や静的なメソッド、構造体そのものを直接モックすることはできません。
これらをモックするには、トレイトでラップするなどの設計上の工夫が求められます。
逆に言えば、mockallが使いにくいと感じたときは、依存の持ち方を見直す良い機会になります。

HTTPモックの2大選択肢、wiremockとmockito

外部APIとの通信を模擬する場合、wiremockとmockitoが主要な選択肢となります。
どちらもローカルにHTTPサーバーを起動し、リクエストのマッチングとレスポンスの返却を行います。

wiremockは非同期テストに最適化されており、tokioやasync_stdといったランタイムで動作します。
リクエストマッチャーをカスタム実装できる拡張性の高さも特徴です。
複数のモックサーバーを並列に起動できるため、複数の外部APIに依存するアプリケーションのテストに適しています。

一方、mockitoは同期・非同期の両方のインターフェースを提供し、シンプルで直感的なAPIが際立っています。
ただし、テストの並列実行には制約があり、複数のAPIを同時にモックする用途には向いていません。
小規模なテストや、同期的なコードの検証に向いていると言えるでしょう。

ライブラリ 対象 非同期対応 並列実行 カスタムマッチャー
mockall トレイト 間接的 可能 述語で対応
wiremock HTTP 必須 可能 拡張可能
mockito HTTP 同期/非同期 制限あり 限定的

選定の判断基準

どのライブラリを選ぶべきかは、テスト対象の依存関係の性質によって決まります。

  • データベースや内部サービスへの依存を差し替えたい場合はmockallが第一候補です。トレイトによる抽象化がすでに施されていれば、導入コストは極めて低いです
  • 外部のHTTP APIを呼び出すコードをテストする場合はwiremockまたはmockitoを選びます。非同期ランタイムを使用しているならwiremockが自然な選択です
  • 複数の外部APIを同時にモックする必要があるなら、並列実行と複数サーバーに対応したwiremockが適しています
  • 軽量な同期コードのテストで、設定の手間を最小限にしたいならmockitoが手頃です

重要なのは、モックのレベルを適切に選ぶことです。
すべてをモックするのではなく、IOや外部サービスとの境界に限定してモックを適用します。
内部ロジックまでモックすると、テストが実装の詳細に過度に結合し、リファクタリングの妨げになります。
モックはテストを助ける道具であると同時に、設計の健全性を映す鏡でもあるのです。

mockallでトレイトをモック化する基本パターン

mockallのautomock属性でトレイトをモック化するRustコードのアイキャッチ

mockallを使いこなす第一歩は、モック対象をトレイトとして定義することです。
Rustのトレイトはインターフェースを表現する仕組みであり、依存性逆転の原則を実現する中心的な道具でもあります。
ここでは、実務でよく使う基本パターンを順を追って確認していきます。

トレイトの定義とautomock属性

最も基本的な流れは、テスト対象のコードが利用する操作をトレイトとして切り出し、そのトレイトにautomock属性を付与することです。
cfg_attrと組み合わせれば、テストビルド時のみモックを生成できます。

#[cfg_attr(test, automock)]
trait UserRepository {
    fn find_by_id(&self, id: u32) -> Option<User>;
    fn save(&self, user: &User) -> Result<(), Error>;
}

この定義により、テストモジュール内ではMockUserRepositoryが自動生成されます。
本番コードはUserRepositoryトレイトに依存させ、テストではMockUserRepositoryを注入するという構造になります。
具体的な型に依存しない設計が、そのままテスタビリティにつながるわけです。

ジェネリクスを活用した依存注入

実際のコードでは、依存をトレイトオブジェクトとして受け取る方法と、ジェネリクスで受け取る方法の2通りがあります。
静的ディスパッチを好むならジェネリクスが適しています。

  • ジェネリクスを使うと、コンパイル時に単相化され、実行時オーバーヘッドがゼロになります
  • トレイトオブジェクトを使うと、異なる実装を実行時に切り替えられます
  • テストではどちらの場合も、モックを渡すだけで外部依存を排除できます

関数側はfn register_user<R: UserRepository>(repo: &R, ...)のように定義します。
この形にしておけば、本番では実装を、テストではモックを渡すだけで済みます。
動的ディスパッチが必要な場面を除き、まずはジェネリクスで設計するのがRustらしい選択です。

複数のメソッドを持つトレイトのモック

トレイトに複数のメソッドがある場合、mockallはそれぞれに対応するexpect_*メソッドを生成します。
テスト対象のコードがどのメソッドを呼ぶかを明示的に設定できるため、テストの意図が明確になります。

let mut mock = MockUserRepository::new();
mock.expect_find_by_id()
    .withf(|id| *id == 42)
    .times(1)
    .returning(|_| Some(User::new(42, "Alice")));

withfは引数の述語を指定し、timesは呼び出し回数を制約します。
これらの設定を怠ると、モックはデフォルトの振る舞いしか返さないため、呼び出しの検証が機能しません。
逆に言えば、expect_*を設定することが、テストの期待値を明示する行為そのものなのです。

ライフタイムと参照を扱う際の注意点

mockallを使う上でつまずきやすいのが、参照やライフタイムを含むメソッドのモックです。
&selfを受け取るメソッドは問題なくモックできますが、引数に参照を含む場合はwithfのクロージャの型推論が難しくなる場合があります。

また、returningで返す値が参照を含む場合、モックの内部に値を保持する必要があり、ライフタイムの整合性を意識した設計が求められます。
所有権を返す設計にしておけば、こうした問題の多くは自然に回避できます。
参照を返す設計はパフォーマンス上有利なこともありますが、テスト容易性とのトレードオフを考慮する必要があります。

モックしにくいケースへの対処

mockallはトレイトに対してのみ機能します。
したがって、自由関数や外部クレートが提供する構造体を直接モックすることはできません。
このような場合は、それらを薄いトレイトでラップするアダプタ層を設けます。
ラップ自体は数行のコードで済み、テスト可能性が大きく向上します。

  • 外部クレートのクライアントは、自前のトレイトで包んでから依存させる
  • 静的メソッドや関連関数は、トレイトのメソッドに変換して抽象化する
  • 標準ライブラリの機能をモックしたい場合は、必要最小限のトレイトを定義する

この作業は冗長に感じられるかもしれませんが、依存の境界を明示するという設計上の利点があります。
モックしにくさは、たいてい結合度の高さのサインです。
mockallの導入を機に、依存関係を整理してみる価値は十分にあります。

mockallのexpectationsと戻り値設定をマスターする

mockallのexpectationsで呼び出し回数や戻り値を細かく制御するRustコードのアイキャッチ

mockallの真価は、単にメソッドをモックするだけでなく、呼び出しの回数や引数、戻り値をきめ細かく制御できる点にあります。
この制御を担うのがexpectationsです。
expectationsを適切に設定できれば、テストは仕様書に近い明確な表現になります。
逆に設定が甘ければ、テストは通るけれど何も検証していないという状態に陥ります。

expectationsの基本構造

expect_*メソッドは、そのメソッドがどのように呼ばれることを期待するかを宣言します。
生成されたモックに対して設定し、設定しなかったメソッドが呼ばれると、モックはパニックを起こします。
これにより、想定外の呼び出しを即座に検出できます。

let mut mock = MockMailer::new();
mock.expect_send()
    .times(1)
    .returning(|_, _| Ok(()));

この例では、sendがちょうど1回呼ばれることを期待し、成功を返すように設定しています。
timesを指定しなければデフォルトで1回が期待されます。
つまり、何も設定しないことと1回を設定することは等価です。
この暗黙の挙動を理解しておかないと、呼び出し回数の検証を意図せず省略してしまうことがあります。

呼び出し回数の制御

呼び出し回数の検証は、副作用を持つ処理や外部APIの呼び出しにおいて特に重要です。
mockallは回数制御のための複数のメソッドを提供しています。

  • times(n)は正確にn回の呼び出しを要求します
  • once()は1回だけの呼び出しを要求します
  • never()は一度も呼ばれないことを要求します
  • times(0..=3)のように範囲で指定することも可能です

never()は特に有用です。
例えば、キャッシュがヒットした場合に外部APIを呼ばないことを検証したい場面で効果を発揮します。
呼ばれないことの検証は、明示的に設定しなければ抜け落ちやすい観点です。

引数のマッチング

呼び出し回数だけでなく、引数の検証も欠かせません。
mockallはいくつかの方法で引数をマッチングできます。

mock.expect_transfer()
    .withf(|from, to, amount| from != to && *amount > 0)
    .returning(|_, _, _| Ok(TransactionId::new()));

withfは任意の述語を受け取るため、複雑な条件も表現できます。
単純な等値比較ならwith(predicate::eq(...))を使う方法もあります。
重要なのは、引数の検証を怠ると、誤った引数で呼ばれてもテストが通ってしまうという点です。
モックが返す値だけを検証して満足するのは、テストとして不十分です。

戻り値とエラーの注入

returningを使えば固定の戻り値を返せますが、呼び出しごとに異なる値を返したい場合もあります。
その場合はreturningにクロージャを渡し、呼び出し回数に応じた値を生成します。
また、エラー系のテストではreturningでErrを返すだけで、例外パスを容易に検証できます。

設定メソッド 用途 典型的な場面
returning 固定値やクロージャで戻り値を返す 正常系の検証
return_once 一度だけ値を返す 所有権の移動を伴う戻り値
returning_st 状態を共有して値を返す 呼び出しごとに変化する値

return_onceは、所有権を持つ値を返す場合に特に便利です。
returningではクロージャが複数回呼ばれる可能性があるため、所有権を移動する値を返せません。
この制約を理解しておくと、コンパイルエラーの原因を素早く特定できます。

順序の検証とシーケンス

複数のメソッドが特定の順序で呼ばれることを検証したい場合、mockallはシーケンス機能を提供します。
Sequenceオブジェクトを生成し、複数のexpectationにin_sequenceを設定することで、呼び出し順序を制約できます。

  • 初期化処理が必ず先に呼ばれることを検証する
  • コミットの前に書き込みが行われることを確認する
  • 状態遷移が正しい順序で進むことを保証する

順序の検証は、状態機械を持つコードやトランザクション処理で特に価値があります。
ただし、過度に順序を固定すると、実装の自由度を不必要に制限します。
本当に順序が本質的な意味を持つ場面に限定して使うのが賢明です。

expectationsをテストの仕様として捉える

expectationsの設定は、単なるテストの準備作業ではありません。
それは「このメソッドはこう呼ばれるべきだ」という仕様をコードで表現する行為です。
timesやwithfを見れば、そのテストが何を保証しようとしているかが読み取れます。
テストが仕様の役割を果たすためには、expectationsを曖昧にせず、意図を明示することが欠かせません。

wiremockとhttpmockで外部APIをシミュレートする方法

wiremockとhttpmockでHTTPレスポンスを模擬するRustテストコードのアイキャッチ

トレイトベースのモックが内部依存の差し替えに適しているのに対し、HTTPレベルのモックは外部APIそのものをシミュレートします。
wiremockとhttpmockはこの用途で最も広く使われるクレートです。
どちらもローカルにHTTPサーバーを起動し、リクエストのマッチングとレスポンスの返却を制御します。
本章では、それぞれの基本的な使い方と、実際のユースケースに沿った活用法を見ていきます。

wiremockの基本構造

wiremockは非同期ランタイムを前提とした設計で、tokioとasync_stdの両方をサポートしています。
テストごとにMockServerを起動し、そこにMockをマウントするという流れが基本です。

use wiremock::{MockServer, Mock, ResponseTemplate};
use wiremock::matchers::{method, path};

#[tokio::test]
async fn test_fetch_user() {
    let server = MockServer::start().await;

    Mock::given(method("GET"))
        .and(path("/users/42"))
        .respond_with(ResponseTemplate::new(200).set_body_json(
            serde_json::json!({"id": 42, "name": "Alice"})
        ))
        .mount(&server)
        .await;

    let client = MyClient::with_base_url(&server.uri());
    let user = client.fetch_user(42).await.unwrap();
    assert_eq!(user.name, "Alice");
}

この構造の利点は、テスト対象のクライアントコードが実際のHTTP通信を行う点にあります。
HTTPクライアントの実装そのものが検証対象に含まれるため、リクエストの構築やレスポンスのパース処理までテストできます。
MockServerはテスト終了時に自動的にシャットダウンされ、使用していたポートを解放します。

リクエストマッチングの詳細

wiremockは豊富なマッチャーを標準で提供しています。
methodやpathに加え、クエリパラメータやヘッダー、ボディの内容までマッチングできます。

  • query_paramで特定のクエリパラメータを検証できます
  • headerでリクエストヘッダーの存在や値を確認できます
  • path_regexで正規表現によるパスマッチングが可能です
  • body_jsonでJSONボディの内容をマッチングできます
use wiremock::matchers::{method, path, query_param, header};

Mock::given(method("GET"))
    .and(path("/users/testuser/repos"))
    .and(query_param("sort", "updated"))
    .and(query_param("per_page", "100"))
    .and(header("Authorization", "token ghp_xxxx"))
    .respond_with(ResponseTemplate::new(200))
    .mount(&server)
    .await;

これらのマッチャーを組み合わせることで、クライアントが正しいリクエストを送信しているかを厳密に検証できます。
カスタムマッチャーをMatchトレイトで実装することも可能です。

エラー系のシミュレーション

外部APIのテストで特に価値が高いのが、エラー系のシミュレーションです。
実際のAPIでは再現が難しいレート制限やサーバーエラーを、モックサーバーなら簡単に再現できます。

#[tokio::test]
async fn test_rate_limit_handling() {
    let server = MockServer::start().await;

    Mock::given(method("GET"))
        .and(path("/users/anyuser"))
        .respond_with(ResponseTemplate::new(429).set_body_json(
            serde_json::json!({"message": "API rate limit exceeded"})
        ))
        .mount(&server)
        .await;

    let result = client.fetch_user("anyuser").await;
    assert!(matches!(result, Err(MyError::RateLimited)));
}

ネットワーク遅延を模擬したい場合は、ResponseTemplateにset_delayを設定します。
タイムアウト処理の検証や、リトライロジックのテストに有効です。

httpmockの特徴と使い方

httpmockはwiremockと同様のHTTPモック機能を提供しますが、APIの設計思想が異なります。
whenとthenという2つのビルダーをクロージャで受け取る形式が特徴的で、同期・非同期の両方のAPIを備えています。

use httpmock::prelude::*;

#[test]
fn test_fetch_repo() {
    let server = MockServer::start();

    let mock = server.mock(|when, then| {
        when.method(GET)
            .path("/repos/owner/repo")
            .header("Authorization", "token ghp_xxxx");
        then.status(200)
            .header("content-type", "application/json")
            .body(r#"{"id": 100, "name": "repo"}"#);
    });

    let client = MyClient::new(server.base_url());
    let repo = client.fetch_repo("owner", "repo").unwrap();

    mock.assert();
    assert_eq!(repo.id, 100);
}

httpmockはテストの並列実行をサポートしていますが、MockServerは内部のプールから割り当てられるため、同時に使用できるサーバー数には上限があります。
デフォルトでは25個に制限されており、HTTPMOCK_MAX_SERVERS環境変数で変更できます。

両者の使い分け

どちらのクレートを選ぶべきかは、プロジェクトの性質とテストの要件によって決まります。

観点 wiremock httpmock
非同期API 必須 同期・非同期の両方
テスト並列実行 完全対応 プール上限あり
複数APIの同時モック 可能 制限あり
スタンドアロンモード 非対応 Dockerイメージ提供
エラーメッセージの詳細さ 標準的 diff付きで詳細

非同期ランタイムを前提としたプロジェクトで、複数の外部APIを同時にモックする必要がある場合はwiremockが適しています。
一方、同期コードのテストが中心で、シンプルなAPIを好む場合や、スタンドアロンでの運用を視野に入れるならhttpmockが候補になります。
いずれにせよ、HTTPレベルのモックはクライアント実装の検証に不可欠な道具です。

データベースアクセスをモックして安全にテストする設計手法

リポジトリパターンでデータベースアクセスをモック化するRust設計のアイキャッチ

データベースはアプリケーションの状態を永続化する中心的な存在であり、それゆえにテストが最も難しい依存のひとつです。
本番データへの書き込みを避けつつ、SQLのロジックやトランザクションの挙動を検証するには、適切な抽象化とモックの組み合わせが欠かせません。
本章では、リポジトリパターンを軸に、安全で保守性の高いテスト設計を解説します。

リポジトリパターンによる抽象化

データベースアクセスをモック可能にする第一歩は、SQLの発行やコネクションの管理をリポジトリと呼ばれるトレイトの背後に隠すことです。
ドメインロジックは具体的なデータベースドライバではなく、リポジトリのインターフェースに依存させます。

#[cfg_attr(test, automock)]
trait UserRepository {
    fn find_by_id(&self, id: u32) -> Result<Option<User>, DbError>;
    fn save(&self, user: &User) -> Result<(), DbError>;
    fn delete(&self, id: u32) -> Result<(), DbError>;
}

この設計により、テスト対象のサービス層はUserRepositoryトレイトだけを認識します。
テストではMockUserRepositoryを注入すれば、実際のデータベースに一切触れることなくロジックを検証できます。
抽象化の境界をどこに引くかが、テスト容易性を決定づけると言っても過言ではありません。

トランザクション境界の扱い

リポジトリをモックする際に注意すべきなのが、トランザクションの境界です。
複数のリポジトリ操作をまとめて原子性を保証する場合、トランザクションの管理をどこで行うかによってモックの設計が変わります。

  • サービス層でトランザクションを開始する場合、トランザクションオブジェクト自体をトレイトで抽象化します
  • リポジトリ層でトランザクションを完結させる場合、各メソッドが原子性を持つ前提でモックします
  • Unit of Workパターンを採用する場合、変更の追跡とコミットを別のトレイトに分離します

トランザクションをモックする場合、コミットやロールバックが正しい順序で呼ばれるかを検証することが重要です。
mockallのシーケンス機能を使えば、これらの呼び出し順序をテストで保証できます。

インメモリデータベースという選択肢

すべてをモックで済ませるのではなく、インメモリデータベースをテストに使う戦略も有効です。
SQLiteのインメモリモードは、実際のSQLを実行しながらディスクに触れないため、SQLの正しさを検証したい場合に適しています。

手法 検証できる範囲 実行速度 本番との乖離
トレイトモック サービス層のロジック 最速 大きい
インメモリDB SQLとスキーマ 速い 中程度
コンテナDB 実際のDB挙動 遅い 小さい

モックはサービス層のロジック検証に、インメモリDBはSQLの検証に、コンテナDBは統合テストにと、目的に応じて使い分けるのが現実的です。
単体テストではモックを、結合テストではインメモリDBを使うという階層化が、多くのプロジェクトで機能します。

SQLをモックすべきかという問い

「SQLそのものをモックすべきか」という問いは、しばしば議論の的になります。
結論から言えば、SQLの正しさはモックでは検証できません。
モックが保証するのは、あくまでサービス層がリポジトリを正しく呼び出しているかという点です。

したがって、複雑なSQLやJOIN、集計処理を含むクエリは、インメモリDBや実際のデータベースに対する統合テストで検証する必要があります。
単体テストでSQLをモックし、統合テストで実SQLを検証するという二段構えが、品質と速度のバランスを取る最善の策です。
モックは万能ではなく、適用範囲を明確にすることが肝心です。

N+1問題とモックの限界

モックベースのテストが見落としやすいのが、パフォーマンスに関わる問題です。
例えば、ループ内でリポジトリを呼び出すN+1問題は、モックでは検出できません。
モックは何度呼ばれても高速に応答するため、非効率なアクセスパターンがテストを通過してしまいます。

  • 呼び出し回数の上限をtimesで設定し、想定以上の呼び出しを検出します
  • バッチ取得用のメソッドを設け、そちらが使われることを検証します
  • パフォーマンスが重要な箇所は、実際のDBに対する計測テストを別途用意します

timesによる回数制約は、意図しない呼び出しの増加を防ぐ簡便な手段です。
ただし、回数を固定しすぎると実装の変更に弱くなるため、本質的な制約に限定して適用します。

テストデータの整合性を保つ

モックを使う場合でも、返すテストデータの整合性には注意が必要です。
例えば、find_by_idが存在しないユーザーを返したり、saveの後にfind_by_idが古い値を返したりすると、テストは通っても実際の挙動を反映しません。

モックの状態を内部に持たせ、saveとfind_by_idが一貫した振る舞いをするように設計すると、より現実に近いテストが可能です。
mockallではreturningに状態を共有するクロージャを渡すことで、簡易的なインメモリ実装をモックとして構成できます。
ただし、これはモックが複雑化するサインでもあります。
状態を持つモックが必要になったら、インメモリDBへの移行を検討する時期かもしれません。

非同期処理とエラーハンドリングを含むモックテストの実践

tokioを使った非同期処理とエラー系のモックテストを検証するRustコードのアイキャッチ

現代のRustアプリケーションは、ネットワーク通信やデータベースアクセスを非同期で行うことが一般的です。
非同期コードのテストは、ランタイムの起動やタイミングの制御といった同期コードにはない考慮事項を伴います。
さらに、エラー系の検証を加えると、テスト設計の難易度は一段と上がります。
本章では、tokioを前提とした非同期モックテストの実践的な手法を整理します。

非同期テストの基本構造

非同期関数をテストする場合、#[tokio::test]属性を使ってテスト用のランタイムを起動します。
mockallで生成したモックは非同期メソッドにも対応しており、expect_*で設定した戻り値は.awaitで取得できます。

#[cfg_attr(test, automock)]
#[async_trait::async_trait]
trait ApiClient {
    async fn fetch(&self, id: u32) -> Result<Data, ApiError>;
}

async_traitクレートを使うことで、トレイトに非同期メソッドを定義できます。
Rust 1.75以降ではネイティブのasync traitも利用可能ですが、mockallとの併用を考えるとasync_traitを使う場面も依然として多いのが現状です。

非同期モックのexpectation設定

非同期メソッドに対するexpect_*の設定方法は、同期メソッドと基本的に同じです。
ただし、戻り値としてResultを返す場合、returningでOkやErrを明示的に返す必要があります。

#[tokio::test]
async fn test_fetch_success() {
    let mut mock = MockApiClient::new();
    mock.expect_fetch()
        .withf(|id| *id == 1)
        .times(1)
        .returning(|_| Ok(Data::new("sample")));

    let service = DataService::new(mock);
    let result = service.get_data(1).await;
    assert!(result.is_ok());
}

注目すべきは、モックの設定自体は同期的に行い、呼び出し側の.awaitで非同期処理が実行される点です。
モックは即座に値を返すため、非同期ランタイム上でも遅延なくテストが完了します。

タイムアウトと遅延のシミュレーション

非同期処理のテストでは、タイムアウトの挙動を検証したい場面があります。
wiremockのset_delayを使えば、レスポンスに意図的な遅延を挿入できます。

  • 短い遅延を設定し、正常に完了することを確認します
  • クライアントのタイムアウトより長い遅延を設定し、タイムアウトが発火することを検証します
  • リトライロジックがある場合、複数回の呼び出しと最終的な成功を検証します
Mock::given(method("GET"))
    .respond_with(ResponseTemplate::new(200).set_delay(
        std::time::Duration::from_millis(500)
    ))
    .mount(&server)
    .await;

タイムアウトの検証では、tokio::time::timeoutと組み合わせることで、想定した時間内に処理が完了するかを確認できます。
ただし、実際の時間に依存するテストは不安定になりやすいため、tokio::time::pauseを使った仮想時間の活用も検討します。

エラー伝播の検証

エラーハンドリングのテストで重要なのは、エラーが正しく伝播し、適切に変換されるかを確認することです。
モックは任意のエラーを注入できるため、実際のAPIでは再現しにくい異常系を網羅できます。

エラー種別 モックでの再現方法 検証すべき挙動
ネットワークエラー returningでErrを返す リトライまたは即時失敗
タイムアウト set_delayとtimeoutの併用 タイムアウトエラーへの変換
認証エラー 401レスポンスを返す トークン更新または失敗
レート制限 429レスポンスを返す バックオフと再試行

エラーを注入する際は、単にErrを返すだけでなく、エラーの型やメッセージが呼び出し側で正しく処理されるかを検証します。
anyhowやthiserrorを使っている場合、エラーの変換が意図通りかをmatches!マクロで確認します。

並行処理とモックのスレッド安全性

非同期処理では複数のタスクが並行して実行されるため、モックがスレッドセーフである必要があります。
mockallが生成するモックはSend + Syncを満たすように設計されていますが、returningで共有状態を扱う場合は注意が必要です。

  • 状態を共有する場合はArc<Mutex<...>>で保護します
  • 呼び出し回数を検証するtimesは、並行呼び出しでも正確にカウントされます
  • 複数のタスクから同じモックを呼ぶ場合、expectationの設定が競合しないよう設計します

並行処理のテストでは、tokio::join!やfutures::future::join_allを使って複数の非同期処理を同時に実行し、モックが期待通りに動作するかを検証します。
競合状態を意図的に再現するのは困難ですが、モックの呼び出し回数を厳密に設定することで、想定外の並行呼び出しを検出できます。

エラーハンドリングをテストの中心に据える

非同期処理のテストでは、正常系よりも異常系の検証にこそ価値があります。
ネットワークは失敗するもの、外部APIは予期せぬ応答を返すものという前提に立てば、エラーパスを網羅することが堅牢なアプリケーションへの近道です。
モックは、その異常系を安全かつ再現可能な形で注入するための最も強力な手段なのです。

モックの過剰使用を避けるための設計原則とリファクタリング指針

モックの過剰使用を避けて依存注入と設計改善を進めるRust開発のアイキャッチ

モックはテストを助ける強力な道具ですが、万能薬ではありません。
過剰にモックを使うと、テストが実装の詳細に過度に結合し、リファクタリングのたびにテストが壊れるという事態を招きます。
本章では、モックを適切な範囲にとどめ、テストと設計の健全性を保つための原則を整理します。

モックすべき境界とそうでない境界

モックの適用範囲を決める基本原則は、「プロセス外の依存」と「制御不能な依存」に限定することです。
具体的には、ネットワーク、ファイルシステム、時刻、乱数、外部サービスが該当します。
これらはテストの決定性を損なうため、モックの対象とすべきです。

一方、純粋な計算ロジック、データ構造の操作、同じプロセス内の単純な関数呼び出しは、モックする必要がありません。
これらをモックすると、テストが本番コードの構造をそのまま写し取るだけの冗長なものになります。
モックは境界にのみ適用するという原則を守れば、テストは本質的な検証に集中できます。

テストが実装に結合する兆候

モックの過剰使用は、いくつかの兆候として現れます。
これらに気づいたら、設計を見直すサインと考えてよいでしょう。

  • 些細なリファクタリングのたびに、多数のテストが失敗する
  • テストコードの行数が、テスト対象のコードを大幅に超えている
  • expect_*の設定が延々と続き、テストの意図が読み取れない
  • モックの戻り値を変更するだけで、テストが通ったり落ちたりする
  • プライベートな内部メソッドまでモックしようとしている

特に最後の項目は重要です。
内部実装の詳細をモックしようとする欲求は、そのコードが適切に抽象化されていない証拠です。
モックしにくいと感じたら、まず設計を見直すべきです。

古典学派とロンドン学派の視点

テスト設計には、古典学派とロンドン学派という2つの立場があります。
古典学派は実オブジェクトを可能な限り使い、モックは最小限にとどめます。
ロンドン学派は協調オブジェクトをモックし、相互作用を検証します。

観点 古典学派 ロンドン学派
検証対象 状態と結果 相互作用
モックの範囲 外部依存のみ 協調オブジェクト全般
リファクタリング耐性 高い 低い傾向
テストの粒度 やや粗い 細かい

どちらが正しいというわけではありませんが、Rustのエコシステムでは古典学派のアプローチが馴染みやすいと言えます。
所有権と型システムが、実オブジェクトを使ったテストを比較的安全にしているためです。
モックは外部境界に限定し、内部の協調は実オブジェクトで検証するのが、保守性の観点で優れています。

モックが複雑化したときのリファクタリング

モックの設定が複雑になってきたら、それはテスト対象の設計に問題がある可能性が高いです。
以下のようなリファクタリングを検討します。

  • 依存の数を減らすため、責務を分割し、各関数の依存を最小化します
  • 状態を持つモックが必要なら、インメモリ実装を用意し、それをテストで使います
  • モックの設定をヘルパー関数に抽出し、テストの意図を明確にします
  • 相互作用の検証が多すぎるなら、戻り値ベースの検証に切り替えます

特に「状態を持つモック」は、モックの限界を示す明確なサインです。
saveした後にfindすると同じ値を返すような振る舞いをモックで再現しようとすると、テストコードは急速に複雑化します。
このような場合は、シンプルなインメモリ実装を書いたほうが、はるかに保守しやすくなります。

テストのピラミッドとモックの位置づけ

テストは一般に、単体テスト、統合テスト、E2Eテストという階層で構成されます。
モックが活躍するのは主に単体テストの層であり、上位の層では実依存を使う比重が高まります。

  • 単体テストでは、外部依存をモックし、ロジックを高速に検証します
  • 統合テストでは、インメモリDBやローカルサーバーを使い、結合を検証します
  • E2Eテストでは、実際の依存を使い、システム全体を検証します

この階層を意識することで、モックの使いどころが自然と定まります。
すべてのテストをモックで済ませようとするのは、ピラミッドの下層に偏りすぎた状態です。
上位の層で実依存を検証するからこそ、下層のモックは安心して使えます。

モックを設計のフィードバック源にする

モックはテストの道具であると同時に、設計の診断ツールでもあります。
モックしやすいコードは、依存が明確で結合度が低いコードです。
逆にモックしにくいコードは、改善の余地を示しています。
モックの使いにくさを感じたときこそ、依存関係を見直し、より良い設計へと導く機会なのです。
テストと設計は、互いに影響し合う関係にあります。

まとめ:Rustのモックライブラリを活用して信頼性の高いテストを実現しよう

Rustのモックライブラリ活用で信頼性の高い単体テストを実現するまとめのアイキャッチ

本記事では、Rustの単体テストにおいて外部APIやデータベースを安全に模擬する方法を、モックライブラリの選定から実践的な活用法まで一貫して解説してきました。
ここで、各章の要点を振り返り、読者の皆さんが明日からのテスト設計に活かせる形に整理します。

各手法の役割の再確認

モックライブラリは、その対象によって役割が明確に分かれます。
mockallはトレイトベースの依存を差し替えるための道具であり、データベースや内部サービスの抽象化に適しています。
wiremockとhttpmockはHTTP通信そのものをシミュレートし、外部APIクライアントの実装検証に向いています。
どちらか一方を選ぶのではなく、依存の性質に応じて使い分けることが重要です。

  • 内部依存の差し替えにはmockallを第一候補とします
  • HTTP通信の模擬にはwiremockまたはhttpmockを選びます
  • データベースのロジック検証には、モックとインメモリDBを目的別に使い分けます
  • 非同期処理のテストでは、tokioのランタイムとモックを組み合わせます

これらの道具は、いずれもテストの決定性と実行速度を高めるために存在します。
目的を明確にすれば、自ずと適切な選択が見えてきます。

テストの階層とモックの位置づけ

モックは単体テストの層で最も威力を発揮しますが、すべてをモックで済ませるのは得策ではありません。
テストは単体、統合、E2Eという階層で構成され、上位の層では実依存を使う比重が高まります。
下層でモックを使い、上層で実依存を検証するという分担が、品質と速度のバランスを取る鍵となります。

テスト層 主な検証対象 モックの使用
単体テスト ロジックと分岐 積極的に使用
統合テスト 結合とSQL 限定的に使用
E2Eテスト システム全体 ほぼ使用しない

この表のように、モックの使用量はテスト層が上がるにつれて減っていくのが自然です。
逆に、すべての層でモックを多用しているなら、テスト戦略を見直す余地があります。

設計のフィードバック源としてのモック

本記事で繰り返し強調したのは、モックの使いにくさが設計の問題を示すサインになり得るという点です。
依存が多すぎる関数、状態を持つモックが必要な設計、内部実装までモックしようとする欲求。
これらはすべて、結合度の高さや責務の混在を示しています。
モックを導入する過程でこうした兆候に気づいたなら、テストを書くこと自体がリファクタリングの機会になります。

モックはテストのためだけの道具ではありません。
依存関係をインターフェースとして明示する行為は、コードの見通しを良くし、変更に強い構造を作ります。
テスタビリティの向上は、そのまま設計品質の向上につながるのです。

エラー系の検証を怠らない

正常系のテストは書きやすく、つい偏りがちです。
しかし、外部依存を持つコードの真価は、異常系でこそ問われます。
ネットワークの失敗、タイムアウト、レート制限、認証エラー。
これらを安全に再現できるのがモックの最大の利点です。
returningでErrを返し、set_delayで遅延を注入し、timesで再試行の回数を検証する。
こうした検証を積み重ねることで、本番環境での予期せぬ障害に耐えるコードが育ちます。

最後に

Rustの型システムと所有権は、テストの信頼性を高める強力な基盤です。
その上でモックライブラリを適切に活用すれば、外部依存に怯えることなく、自信を持ってリファクタリングできるようになります。
大切なのは、モックを目的ではなく手段として捉え、適用範囲を明確にすることです。
境界にのみモックを適用し、本質的なロジックは実オブジェクトや統合テストで検証する。
この原則を守れば、テストは仕様書として機能し、開発を加速させる味方になります。
読者の皆さんのテストが、より堅牢で保守しやすいものになることを願っています。

コメント

タイトルとURLをコピーしました