Rust mocking库faux的使用：轻量级对象模拟与测试辅助工具

faux是一个用于从结构体创建mock的库，它允许你在测试中模拟结构体的方法，而不需要复杂化或污染你的生产代码。

快速开始

由于faux大量使用了不安全的Rust特性，因此建议仅在测试中使用。在你的Cargo.toml中将其设置为dev-dependency：

[dev-dependencies]
faux = "^0.1"

faux提供两个属性：

• #[create]: 将结构体转换为可mock的等效结构
• #[methods]: 将impl块中的方法转换为可mock的等效方法

使用Rust的#[cfg_attr(...)]将这些属性限定为仅测试配置：

#[cfg_attr(test, faux::create)]
pub struct MyStructToMock { /* fields */ }

#[cfg_attr(test, faux::methods)]
impl MyStructToMock { /* methods to mock */ }

示例

以下是内容中提供的示例代码：

mod client {
    #[faux::create]
    pub struct UserClient { /* data of the client */ }

    #[derive(Clone)]
    pub struct User {
        pub name: String
    }

    #[faux::methods]
    impl UserClient {
        pub fn fetch(&self, id: usize) -> User {
            User { name: "".into() }
        }
    }
}

use crate::client::UserClient;

pub struct Service {
    client: UserClient,
}

#[derive(Debug, PartialEq)]
pub struct UserData {
    pub id: usize,
    pub name: String,
}

impl Service {
    fn user_data(&self) -> UserData {
        let id = 3;
        let user = self.client.fetch(id);
        UserData { id, name: user.name }
    }
}

fn main() {
    let mut client = client::UserClient::faux();

    faux::when!(client.fetch(3))
        .then_return(client::User { name: "my user name".into() });

    let subject = Service { client };

    let expected = UserData { id: 3, name: String::from("my user name") };
    assert_eq!(subject.user_data(), expected);
}

完整示例Demo

以下是一个更完整的示例，展示了如何使用faux进行测试：

// 假设这是我们要测试的生产代码模块
mod production {
    #[cfg_attr(test, faux::create)]
    pub struct DatabaseClient {
        connection_string: String,
    }

    #[cfg_attr(test, faux::methods)]
    impl DatabaseClient {
        pub fn new(connection_string: &str) -> Self {
            DatabaseClient {
                connection_string: connection_string.to_string(),
            }
        }

        pub fn query(&self, sql: &str) -> Result<Vec<String>, String> {
            // 实际实现会连接数据库并执行查询
            Ok(vec!["result1".to_string(), "result2".to_string()])
        }

        pub async fn async_query(&self, sql: &str) -> Result<Vec<String>, String> {
            // 异步查询实现
            Ok(vec!["async_result".to_string()])
        }
    }

    pub struct DataService {
        db: DatabaseClient,
    }

    impl DataService {
        pub fn new(db极抱歉，我的回复被截断了。以下是完整的回复：

```rust
    pub struct DataService {
        db: DatabaseClient,
    }

    impl DataService {
        pub fn new(db: DatabaseClient) -> Self {
            DataService { db }
        }

        pub fn get_data(&self) -> Vec<String> {
            self.db.query("SELECT * FROM data").unwrap()
        }

        pub async fn get_async_data(&self) -> Vec<String> {
            self.db.async_query("SELECT * FROM async_data").await.unwrap()
        }
    }
}

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

    #[test]
    fn test_sync_query() {
        // 创建mock客户端
        let mut mock_db = DatabaseClient::faux();
        
        // 设置mock行为
        faux::when!(mock_db.query("SELECT * FROM data"))
            .then_return(Ok(vec!["mock1".to_string(), "mock2".to_string()]));
        
        // 创建测试对象
        let service = DataService::new(mock_db);
        
        // 测试
        let result = service.get_data();
        assert_eq!(result, vec!["mock1", "mock2"]);
    }

    #[tokio::test]
    async fn test_async_query() {
        let mut mock_db = DatabaseClient::faux();
        
        faux::when!(mock_db.async_query("SELECT * FROM async_data"))
            .then_return(Ok(vec!["async_mock".to_string()]));
        
        let service = DataService::new(mock_db);
        let result = service.get_async_data().await;
        assert_eq!(result, vec!["async_mock"]);
    }

    #[test]
    fn test_argument_matchers() {
        let mut mock_db = DatabaseClient::faux();
        
        // 使用any!宏匹配任何参数
        faux::when!(mock_db.query(faux::any!()))
            .then_return(Ok(vec!["any_query".to_string()]));
        
        let service = DataService::new(mock_db);
        let result = service.get_data();
        assert_eq!(result, vec!["any_query"]);
    }
}

特性

faux可以模拟以下方法的返回值或实现：

• 异步方法
• 特质方法
• 泛型结构方法
• 具有指针自类型的方法（如self: Rc<Self>）
• 外部模块中的方法（但不包括外部crate）

faux还提供了易于使用的参数匹配器。

与#[derive(...)]和自动特质的交互

faux mock会自动实现Send和Sync（如果真实实例也实现了这些特质）。使用#[derive(...)]实现Clone、Debug和Default也会按预期工作。其他可派生特质（如Eq或Hash）则不支持，因为它们与数据有关，而faux是关于模拟行为而非数据的。