Struct wiremock::Mock

pub struct Mock { /* fields omitted */ }

Given a set of matchers, a Mock instructs an instance of MockServer to return a pre-determined response if the matching conditions are satisfied.

Mocks have to be mounted (or registered) with a MockServer to become effective.

Example (using register):

use wiremock::{MockServer, Mock, ResponseTemplate};
use wiremock::matchers::method;

#[async_std::main]
async fn main() {
    // Arrange
    let mock_server = MockServer::start().await;

    let response = ResponseTemplate::new(200);

    let mock = Mock::given(method("GET")).respond_with(response.clone());
    // Registering the mock with the mock server - it's now effective!
    mock_server.register(mock).await;

    // We won't register this mock instead.
    let unregistered_mock = Mock::given(method("GET")).respond_with(response);
     
    // Act
    let status = surf::get(&mock_server.uri())
        .await
        .unwrap()
        .status();
    assert_eq!(status.as_u16(), 200);

    // This would have matched `unregistered_mock`, but we haven't registered it!
    // Hence it returns a 404, the default response when no mocks matched on the mock server.
    let status = surf::post(&mock_server.uri())
        .await
        .unwrap()
        .status();
    assert_eq!(status.as_u16(), 404);
}

Example (using mount):

If you prefer a fluent style, you can use the mount method on the Mock itself instead of register.

use wiremock::{MockServer, Mock, ResponseTemplate};
use wiremock::matchers::method;

#[async_std::main]
async fn main() {
    // Arrange
    let mock_server = MockServer::start().await;

    Mock::given(method("GET"))
        .respond_with(ResponseTemplate::new(200))
        // Mounting the mock on the mock server - it's now effective!
        .mount(&mock_server)
        .await;
     
    // Act
    let status = surf::get(&mock_server.uri())
        .await
        .unwrap()
        .status();
    assert_eq!(status.as_u16(), 200);
}

Both register and mount are asynchronous methods - don't forget to .await them!

Methods

impl Mock

pub fn given<M: 'static + Match>(matcher: M) -> MockBuilder

Start building a Mock specifying the first matcher.

It returns an instance of MockBuilder.

pub async fn mount<'_>(self, server: &'_ MockServer)

Mount a Mock on an instance of MockServer.

Be careful! Mocks are not effective until they are mounted or registered on a MockServer.

mount is an asynchronous method, make sure to .await it!

pub fn response(&self) -> Response

Build an instance of http_types::Response from the ResponseTemplate associated with a Mock.

Trait Implementations

impl Debug for Mock

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

Formats the value using the given formatter.

impl Match for Mock

fn matches(&self, request: &Request) -> bool

Given a reference to a Request, determine if it should match or not given a specific criterion.