Trait asserhttp::AsserhttpStatus

pub trait AsserhttpStatus<T> {
    fn expect_status_eq<S: Into<AnyStatus>>(&mut self, status: S) -> &mut T;
    fn expect_status_in_range(&mut self, lower: u16, upper: u16) -> &mut T;

    fn expect_status_success(&mut self) -> &mut T { ... }
    fn expect_status_redirection(&mut self) -> &mut T { ... }
    fn expect_status_client_error(&mut self) -> &mut T { ... }
    fn expect_status_server_error(&mut self) -> &mut T { ... }
    fn expect_status_ok(&mut self) -> &mut T { ... }
    fn expect_status_created(&mut self) -> &mut T { ... }
    fn expect_status_accepted(&mut self) -> &mut T { ... }
    fn expect_status_no_content(&mut self) -> &mut T { ... }
    fn expect_status_partial_content(&mut self) -> &mut T { ... }
    fn expect_status_bad_request(&mut self) -> &mut T { ... }
    fn expect_status_unauthorized(&mut self) -> &mut T { ... }
    fn expect_status_forbidden(&mut self) -> &mut T { ... }
    fn expect_status_not_found(&mut self) -> &mut T { ... }
    fn expect_status_conflict(&mut self) -> &mut T { ... }
    fn expect_status_gone(&mut self) -> &mut T { ... }
    fn expect_status_internal_server_error(&mut self) -> &mut T { ... }
}

For assertions on http response status

Required methods

fn expect_status_eq<S: Into<AnyStatus>>(&mut self, status: S) -> &mut T

Expects response status to be equal

• status - expected status

Example

use asserhttp::*;

#[async_std::main]
async fn main() {
    reqwest::blocking::get("http://localhost").unwrap().expect_status_eq(200);
    reqwest::blocking::get("http://localhost").unwrap().expect_status_eq(Status::Ok);
    reqwest::blocking::get("http://localhost").expect_status_eq(200);
    reqwest::blocking::get("http://localhost").expect_status_eq(Status::Ok);
    reqwest::get("http://localhost").await.unwrap().expect_status_eq(200);
    reqwest::get("http://localhost").await.unwrap().expect_status_eq(Status::Ok);
    reqwest::get("http://localhost").await.expect_status_eq(200);
    reqwest::get("http://localhost").await.expect_status_eq(Status::Ok);

    isahc::get("http://localhost").unwrap().expect_status_eq(200);
    isahc::get("http://localhost").unwrap().expect_status_eq(Status::Ok);
    isahc::get("http://localhost").expect_status_eq(200);
    isahc::get("http://localhost").expect_status_eq(Status::Ok);
    isahc::get_async("http://localhost").await.unwrap().expect_status_eq(200);
    isahc::get_async("http://localhost").await.unwrap().expect_status_eq(Status::Ok);
    isahc::get_async("http://localhost").await.expect_status_eq(200);
    isahc::get_async("http://localhost").await.expect_status_eq(Status::Ok);

    surf::get("http://localhost").await.unwrap().expect_status_eq(200);
    surf::get("http://localhost").await.unwrap().expect_status_eq(Status::Ok);
    surf::get("http://localhost").await.expect_status_eq(200);
    surf::get("http://localhost").await.expect_status_eq(Status::Ok);

    hyper::Client::new().get("http://localhost".parse().unwrap()).await.unwrap().expect_status_eq(200);
    hyper::Client::new().get("http://localhost".parse().unwrap()).await.unwrap().expect_status_eq(Status::Ok);
    hyper::Client::new().get("http://localhost".parse().unwrap()).await.expect_status_eq(200);
    hyper::Client::new().get("http://localhost".parse().unwrap()).await.expect_status_eq(Status::Ok);

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_eq(200);
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_eq(Status::Ok);
        awc::Client::default().get("http://localhost").send().await.expect_status_eq(200);
        awc::Client::default().get("http://localhost").send().await.expect_status_eq(Status::Ok);
    });
}

fn expect_status_in_range(&mut self, lower: u16, upper: u16) -> &mut T

Expects response status to be in range

• lower - lower inclusive bound
• upper - upper exclusive bound

Example

use asserhttp::*;

