Trait asserhttp::AsserhttpHeader

source ·

pub trait AsserhttpHeader<T> {
    const APPLICATION_JSON: &'static str = "application/json";
    const TEXT_PLAIN: &'static str = "text/plain";

    // Required methods
    fn expect_header(
        &mut self,
        key: impl Into<HeaderKey>,
        value: impl Into<HeaderValueAsserter>
    ) -> &mut T;
    fn expect_headers(
        &mut self,
        key: impl Into<HeaderKey>,
        values: impl Into<HeaderValuesAsserter>
    ) -> &mut T;
    fn expect_header_present(&mut self, key: impl Into<HeaderKey>) -> &mut T;
    fn expect_header_absent(&mut self, key: impl Into<HeaderKey>) -> &mut T;

    // Provided methods
    fn expect_content_type_json(&mut self) -> &mut T { ... }
    fn expect_content_type_text(&mut self) -> &mut T { ... }
}

Expand description

For assertions on http response headers

Provided Associated Constants§

source

const APPLICATION_JSON: &'static str = "application/json"

source

const TEXT_PLAIN: &'static str = "text/plain"

Required Methods§

source

fn expect_header( &mut self, key: impl Into<HeaderKey>, value: impl Into<HeaderValueAsserter> ) -> &mut T

Expects response header to be equal

key - expected header key
value - expected header value or closure

§Example

use asserhttp::*;

#[tokio::main]
async fn main() {
    reqwest::blocking::get("http://localhost").expect_header("content-type", "application/json");
    reqwest::blocking::get("http://localhost").expect_header(headers::CONTENT_TYPE, "application/json");
    reqwest::blocking::get("http://localhost").expect_header("content-type", |h: &str| assert!(h.contains("application/")));
    reqwest::blocking::get("http://localhost").expect_header(headers::CONTENT_TYPE, |h: &str| assert!(h.contains("application/")));
    reqwest::get("http://localhost").await.expect_header("content-type", "application/json");
    reqwest::get("http://localhost").await.expect_header(headers::CONTENT_TYPE, "application/json");
    reqwest::get("http://localhost").await.expect_header("content-type", |h: &str| assert!(h.contains("application/")));
    reqwest::get("http://localhost").await.expect_header(headers::CONTENT_TYPE, |h: &str| assert!(h.contains("application/")));

    isahc::get("http://localhost").expect_header("content-type", "application/json");
    isahc::get("http://localhost").expect_header(headers::CONTENT_TYPE, "application/json");
    isahc::get("http://localhost").expect_header("content-type", |h: &str| assert!(h.contains("application/")));
    isahc::get("http://localhost").expect_header(headers::CONTENT_TYPE, |h: &str| assert!(h.contains("application/")));
    isahc::get_async("http://localhost").await.expect_header("content-type", "application/json");
    isahc::get_async("http://localhost").await.expect_header(headers::CONTENT_TYPE, "application/json");
    isahc::get_async("http://localhost").await.expect_header("content-type", |h: &str| assert!(h.contains("application/")));
    isahc::get_async("http://localhost").await.expect_header(headers::CONTENT_TYPE, |h: &str| assert!(h.contains("application/")));

    surf::get("http://localhost").await.expect_header("content-type", "application/json");
    surf::get("http://localhost").await.expect_header(headers::CONTENT_TYPE, "application/json");
    surf::get("http://localhost").await.expect_header("content-type", |h: &str| assert!(h.contains("application/")));
    surf::get("http://localhost").await.expect_header(headers::CONTENT_TYPE, |h: &str| assert!(h.contains("application/")));

    ureq::get("http://localhost").call().or_any_status().expect_header("content-type", "application/json");
    ureq::get("http://localhost").call().or_any_status().expect_header(headers::CONTENT_TYPE, "application/json");
    ureq::get("http://localhost").call().or_any_status().expect_header("content-type", |h: &str| assert!(h.contains("application/")));
    ureq::get("http://localhost").call().or_any_status().expect_header(headers::CONTENT_TYPE, |h: &str| assert!(h.contains("application/")));

    hyper::Client::new().get("http://localhost".parse().unwrap()).await.expect_header("content-type", "application/json");
    hyper::Client::new().get("http://localhost".parse().unwrap()).await.expect_header(headers::CONTENT_TYPE, "application/json");
    hyper::Client::new().get("http://localhost".parse().unwrap()).await.expect_header("content-type", |h: &str| assert!(h.contains("application/")));
    hyper::Client::new().get("http://localhost".parse().unwrap()).await.expect_header(headers::CONTENT_TYPE, |h: &str| assert!(h.contains("application/")));

    awc::Client::default().get("http://localhost").send().await.expect_header("content-type", "application/json");
    awc::Client::default().get("http://localhost").send().await.expect_header(headers::CONTENT_TYPE, "application/json");
    awc::Client::default().get("http://localhost").send().await.expect_header("content-type", |h: &str| assert!(h.contains("application/")));
    awc::Client::default().get("http://localhost").send().await.expect_header(headers::CONTENT_TYPE, |h: &str| assert!(h.contains("application/")));
}

