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 庫允許開發人員隔離一個單元進行測試，進而可以控制單元依賴項的行爲，並使測試更加集中。在處理複雜系統或外部依賴時，模擬測試庫特別有用。

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/cUg3YibyUjT-iobb8h83iQ

猜你喜歡