Struct wiremock::MockServer

pub struct MockServer { /* fields omitted */ }

An HTTP web-server running in the background to behave as one of your dependencies using Mocks for testing purposes.

Each instance of MockServer is fully isolated: start takes care of finding a random port available on your local machine which is assigned to the new MockServer.

Best practices

You should use one instance of MockServer for each REST API that your application interacts with and needs mocking for testing purposes.

You should use one instance of MockServer for each test, to ensure full isolation and no cross-test interference.

You can register as many Mocks as your scenario requires on a MockServer.

Methods

impl MockServer

pub async fn start() -> Self

Start a new instance of a MockServer.

Each instance of MockServer is fully isolated: start takes care of finding a random port available on your local machine which is assigned to the new MockServer.

You should use one instance of MockServer for each REST API that your application interacts with and needs mocking for testing purposes.

Example:

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

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

    assert!(mock_server_one.address() != mock_server_two.address());

    let mock = Mock::given(method("GET")).respond_with(ResponseTemplate::new(200));
    // Registering the mock with the first mock server - it's now effective!
    // But it *won't* be used by the second mock server!
    mock_server_one.register(mock).await;

    // Act

    let status = surf::get(&mock_server_one.uri())
        .await
        .unwrap()
        .status();
    assert_eq!(status.as_u16(), 200);

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

pub async fn register<'_>(&'_ self, mock: Mock)

Register a Mock on an instance of MockServer.

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

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

Example:

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

pub fn uri(&self) -> String

Return the base uri of this running instance of MockServer, e.g. http://127.0.0.1:4372.

Use this method to compose uris when interacting with this instance of MockServer via an HTTP client.

Example:

use wiremock::MockServer;

#[async_std::main]
async fn main() {
    // Arrange - no mocks mounted

    let mock_server = MockServer::start().await;
    // Act
    let uri = format!("{}/health_check", &mock_server.uri());
    let status = surf::get(uri).await.unwrap().status();

    // Assert - default response
    assert_eq!(status.as_u16(), 404);
}

pub fn address(&self) -> &SocketAddr

Return the socket address of this running instance of MockServer, e.g. 127.0.0.1:4372.

Use this method to interact with the MockServer using TcpStreams.

Example:

use wiremock::MockServer;
use std::net::TcpStream;

#[async_std::main]
async fn main() {
    // Act - the server is started
    let mock_server = MockServer::start().await;

    // Assert - we can connect to it
    assert!(TcpStream::connect(mock_server.address()).is_ok());
}

Trait Implementations

impl Drop for MockServer

fn drop(&mut self)

Executes the destructor for this type.