Struct trillium_client::UnexpectedStatusError

source ·

pub struct UnexpectedStatusError(/* private fields */);

Expand description

An unexpected http status code was received. Transform this back into the conn with From::from/Into::into.

Currently only returned by Conn::success

Methods from Deref<Target = Conn>§

source

pub fn request_headers(&self) -> &Headers

borrow the request headers

source

pub fn response_headers(&self) -> &Headers

let handler = |conn: trillium::Conn| async move {
    conn.with_response_header("some-header", "some-value")
        .with_status(200)
};

use trillium_client::Client;
use trillium_testing::ClientConfig;

trillium_testing::with_server(handler, move |url| async move {
    let client = Client::new(ClientConfig::new());
    let conn = client.get(url).await?;

    let headers = conn.response_headers(); //<-

    assert_eq!(headers.get_str("some-header"), Some("some-value"));
    Ok(())
})

source

pub fn request_headers_mut(&mut self) -> &mut Headers

retrieves a mutable borrow of the request headers, suitable for appending a header. generally, prefer using chainable methods on Conn

use trillium_testing::ClientConfig;
use trillium_client::Client;

let handler = |conn: trillium::Conn| async move {
    let header = conn.request_headers().get_str("some-request-header").unwrap_or_default();
    let response = format!("some-request-header was {}", header);
    conn.ok(response)
};

let client = Client::new(ClientConfig::new());

trillium_testing::with_server(handler, move |url| async move {
    let mut conn = client.get(url);

    conn.request_headers_mut() //<-
        .insert("some-request-header", "header-value");

    let mut conn = conn.await?;

    assert_eq!(
        conn.response_body().read_string().await?,
        "some-request-header was header-value"
    );
    Ok(())
})

source

pub fn response_headers_mut(&mut self) -> &mut Headers

get a mutable borrow of the response headers

source

pub fn set_request_body(&mut self, body: impl Into<Body>)

sets the request body on a mutable reference. prefer the chainable Conn::with_body wherever possible

env_logger::init();
use trillium_client::Client;
use trillium_testing::ClientConfig;


let handler = |mut conn: trillium::Conn| async move {
    let body = conn.request_body_string().await.unwrap();
    conn.ok(format!("request body was: {}", body))
};

trillium_testing::with_server(handler, move |url| async move {
    let client = Client::new(ClientConfig::new());
    let mut conn = client.post(url);

    conn.set_request_body("body"); //<-

    (&mut conn).await?;

    assert_eq!(conn.response_body().read_string().await?, "request body was: body");
    Ok(())
});

source

pub fn url(&self) -> &Url

retrieves the url for this conn.

use trillium_testing::ClientConfig;
use trillium_client::Client;
let client = Client::from(ClientConfig::new());
let conn = client.get("http://localhost:9080");

let url = conn.url(); //<-

assert_eq!(url.host_str().unwrap(), "localhost");

source

pub fn method(&self) -> Method

retrieves the url for this conn.

use trillium_testing::ClientConfig;
use trillium_client::Client;

use trillium_testing::prelude::*;

let client = Client::from(ClientConfig::new());
let conn = client.get("http://localhost:9080");

let method = conn.method(); //<-

assert_eq!(method, Method::Get);

source

pub fn response_body(&mut self) -> ReceivedBody<'_, BoxedTransport>

returns a ReceivedBody that borrows the connection inside this conn.

env_logger::init();
use trillium_testing::ClientConfig;
use trillium_client::Client;



let handler = |mut conn: trillium::Conn| async move {
    conn.ok("hello from trillium")
};

trillium_testing::with_server(handler, |url| async move {
    let client = Client::from(ClientConfig::new());
    let mut conn = client.get(url).await?;

    let response_body = conn.response_body(); //<-

    assert_eq!(19, response_body.content_length().unwrap());
    let string = response_body.read_string().await?;
    assert_eq!("hello from trillium", string);
    Ok(())
});

source

pub fn status(&self) -> Option<Status>

returns the status code for this conn. if the conn has not yet been sent, this will be None.

use trillium_testing::ClientConfig;
use trillium_client::Client;
use trillium_testing::prelude::*;

async fn handler(conn: trillium::Conn) -> trillium::Conn {
    conn.with_status(418)
}

trillium_testing::with_server(handler, |url| async move {
    let client = Client::new(ClientConfig::new());
    let conn = client.get(url).await?;
    assert_eq!(Status::ImATeapot, conn.status().unwrap());
    Ok(())
});