Struct CaseBuilder

pub struct CaseBuilder<'c, W = DefaultWith> { /* private fields */ }

Builder for specific mock cases

Example

let mut builder = Connector::builder();
let mut case_builder = builder.expect();

case_builder
    .with_uri("https://test.example/some/path")
    .times(3)
    .returning("Some response")?;

Implementations

impl<'c> CaseBuilder<'c>

pub fn with<W, E, R>(self, with: W) -> CaseBuilder<'c, W>

where for<'r> W: Fn(&'r Request<String>) -> Result<R, E>, R: Into<Report>, E: StdError + Send + Sync + 'static,

Pass a function or closure to check if the incoming payload matches this mock case

If you only need to validate the Uri, Method, headers, or incoming payload, you should use one of the other with_* methods. You also cannot combine this validator with the other with methods.

Example

let mut builder = Connector::builder();
builder
    .expect()
    .with(|req: &Request<String>| Ok::<_, Infallible>(req.body().contains("hello")))
    .returning("OK")?;

pub fn with_uri<U>(self, uri: U) -> CaseBuilder<'c, WithHandler>

where U: TryInto<Uri>, U::Error: Into<Error>,

Match requests with the specified Uri

Example

let mut builder = Connector::builder();
builder
    .expect()
    .with_uri("https://example.test/hello")
    .returning("OK")?;

Remark

You can combine this with other validators, such as with_header, but not with with.

pub fn with_method<M>(self, method: M) -> CaseBuilder<'c, WithHandler>

where M: TryInto<Method>, M::Error: Into<Error>,

Match requests with the specified Method

Example

let mut builder = Connector::builder();
builder
    .expect()
    .with_method("GET")
    .returning("OK")?;

Remark

You can combine this with other validators, such as with_uri, but not with with.

pub fn with_header<K, V>(self, key: K, value: V) -> CaseBuilder<'c, WithHandler>

where K: TryInto<HeaderName>, K::Error: Into<Error>, V: TryInto<HeaderValue>, V::Error: Into<Error>,

Match requests that contains the specific header

An HTTP request can contain multiple headers with the same key, but different values. This checks that there is at least one value matching. If you want to ensure that there is only one entry for this key, consider using with_header_once.

Example

let mut builder = Connector::builder();
builder
    .expect()
    .with_header("content-type", "application/json")
    .returning("OK")?;

Remark

You can combine this with other validators, such as with_uri, but not with with.

pub fn with_header_once<K, V>( self, key: K, value: V, ) -> CaseBuilder<'c, WithHandler>

where K: TryInto<HeaderName>, K::Error: Into<Error>, V: TryInto<HeaderValue>, V::Error: Into<Error>,

Match requests that contains the specific header

An HTTP request can contain multiple headers with the same key, but different values. This checks that there is only one value for the given header.

Example

let mut builder = Connector::builder();
builder
    .expect()
    .with_header_once("content-type", "application/json")
    .returning("OK")?;

Remark

You can combine this with other validators, such as with_uri, but not with with.

pub fn with_header_all<K, IV, V>( self, key: K, values: IV, ) -> CaseBuilder<'c, WithHandler>

where K: TryInto<HeaderName>, K::Error: Into<Error>, IV: IntoIterator<Item = V>, V: TryInto<HeaderValue>, V::Error: Into<Error>,

Match requests that contains the specific header

An HTTP request can contain multiple headers with the same key, but different values. This checks that all entries correspond to the given set of values.

If you want to check that a header name has multiple values, but do not mind if there are additional values, you can use with_header multiple times instead.

If you want to ensure that a header name only has one value, you can use with_header_once instead.

Example

let mut builder = Connector::builder();
builder
    .expect()
    .with_header_all("content-type", ["application/json", "text/html"])
    .returning("OK")?;

Remark

You can combine this with other validators, such as with_uri, but not with with.

pub fn with_body<B>(self, body: B) -> CaseBuilder<'c, WithHandler>

where B: ToString,

Match requests that contains the provided payload

Example

let mut builder = Connector::builder();
builder
    .expect()
    .with_body("some body")
    .returning("OK")?;

Remark

You can combine this with other validators, such as with_uri, but not with with.

A mock case only supports with_body, with_json, or with_json_value, but not multiple ones at the same time.

pub fn with_json<V>(self, value: V) -> CaseBuilder<'c, WithHandler>

where V: Serialize,

Match requests with a body that exactly matches the provided JSON payload

Example

let mut builder = Connector::builder();
builder
    .expect()
    .with_json(serde_json::json!({"status": "OK"}))
    .returning("OK")?;

Remark

You can combine this with other validators, such as with_uri, but not with with.

A mock case only supports with_body, with_json, or with_json_value, but not multiple ones at the same time.

pub fn with_json_partial<V>(self, value: V) -> CaseBuilder<'c, WithHandler>

where V: Serialize,

Match requests that contains the provided JSON payload, but may contain other properties

You can combine this with other validators, such as with_uri, but not with with.

impl<W> CaseBuilder<'_, W>

pub fn times(self, count: usize) -> Self

Mark how many times this mock case can be called

Nothing enforces how many times a mock case is called, but you can use the checkpoint method on the Connector to ensure all methods were called the right amount of times.

impl<W> CaseBuilder<'_, W>

where W: With + 'static,

pub fn returning<R>(self, returning: R) -> Result<(), Error>

where R: Returning + 'static,

Mark what will generate the response for a given mock case

You can either pass a static value, or a function or closure that takes a Request<String> as an input.

See the documentation for Returning to see the full list of what is accepted by this method.

Errors

This will fail if any of the previous steps in CaseBuilder failed, or if it fails to store the case into the connector.