1use std::pin::Pin;
17use std::task::{Context, Poll};
18
19use bytes::{Bytes, BytesMut};
20use futures_core::Stream;
21use http::{HeaderMap, StatusCode, Version};
22use url::Url;
23
24use crate::body::{BoxBytesStream, ResponseBody, SharedTrailers};
25use crate::error::Result;
26use crate::network_stream::NetworkStream;
27
28#[derive(Clone)]
34pub struct HistoryEntry {
35 status: StatusCode,
36 version: Version,
37 headers: HeaderMap,
38 url: Url,
39 reason_phrase: String,
40}
41
42impl std::fmt::Debug for HistoryEntry {
43 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
44 f.debug_struct("HistoryEntry")
45 .field("status", &self.status)
46 .field("version", &self.version)
47 .field("headers", &redacted_headers(&self.headers))
48 .field("url", &redacted_url(&self.url))
49 .field("reason_phrase", &self.reason_phrase)
50 .finish()
51 }
52}
53
54impl HistoryEntry {
55 #[cfg(feature = "redirects")]
61 pub(crate) fn from_response(response: &Response) -> Self {
62 let reason = response
63 .wire_reason_phrase
64 .clone()
65 .or_else(|| response.status.canonical_reason().map(str::to_owned))
66 .unwrap_or_default();
67 Self {
68 status: response.status,
69 version: response.version,
70 headers: response.headers.clone(),
71 url: response.url.clone(),
72 reason_phrase: reason,
73 }
74 }
75
76 #[must_use]
78 pub fn status(&self) -> StatusCode {
79 self.status
80 }
81
82 #[must_use]
84 pub fn version(&self) -> Version {
85 self.version
86 }
87
88 #[must_use]
90 pub fn headers(&self) -> &HeaderMap {
91 &self.headers
92 }
93
94 #[must_use]
96 pub fn url(&self) -> &Url {
97 &self.url
98 }
99
100 #[must_use]
102 pub fn reason_phrase(&self) -> &str {
103 &self.reason_phrase
104 }
105}
106
107pub struct Response {
129 status: StatusCode,
130 version: Version,
131 headers: HeaderMap,
132 url: Url,
133 wire_content_encoding: Option<String>,
136 wire_content_length: Option<String>,
139 wire_reason_phrase: Option<String>,
147 pub(crate) body: ResponseBody,
148 history: Vec<HistoryEntry>,
149 trailers: SharedTrailers,
154 network_stream: Option<NetworkStream>,
168}
169
170impl std::fmt::Debug for Response {
171 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
172 f.debug_struct("Response")
173 .field("status", &self.status)
174 .field("version", &self.version)
175 .field("headers", &redacted_headers(&self.headers))
176 .field("url", &redacted_url(&self.url))
177 .field("wire_content_encoding", &self.wire_content_encoding)
178 .field("wire_content_length", &self.wire_content_length)
179 .field("wire_reason_phrase", &self.wire_reason_phrase)
180 .field("body", &self.body)
181 .field("history", &self.history)
182 .field(
183 "trailers",
184 &self.trailers.get().map(|h| redacted_headers(&h)),
185 )
186 .field(
187 "network_stream",
188 &self.network_stream.as_ref().map(|_| "..."),
189 )
190 .finish()
191 }
192}
193
194fn redacted_headers(headers: &HeaderMap) -> HeaderMap {
195 crate::redact::redact_headers(headers)
196}
197
198fn redacted_url(url: &Url) -> String {
199 crate::redact::redact_url(url)
200}
201
202impl Response {
203 pub(crate) fn new(
205 status: StatusCode,
206 version: Version,
207 headers: HeaderMap,
208 url: Url,
209 body: ResponseBody,
210 ) -> Self {
211 #[allow(
217 clippy::unnecessary_lazy_evaluations,
218 reason = "the trace event must fire only when the value is dropped, so the lazy closure is not equivalent to eager evaluation"
219 )]
220 let wire_content_encoding = headers
221 .get("content-encoding")
222 .and_then(|value| {
223 value.to_str().ok().or_else(|| {
224 #[cfg(feature = "tracing")]
225 tracing::debug!("eggfetch: dropped non-UTF8 content-encoding");
226 None
227 })
228 })
229 .map(ToOwned::to_owned);
230 #[allow(
233 clippy::unnecessary_lazy_evaluations,
234 reason = "the trace event must fire only when the value is dropped, so the lazy closure is not equivalent to eager evaluation"
235 )]
236 let wire_content_length = headers
237 .get("content-length")
238 .and_then(|value| {
239 value.to_str().ok().or_else(|| {
240 #[cfg(feature = "tracing")]
241 tracing::debug!("eggfetch: dropped non-UTF8 content-length");
242 None
243 })
244 })
245 .map(ToOwned::to_owned);
246 Self {
247 status,
248 version,
249 headers,
250 url,
251 wire_content_encoding,
252 wire_content_length,
253 wire_reason_phrase: None,
254 body,
255 history: Vec::new(),
256 trailers: SharedTrailers::new(),
257 network_stream: None,
258 }
259 }
260
261 pub(crate) fn set_body(&mut self, body: ResponseBody) {
264 self.body = body;
265 }
266
267 pub(crate) fn set_trailers(&mut self, trailers: SharedTrailers) {
273 self.trailers = trailers;
274 }
275
276 #[must_use]
286 pub fn trailers(&self) -> Option<HeaderMap> {
287 self.trailers.get()
288 }
289
290 #[must_use]
292 pub fn status(&self) -> StatusCode {
293 self.status
294 }
295
296 #[must_use]
298 pub fn version(&self) -> Version {
299 self.version
300 }
301
302 #[must_use]
304 pub fn headers(&self) -> &HeaderMap {
305 &self.headers
306 }
307
308 pub fn headers_mut(&mut self) -> &mut HeaderMap {
310 &mut self.headers
311 }
312
313 #[must_use]
319 pub fn wire_content_encoding(&self) -> Option<&str> {
320 self.wire_content_encoding.as_deref()
321 }
322
323 #[must_use]
328 pub fn wire_content_length(&self) -> Option<&str> {
329 self.wire_content_length.as_deref()
330 }
331
332 #[must_use]
338 pub fn content_length(&self) -> Option<u64> {
339 self.wire_content_length.as_deref()?.parse().ok()
340 }
341
342 #[must_use]
348 pub fn wire_reason_phrase(&self) -> Option<&str> {
349 self.wire_reason_phrase.as_deref()
350 }
351
352 #[allow(
357 dead_code,
358 reason = "the wire reason phrase is only set by the proxy and CONNECT transports, which are compiled out when the proxy feature is disabled"
359 )]
360 pub(crate) fn set_wire_reason_phrase(&mut self, reason: Option<String>) {
361 self.wire_reason_phrase = reason;
362 }
363
364 #[must_use]
366 pub fn url(&self) -> &Url {
367 &self.url
368 }
369
370 #[must_use]
372 pub fn history(&self) -> &[HistoryEntry] {
373 &self.history
374 }
375
376 pub fn history_mut(&mut self) -> &mut Vec<HistoryEntry> {
378 &mut self.history
379 }
380
381 #[cfg(feature = "redirects")]
386 pub(crate) fn set_history(&mut self, history: Vec<HistoryEntry>) {
387 self.history = history;
388 }
389
390 #[must_use]
392 pub fn is_success(&self) -> bool {
393 self.status.is_success()
394 }
395
396 #[must_use]
398 pub fn body(&self) -> &ResponseBody {
399 &self.body
400 }
401
402 pub fn body_mut(&mut self) -> &mut ResponseBody {
404 &mut self.body
405 }
406
407 pub async fn bytes(&mut self) -> Result<Bytes> {
417 self.body.bytes().await
418 }
419
420 pub async fn text(&mut self) -> Result<String> {
427 self.body.text().await
428 }
429
430 #[cfg(feature = "json")]
442 pub async fn json<T: serde::de::DeserializeOwned>(&mut self) -> Result<T> {
443 let bytes = self.bytes().await?;
444 serde_json::from_slice(&bytes).map_err(|error| {
445 crate::Error::JsonDeserialize(format!(
446 "invalid JSON at line {}, column {}",
447 error.line(),
448 error.column()
449 ))
450 })
451 }
452
453 pub fn bytes_stream(&mut self) -> Result<BoxBytesStream> {
462 self.body.bytes_stream()
463 }
464
465 pub fn raw_bytes_stream(&mut self) -> Result<BoxBytesStream> {
475 self.body.raw_bytes_stream()
476 }
477
478 pub fn text_lines(&mut self) -> Result<impl Stream<Item = Result<String>>> {
489 let byte_stream = self.bytes_stream()?;
490 Ok(LineStream::new(byte_stream))
491 }
492
493 #[must_use]
499 pub fn network_stream(&self) -> Option<&NetworkStream> {
500 self.network_stream.as_ref()
501 }
502
503 pub fn network_stream_mut(&mut self) -> Option<&mut NetworkStream> {
505 self.network_stream.as_mut()
506 }
507
508 #[must_use]
512 pub fn take_network_stream(&mut self) -> Option<NetworkStream> {
513 self.network_stream.take()
514 }
515
516 pub(crate) fn set_network_stream(&mut self, stream: NetworkStream) {
518 self.network_stream = Some(stream);
519 }
520
521 #[must_use]
526 pub fn into_network_stream(self) -> Option<NetworkStream> {
527 self.network_stream
528 }
529}
530
531struct LineStream {
533 stream: BoxBytesStream,
534 buffer: BytesMut,
535}
536
537const MAX_LINE_LENGTH: usize = 1024 * 1024;
538
539impl LineStream {
540 fn new(stream: BoxBytesStream) -> Self {
541 Self {
542 stream,
543 buffer: BytesMut::new(),
544 }
545 }
546}
547
548impl Stream for LineStream {
549 type Item = Result<String>;
550
551 fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
552 loop {
553 if let Some(pos) = self.buffer.iter().position(|&b| b == b'\n') {
557 if pos > MAX_LINE_LENGTH {
558 return Poll::Ready(Some(Err(crate::error::Error::Body(format!(
559 "response line exceeded maximum length of {MAX_LINE_LENGTH} bytes"
560 )))));
561 }
562 let line_bytes = self.buffer.split_to(pos + 1);
563 let mut line = &line_bytes[..line_bytes.len() - 1]; if line.ends_with(b"\r") {
565 line = &line[..line.len() - 1];
566 }
567 let line = std::str::from_utf8(line)
568 .map(str::to_owned)
569 .map_err(|e| crate::error::Error::Body(e.to_string()))?;
570 return Poll::Ready(Some(Ok(line)));
571 }
572
573 if self.buffer.len() > MAX_LINE_LENGTH {
575 return Poll::Ready(Some(Err(crate::error::Error::Body(format!(
576 "response line exceeded maximum length of {MAX_LINE_LENGTH} bytes"
577 )))));
578 }
579
580 match Pin::new(&mut self.stream).poll_next(cx) {
583 Poll::Ready(Some(Ok(chunk))) => {
584 if chunk.is_empty() {
585 continue;
589 }
590 if self.buffer.len().saturating_add(chunk.len()) > MAX_LINE_LENGTH {
597 let remaining = MAX_LINE_LENGTH.saturating_sub(self.buffer.len());
598 let prefix = &chunk[..remaining.min(chunk.len())];
603 if !prefix.contains(&b'\n') {
604 if let Some(pos) = chunk.iter().position(|&b| b == b'\n') {
609 if self.buffer.len() + pos > MAX_LINE_LENGTH {
610 return Poll::Ready(Some(Err(
611 crate::error::Error::Body(format!(
612 "response line exceeded maximum length of {MAX_LINE_LENGTH} bytes"
613 )),
614 )));
615 }
616 } else {
617 return Poll::Ready(Some(Err(
618 crate::error::Error::Body(format!(
619 "response line exceeded maximum length of {MAX_LINE_LENGTH} bytes"
620 )),
621 )));
622 }
623 }
624 }
625 self.buffer.extend_from_slice(&chunk);
626 }
627 Poll::Ready(Some(Err(e))) => return Poll::Ready(Some(Err(e))),
628 Poll::Ready(None) => {
629 if self.buffer.is_empty() {
631 return Poll::Ready(None);
632 }
633 let remaining = std::mem::take(&mut self.buffer);
634 if remaining.len() > MAX_LINE_LENGTH {
635 return Poll::Ready(Some(Err(crate::error::Error::Body(format!(
636 "response line exceeded maximum length of {MAX_LINE_LENGTH} bytes"
637 )))));
638 }
639 let mut line = &remaining[..remaining.len()];
640 if line.ends_with(b"\r") {
641 line = &line[..line.len() - 1];
642 }
643 let line = std::str::from_utf8(line)
644 .map(str::to_owned)
645 .map_err(|e| crate::error::Error::Body(e.to_string()))?;
646 return Poll::Ready(Some(Ok(line)));
647 }
648 Poll::Pending => return Poll::Pending,
649 }
650 }
651 }
652}
653
654#[cfg(test)]
655mod tests {
656 use super::*;
657 use http::HeaderValue;
658
659 #[test]
660 fn response_debug_redacts_sensitive_headers_and_url_parts() {
661 let mut headers = HeaderMap::new();
662 headers.insert("authorization", HeaderValue::from_static("Bearer secret"));
663 headers.insert("set-cookie", HeaderValue::from_static("session=secret"));
664 let response = Response::new(
665 StatusCode::FOUND,
666 Version::HTTP_11,
667 headers,
668 Url::parse("https://user:pass@example.com/path?token=secret#fragment").unwrap(),
669 ResponseBody::buffered(Bytes::new()),
670 );
671 let rendered = format!("{response:?}");
672 assert!(!rendered.contains("secret"));
673 assert!(!rendered.contains("user:pass"));
674 assert!(rendered.contains("https://example.com/path"));
675 }
676
677 #[test]
678 fn response_retains_wire_content_metadata_without_changing_headers() {
679 let mut headers = HeaderMap::new();
680 headers.insert("content-encoding", HeaderValue::from_static("gzip"));
681 headers.insert("content-length", HeaderValue::from_static("42"));
682 let response = Response::new(
683 StatusCode::OK,
684 Version::HTTP_11,
685 headers,
686 Url::parse("http://example.com").unwrap(),
687 ResponseBody::buffered(Bytes::new()),
688 );
689
690 assert_eq!(response.wire_content_encoding(), Some("gzip"));
691 assert_eq!(response.wire_content_length(), Some("42"));
692 assert_eq!(
693 response.headers().get("content-encoding"),
694 Some(&HeaderValue::from_static("gzip"))
695 );
696 assert_eq!(
697 response.headers().get("content-length"),
698 Some(&HeaderValue::from_static("42"))
699 );
700 assert_eq!(response.content_length(), Some(42));
701 }
702
703 #[test]
704 fn invalid_wire_content_length_is_not_inferred() {
705 let mut headers = HeaderMap::new();
706 headers.insert("content-length", HeaderValue::from_static("not-a-number"));
707 let response = Response::new(
708 StatusCode::OK,
709 Version::HTTP_11,
710 headers,
711 Url::parse("http://example.com").unwrap(),
712 ResponseBody::buffered(Bytes::from_static(b"1234")),
713 );
714 assert_eq!(response.content_length(), None);
715 }
716
717 #[cfg(feature = "json")]
718 #[tokio::test]
719 async fn response_json_deserializes_once_and_classifies_parse_errors() {
720 let mut response = Response::new(
721 StatusCode::OK,
722 Version::HTTP_11,
723 HeaderMap::new(),
724 Url::parse("http://example.com").unwrap(),
725 ResponseBody::buffered(Bytes::from_static(br#"{"key":"value"}"#)),
726 );
727 let value: serde_json::Value = response.json().await.unwrap();
728 assert_eq!(value["key"], "value");
729 assert!(matches!(response.bytes().await, Err(crate::Error::Body(_))));
730
731 let mut invalid = Response::new(
732 StatusCode::OK,
733 Version::HTTP_11,
734 HeaderMap::new(),
735 Url::parse("http://example.com").unwrap(),
736 ResponseBody::buffered(Bytes::from_static(b"{not-json")),
737 );
738 let error = invalid.json::<serde_json::Value>().await.unwrap_err();
739 assert_eq!(error.kind(), "json_deserialize");
740 assert!(!error.to_string().contains("not-json"));
741 }
742 use futures_util::StreamExt;
743
744 #[tokio::test]
745 async fn response_bytes_and_text() {
746 let mut resp = Response::new(
747 StatusCode::OK,
748 Version::HTTP_11,
749 HeaderMap::new(),
750 Url::parse("http://example.com").unwrap(),
751 ResponseBody::buffered(Bytes::from("hello")),
752 );
753 assert!(resp.is_success());
754 let text = resp.text().await.unwrap();
755 assert_eq!(text, "hello");
756 }
757
758 #[tokio::test]
759 async fn response_streaming_bytes_collect() {
760 let chunks = vec![Ok(Bytes::from("hello ")), Ok(Bytes::from("world"))];
761 let stream = Box::pin(futures_util::stream::iter(chunks));
762 let mut resp = Response::new(
763 StatusCode::OK,
764 Version::HTTP_11,
765 HeaderMap::new(),
766 Url::parse("http://example.com").unwrap(),
767 ResponseBody::streaming(stream),
768 );
769 let bytes = resp.bytes().await.unwrap();
770 assert_eq!(bytes, "hello world");
771 }
772
773 #[tokio::test]
774 async fn response_text_lines_rejects_unbounded_line() {
775 let stream = Box::pin(futures_util::stream::iter(vec![Ok(Bytes::from(vec![
776 b'a'; MAX_LINE_LENGTH + 1
777 ]))]));
778 let mut response = Response::new(
779 StatusCode::OK,
780 Version::HTTP_11,
781 HeaderMap::new(),
782 Url::parse("http://example.com").unwrap(),
783 ResponseBody::streaming(stream),
784 );
785 let mut lines = response.text_lines().unwrap();
786 let error = lines.next().await.unwrap().unwrap_err();
787 assert!(matches!(error, crate::error::Error::Body(_)));
788 }
789
790 #[tokio::test]
791 async fn response_text_lines_rejects_overlong_line_after_valid_line() {
792 let mut payload = b"ok\n".to_vec();
796 payload.extend_from_slice(&vec![b'a'; MAX_LINE_LENGTH + 1]);
797 payload.push(b'\n');
798 let stream = Box::pin(futures_util::stream::iter(vec![Ok(Bytes::from(payload))]));
799 let mut resp = Response::new(
800 StatusCode::OK,
801 Version::HTTP_11,
802 HeaderMap::new(),
803 Url::parse("http://example.com").unwrap(),
804 ResponseBody::streaming(stream),
805 );
806 let mut lines = resp.text_lines().unwrap();
807 assert_eq!(lines.next().await.unwrap().unwrap(), "ok");
808 let error = lines.next().await.unwrap().unwrap_err();
809 assert!(matches!(error, crate::error::Error::Body(_)));
810 }
811
812 #[tokio::test]
813 async fn response_text_lines_rejects_unbounded_terminal_line() {
814 let stream = Box::pin(futures_util::stream::iter(vec![Ok(Bytes::from(vec![
818 b'a'; MAX_LINE_LENGTH + 1
819 ]))]));
820 let mut resp = Response::new(
821 StatusCode::OK,
822 Version::HTTP_11,
823 HeaderMap::new(),
824 Url::parse("http://example.com").unwrap(),
825 ResponseBody::streaming(stream),
826 );
827 let mut lines = resp.text_lines().unwrap();
828 let error = lines.next().await.unwrap().unwrap_err();
829 assert!(matches!(error, crate::error::Error::Body(_)));
830 }
831
832 #[tokio::test]
833 async fn response_bytes_stream_yields_chunks() {
834 let chunks = vec![Ok(Bytes::from("a")), Ok(Bytes::from("b"))];
835 let stream = Box::pin(futures_util::stream::iter(chunks));
836 let mut resp = Response::new(
837 StatusCode::OK,
838 Version::HTTP_11,
839 HeaderMap::new(),
840 Url::parse("http://example.com").unwrap(),
841 ResponseBody::streaming(stream),
842 );
843 let mut stream = resp.bytes_stream().unwrap();
844 assert_eq!(stream.next().await.unwrap().unwrap(), "a");
845 assert_eq!(stream.next().await.unwrap().unwrap(), "b");
846 assert!(stream.next().await.is_none());
847 }
848
849 #[tokio::test]
850 async fn response_text_lines_basic() {
851 let chunks = vec![Ok(Bytes::from("line1\nline2\nline3\n"))];
852 let stream = Box::pin(futures_util::stream::iter(chunks));
853 let mut resp = Response::new(
854 StatusCode::OK,
855 Version::HTTP_11,
856 HeaderMap::new(),
857 Url::parse("http://example.com").unwrap(),
858 ResponseBody::streaming(stream),
859 );
860 let mut lines = resp.text_lines().unwrap();
861 assert_eq!(lines.next().await.unwrap().unwrap(), "line1");
862 assert_eq!(lines.next().await.unwrap().unwrap(), "line2");
863 assert_eq!(lines.next().await.unwrap().unwrap(), "line3");
864 assert!(lines.next().await.is_none());
865 }
866
867 #[tokio::test]
868 async fn response_text_lines_crlf() {
869 let chunks = vec![Ok(Bytes::from("line1\r\nline2\r\n"))];
870 let stream = Box::pin(futures_util::stream::iter(chunks));
871 let mut resp = Response::new(
872 StatusCode::OK,
873 Version::HTTP_11,
874 HeaderMap::new(),
875 Url::parse("http://example.com").unwrap(),
876 ResponseBody::streaming(stream),
877 );
878 let mut lines = resp.text_lines().unwrap();
879 assert_eq!(lines.next().await.unwrap().unwrap(), "line1");
880 assert_eq!(lines.next().await.unwrap().unwrap(), "line2");
881 assert!(lines.next().await.is_none());
882 }
883
884 #[tokio::test]
885 async fn response_text_lines_across_chunks() {
886 let chunks = vec![
887 Ok(Bytes::from("hel")),
888 Ok(Bytes::from("lo\nwor")),
889 Ok(Bytes::from("ld\n")),
890 ];
891 let stream = Box::pin(futures_util::stream::iter(chunks));
892 let mut resp = Response::new(
893 StatusCode::OK,
894 Version::HTTP_11,
895 HeaderMap::new(),
896 Url::parse("http://example.com").unwrap(),
897 ResponseBody::streaming(stream),
898 );
899 let mut lines = resp.text_lines().unwrap();
900 assert_eq!(lines.next().await.unwrap().unwrap(), "hello");
901 assert_eq!(lines.next().await.unwrap().unwrap(), "world");
902 assert!(lines.next().await.is_none());
903 }
904
905 #[tokio::test]
906 async fn response_text_lines_no_trailing_newline() {
907 let chunks = vec![Ok(Bytes::from("hello"))];
908 let stream = Box::pin(futures_util::stream::iter(chunks));
909 let mut resp = Response::new(
910 StatusCode::OK,
911 Version::HTTP_11,
912 HeaderMap::new(),
913 Url::parse("http://example.com").unwrap(),
914 ResponseBody::streaming(stream),
915 );
916 let mut lines = resp.text_lines().unwrap();
917 assert_eq!(lines.next().await.unwrap().unwrap(), "hello");
918 assert!(lines.next().await.is_none());
919 }
920
921 #[test]
922 fn trailers_absent_initially() {
923 let resp = Response::new(
924 StatusCode::OK,
925 Version::HTTP_11,
926 HeaderMap::new(),
927 Url::parse("http://example.com").unwrap(),
928 ResponseBody::buffered(Bytes::new()),
929 );
930 assert!(resp.trailers().is_none());
931 }
932
933 #[test]
934 fn trailers_preserve_duplicate_multi_value() {
935 use crate::body::SharedTrailers;
936 let shared = SharedTrailers::new();
937 let mut map = HeaderMap::new();
938 map.append("x-trailer", HeaderValue::from_static("a"));
939 map.append("x-trailer", HeaderValue::from_static("b"));
940 map.insert("x-single", HeaderValue::from_static("v"));
941 shared.store(map);
942 let mut resp = Response::new(
943 StatusCode::OK,
944 Version::HTTP_11,
945 HeaderMap::new(),
946 Url::parse("http://example.com").unwrap(),
947 ResponseBody::buffered(Bytes::new()),
948 );
949 resp.set_trailers(shared);
950 let trailers = resp.trailers().expect("trailers present");
951 let values: Vec<_> = trailers
952 .get_all("x-trailer")
953 .iter()
954 .map(|v| v.to_str().unwrap().to_owned())
955 .collect();
956 assert_eq!(values, vec!["a", "b"]);
957 assert_eq!(trailers.get("x-single").unwrap(), "v");
958 }
959
960 #[tokio::test]
961 async fn trailers_available_after_bytes_collection() {
962 use crate::body::SharedTrailers;
963 let shared = SharedTrailers::new();
966 let shared_for_stream = shared.clone();
967 let stream = Box::pin(futures_util::stream::unfold(0, move |step| {
968 let shared_for_stream = shared_for_stream.clone();
969 async move {
970 if step == 0 {
971 Some((Ok(Bytes::from("hello")), 1))
972 } else if step == 1 {
973 let mut map = HeaderMap::new();
974 map.insert("x-done", HeaderValue::from_static("yes"));
975 shared_for_stream.store(map);
976 None
977 } else {
978 None
979 }
980 }
981 }));
982 let mut resp = Response::new(
983 StatusCode::OK,
984 Version::HTTP_11,
985 HeaderMap::new(),
986 Url::parse("http://example.com").unwrap(),
987 ResponseBody::streaming(stream),
988 );
989 resp.set_trailers(shared);
990 assert!(
991 resp.trailers().is_none(),
992 "partial consumption reports None"
993 );
994 let bytes = resp.bytes().await.unwrap();
995 assert_eq!(bytes, "hello");
996 assert_eq!(
997 resp.trailers().unwrap().get("x-done").unwrap(),
998 "yes",
999 "trailers available after body completion"
1000 );
1001 }
1002
1003 #[tokio::test]
1004 async fn partial_consumption_does_not_falsely_report_trailers() {
1005 let stream = Box::pin(futures_util::stream::iter(vec![Ok(Bytes::from("a"))]));
1006 let mut resp = Response::new(
1007 StatusCode::OK,
1008 Version::HTTP_11,
1009 HeaderMap::new(),
1010 Url::parse("http://example.com").unwrap(),
1011 ResponseBody::streaming(stream),
1012 );
1013 let mut s = resp.bytes_stream().unwrap();
1015 assert_eq!(s.next().await.unwrap().unwrap(), "a");
1016 assert!(resp.trailers().is_none());
1017 }
1018
1019 #[tokio::test]
1020 async fn body_error_before_trailers_leaves_no_trailers() {
1021 use crate::body::SharedTrailers;
1022 let shared = SharedTrailers::new();
1023 let stream = Box::pin(futures_util::stream::iter(vec![
1024 Ok(Bytes::from("a")),
1025 Err(crate::error::Error::Body("boom".into())),
1026 ]));
1027 let mut resp = Response::new(
1028 StatusCode::OK,
1029 Version::HTTP_11,
1030 HeaderMap::new(),
1031 Url::parse("http://example.com").unwrap(),
1032 ResponseBody::streaming(stream),
1033 );
1034 resp.set_trailers(shared);
1035 let err = resp.bytes().await.unwrap_err();
1036 assert!(matches!(err, crate::error::Error::Body(_)));
1037 assert!(
1038 resp.trailers().is_none(),
1039 "body errors must not fabricate trailer state"
1040 );
1041 }
1042}