Rust中如何隔离依赖结构体，独立测试目标结构体？

从Python转Rust确实会遇到类型系统带来的差异，要实现单元测试的依赖隔离，核心思路是通过Trait抽象来解耦具体类型，再结合Mock或自定义测试类型验证逻辑。下面针对你的场景给出具体实现方式：

1. 抽象Trait解耦依赖 #

首先给Person的核心行为定义一个Trait，让Company依赖这个Trait而非具体的Person结构体：

// src/person.rs
pub trait CanAge {
    fn get_older(&mut self, by_how_much: i16);
}

pub struct Person {
    pub age: i16,
}

impl CanAge for Person {
    fn get_older(&mut self, by_how_much: i16) {
        self.age += by_how_much;
    }
}

2. 两种依赖注入方式 #

方式一：泛型静态分发（推荐，性能更优） #

修改Company为泛型结构体，约束泛型参数实现CanAge：

// src/company.rs
use crate::person::CanAge;

pub struct Company<C: CanAge> {
    pub ceo: C,
}

impl<C: CanAge> Company<C> {
    pub fn celebrate_ceos_birthday(&mut self) {
        self.ceo.get_older(1);
    }
}

测试时自定义Mock类型实现CanAge，验证方法调用：

// 在src/company.rs中添加测试模块
#[cfg(test)]
mod tests {
    use super::*;
    use crate::person::CanAge;

    // 自定义Mock类型，记录调用次数和参数
    struct MockPerson {
        called_count: u32,
        last_increment: i16,
    }

    impl CanAge for MockPerson {
        fn get_older(&mut self, by_how_much: i16) {
            self.last_increment = by_how_much;
            self.called_count += 1;
        }
    }

    #[test]
    fn celebrate_birthday_calls_get_older_with_1() {
        let mut mock_ceo = MockPerson { called_count: 0, last_increment: 0 };
        let mut company = Company { ceo: mock_ceo };

        company.celebrate_ceos_birthday();

        assert_eq!(company.ceo.called_count, 1);
        assert_eq!(company.ceo.last_increment, 1);
    }
}

方式二：动态分发（适用多类型场景） #

如果需要在运行时切换不同的实现，用Box<dyn CanAge>实现动态分发，解决你遇到的"大小未知"问题：

// src/company.rs
use crate::person::CanAge;

pub struct Company {
    pub ceo: Box<dyn CanAge>,
}

impl Company {
    pub fn celebrate_ceos_birthday(&mut self) {
        self.ceo.get_older(1);
    }
}

测试时同样使用自定义Mock：

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

    struct MockPerson {
        called_count: u32,
    }

    impl CanAge for MockPerson {
        fn get_older(&mut self, by_how_much: i16) {
            assert_eq!(by_how_much, 1);
            self.called_count += 1;
        }
    }

    #[test]
    fn test_dynamic_mock() {
        let mut mock_ceo = Box::new(MockPerson { called_count: 0 });
        let mut company = Company { ceo: mock_ceo };

        company.celebrate_ceos_birthday();

        assert_eq!(company.ceo.called_count, 1);
    }
}

3. 使用mockall框架简化Mock #

如果你不想手动写Mock类型，可以用mockall自动生成：

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

[dev-dependencies]
mockall = "0.11"

2. 给Trait添加#[automock]宏：

// src/person.rs
use mockall::automock;

#[automock]
pub trait CanAge {
    fn get_older(&mut self, by_how_much: i16);
}

// 原Person实现不变

3. 测试时直接用自动生成的MockCanAge：

#[cfg(test)]
mod tests {
    use super::*;
    use crate::person::{CanAge, MockCanAge};
    use mockall::predicate::eq;

    #[test]
    fn test_with_mockall() {
        let mut mock_ceo = MockCanAge::new();
        // 预期get_older被调用1次，参数为1
        mock_ceo.expect_get_older()
            .with(eq(1))
            .times(1)
            .return_const(());

        let mut company = Company { ceo: mock_ceo };
        company.celebrate_ceos_birthday();
    }
}

关于测试思路的调整 #

Rust的类型系统要求显式抽象，这和Python的鸭子类型Mock差异很大。如果依赖的类型逻辑简单（比如你的Person），其实也可以直接用真实类型测试——单元测试的隔离原则不是绝对的，要权衡实现成本和测试价值。但当依赖逻辑复杂或有外部交互时，Trait抽象+Mock就是标准解法。

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