具有默认实现的特质

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()输出，以在单元测试中使用合理的代码。有一篇不错的文章比较了different mocking libraries，得出的结论（非常可悲）是，它们中没有一个能与众不同。

在阅读这些库的说明时，我唯一了解到的是，我可以模拟方法的唯一方法是将它们移至特征。我在这些库中没有看到任何示例（我查看了其中的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进行的所有测试一次。

如何在Rust中模拟特定的方法，但不是全部？

2 个答案:

具有默认实现的特质

真正的兰特大包做什么？