Mry

一个简单但功能强大的模拟库，用于 结构体、特性 和 函数。

功能

• 一个真正简单易用的 API
• 支持结构体、特性和函数的模拟。
• 无需在模拟对象和真实对象之间切换。
• 支持部分模拟。

与 mockall 比较

Mry 的明显区别在于 API 简单且小巧，而且因为它仍在开发中，您会发现一些尚不支持的行为。此外，基于最小惊讶原则，mry 以最简单的方式解决了 mockall 的几个问题。

Mry 无 cfg

在 mockall 中，使用 #[double] 来切换真实和模拟的结构体。问题是 #[double] 使得模拟结构体适用于所有测试用例，因此当某些测试用例需要真实结构体时，尤其是测试结构体本身时，会变得很复杂。

在 mry 中，不需要 #[double] 或复杂的 use 策略。

Mry 不会引起数据竞争

在 mockall 中，您需要与静态函数和方法的模拟进行手动同步。问题是，如果您忘记加锁，结果将是不可预测的，并且难以调试。

在 mry 中，有一个管理的同步机制，如果您忘记它，您会得到一个错误，告诉您需要它。

示例

#[mry::mry]
struct Cat {
    name: String,
}

#[mry::mry]
impl Cat {
    fn meow(&self, count: usize) -> String {
        format!("{}: {}", self.name, "meow".repeat(count))
    }
}

#[test]
fn meow_returns() {
    let mut cat = mry::new!(Cat { name: "Tama".into() });

    let mock_meow = cat.mock_meow(mry::Any).returns("Called".to_string());

    assert_eq!(cat.meow(2), "Called".to_string());

    mock_meow.assert_called(1);
}

如何模拟方法或函数

步骤1. 创建方法或函数的模式

a. 如果你有一个模拟对象 cat：你可以通过调用 cat.mock_meow 并为每个参数提供一个匹配器来为名为 meow 的方法创建一个模式。

// If you mock a struct called `Cat`
let mut cat = mry::new!(Cat { name: "Tama".into() });
// If you mock a trait called `Cat`
let mut cat = MockCat::default();

cat.mock_meow(mry::Any) // Any value can be matched
cat.mock_meow(3) // matched with 3

b. 如果你模拟一个名为 new 的关联函数，该函数属于结构体 Cat，你可以使用 Cat::mock_new 来创建一个模式。

Cat::mock_new(mry::Any)

c. 如果你模拟一个名为 hello 的函数，你可以使用 mock_hello 来创建一个模式。

mock_hello(mry::Any)

[!NOTE] 你可以为同一个方法或函数创建多个模式，并且它们会按照创建的顺序进行匹配。

第二步。为模式设置预期行为

在模式之后，你可以链接着以下之一来设置预期行为。

• returns(value) - 总是返回一个值。该值必须实现 Clone 以便多次返回。
• returns_once(value) - 只返回一次值。无需实现 Clone。
• returns_with(closure) - 通过一个接收参数的闭包返回一个动态值。输出不需要实现 Clone。
• calls_real_impl() - 调用方法或函数的真实实现。用于部分模拟。

cat.mock_meow(3).returns("Called with 3".into());
Cat::mock_new(mry::Any).returns(cat);
mock_hello(mry::Any).returns("World".into());

(可选) 第三步。断言模式按预期次数调用

你可以调用 assert_called 来断言模式按预期次数调用。

cat.mock_meow(3).returns("Returns this string when called with 3".into());

assert_eq!(cat.meow(3), "Returns this string when called with 3".to_string());

cat.mock_meow(3).assert_called(1);

此外，你还可以对特定的模式进行计数。

cat.mock_meow(mry::Any).returns("Called".into());

assert_eq!(cat.meow(1), "Called".to_string());
assert_eq!(cat.meow(2), "Called".to_string());
assert_eq!(cat.meow(3), "Called".to_string());

