Mockall具有丰富的功能集和简洁的人体工程学API。Mockall是安全稳定的，因为它100%是用Rust编写的。
通常，Mockall仅用于单元测试，这里有一个使用Mockall的例子：
#[cfg(test)]
use mockall::{automock, mock, predicate::*};
#[cfg_attr(test, automock)]
trait MyTrait {
fn foo(&self, x: u32) -> u32;
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn mytest() {
let mut mock = MockMyTrait::new();
mock.expect_foo()
.with(eq(4))
.times(1)
.returning(|x| x + 1);
assert_eq!(5, mock.foo(4));
}
}Mockers的灵感来自于Google的C语言Mock库，Mockers具有高效的语法。Mockers使用Scenario对象来创建和控制模拟对象。
这里有一个使用Mockers的例子：
mod test {
#[cfg(test)]
use mockers::Scenario;
#[cfg(test)]
use mockers_derive::mocked;
#[cfg_attr(test, mocked)]
trait MyTrait {
fn do_something(&self, x: i32) -> i32;
}
// 定义一个使用trait的函数
fn my_function(obj: &dyn MyTrait, x: i32) -> i32 {
obj.do_something(x)
}
// 编写一个使用模拟对象的测试
#[test]
fn test_my_function() {
// 创建一个新的模拟对象和scenario
let scenario = Scenario::new();
let (my_mock, my_mock_handle) = Scenario::create_mock_for::<dyn MyTrait>(&scenario);
// 定义模拟对象的预期行为
scenario.expect( my_mock_handle.do_something(10).and_return(42) );
// 验证是否按预期调用了模拟对象
assert_eq!(42, my_function(&my_mock, 10) );
}
}mock_derived是一个易于设置的、丰富的Rust编程语言模拟库。
下面是一个使用Mock Derive进行模拟的例子：
use mock_derive::mock;
// 定义一个我们想要模拟的特征
#[mock]
trait MyTrait {
fn do_something(&self) -> i32;
}
// 编写一个使用模拟对象的测试
#[test]
fn test_my_function() {
// 创建模拟对象的新实例
let mut mock = MockMyTrait::new();
// 在模拟对象上设置期望
mock.method_do_something()
.first_call()
.set_result(32);
// 将模拟对象注入被测函数
let result = mock.do_something();
// 验证是否按预期调用了模拟对象
assert_eq!(result, 32);
}galvanic-mock是一个行为驱动的mock库。它是galvanic-test和galvanic-assert测试库的一部分。
Galvanic Mock能实现以下任务：- 从一个或多个特征创建模拟对象
这里有一个用Galvanic Mock进行mocking的例子：
extern crate galvanic_mock;
use galvanic_mock::{mockable, use_mocks};
#[mockable]
trait MyTrait {
fn do_something(&self, x: i32) -> i32;
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
#[use_mocks]
fn simple_mock_usage() {
// 创建一个新的对象
let mock = new_mock!(MyTrait);
// 为模拟对象定义行为
given! {
<mock as MyTrait>::do_something( |&x| x < 0 ) then_return_from |&(x,)| x - 1 always;
<mock as MyTrait>::do_something( |&x| x > 0 ) then_return_from |&(x,)| x + 1 always;
<mock as MyTrait>::do_something( |&x| x == 0 ) then_return 0 always;
}
// 匹配第一个行为
assert_eq!(mock.do_something(4), 5);
// 匹配第二个行为
assert_eq!(mock.do_something(-1), -2);
// 匹配最后的行为
assert_eq!(mock.do_something(0), 0);
}
}Pseudo是一个小型模拟库。它提供了你所需要的mocking，仅此而已。下面是一些你可以用Pseudo做的事情：- 模拟trait实现
下面是一个使用Pseudo进行mocking的例子：
extern crate pseudo;
use pseudo::Mock;
// 定义我们想要模拟的trait
trait MyTrait: Clone {
fn do_something(&self, x: i32) -> i32;
}
// 使用trait创建一个模拟struct
#[derive(Clone)]
struct MockMyTrait {
pub do_something: Mock<(i32,), i32>,
}
// 为模拟struct实现trait
impl MyTrait for MockMyTrait {
fn do_something(&self, x: i32) -> i32 {
self.do_something.call((x,))
}
}
fn function_to_test <T: MyTrait> (my_trait: &T, x: i32) -> i32 {
my_trait.do_something(x)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn doubles_return_value() {
let mock = MockMyTrait { do_something: Mock::default() };
mock.do_something.return_value(2);
assert_eq!(function_to_test(&mock, 1), 2);
}
#[test]
fn uses_correct_args() {
let mock = MockMyTrait { do_something: Mock::default() };
assert!(!mock.do_something.called());
function_to_test(&mock, 1);
assert_eq!(mock.do_something.num_calls(), 1);
assert!(mock.do_something.called_with((1,)));
}
}Wiremock为与HTTP api交互的应用程序提供模拟服务。使用Wiremock，你可以创建用于测试的模拟HTTP服务器。
Wiremock使用请求匹配和响应模板技术模拟HTTP响应。请求匹配检查传入请求是否满足指定条件，响应模板有助于生成API响应的内容。
下面是一个用Wiremock进行mocking的例子：
#[cfg(test)]
mod test {
use wiremock::{MockServer, Mock, ResponseTemplate};
use wiremock::matchers::{method, path};
#[tokio::main]
#[test]
async fn hello() {
// 在本地随机端口上启动模拟HTTP服务器
let mock_server = MockServer::start().await;
// 设置模拟服务器的行为
Mock::given(method("GET"))
.and(path("/hello"))
// 当它接收到'/hello'的GET请求时，以200状态响应。
.respond_with(ResponseTemplate::new(200))
// 将行为挂载到模拟服务器上
.mount(&mock_server)
.await;
// 用任何HTTP客户机测试模拟服务器，看看它的行为是否符合预期
let status = surf::get(format!("{}/hello", &mock_server.uri()))
.await
.unwrap()
.status();
assert_eq!(status as u16, 200);
}
#[tokio::main]
#[test]
async fn missing_route_returns_404() {
let mock_server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/hello"))
.respond_with(ResponseTemplate::new(200))
.mount(&mock_server)
.await;
// 测试模拟服务器未注册的路由，它按预期返回状态404。
let status = surf::get(format!("{}/missing", &mock_server.uri()))
.await
.unwrap()
.status();
assert_eq!(status as u16, 404);
}
}Faux允许你创建struct的模拟版本，而不会使代码复杂化。与许多mock库一样，faux仅推荐用于测试目的。生产中的模拟对象可能不稳定，并导致生产问题。
Faux库只模拟结构体的公共方法。该库不模拟任何私有方法或字段。
下面是一个用Faux进行mocking的例子：
#[cfg(test)]
#[faux::create]
pub struct MyStruct { }
// ' faux::methods '使' MyStruct '的所有公共方法都是可mock的
#[cfg(test)]
#[faux::methods]
impl MyStruct {
pub fn do_something(&self, x: usize) -> String {
"Result of doing something".to_string()
}
}
mod test {
use super::*;
#[test]
fn it_works() {
// create mock version of MyStruct with `faux` method
let mut mock = MyStruct::faux();
// 只在参数为3时模拟取值
faux::when!(mock.do_something(3))
.then_return( "A third string".to_string() );
assert_eq!(mock.do_something(3), "A third string".to_string() );
}
}Unimock是一种不同类型的模拟库。与其他库不同，Unimock使用相同的类型实现所有生成的模拟对象。与其他库相比，该方法在测试中具有更好的灵活性和效率。
让我们看一个例子，看看mock是如何在Unimock中工作的：
use unimock::{MockFn, matching, Unimock, unimock};
// 创建一个模拟版本的“MyTrait”
#[unimock(api=MockMyTrait)]
trait MyTrait {
fn do_something(&self) -> i32;
}
// 编写要测试的函数
fn test_me(mock: impl MyTrait) -> i32 {
mock.do_something()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_function_works() {
// 为“MockMyTrait.do_something”编写一个行为
let clause = MockMyTrait::do_something
.each_call(matching!())
.returns(1337);
// 初始化模拟对象
let mock = Unimock::new(clause);
assert_eq!(1337, test_me(mock));
}
}Mry允许你轻松地为单元测试创建模拟对象，可以将Mry与任何Rust测试框架集成。包括内建测试框架(cargo test)。
Mry是一个易于使用的库。它提供了一个简单的API来构造模拟对象。下面是一个用Mry进行mocking的例子：
#[mry::mry]
struct MyStruct {}
#[mry::mry]
impl MyStruct {
fn do_something(&self, count: usize) -> String {
format!("The trait says {}", count)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn meow_returns() {
// 从“MyStruct”初始化模拟对象
let mut mock = mry::new!( MyStruct{} );
// 为模拟对象构造一个行为
mock.mock_do_something(mry::Any)
.returns( "Called".to_string() );
// 测试模拟对象的行为
assert_eq!(mock.do_something(2), "Called".to_string());
}
}Mock库允许开发人员隔离一个单元进行测试，进而可以控制单元依赖项的行为，并使测试更加集中。在处理复杂系统或外部依赖时，模拟测试库特别有用。
Copyright© 2013-2020
All Rights Reserved 京ICP备2023019179号-8