9个在Rust中用于Mock的测试库

1，Mackall

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

2，Mockers

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

3，mock_derive

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

4，Galvanic Mock

galvanic-mock是一个行为驱动的mock库。它是galvanic-test和galvanic-assert测试库的一部分。

Galvanic Mock能实现以下任务：- 从一个或多个特征创建模拟对象

• 根据模式为模拟对象定义行为
• 状态与模拟对象交互
• 模拟泛型特征和关联类型
• 模拟泛型特征方法
• 将你的测试与galvanic-test和galvanic-assert集成

这里有一个用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);
   }
}

5，Pseudo

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

6，Wiremock

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

7，Faux

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

8，Unimock

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

9，Mry

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库允许开发人员隔离一个单元进行测试，进而可以控制单元依赖项的行为，并使测试更加集中。在处理复杂系统或外部依赖时，模拟测试库特别有用。

本文由微信公众号coding到灯火阑珊原创，哈喽比特收录。
文章来源：https://mp.weixin.qq.com/s/cUg3YibyUjT-iobb8h83iQ