Struct mockito::Mock

pub struct Mock { /* private fields */ }

Stores information about a mocked request. Should be initialized via Server::mock().

Implementations

impl Mock

pub fn match_query<M: Into<Matcher>>(self, query: M) -> Self

Allows matching against the query part when responding with a mock.

Note that you can also specify the query as part of the path argument in a mock call, in which case an exact match will be performed. Any future calls of Mock#match_query will override the query matcher.

Example

use mockito::Matcher;

let mut s = mockito::Server::new();

// This will match requests containing the URL-encoded
// query parameter `greeting=good%20day`
let _m1 = s.mock("GET", "/test")
  .match_query(Matcher::UrlEncoded("greeting".into(), "good day".into()))
  .create();

// This will match requests containing the URL-encoded
// query parameters `hello=world` and `greeting=good%20day`
let _m2 = s.mock("GET", "/test")
  .match_query(Matcher::AllOf(vec![
    Matcher::UrlEncoded("hello".into(), "world".into()),
    Matcher::UrlEncoded("greeting".into(), "good day".into())
  ]))
  .create();

// You can achieve similar results with the regex matcher
let _m3 = s.mock("GET", "/test")
  .match_query(Matcher::Regex("hello=world".into()))
  .create();

pub fn match_header<M: Into<Matcher>>(self, field: &str, value: M) -> Self

Allows matching a particular request header when responding with a mock.

When matching a request, the field letter case is ignored.

Example

let mut s = mockito::Server::new();

let _m = s.mock("GET", "/").match_header("content-type", "application/json");

Like most other Mock methods, it allows chanining:

Example

let mut s = mockito::Server::new();

let _m = s.mock("GET", "/")
  .match_header("content-type", "application/json")
  .match_header("authorization", "password");

pub fn match_body<M: Into<Matcher>>(self, body: M) -> Self

Allows matching a particular request body when responding with a mock.

Example

let mut s = mockito::Server::new();

let _m1 = s.mock("POST", "/").match_body(r#"{"hello": "world"}"#).with_body("json").create();
let _m2 = s.mock("POST", "/").match_body("hello=world").with_body("form").create();

// Requests passing `{"hello": "world"}` inside the body will be responded with "json".
// Requests passing `hello=world` inside the body will be responded with "form".

// Create a temporary file
use std::env;
use std::fs::File;
use std::io::Write;
use std::path::Path;
use rand;
use rand::Rng;

let random_bytes: Vec<u8> = (0..1024).map(|_| rand::random::<u8>()).collect();

let mut tmp_file = env::temp_dir();
tmp_file.push("test_file.txt");
let mut f_write = File::create(tmp_file.clone()).unwrap();
f_write.write_all(random_bytes.as_slice()).unwrap();
let mut f_read = File::open(tmp_file.clone()).unwrap();


// the following are equivalent ways of defining a mock matching
// a binary payload
let _b1 = s.mock("POST", "/").match_body(tmp_file.as_path()).create();
let _b3 = s.mock("POST", "/").match_body(random_bytes).create();
let _b2 = s.mock("POST", "/").match_body(&mut f_read).create();

pub fn with_status(self, status: usize) -> Self

Sets the status code of the mock response. The default status code is 200.

Example

let mut s = mockito::Server::new();

let _m = s.mock("GET", "/").with_status(201);

pub fn with_header(self, field: &str, value: &str) -> Self

Sets a header of the mock response.

Example

let mut s = mockito::Server::new();

let _m = s.mock("GET", "/").with_header("content-type", "application/json");

pub fn with_body<StrOrBytes: AsRef<[u8]>>(self, body: StrOrBytes) -> Self

Sets the body of the mock response. Its Content-Length is handled automatically.

Example

let mut s = mockito::Server::new();

let _m = s.mock("GET", "/").with_body("hello world");

pub fn with_body_from_fn( self, callback: impl Fn(&mut dyn Write) -> Result<()> + Send + Sync + 'static ) -> Self

Sets the body of the mock response dynamically. The response will use chunked transfer encoding.

The function must be thread-safe. If it’s a closure, it can’t be borrowing its context. Use move closures and Arc to share any data.

Example

let mut s = mockito::Server::new();

let _m = s.mock("GET", "/").with_body_from_fn(|w| w.write_all(b"hello world"));

pub fn with_body_from_request( self, callback: impl Fn(&Request) -> Vec<u8> + Send + Sync + 'static ) -> Self

Sets the body of the mock response dynamically while exposing the request object.

You can use this method to provide a custom reponse body for every incoming request.

The function must be thread-safe. If it’s a closure, it can’t be borrowing its context. Use move closures and Arc to share any data.

Example

let mut s = mockito::Server::new();

let _m = s.mock("GET", mockito::Matcher::Any).with_body_from_request(|request| {
    if request.path() == "/bob" {
        "hello bob".into()
    } else if request.path() == "/alice" {
        "hello alice".into()
    } else {
        "hello world".into()
    }
});

pub fn with_body_from_file(self, path: impl AsRef<Path>) -> Self

Sets the body of the mock response from the contents of a file stored under path. Its Content-Length is handled automatically.

Example

let mut s = mockito::Server::new();

let _m = s.mock("GET", "/").with_body_from_file("tests/files/simple.http");

pub fn expect(self, hits: usize) -> Self

Sets the expected amount of requests that this mock is supposed to receive. This is only enforced when calling the assert method. Defaults to 1 request.

pub fn expect_at_least(self, hits: usize) -> Self

Sets the minimum amount of requests that this mock is supposed to receive. This is only enforced when calling the assert method.

pub fn expect_at_most(self, hits: usize) -> Self

Sets the maximum amount of requests that this mock is supposed to receive. This is only enforced when calling the assert method.

pub fn assert(&self)

Asserts that the expected amount of requests (defaults to 1 request) were performed.

pub async fn assert_async(&self)

Same as Mock::assert but async.

pub fn matched(&self) -> bool

Returns whether the expected amount of requests (defaults to 1) were performed.

pub async fn matched_async(&self) -> bool

Same as Mock::matched but async.

pub fn create(self) -> Mock

Registers the mock to the server - your mock will be served only after calling this method.

Example

let mut s = mockito::Server::new();

let _m = s.mock("GET", "/").with_body("hello world").create();

pub async fn create_async(self) -> Mock

Same as Mock::create but async.

Trait Implementations

impl Debug for Mock

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Mock

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for Mock

fn drop(&mut self)

Executes the destructor for this type.

impl PartialEq<Mock> for Mock

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.