Struct wiremock::ResponseTemplate[][src]

pub struct ResponseTemplate { /* fields omitted */ }
Expand description

The blueprint for the response returned by a MockServer when a Mock matches on an incoming request.

Implementations

Start building a ResponseTemplate specifying the status code of the response.

Append a header value to list of headers with key as header name.

Unlike insert_header, this function will not override the contents of a header:

  • if there are no header values with key as header name, it will insert one;
  • if there are already some values with key as header name, it will append to the existing list.

Insert a header value with key as header name.

This function will override the contents of a header:

  • if there are no header values with key as header name, it will insert one;
  • if there are already some values with key as header name, it will drop them and start a new list of header values, containing only value.

Example:

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

#[async_std::main]
async fn main() {
    // Arrange
    let mock_server = MockServer::start().await;
    let correlation_id = "1311db4f-fe65-4cb2-b514-1bb47f781aa7";
    let template = ResponseTemplate::new(200).insert_header(
        "X-Correlation-ID",
        correlation_id
    );
    Mock::given(method("GET"))
        .respond_with(template)
        .mount(&mock_server)
        .await;

    // Act
    let res = surf::get(&mock_server.uri())
        .await
        .unwrap();

    // Assert
    assert_eq!(res.header("X-Correlation-ID").unwrap().as_str(), correlation_id);
}

Set the response body with bytes.

It sets “Content-Type” to “application/octet-stream”.

To set a body with bytes but a different “Content-Type” set_body_raw can be used.

Set the response body from a JSON-serializable value.

It sets “Content-Type” to “application/json”.

Set the response body to a string.

It sets “Content-Type” to “text/plain”.

Set a raw response body. The mime type needs to be set because the raw body could be of any type.

Example:

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

mod external {
    // This could be a method of a struct that is
    // implemented in another crate and the struct
    // does not implement Serialize.
    pub fn body() -> Vec<u8>{
        r#"{"hello": "world"}"#.as_bytes().to_owned()
    }
}

#[async_std::main]
async fn main() {
    // Arrange
    let mock_server = MockServer::start().await;
    let template = ResponseTemplate::new(200).set_body_raw(
        external::body(),
        "application/json"
    );
    Mock::given(method("GET"))
        .respond_with(template)
        .mount(&mock_server)
        .await;

    // Act
    let mut res = surf::get(&mock_server.uri())
        .await
        .unwrap();
    let body = res.body_string()
        .await
        .unwrap();

    // Assert
    assert_eq!(body, r#"{"hello": "world"}"#);
    assert_eq!(res.content_type(), Some(mime::JSON));
}

By default the MockServer tries to fulfill incoming requests as fast as possible.

You can use set_delay to introduce an artificial delay to simulate the behaviour of a real server with a non-neglibible latency.

In particular, you can use it to test the behaviour of your timeout policies.

Example:

use isahc::config::Configurable;
use wiremock::{MockServer, Mock, ResponseTemplate};
use wiremock::matchers::method;
use std::time::Duration;
use async_std::prelude::FutureExt;

#[async_std::main]
async fn main() {
    // Arrange
    let mock_server = MockServer::start().await;
    let delay = Duration::from_secs(1);
    let template = ResponseTemplate::new(200).set_delay(delay.clone());
    Mock::given(method("GET"))
        .respond_with(template)
        .mount(&mock_server)
        .await;

    // Act
    let mut res = async_std::future::timeout(
        // Shorter than the response delay!
        delay / 3,
        surf::get(&mock_server.uri())
    )
    .await;

    // Assert - Timeout error!
    assert!(res.is_err());
}

Trait Implementations

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

A ResponseTemplate is the simplest Respond implementation: it returns a clone of itself no matter what the incoming request contains!

Given a reference to a Request return a ResponseTemplate that will be used by the MockServer as blueprint for the response returned to the client. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Performs the conversion.

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

Performs the conversion.

Should always be Self

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.