Unit testing 如何模拟特定的方法，但不是所有的生锈？

我很难为目标结构的方法进行单元测试

我有一个方法

random\u number

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

加上\u 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\u number（）

的单元测试的输出加上一个（），以便在单元测试中拥有健全的代码。有一篇很好的帖子比较并得出结论（很遗憾），没有一篇文章真的能从其他文章中脱颖而出

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

在将这些方法移动到一个trait（即使是这样）之后，如何模拟

随机数

，对

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 {}

如何模拟特定的方法，但不是所有的生锈

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

带有默认实现的Trait 根据您的用例，您可能能够使用默认实现：

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\u number

是必需的方法，但是

plus\u one

有一个默认实现。实现

random\u number

在默认情况下为您提供

加1

。如果可以更有效地实现，您还可以选择实现

加上一个

真正的兰德板条箱是做什么的？
雷亚尔人有两个特点：



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);
}

trait SomeRngCore{
fn随机数（&self）->u64；
}
特征：一些核心{
fn plus_one（&self）->u64{
自身随机数（）+1
}
}
R{}的impl SomeRng
结构RngTest（u64）；
为RngTest安装一些RNGCore{
fn随机数（&self）->u64{
self.0
}
}
#[测试]
fn加上一个工程（）{
设rng=RngTest（41）；
断言（rng.plus_one（），42）；
}

如何模拟特定的方法，但不是所有的生锈

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

带有默认实现的Trait
根据您的用例，您可能能够使用默认实现：

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\u number
是必需的方法，但是
plus\u one
有一个默认实现。实现
random\u number
在默认情况下为您提供
加1
。如果可以更有效地实现，您还可以选择实现
加上一个

真正的兰德板条箱是做什么的？
雷亚尔人有两个特点：



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);
}

trait SomeRngCore{
fn随机数（&self）->u64；
}
特征：一些核心{
fn plus_one（&self）->u64{
自身随机数（）+1
}
}
R{}的impl SomeRng
结构RngTest（u64）；
为RngTest安装一些RNGCore{
fn随机数（&self）->u64{
self.0
}
}
#[测试]
fn加上一个工程（）{
设rng=RngTest（41）；
断言（rng.plus_one（），42）；
}
多亏了@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);
}

使用rand:：{thread\u rng，rng}；//0.6.5
结构RngTest（Vec）；
安装测试{
fn随机数（&self）->u64{
让random_value=thread_rng（）。选择（&self.0）；
*随机_值。展开（）
}
fn plus_one（&self）->u64{
自身随机数（）+1
}
}
#[测试]
fn加上一个工程（）{
设rng=RngTest（vec！[1]）；
断言（rng.plus_one（），2）；
}

我可以在对象中设置适当的值，而不需要使用traits。不过也有一个缺点——这迫使我在这个特定的测试中使用我的类型的一个特殊实例，我想避免使用这个实例，因为我的实际类型有很多字段，我想使用
推测
为所有测试定义一次它的创建，多亏了@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);
}

使用rand:：{thread\u rng，rng}；//0.6.5
结构RngTest（Vec）；
安装测试{
fn随机数（&self）->u64{
让random_value=thread_rng（）。选择（&self.0）；
*随机_值。展开（）
}
fn plus_one（&self）->u64{
自身随机数（）+1
}
}
#[测试]
fn加上一个工程（）{
设rng=RngTest（vec！[1]）；
断言（rng.plus_one（），2）；
}

我可以在对象中设置适当的值，而不需要使用traits。不过也有一个缺点——这迫使我为这类文件创建一个特殊的实例