cat.mock_meow(mry::Any)..assert_called(3);
// specific pattern
cat.mock_meow(2).assert_called(1);

如果你想断言与行为设置相同的模式，你可以绑定设置的结果并对其调用 assert_called。

let mock_meow = cat.mock_meow(3).returns("Called".to_string());

assert_eq!(cat.meow(3), "Called".to_string());

mock_meow.assert_called(1);

基本用法

模拟结构体

我们需要在结构体定义和实现块前面添加一个属性 #[mry::mry] 来模拟它们。

#[mry::mry] // This
struct Cat {
    name: &'static str,
}

#[mry::mry] // And this
impl Cat {
    fn meow(&self, count: usize) -> String {
        format!("{}: {}", self.name, "meow".repeat(count))
    }
}

#[mry::mry] 向你的结构体添加了一个可见但虚幻的字段 mry，因此你的结构体必须通过以下方式构造。

// An easy way
mry::new!(Cat { name: "Tama" })

// is equivalent to:
Cat {
    name: "Tama",
    mry: Default::default(),
};

// If you derive or impl Default trait.
Cat::default();
// or
Cat { name: "Tama", ..Default::default() };

[!IMPORTANT] 在发布构建时，你的结构体的 mry 字段将为零大小，并且 mock_* 函数将不可用。

#[mry::mry]
impl Cat {
    fn meow(&self, count: usize) -> String {
        self.meow_single().repeat(count)
    }

    fn meow_single(&self) -> String {
        "meow".into()
    }
}

#[test]
fn partial_mock() {
    let mut cat: Cat = Cat {
        name: "Tama".into(),
        ..Default::default()
    };

    cat.mock_meow_single().returns("hello".to_string());

    cat.mock_meow(mry::Any).calls_real_impl();

    // not "meowmeow"
    assert_eq!(cat.meow(2), "hellohello".to_string());
}

#[mry::mry]
pub trait Cat {
    fn meow(&self, count: usize) -> String;
}

// You can construct it by Default trait
let mut cat = MockCat::default();

// API's are the same as the struct mocks.
cat.mock_meow(2).returns("Called with 2".into());

assert_eq!(cat.meow(2), "Called with 2".to_string());

#[mry::mry]
fn hello(count: usize) -> String {
    "hello".repeat(count)
}

#[test]
#[mry::lock(hello)] // This is required!
fn function_keeps_original_function() {
    // Usage is the same as the struct mocks.
    mock_hello(Any).calls_real_impl();

    assert_eq!(hello(3), "hellohellohello");
}

#[mry::mry]
struct Cat {}

#[mry::mry]
impl Cat {
    fn meow(count: usize) -> String {
        "meow".repeat(count)
    }
}

#[test]
#[mry::lock(Cat::meow)] // This is required!
fn meow_returns() {
    // Usage is the same as the struct mocks.
    Cat::mock_meow(Any).returns("Called".to_string());

    assert_eq!(Cat::meow(2), "Called".to_string());
}

#[mry::mry]
pub trait Cat {
    async fn meow(&self, count: usize) -> String;
}

#[trait_variant::make(Cat: Send)]
#[mry::mry]
pub trait LocalCat {
    async fn meow(&self) -> String;
}

let mut cat = MockLocalCat::default();
cat.mock_meow().returns("Called".to_string());

let mut cat = MockCat::default();
cat.mock_meow().returns("Called".to_string());

#[mry::mry]
#[async_trait::async_trait]
pub trait Cat {
    async fn meow(&self, count: usize) -> String;
}

#[mry::mry]
impl Into<&'static str> for Cat {
    fn into(self) -> &'static str {
        self.name
    }
}

#[mry::mry]
#[derive(Default)]
struct MockIterator {}

#[mry::mry]
impl Iterator for MockIterator {
    type Item = u8;

    fn next(&mut self) -> Option<Self::Item> {
        todo!()
    }
}