Struct ContainsPart 

pub struct ContainsPart<'a, 'b, 'c, 'd> {
    pub name: Option<Cow<'a, str>>,
    pub filename: Option<Cow<'b, str>>,
    pub content_type: Option<Cow<'c, str>>,
    pub body: Option<Cow<'d, [u8]>>,
}

Matcher builder to assert the presence of a matching part in the request.

Example

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

#[async_std::main]
async fn main() {
    // Start a background HTTP server on a random local port
    let mock_server = MockServer::start().await;

    Mock::given(method("POST"))
        .and(ContainsPart::new()
            .with_name("data-part")
            .with_content_type("text/plain")
            .with_body("simple text".as_bytes()))
        .respond_with(ResponseTemplate::new(200))
        .mount(&mock_server)
        .await;
}

Fields

name: Option<Cow<'a, str>>

filename: Option<Cow<'b, str>>

content_type: Option<Cow<'c, str>>

body: Option<Cow<'d, [u8]>>

Implementations

impl<'a, 'b, 'c, 'd> ContainsPart<'a, 'b, 'c, 'd>

pub fn new() -> Self

pub fn with_name<T: Into<Cow<'a, str>>>(self, name: T) -> Self

pub fn with_filename<T: Into<Cow<'b, str>>>(self, filename: T) -> Self

pub fn with_content_type<T: Into<Cow<'c, str>>>(self, content_type: T) -> Self

pub fn with_body<T: Into<Cow<'d, [u8]>>>(self, body: T) -> Self

Trait Implementations

impl<'a, 'b, 'c, 'd> Debug for ContainsPart<'a, 'b, 'c, 'd>

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

Formats the value using the given formatter.

impl<'a, 'b, 'c, 'd> Default for ContainsPart<'a, 'b, 'c, 'd>

fn default() -> ContainsPart<'a, 'b, 'c, 'd>

Returns the “default value” for a type.

impl<'a, 'b, 'c, 'd> Match for ContainsPart<'a, 'b, 'c, 'd>

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

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

impl<'a, 'b, 'c, 'd> PartialEq for ContainsPart<'a, 'b, 'c, 'd>

fn eq(&self, other: &ContainsPart<'a, 'b, 'c, 'd>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, 'c, 'd> Eq for ContainsPart<'a, 'b, 'c, 'd>

impl<'a, 'b, 'c, 'd> StructuralPartialEq for ContainsPart<'a, 'b, 'c, 'd>