source

fn expect_headers( &mut self, key: impl Into<HeaderKey>, values: impl Into<HeaderValuesAsserter> ) -> &mut T

Expects response multivalued headers to be equal

key - expected header key
value - expected header values or closure

§Example

use asserhttp::*;

#[tokio::main]
async fn main() {
    reqwest::blocking::get("http://localhost").expect_headers("cache-control", ["no-cache", "no-store"]);
    reqwest::blocking::get("http://localhost").expect_headers(headers::CACHE_CONTROL, ["no-cache", "no-store"]);
    reqwest::blocking::get("http://localhost").expect_headers("cache-control", |h: Vec<&str>| assert!(h.contains(&"no-cache") && h.contains(&"no-store")));
    reqwest::blocking::get("http://localhost").expect_headers(headers::CACHE_CONTROL, |h: Vec<&str>| assert!(h.contains(&"no-cache") && h.contains(&"no-store")));
    reqwest::get("http://localhost").await.expect_headers("cache-control", ["no-cache", "no-store"]);
    reqwest::get("http://localhost").await.expect_headers(headers::CACHE_CONTROL, ["no-cache", "no-store"]);
    reqwest::get("http://localhost").await.expect_headers("cache-control", |h: Vec<&str>| assert!(h.contains(&"no-cache") && h.contains(&"no-store")));
    reqwest::get("http://localhost").await.expect_headers(headers::CACHE_CONTROL, |h: Vec<&str>| assert!(h.contains(&"no-cache") && h.contains(&"no-store")));

    isahc::get("http://localhost").expect_headers("cache-control", ["no-cache", "no-store"]);
    isahc::get("http://localhost").expect_headers(headers::CACHE_CONTROL, ["no-cache", "no-store"]);
    isahc::get("http://localhost").expect_headers("cache-control", |h: Vec<&str>| assert!(h.contains(&"no-cache") && h.contains(&"no-store")));
    isahc::get("http://localhost").expect_headers(headers::CACHE_CONTROL, |h: Vec<&str>| assert!(h.contains(&"no-cache") && h.contains(&"no-store")));
    isahc::get_async("http://localhost").await.expect_headers("cache-control", ["no-cache", "no-store"]);
    isahc::get_async("http://localhost").await.expect_headers(headers::CACHE_CONTROL, ["no-cache", "no-store"]);
    isahc::get_async("http://localhost").await.expect_headers("cache-control", |h: Vec<&str>| assert!(h.contains(&"no-cache") && h.contains(&"no-store")));
    isahc::get_async("http://localhost").await.expect_headers(headers::CACHE_CONTROL, |h: Vec<&str>| assert!(h.contains(&"no-cache") && h.contains(&"no-store")));

    surf::get("http://localhost").await.expect_headers("cache-control", ["no-cache", "no-store"]);
    surf::get("http://localhost").await.expect_headers(headers::CACHE_CONTROL, ["no-cache", "no-store"]);
    surf::get("http://localhost").await.expect_headers("cache-control", |h: Vec<&str>| assert!(h.contains(&"no-cache") && h.contains(&"no-store")));
    surf::get("http://localhost").await.expect_headers(headers::CACHE_CONTROL, |h: Vec<&str>| assert!(h.contains(&"no-cache") && h.contains(&"no-store")));

    ureq::get("http://localhost").call().or_any_status().expect_headers("cache-control", ["no-cache", "no-store"]);
    ureq::get("http://localhost").call().or_any_status().expect_headers(headers::CACHE_CONTROL, ["no-cache", "no-store"]);
    ureq::get("http://localhost").call().or_any_status().expect_headers("cache-control", |h: Vec<&str>| assert!(h.contains(&"no-cache") && h.contains(&"no-store")));
    ureq::get("http://localhost").call().or_any_status().expect_headers(headers::CACHE_CONTROL, |h: Vec<&str>| assert!(h.contains(&"no-cache") && h.contains(&"no-store")));

    hyper::Client::new().get("http://localhost".parse().unwrap()).await.expect_headers("cache-control", ["no-cache", "no-store"]);
    hyper::Client::new().get("http://localhost".parse().unwrap()).await.expect_headers(headers::CACHE_CONTROL, ["no-cache", "no-store"]);
    hyper::Client::new().get("http://localhost".parse().unwrap()).await.expect_headers("cache-control", |h: Vec<&str>| assert!(h.contains(&"no-cache") && h.contains(&"no-store")));
    hyper::Client::new().get("http://localhost".parse().unwrap()).await.expect_headers(headers::CACHE_CONTROL, |h: Vec<&str>| assert!(h.contains(&"no-cache") && h.contains(&"no-store")));

    awc::Client::default().get("http://localhost").send().await.expect_headers("cache-control", ["no-cache", "no-store"]);
    awc::Client::default().get("http://localhost").send().await.expect_headers(headers::CACHE_CONTROL, ["no-cache", "no-store"]);
    awc::Client::default().get("http://localhost").send().await.expect_headers("cache-control", |h: Vec<&str>| assert!(h.contains(&"no-cache") && h.contains(&"no-store")));
    awc::Client::default().get("http://localhost").send().await.expect_headers(headers::CACHE_CONTROL, |h: Vec<&str>| assert!(h.contains(&"no-cache") && h.contains(&"no-store")));
}

