feat(response): introduce trailers support

0x676e67 · 0x676e67 · commit 2e96e513da59 · 2025-12-19T11:51:21.000+08:00
diff --git a/src/async_impl/response.rs b/src/async_impl/response.rs
@@ -30,6 +30,7 @@ pub struct Response {
     // Boxed to save space (11 words to 1 word), and it's not accessed
     // frequently internally.
     url: Box<Url>,
+    trailers: Option<HeaderMap>,
 }
 
 impl Response {
@@ -48,6 +49,7 @@ impl Response {
         Response {
             res,
             url: Box::new(url),
+            trailers: None,
         }
     }
 
@@ -93,6 +95,11 @@ impl Response {
         Body::size_hint(self.res.body()).exact()
     }
 
+    /// Get the trailers of this `Response`.
+    pub fn trailers(&mut self) -> Option<&HeaderMap> {
+        self.trailers.as_ref()
+    }
+
     /// Retrieve the cookies contained in the response.
     ///
     /// Note that invalid 'Set-Cookie' headers will be ignored.
@@ -313,16 +320,22 @@ impl Response {
     /// # }
     /// ```
     pub async fn chunk(&mut self) -> crate::Result<Option<Bytes>> {
+        use http_body::Frame;
         use http_body_util::BodyExt;
 
         // loop to ignore unrecognized frames
         loop {
             if let Some(res) = self.res.body_mut().frame().await {
                 let frame = res.map_err(crate::error::decode)?;
-                if let Ok(buf) = frame.into_data() {
-                    return Ok(Some(buf));
+                match frame.into_trailers().map_err(Frame::into_data) {
+                    Ok(trailers) => {
+                        self.trailers = Some(trailers);
+                    }
+                    Err(Ok(buf)) => {
+                        return Ok(Some(buf));
+                    }
+                    _ => continue,
                 }
-                // else continue
             } else {
                 return Ok(None);
             }
@@ -468,6 +481,7 @@ impl<T: Into<Body>> From<http::Response<T>> for Response {
         Response {
             res,
             url: Box::new(url),
+            trailers: None,
         }
     }
 }
diff --git a/tests/client.rs b/tests/client.rs
@@ -2,13 +2,18 @@
 #![cfg(not(feature = "rustls-tls-manual-roots-no-provider"))]
 mod support;
 
+use bytes::Bytes;
+use http_body_util::{BodyExt, Full};
 use support::server;
 
-use http::header::{CONTENT_LENGTH, CONTENT_TYPE, TRANSFER_ENCODING};
+use http::{
+    header::{self, CONTENT_LENGTH, CONTENT_TYPE, TRANSFER_ENCODING},
+    StatusCode,
+};
 #[cfg(feature = "json")]
 use std::collections::HashMap;
 
-use reqwest::Client;
+use reqwest::{Body, Client};
 use tokio::io::AsyncWriteExt;
 
 #[tokio::test]
@@ -528,3 +533,48 @@ async fn error_has_url() {
     let err = reqwest::get(u).await.unwrap_err();
     assert_eq!(err.url().map(AsRef::as_ref), Some(u), "{err:?}");
 }
+
+#[tokio::test]
+async fn response_trailers() {
+    let server = server::http(move |req| async move {
+        assert_eq!(req.uri().path(), "/trailers");
+
+        let body = Full::new(Bytes::from("HelloWorld!")).with_trailers(async move {
+            let mut trailers = http::HeaderMap::new();
+            trailers.insert("chunky-trailer", "custom-value".parse().unwrap());
+            Some(Ok(trailers))
+        });
+        let mut resp = http::Response::new(Body::wrap(body));
+        resp.headers_mut().insert(
+            header::TRAILER,
+            header::HeaderValue::from_static("chunky-trailer"),
+        );
+        resp.headers_mut().insert(
+            header::TRANSFER_ENCODING,
+            header::HeaderValue::from_static("chunked"),
+        );
+
+        resp
+    });
+
+    let mut res = reqwest::Client::new()
+        .get(format!("http://{}/trailers", server.addr()))
+        .header(header::TE, "trailers")
+        .send()
+        .await
+        .expect("Failed to get response");
+
+    assert_eq!(res.status(), StatusCode::OK);
+
+    // Read the body using chunk() to preserve response ownership
+    let mut body_content = Vec::new();
+    while let Some(chunk) = res.chunk().await.expect("Failed to read chunk") {
+        body_content.extend_from_slice(&chunk);
+    }
+
+    let body = String::from_utf8(body_content).expect("Invalid UTF-8");
+    assert_eq!(body, "HelloWorld!");
+
+    let trailers = res.trailers().expect("Expected trailers but got None");
+    assert_eq!(trailers.get("chunky-trailer").unwrap(), "custom-value");
+}
