Rustモックテスト完全ガイド｜mockall・mockito・fakeの使い分けと実践コード

// domain層: リポジトリのインターフェイス
pub trait UserRepository {
    fn find_by_id(&self, id: u64) -> Option<String>;
    fn save(&self, id: u64, name: &str) -> Result<(), String>;
}

// ユースケース: ジェネリクスで依存を受け取る
pub struct GetUserUseCase<R: UserRepository> {
    repo: R,
}

impl<R: UserRepository> GetUserUseCase<R> {
    pub fn new(repo: R) -> Self {
        Self { repo }
    }

    pub fn execute(&self, id: u64) -> String {
        self.repo
            .find_by_id(id)
            .unwrap_or_else(|| "unknown".to_string())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    struct StubUserRepo {
        users: std::collections::HashMap<u64, String>,
    }

    impl UserRepository for StubUserRepo {
        fn find_by_id(&self, id: u64) -> Option<String> {
            self.users.get(&id).cloned()
        }

        fn save(&self, _id: u64, _name: &str) -> Result<(), String> {
            Ok(())
        }
    }

    #[test]
    fn returns_user_name_when_found() {
        let mut users = std::collections::HashMap::new();
        users.insert(1, "Alice".to_string());
        let repo = StubUserRepo { users };
        let uc = GetUserUseCase::new(repo);

        assert_eq!(uc.execute(1), "Alice");
    }

    #[test]
    fn returns_unknown_when_not_found() {
        let repo = StubUserRepo {
            users: std::collections::HashMap::new(),
        };
        let uc = GetUserUseCase::new(repo);

        assert_eq!(uc.execute(999), "unknown");
    }
}

[dev-dependencies]
mockall = "0.14"

use mockall::automock;

#[automock]
pub trait UserRepository {
    fn find_by_id(&self, id: u64) -> Option<String>;
    fn save(&self, id: u64, name: &str) -> Result<(), String>;
}

#[cfg(test)]
mod tests {
    use super::*;
    use mockall::predicate::eq;

    #[test]
    fn mock_returns_expected_value() {
        let mut mock = MockUserRepository::new();

        // find_by_id(1)が呼ばれたら"Alice"を返す
        mock.expect_find_by_id()
            .with(eq(1))
            .times(1)
            .returning(|_| Some("Alice".to_string()));

        let uc = GetUserUseCase::new(mock);
        assert_eq!(uc.execute(1), "Alice");
    }

