Rust单元测试中如何Mock标准库组件？以Command为例

一、优化依赖注入的繁琐感 #

依赖注入是Rust生态下Mock这类组件的主流方案，但可以通过最小化Trait定义+条件编译大幅降低代码侵入性：

• 只定义业务代码实际用到的方法，不用复刻std::process::Command的全部API；
• 用#[cfg_attr(test, ...)]让Mock相关代码仅在测试编译时生效，避免污染主逻辑。

示例代码：

// src/main.rs
use std::process::{Command, Output};

// 仅保留业务需要的方法，测试时才生成Mock
#[cfg_attr(test, mockall::automock)]
pub trait CommandRunner {
    fn args(&mut self, args: impl IntoIterator<Item = impl AsRef<str>>) -> &mut Self;
    fn output(&mut self) -> std::io::Result<Output>;
}

// 给真实Command实现Trait
impl CommandRunner for Command {
    fn args(&mut self, args: impl IntoIterator<Item = impl AsRef<str>>) -> &mut Self {
        Command::args(self, args)
    }

    fn output(&mut self) -> std::io::Result<Output> {
        Command::output(self)
    }
}

// 业务代码依赖Trait而非具体类型
pub fn run_my_command(mut runner: impl CommandRunner) -> Output {
    runner.args(["--flag", "1"]).output().unwrap()
}

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

    #[test]
    fn test_command_calls() {
        let mut mock = MockCommandRunner::new();
        // 断言args被调用1次，参数匹配
        mock.expect_args()
            .with(eq(vec!["--flag".to_string(), "1".to_string()]))
            .times(1)
            .returning(|_| &mut mock);
        // 断言output被调用1次
        mock.expect_output()
            .times(1)
            .returning(|| Ok(Output {
                status: Default::default(),
                stdout: vec![],
                stderr: vec![],
            }));

        run_my_command(mock);
    }
}

二、轻量级Mock库替代mockall #

如果觉得mockall太重，可以选择更聚焦CLI场景的轻量库：

• fake_cli：专门为Mock CLI命令设计，API简洁，无需手动定义Trait，直接创建Mock对象并断言调用：

use fake_cli::MockCommand;

#[test]
fn test_command() {
    let mut cmd = MockCommand::new();
    cmd.expect_args(["--flag", "1"]).times(1);
    cmd.expect_output().returns(Ok(Default::default())).times(1);

    run_my_command(cmd);
}

三、标准库手动实现Mock（无外部依赖） #

如果不想引入任何第三方库，可以自己编写极简Mock结构体，手动记录调用情况：

// src/main.rs
use std::process::Output;

pub trait CommandRunner {
    fn args(&mut self, args: Vec<&str>) -> &mut Self;
    fn output(&mut self) -> std::io::Result<Output>;
}

// 真实Command的Trait实现
impl CommandRunner for std::process::Command {
    fn args(&mut self, args: Vec<&str>) -> &mut Self {
        self.args(args)
    }
    fn output(&mut self) -> std::io::Result<Output> {
        self.output()
    }
}

// 测试专属Mock结构体
#[cfg(test)]
pub struct MockCommand {
    args_calls: Vec<Vec<&'static str>>,
    output_calls: usize,
    output_result: std::io::Result<Output>,
}

#[cfg(test)]
impl MockCommand {
    pub fn new(output_result: std::io::Result<Output>) -> Self {
        Self {
            args_calls: vec![],
            output_calls: 0,
            output_result,
        }
    }

    // 自定义断言方法
    pub fn assert_args_called_once(&self, expected: Vec<&'static str>) {
        assert_eq!(self.args_calls.len(), 1);
        assert_eq!(self.args_calls[0], expected);
    }

    pub fn assert_output_called_once(&self) {
        assert_eq!(self.output_calls, 1);
    }
}

#[cfg(test)]
impl CommandRunner for MockCommand {
    fn args(&mut self, args: Vec<&str>) -> &mut Self {
        self.args_calls.push(args.iter().map(|s| *s).collect());
        self
    }

    fn output(&mut self) -> std::io::Result<Output> {
        self.output_calls += 1;
        self.output_result.clone()
    }
}

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

    #[test]
    fn test_command_calls() {
        let output = Output {
            status: Default::default(),
            stdout: vec![],
            stderr: vec![],
        };
        let mut mock = MockCommand::new(Ok(output));

        run_my_command(&mut mock);

        mock.assert_args_called_once(vec!["--flag", "1"]);
        mock.assert_output_called_once();
    }
}

四、关于Rust中猴子补丁的说明 #

Rust是静态编译语言，没有Ruby/Python那样的动态猴子补丁机制（强行用nightly特性+unsafe实现会破坏类型安全，不推荐）。因此依赖注入+Mock Trait是Rust生态下最符合语言设计的方案，通过上述优化可以大幅降低繁琐感。

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