如何优雅测试Rust中依赖系统时间的代码？

不用在业务代码里塞#[cfg]宏，最优雅的方案是依赖注入+Trait抽象，把时间获取逻辑和业务代码完全解耦，测试时替换成可控的时间实现就行。

具体步骤如下：

1. 抽象时间获取的Trait #

先定义一个Trait封装时间获取行为，让业务代码只依赖这个抽象，不关心具体是系统时间还是测试用的模拟时间：

use std::time::{SystemTime, UNIX_EPOCH};

pub trait TimeProvider {
    fn get_current_unix_time(&self) -> u64;
}

2. 生产环境的系统时间实现 #

写一个生产用的实现，调用系统真实时间：

pub struct SystemTimeProvider;

impl TimeProvider for SystemTimeProvider {
    fn get_current_unix_time(&self) -> u64 {
        SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .expect("System time before Unix epoch")
            .as_secs()
    }
}

3. 业务代码依赖Trait而非具体实现 #

在业务逻辑里，通过Trait获取时间，比如把TimeProvider作为结构体字段，或者用全局默认实例（可借助once_cell或lazy_static初始化）：

// 业务结构体，依赖TimeProvider
pub struct BusinessLogic<T: TimeProvider> {
    time_provider: T,
    // 其他业务字段
}

impl<T: TimeProvider> BusinessLogic<T> {
    pub fn new(time_provider: T) -> Self {
        Self { time_provider }
    }

    // 业务方法，使用时间生成输出
    pub fn generate_output(&self) -> String {
        let current_time = self.time_provider.get_current_unix_time();
        format!("Output based on time: {}", current_time)
    }
}

// 生产环境提供默认构造函数，用SystemTimeProvider
impl BusinessLogic<SystemTimeProvider> {
    pub fn default() -> Self {
        Self::new(SystemTimeProvider)
    }
}

4. 测试环境的可控时间实现 #

写一个Mock实现，可以手动设置固定时间，甚至支持动态修改时间，满足不同测试场景：

#[cfg(test)]
pub struct MockTimeProvider {
    current_time: u64,
}

#[cfg(test)]
impl MockTimeProvider {
    pub fn new(fixed_time: u64) -> Self {
        Self { current_time: fixed_time }
    }

    // 可选：支持修改时间，模拟时间流逝
    pub fn set_time(&mut self, new_time: u64) {
        self.current_time = new_time;
    }
}

#[cfg(test)]
impl TimeProvider for MockTimeProvider {
    fn get_current_unix_time(&self) -> u64 {
        self.current_time
    }
}

5. 测试用例示例 #

测试时直接使用MockTimeProvider，完全控制时间：

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

    #[test]
    fn test_generate_output_with_fixed_time() {
        let mock_time = MockTimeProvider::new(1770000000);
        let logic = BusinessLogic::new(mock_time);
        assert_eq!(logic.generate_output(), "Output based on time: 1770000000");
    }

    #[test]
    fn test_generate_output_with_changed_time() {
        let mut mock_time = MockTimeProvider::new(1770000000);
        let mut logic = BusinessLogic::new(mock_time);
        assert_eq!(logic.generate_output(), "Output based on time: 1770000000");

        // 修改时间，验证输出变化
        logic.time_provider.set_time(1770000001);
        assert_eq!(logic.generate_output(), "Output based on time: 1770000001");
    }
}

额外补充：现成库替代 #

如果不想自己写这套抽象，也可以用现成的Rust库，比如：

• time 库提供了MockClock，可以全局替换系统时间
• chrono 生态下有chrono-mock这类扩展库，支持模拟时间

这种模式的好处：

• 业务代码完全干净，没有任何测试相关的条件编译标记
• 测试灵活性更高，不仅能固定时间，还能模拟时间推进
• 符合依赖倒置原则，代码扩展性更好，后续要换时间实现也不用改业务逻辑

内容的提问来源于stack exchange，提问作者Pawel Pabian bbkr