Rust单元测试中如何Mock底层函数？多测试用例场景求解

1. 依赖注入（最推荐的轻量方案） #

核心思路是把底层IO逻辑抽象成trait，让service层依赖这个抽象接口而非具体实现，测试时传入自定义的Mock结构体，每个测试用例可以自由配置返回值。

举个实际代码例子：
首先在low_level.rs里定义抽象接口和生产实现：

// low_level.rs
pub trait NetworkIO {
    fn fetch_data(&self) -> Result<String, std::io::Error>;
}

// 生产环境的真实网络IO实现
pub struct RealNetworkIO;

impl NetworkIO for RealNetworkIO {
    fn fetch_data(&self) -> Result<String, std::io::Error> {
        // 这里写真实的网络请求逻辑
        Ok("real server response".to_string())
    }
}

然后修改service.rs，让Service依赖trait而非直接调用底层函数：

// service.rs
use crate::low_level::NetworkIO;

pub struct Service {
    io: Box<dyn NetworkIO>,
}

impl Service {
    // 外部传入IO实现，生产环境传RealNetworkIO
    pub fn new(io: Box<dyn NetworkIO>) -> Self {
        Service { io }
    }

    pub fn process(&self) -> Result<String, std::io::Error> {
        let raw_data = self.io.fetch_data()?;
        Ok(format!("processed result: {}", raw_data))
    }
}

测试时，每个用例可以定义专属的Mock：

// service.rs中的测试模块
#[cfg(test)]
mod tests {
    use super::*;
    use crate::low_level::NetworkIO;
    use std::io;

    // 测试用Mock，支持自定义返回结果
    struct TestMockIO {
        mock_result: Result<String, io::Error>,
    }

    impl NetworkIO for TestMockIO {
        fn fetch_data(&self) -> Result<String, io::Error> {
            self.mock_result.clone()
        }
    }

    #[test]
    fn test_process_success() {
        let mock_io = TestMockIO {
            mock_result: Ok("test mock data".to_string()),
        };
        let service = Service::new(Box::new(mock_io));
        assert_eq!(service.process().unwrap(), "processed result: test mock data");
    }

    #[test]
    fn test_process_failure() {
        let mock_io = TestMockIO {
            mock_result: Err(io::Error::new(io::ErrorKind::ConnectionRefused, "refused")),
        };
        let service = Service::new(Box::new(mock_io));
        assert!(service.process().is_err());
    }
}

这种方案不需要任何宏，完全遵循Rust的类型系统，每个测试用例的Mock相互独立，不会互相干扰。

2. 用Mock库简化代码（比如mockall） #

如果觉得手动写Mock结构体麻烦，可以用成熟的Mock库自动生成Mock实现，还支持配置调用次数、参数匹配等复杂逻辑。

步骤如下：

1. 在Cargo.toml的开发依赖中添加mockall：

[dev-dependencies]
mockall = "0.11"

2. 修改low_level.rs，用mockall宏生成Mock：

// low_level.rs
use mockall::mock;

// 生成Mock版本的NetworkIO
mock! {
    pub NetworkIO {}
    impl NetworkIO for NetworkIO {
        fn fetch_data(&self) -> Result<String, std::io::Error>;
    }
}

// 保留真实的RealNetworkIO实现...

3. 测试时直接用生成的Mock：

// service.rs的测试模块
#[cfg(test)]
mod tests {
    use super::*;
    use crate::low_level::MockNetworkIO;
    use std::io;

    #[test]
    fn test_with_mockall() {
        let mut mock_io = MockNetworkIO::new();
        // 配置Mock返回指定结果
        mock_io.expect_fetch_data()
            .returning(|| Ok("mockall generated data".to_string()));
        
        let service = Service::new(Box::new(mock_io));
        assert_eq!(service.process().unwrap(), "processed result: mockall generated data");
    }

    #[test]
    fn test_error_with_mockall() {
        let mut mock_io = MockNetworkIO::new();
        mock_io.expect_fetch_data()
            .returning(|| Err(io::Error::new(io::ErrorKind::TimedOut, "timeout")));
        
        let service = Service::new(Box::new(mock_io));
        assert!(service.process().is_err());
    }
}

这种方案省去了手动编写Mock结构体的工作量，适合复杂接口或需要验证调用行为的场景。

3. 全局静态Mock（仅临时场景用，不推荐） #

如果不想大面积修改现有代码，可以用全局静态变量存Mock逻辑，但要注意线程安全（并行测试可能冲突），且需要用unsafe块操作：

在low_level.rs中：

// low_level.rs
#[cfg(not(test))]
pub fn fetch_data() -> Result<String, std::io::Error> {
    // 真实网络逻辑
    Ok("real data".to_string())
}

#[cfg(test)]
pub static mut MOCK_FETCH: Option<fn() -> Result<String, std::io::Error>> = None;

#[cfg(test)]
pub fn fetch_data() -> Result<String, std::io::Error> {
    unsafe { MOCK_FETCH.unwrap()() }
}

测试时设置Mock：

// service.rs的测试模块
#[cfg(test)]
mod tests {
    use super::*;
    use crate::low_level;
    use std::io;

    #[test]
    fn test_global_mock() {
        unsafe {
            low_level::MOCK_FETCH = Some(|| Ok("global mock data".to_string()));
        }
        assert_eq!(service::process().unwrap(), "processed result: global mock data");
        // 测试后重置，避免影响其他用例
        unsafe {
            low_level::MOCK_FETCH = None;
        }
    }
}

这种方案有安全风险，且不支持并行测试，只适合临时快速测试，不推荐长期使用。

内容的提问来源于stack exchange，提问作者Treagzhao