如何在 Rust 中模拟特定方法而不是所有方法？

Question

我在确定目标结构的方法的单元测试时遇到了麻烦。

我有一个方法

random_number

，它根据结构体的属性返回一个随机值，还有另一个方法

plus_one

，它获取第一个方法的结果并用它做一些事情：

pub struct RngTest {
    pub attr: u64,
}

impl RngTest {
    pub fn random_number(&self) -> u64 {
        let random = 42; // lets pretend it is random
        return random * self.attr;
    }

    pub fn plus_one(&self) -> u64 {
        return self.random_number() + 1;
    }
}

对第一个方法进行了单元测试，测试另一个方法的策略是什么？我想模拟

self.random_number()

单元测试的

plus_one()

输出，以便在单元测试中拥有健全的代码。有一篇很好的文章比较了不同的模拟库并得出结论（遗憾的是）它们中没有一个能够真正脱颖而出。

在阅读这些库的说明时我学到的唯一一件事是，我模拟方法的唯一方法是将它们移动到一个特征。我在这些库中没有看到任何测试与此类似的案例的示例（我查看了其中的 4 个或 5 个）。

将这些方法移至特征后（即使它们是），我如何模拟

random_number

对

RngTest::plus_one

的输出进行单元测试？

pub trait SomeRng {
    fn random_number(&self) -> u64 {
        let random = 42; // lets pretend it is random
        return random * self.attr;
    }

    fn plus_one(&self) -> u64 {
        return self.random_number() + 1;
    }
}

impl SomeRng for RngTest {}

Answer 1

如何在 Rust 中模拟特定方法而不是所有方法？

正如您已经了解到的，您无法替换类型上的方法。您唯一能做的就是将方法移至特征，然后提供该特征的特定于生产和测试的实现。您构建特征的方式决定了您能够测试的粒度。

具有默认实现的特征

根据您的用例，您也许可以使用默认实现：

trait SomeRng {
    fn random_number(&self) -> u64;

    fn plus_one(&self) -> u64 {
        self.random_number() + 1
    }
}

struct RngTest(u64);
impl SomeRng for RngTest {
    fn random_number(&self) -> u64 {
        self.0
    }
}

#[test]
fn plus_one_works() {
    let rng = RngTest(41);
    assert_eq!(rng.plus_one(), 42);
}

这里，

random_number

是必需的方法，但

plus_one

有一个默认实现。默认情况下，实现

random_number

会为您提供

plus_one

。如果您可以更有效地完成，您也可以选择实施

plus_one

。

真正的兰特箱子有什么作用？

真正的rand crate使用两个特征：

• Rng

  pub trait Rng: RngCore { /* ... */ }
  

  RngCore

  上自动实现的扩展特征，为采样值和其他便捷方法提供高级通用方法。

• RngCore

  pub trait RngCore { /* ... */ }
  

  随机数生成器的核心。

这将实现的核心有趣部分与辅助方法分开。然后您可以控制核心并测试助手：

trait SomeRngCore {
    fn random_number(&self) -> u64;
}

trait SomeRng: SomeRngCore {
    fn plus_one(&self) -> u64 {
        self.random_number() + 1
    }
}

impl<R: SomeRngCore> SomeRng for R {}

struct RngTest(u64);
impl SomeRngCore for RngTest {
    fn random_number(&self) -> u64 {
        self.0
    }
}

#[test]
fn plus_one_works() {
    let rng = RngTest(41);
    assert_eq!(rng.plus_one(), 42);
}

Answer 2

感谢@Shepmaster，我找到了这个解决方法。我添加了实际的

Rng

以获取更多上下文。

use rand::{thread_rng, Rng}; // 0.6.5

struct RngTest(Vec<u64>);

impl RngTest {
    fn random_number(&self) -> u64 {
        let random_value = thread_rng().choose(&self.0);
        *random_value.unwrap()
    }

    fn plus_one(&self) -> u64 {
        self.random_number() + 1
    }
}

#[test]
fn plus_one_works() {
    let rng = RngTest(vec![1]);
    assert_eq!(rng.plus_one(), 2);
}

我可以在对象中设置适当的值，而不需要使用特征。但这有一个缺点 - 这迫使我为这个特定的测试拥有一个我的类型的特殊实例，我想避免它，因为我的实际类型有很多的字段，并且我想为所有测试定义一次它的创建使用

speculate

。

Answer 3

您可以使用 create mockall 来定义真正的

mock

（更灵活），而不是像 Shepmaster 在他们的答案中那样定义 stub 。你仍然必须遵循 Shepmaster 提议的结构 + 特征模式：

pub struct RngTest {
    pub attr: u64,
}

trait SomeRng {
    fn random_number(&self) -> u64;

    fn plus_one(&self) -> u64 {
        self.random_number() + 1
    }
}

// Your real implementation
impl SomeRng for RngTest {
    fn random_number(&self) -> u64 {
        42
    }
}


// Test part

mock! {
    SomeRngForTest {}
    impl SomeRng for SomeRngForTest {
        fn random_number(&self) -> u64;
    }
}


mod rngtest {
    use super::{SomeRng, MockSomeRngForTest};

    #[test]
    fn test() {
        let mut mock = MockSomeRngForTest::new();
        mock.expect_random_number().return_const(100u64);

        assert_eq!(mock.plus_one(), 101);
    }
}

参见：https://docs.rs/mockall/latest/mockall/