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
pub fn new<S>(s: S) -> Self where
S: TryInto<StatusCode>,
<S as TryInto<StatusCode>>::Error: Debug,
pub fn new<S>(s: S) -> Self where
S: TryInto<StatusCode>,
<S as TryInto<StatusCode>>::Error: Debug,
Start building a ResponseTemplate
specifying the status code of the response.
pub fn append_header<K, V>(self, key: K, value: V) -> Self where
K: TryInto<HeaderName>,
<K as TryInto<HeaderName>>::Error: Debug,
V: TryInto<HeaderValue>,
<V as TryInto<HeaderValue>>::Error: Debug,
pub fn append_header<K, V>(self, key: K, value: V) -> Self where
K: TryInto<HeaderName>,
<K as TryInto<HeaderName>>::Error: Debug,
V: TryInto<HeaderValue>,
<V as TryInto<HeaderValue>>::Error: Debug,
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.
pub fn insert_header<K, V>(self, key: K, value: V) -> Self where
K: TryInto<HeaderName>,
<K as TryInto<HeaderName>>::Error: Debug,
V: TryInto<HeaderValue>,
<V as TryInto<HeaderValue>>::Error: Debug,
pub fn insert_header<K, V>(self, key: K, value: V) -> Self where
K: TryInto<HeaderName>,
<K as TryInto<HeaderName>>::Error: Debug,
V: TryInto<HeaderValue>,
<V as TryInto<HeaderValue>>::Error: Debug,
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 onlyvalue
.
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
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
impl RefUnwindSafe for ResponseTemplate
impl Send for ResponseTemplate
impl Sync for ResponseTemplate
impl Unpin for ResponseTemplate
impl UnwindSafe for ResponseTemplate
Blanket Implementations
Mutably borrows from an owned value. Read more
pub fn vzip(self) -> V
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more