#[async_std::main]
async fn main() {
    reqwest::blocking::get("http://localhost").unwrap().expect_status_in_range(200, 400);
    reqwest::blocking::get("http://localhost").expect_status_in_range(200, 400);
    reqwest::get("http://localhost").await.unwrap().expect_status_in_range(200, 400);
    reqwest::get("http://localhost").await.expect_status_in_range(200, 400);

    isahc::get("http://localhost").unwrap().expect_status_in_range(200, 400);
    isahc::get("http://localhost").expect_status_in_range(200, 400);
    isahc::get_async("http://localhost").await.unwrap().expect_status_in_range(200, 400);
    isahc::get_async("http://localhost").await.expect_status_in_range(200, 400);

    surf::get("http://localhost").await.unwrap().expect_status_in_range(200, 400);
    surf::get("http://localhost").await.expect_status_in_range(200, 400);

    hyper::Client::new().get("http://localhost".parse().unwrap()).await.unwrap().expect_status_in_range(200, 400);
    hyper::Client::new().get("http://localhost".parse().unwrap()).await.expect_status_in_range(200, 400);

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_in_range(200, 400);
        awc::Client::default().get("http://localhost").send().await.expect_status_in_range(200, 400);
    });
}

Provided methods

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

Expects response status to be in 2xx range

Example

use asserhttp::*;

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

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

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

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

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_success();
        awc::Client::default().get("http://localhost").send().await.expect_status_success();
    });
}

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

Expects response status to be in 3xx range

Example

use asserhttp::*;

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

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

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

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

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_redirection();
        awc::Client::default().get("http://localhost").send().await.expect_status_redirection();
    });
}

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

Expects response status to be in 4xx range

Example

use asserhttp::*;

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

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

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

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

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_client_error();
        awc::Client::default().get("http://localhost").send().await.expect_status_client_error();
    });
}

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

Expects response status to be in 5xx range

Example

use asserhttp::*;

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

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

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

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

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_server_error();
        awc::Client::default().get("http://localhost").send().await.expect_status_server_error();
    });
}

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

Expects response status to be OK 200

Example

use asserhttp::*;

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

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

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

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

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_ok();
        awc::Client::default().get("http://localhost").send().await.expect_status_ok();
    });
}

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

Expects response status to be Created 201

Example

use asserhttp::*;

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

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

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

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

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_created();
        awc::Client::default().get("http://localhost").send().await.expect_status_created();
    });
}

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

Expects response status to be Accepted 202

Example

use asserhttp::*;

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

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

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

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

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_accepted();
        awc::Client::default().get("http://localhost").send().await.expect_status_accepted();
    });
}

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

Expects response status to be No Content 204

Example

use asserhttp::*;

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

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

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

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

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_no_content();
        awc::Client::default().get("http://localhost").send().await.expect_status_no_content();
    });
}

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

Expects response status to be Partial Content 206

Example

use asserhttp::*;

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

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

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

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

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_partial_content();
        awc::Client::default().get("http://localhost").send().await.expect_status_partial_content();
    });
}

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

Expects response status to be Bad Request 400

Example

use asserhttp::*;

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

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

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

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

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_bad_request();
        awc::Client::default().get("http://localhost").send().await.expect_status_bad_request();
    });
}

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

Expects response status to be Unauthorized 401

Example

use asserhttp::*;

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

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

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

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

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_unauthorized();
        awc::Client::default().get("http://localhost").send().await.expect_status_unauthorized();
    });
}

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

Expects response status to be Forbidden 403

Example

use asserhttp::*;

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

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

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

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

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_forbidden();
        awc::Client::default().get("http://localhost").send().await.expect_status_forbidden();
    });
}

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

Expects response status to be Not Found 404

Example

use asserhttp::*;

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

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

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

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

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_not_found();
        awc::Client::default().get("http://localhost").send().await.expect_status_not_found();
    });
}

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

Expects response status to be Conflict 409

Example

use asserhttp::*;

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

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

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

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

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_conflict();
        awc::Client::default().get("http://localhost").send().await.expect_status_conflict();
    });
}

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

Expects response status to be Gone 410

Example

use asserhttp::*;

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

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

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

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

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_gone();
        awc::Client::default().get("http://localhost").send().await.expect_status_gone();
    });
}

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

Expects response status to be Internal Server Error 500

Example

use asserhttp::*;

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

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

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

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

    System::new("test").block_on(async move {
        awc::Client::default().get("http://localhost").send().await.unwrap().expect_status_internal_server_error();
        awc::Client::default().get("http://localhost").send().await.expect_status_internal_server_error();
    });
}

Implementors