Как издеваться над конкретными методами, но не всеми в 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, если сможете сделать это более эффективно.

Что делает настоящий ранд-ящик?

Реальный ранд-ящик использует две черты:

• 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.