    #[test]
    fn verify_save_is_called() {
        let mut mock = MockUserRepository::new();

        mock.expect_save()
            .with(eq(42), eq("Bob"))
            .times(1)
            .returning(|_, _| Ok(()));

        // find_by_idも最低限セットアップ
        mock.expect_find_by_id()
            .returning(|_| None);

        assert!(mock.save(42, "Bob").is_ok());
    }
}

// src/client.rs
pub struct ApiClient;

#[cfg_attr(test, mockall::automock)]
impl ApiClient {
    pub fn fetch(&self, endpoint: &str) -> Result<String, String> {
        // 本番ではHTTP通信を実行
        todo!()
    }
}

// src/service.rs
#[cfg(test)]
use mockall_double::double;

#[cfg_attr(test, double)]
use crate::client::ApiClient;

pub fn get_status(client: &ApiClient) -> String {
    match client.fetch("/health") {
        Ok(body) => body,
        Err(_) => "unavailable".to_string(),
    }
}

{
  "rust-analyzer.cargo.features": "all",
  "rust-analyzer.diagnostics.disabled": ["unresolved-import"]
}

[dev-dependencies]
mockito = "1.7"
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
reqwest = { version = "0.12", features = ["json"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"

use serde::Deserialize;

#[derive(Debug, Deserialize, PartialEq)]
pub struct Todo {
    pub id: u32,
    pub title: String,
    pub completed: bool,
}

pub async fn fetch_todo(base_url: &str, id: u32) -> Result<Todo, String> {
    let url = format!("{}/todos/{}", base_url, id);
    let resp = reqwest::get(&url)
        .await
        .map_err(|e| e.to_string())?;
    resp.json::<Todo>()
        .await
        .map_err(|e| e.to_string())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn fetch_todo_returns_parsed_response() {
        let mut server = mockito::Server::new_async().await;

        let mock = server
            .mock("GET", "/todos/1")
            .with_status(200)
            .with_header("content-type", "application/json")
            .with_body(r#"{"id":1,"title":"Buy milk","completed":false}"#)
            .create_async()
            .await;

        let result = fetch_todo(&server.url(), 1).await.unwrap();

        assert_eq!(result, Todo {
            id: 1,
            title: "Buy milk".to_string(),
            completed: false,
        });

        mock.assert_async().await; // リクエストが1回来たことを検証
    }
}

[dev-dependencies]
wiremock = "0.6"

#[cfg(test)]
mod tests {
    use wiremock::{MockServer, Mock, ResponseTemplate};
    use wiremock::matchers::{method, path};

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

        Mock::given(method("GET"))
            .and(path("/api/users/1"))
            .respond_with(
                ResponseTemplate::new(200)
                    .set_body_json(serde_json::json!({"name": "Alice"}))
            )
            .expect(1)
            .mount(&mock_server)
            .await;

        let resp = reqwest::get(format!("{}/api/users/1", mock_server.uri()))
            .await
            .unwrap();

        assert_eq!(resp.status(), 200);
    }
}

[dev-dependencies]
fake = { version = "4.4", features = ["derive"] }
rand = "0.8"

use fake::{Fake, Faker};
use fake::faker::name::en::Name;
use fake::faker::internet::en::SafeEmail;

#[test]
fn generate_fake_data() {
    let name: String = Name().fake();
    let email: String = SafeEmail().fake();
    let age: u32 = (18..65).fake();

    assert!(!name.is_empty());
    assert!(email.contains('@'));
    assert!(age >= 18 && age < 65);
}

use fake::Dummy;

#[derive(Debug, Dummy)]
pub struct User {
    #[dummy(faker = "1..1000")]
    pub id: u64,
    #[dummy(faker = "fake::faker::name::en::Name()")]
    pub name: String,
    #[dummy(faker = "fake::faker::internet::en::SafeEmail()")]
    pub email: String,
}

#[test]
fn generate_dummy_user() {
    let user: User = Faker.fake();
    assert!(user.id >= 1 && user.id < 1000);
    assert!(!user.name.is_empty());
}

[dev-dependencies]
insta = { version = "1.46", features = ["json"] }

use insta::assert_json_snapshot;
use serde_json::json;

#[test]
fn snapshot_api_response() {
    let response = json!({
        "status": "ok",
        "users": [
            {"id": 1, "name": "Alice"},
            {"id": 2, "name": "Bob"}
        ]
    });

    assert_json_snapshot!(response);
}

# スナップショットの確認・承認
cargo install cargo-insta
cargo insta review

// よい設計: traitで抽象化
pub fn process_order<R: OrderRepository, N: Notifier>(
    repo: &R,
    notifier: &N,
    order_id: u64,
) -> Result<(), String> {
    let order = repo.find(order_id).ok_or("not found")?;
    notifier.send(&format!("Order {} processed", order.id))?;
    Ok(())
}

use async_trait::async_trait;
use mockall::automock;

#[automock]
#[async_trait]
pub trait AsyncUserRepository {
    async fn find_by_id(&self, id: u64) -> Option<String>;
}

#[cfg(test)]
mod tests {
    use super::*;
    use mockall::predicate::eq;

    #[tokio::test]
    async fn async_mock_test() {
        let mut mock = MockAsyncUserRepository::new();
        mock.expect_find_by_id()
            .with(eq(1))
            .returning(|_| Some("Alice".to_string()));

        let result = mock.find_by_id(1).await;
        assert_eq!(result, Some("Alice".to_string()));
    }
}