source

fn expect_header_present(&mut self, key: impl Into<HeaderKey>) -> &mut T

Expects response header to be present

key - expected present header key

§Example

use asserhttp::*;

#[tokio::main]
async fn main() {
    reqwest::blocking::get("http://localhost").expect_header_present("content-type");
    reqwest::blocking::get("http://localhost").expect_header_present(headers::CONTENT_TYPE);
    reqwest::get("http://localhost").await.expect_header_present("content-type");
    reqwest::get("http://localhost").await.expect_header_present(headers::CONTENT_TYPE);

    isahc::get("http://localhost").expect_header_present("content-type");
    isahc::get("http://localhost").expect_header_present(headers::CONTENT_TYPE);
    isahc::get_async("http://localhost").await.expect_header_present("content-type");
    isahc::get_async("http://localhost").await.expect_header_present(headers::CONTENT_TYPE);

    surf::get("http://localhost").await.expect_header_present("content-type");
    surf::get("http://localhost").await.expect_header_present(headers::CONTENT_TYPE);

    ureq::get("http://localhost").call().or_any_status().expect_header_present("content-type");
    ureq::get("http://localhost").call().or_any_status().expect_header_present(headers::CONTENT_TYPE);

    hyper::Client::new().get("http://localhost".parse().unwrap()).await.expect_header_present("content-type");
    hyper::Client::new().get("http://localhost".parse().unwrap()).await.expect_header_present(headers::CONTENT_TYPE);

    awc::Client::default().get("http://localhost").send().await.expect_header_present("content-type");
    awc::Client::default().get("http://localhost").send().await.expect_header_present(headers::CONTENT_TYPE);
}

source

fn expect_header_absent(&mut self, key: impl Into<HeaderKey>) -> &mut T

Expects response header to be absent

key - expected absent header key

§Example

use asserhttp::*;

#[tokio::main]
async fn main() {
    reqwest::blocking::get("http://localhost").expect_header_absent("content-type");
    reqwest::blocking::get("http://localhost").expect_header_absent(headers::CONTENT_TYPE);
    reqwest::get("http://localhost").await.expect_header_absent("content-type");
    reqwest::get("http://localhost").await.expect_header_absent(headers::CONTENT_TYPE);

    isahc::get("http://localhost").expect_header_absent("content-type");
    isahc::get("http://localhost").expect_header_absent(headers::CONTENT_TYPE);
    isahc::get_async("http://localhost").await.expect_header_absent("content-type");
    isahc::get_async("http://localhost").await.expect_header_absent(headers::CONTENT_TYPE);

    surf::get("http://localhost").await.expect_header_absent("content-type");
    surf::get("http://localhost").await.expect_header_absent(headers::CONTENT_TYPE);

    ureq::get("http://localhost").call().or_any_status().expect_header_absent("content-type");
    ureq::get("http://localhost").call().or_any_status().expect_header_absent(headers::CONTENT_TYPE);

    hyper::Client::new().get("http://localhost".parse().unwrap()).await.expect_header_absent("content-type");
    hyper::Client::new().get("http://localhost".parse().unwrap()).await.expect_header_absent(headers::CONTENT_TYPE);

    awc::Client::default().get("http://localhost").send().await.expect_header_absent("content-type");
    awc::Client::default().get("http://localhost").send().await.expect_header_absent(headers::CONTENT_TYPE);
}

