Struct BodyReader

Source

pub struct BodyReader<B> { /* private fields */ }

Expand description

Convenient wrapper for reading Body content from http::Response.

It is useful in the most common response body reading cases.

Implementations§

Source §

impl BodyReader

Source

pub async fn bytes(self) -> Result<Bytes, ::Error>
where B: Body, ::Data: Buf,

Reads the full response body as Bytes.

§Example

use http::Response;
use http_body_reader::ResponseExt as _;
use http_body_util::Full;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Create a new response with the given text as the body.
    let message = b"Hello world";
    let response = Response::builder().body(Full::new(message.as_ref()))?;
    // Read the response body as bytes and check that it matches the original message.
    assert_eq!(response.body_reader().bytes().await?, message.as_ref());

    Ok(())
}

Source

pub async fn utf8( self, ) -> Result<String, BodyReaderError<::Error, FromUtf8Error>>
where B: Body, ::Data: Buf,

Reads the full response text.

§Note

The method will only attempt to decode the response as UTF-8, regardless of the Content-Type header.

§Errors

This method fails if the response body cannot be decoded as UTF-8.

§Example

use http::Response;
use http_body_reader::ResponseExt as _;
use http_body_util::Full;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Create a new response with the given text as the body.
    let message = "Hello world";
    let response = Response::builder().body(Full::new(message.as_ref()))?;
    // Read the response body as UTF-8 and check that it matches the original message.
    assert_eq!(response.body_reader().utf8().await?, message);

    Ok(())
}

Source

pub async fn json<T>( self, ) -> Result<T, BodyReaderError<::Error, Error>>
where T: DeserializeOwned, B: Body, ::Data: Buf,

Deserializes the response body as JSON.

§Errors

This method fails whenever the response body is not valid JSON or it cannot be properly deserialized to the target type T.

§Examples

use http::Response;
use http_body_reader::ResponseExt as _;
use http_body_util::Full;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct SomeInfo {
    id: u32,
    name: String,
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let info = SomeInfo {
        id: 1234,
        name: "Alice".to_string(),
    };

    // Create a response with JSON body.
    let data = serde_json::to_vec(&info)?;
    let response = Response::builder().body(Full::new(data.as_ref()))?;
    // Read the response body as JSON and check that it matches the original info.
    assert_eq!(response.body_reader().json::<SomeInfo>().await?, info);

    Ok(())
}

Source

pub async fn form<T>( self, ) -> Result<T, BodyReaderError<::Error, Error>>
where T: DeserializeOwned, B: Body, ::Data: Buf,

Deserializes the response body as form data.

§Errors

This method fails whenever the response body is not valid form data or it cannot be properly deserialized to the target type T.

§Examples

use http::Response;
use http_body_reader::ResponseExt as _;
use http_body_util::Full;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct SomeInfo {
    id: u32,
    name: String,
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let info = SomeInfo {
        id: 1234,
        name: "Alice".to_string(),
    };

    // Create a response with form data.
    let data = serde_urlencoded::to_string(&info)?;
    let response = Response::builder().body(Full::new(data.as_ref()))?;
    // Read the response body as form data and check that it matches the original info.
    assert_eq!(response.body_reader().form::<SomeInfo>().await?, info);

    Ok(())
}

Source

pub fn map<F, T>(self, f: F) -> BodyReader<T>
where F: FnOnce(B) -> T, T: Body, <T as Body>::Data: Buf,

Maps the body content using the provided function.

§Example

use http::Response;
use http_body_reader::ResponseExt as _;
use http_body_util::{Full, Limited};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Create a response with a body
    let response = Response::builder().body(Full::new("Lorem ipsum dolor sit amet".as_ref()))?;
    // Create a body reader with a limit of 8 bytes
    let body_reader = response.body_reader().map(|body| Limited::new(body, 8));
    // Make sure the body reader returns an error when the limit is exceeded.
    assert_eq!(
        body_reader.utf8().await.unwrap_err().to_string(),
        "length limit exceeded"
    );

    Ok(())
}