Provided Methods§

source

fn expect_content_type_json(&mut self) -> &mut T

Expects response header Content-Type: application/json

§Example

use asserhttp::*;

#[tokio::main]
async fn main() {
    reqwest::blocking::get("http://localhost").expect_content_type_json();
    reqwest::get("http://localhost").await.expect_content_type_json();

    isahc::get("http://localhost").expect_content_type_json();
    isahc::get_async("http://localhost").await.expect_content_type_json();

    surf::get("http://localhost").await.expect_content_type_json();

    ureq::get("http://localhost").call().or_any_status().expect_content_type_json();

    hyper::Client::new().get("http://localhost".parse().unwrap()).await.expect_content_type_json();

    awc::Client::default().get("http://localhost").send().await.expect_content_type_json();
}

source

fn expect_content_type_text(&mut self) -> &mut T

Expects response header Content-Type: text/plain

§Example

use asserhttp::*;

#[tokio::main]
async fn main() {
    reqwest::blocking::get("http://localhost").expect_content_type_text();
    reqwest::get("http://localhost").await.expect_content_type_text();

    isahc::get("http://localhost").expect_content_type_text();
    isahc::get_async("http://localhost").await.expect_content_type_text();

    surf::get("http://localhost").await.expect_content_type_text();

    ureq::get("http://localhost").call().or_any_status().expect_content_type_text();

    hyper::Client::new().get("http://localhost".parse().unwrap()).await.expect_content_type_text();

    awc::Client::default().get("http://localhost").send().await.expect_content_type_text();
}

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source §

impl<T, E> AsserhttpHeader<T> for Result<T, E>
where T: HeaderAccessor, E: Debug,

source §

fn expect_header( &mut self, key: impl Into<HeaderKey>, value: impl Into<HeaderValueAsserter> ) -> &mut T

source §

fn expect_headers( &mut self, key: impl Into<HeaderKey>, values: impl Into<HeaderValuesAsserter> ) -> &mut T

source §

fn expect_header_present(&mut self, key: impl Into<HeaderKey>) -> &mut T

source §

fn expect_header_absent(&mut self, key: impl Into<HeaderKey>) -> &mut T

Implementors§

source §

Trait asserhttp::AsserhttpHeaderCopy item path

Provided Associated Constants§

const APPLICATION_JSON: &'static str = "application/json"

const TEXT_PLAIN: &'static str = "text/plain"

Required Methods§

fn expect_header( &mut self, key: impl Into<HeaderKey>, value: impl Into<HeaderValueAsserter> ) -> &mut T

§Example

fn expect_headers( &mut self, key: impl Into<HeaderKey>, values: impl Into<HeaderValuesAsserter> ) -> &mut T

§Example

fn expect_header_present(&mut self, key: impl Into<HeaderKey>) -> &mut T

§Example

fn expect_header_absent(&mut self, key: impl Into<HeaderKey>) -> &mut T

§Example

Provided Methods§

fn expect_content_type_json(&mut self) -> &mut T

§Example

fn expect_content_type_text(&mut self) -> &mut T

§Example

Object Safety§

Implementations on Foreign Types§

impl<T, E> AsserhttpHeader<T> for Result<T, E>where T: HeaderAccessor, E: Debug,

fn expect_header( &mut self, key: impl Into<HeaderKey>, value: impl Into<HeaderValueAsserter> ) -> &mut T

fn expect_headers( &mut self, key: impl Into<HeaderKey>, values: impl Into<HeaderValuesAsserter> ) -> &mut T

fn expect_header_present(&mut self, key: impl Into<HeaderKey>) -> &mut T

fn expect_header_absent(&mut self, key: impl Into<HeaderKey>) -> &mut T

Implementors§

impl<T> AsserhttpHeader<T> for Twhere T: HeaderAccessor,

Trait asserhttp::AsserhttpHeader

impl<T, E> AsserhttpHeader<T> for Result<T, E>
where T: HeaderAccessor, E: Debug,

impl<T> AsserhttpHeader<T> for T
where T: HeaderAccessor,