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(clippy::unnecessary_lazy_evaluations)]
217 let wire_content_encoding = headers
218 .get("content-encoding")
219 .and_then(|value| {
220 value.to_str().ok().or_else(|| {
221 #[cfg(feature = "tracing")]
222 tracing::debug!("eggfetch: dropped non-UTF8 content-encoding");
223 None
224 })
225 })
226 .map(ToOwned::to_owned);
227 #[allow(clippy::unnecessary_lazy_evaluations)]
230 let wire_content_length = headers
231 .get("content-length")
232 .and_then(|value| {
233 value.to_str().ok().or_else(|| {
234 #[cfg(feature = "tracing")]
235 tracing::debug!("eggfetch: dropped non-UTF8 content-length");
236 None
237 })
238 })
239 .map(ToOwned::to_owned);
240 Self {
241 status,
242 version,
243 headers,
244 url,
245 wire_content_encoding,
246 wire_content_length,
247 wire_reason_phrase: None,
248 body,
249 history: Vec::new(),
250 trailers: SharedTrailers::new(),
251 network_stream: None,
252 }
253 }
254
255 pub(crate) fn set_body(&mut self, body: ResponseBody) {
258 self.body = body;
259 }
260
261 pub(crate) fn set_trailers(&mut self, trailers: SharedTrailers) {
267 self.trailers = trailers;
268 }
269
270 #[must_use]
280 pub fn trailers(&self) -> Option<HeaderMap> {
281 self.trailers.get()
282 }
283
284 #[allow(dead_code)]
286 pub(crate) fn into_body(self) -> ResponseBody {
287 self.body
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(dead_code)]
357 pub(crate) fn set_wire_reason_phrase(&mut self, reason: Option<String>) {
358 self.wire_reason_phrase = reason;
359 }
360
361 #[must_use]
363 pub fn url(&self) -> &Url {
364 &self.url
365 }
366
367 #[must_use]
369 pub fn history(&self) -> &[HistoryEntry] {
370 &self.history
371 }
372
373 pub fn history_mut(&mut self) -> &mut Vec<HistoryEntry> {
375 &mut self.history
376 }
377
378 #[cfg(feature = "redirects")]
383 pub(crate) fn set_history(&mut self, history: Vec<HistoryEntry>) {
384 self.history = history;
385 }
386
387 #[must_use]
389 pub fn is_success(&self) -> bool {
390 self.status.is_success()
391 }
392
393 #[must_use]
395 pub fn body(&self) -> &ResponseBody {
396 &self.body
397 }
398
399 pub fn body_mut(&mut self) -> &mut ResponseBody {
401 &mut self.body
402 }
403
404 pub async fn bytes(&mut self) -> Result<Bytes> {
414 self.body.bytes().await
415 }
416
417 pub async fn text(&mut self) -> Result<String> {
424 self.body.text().await
425 }
426
427 #[cfg(feature = "json")]
439 pub async fn json<T: serde::de::DeserializeOwned>(&mut self) -> Result<T> {
440 let bytes = self.bytes().await?;
441 serde_json::from_slice(&bytes).map_err(|error| {
442 crate::Error::JsonDeserialize(format!(
443 "invalid JSON at line {}, column {}",
444 error.line(),
445 error.column()
446 ))
447 })
448 }
449
450 pub fn bytes_stream(&mut self) -> Result<BoxBytesStream> {
459 self.body.bytes_stream()
460 }
461
462 pub fn raw_bytes_stream(&mut self) -> Result<BoxBytesStream> {
472 self.body.raw_bytes_stream()
473 }
474
475 pub fn text_lines(&mut self) -> Result<impl Stream<Item = Result<String>>> {
486 let byte_stream = self.bytes_stream()?;
487 Ok(LineStream::new(byte_stream))
488 }
489
490 #[must_use]
496 pub fn network_stream(&self) -> Option<&NetworkStream> {
497 self.network_stream.as_ref()
498 }
499
500 pub fn network_stream_mut(&mut self) -> Option<&mut NetworkStream> {
502 self.network_stream.as_mut()
503 }
504
505 #[must_use]
509 pub fn take_network_stream(&mut self) -> Option<NetworkStream> {
510 self.network_stream.take()
511 }
512
513 pub(crate) fn set_network_stream(&mut self, stream: NetworkStream) {
515 self.network_stream = Some(stream);
516 }
517
518 #[must_use]
523 pub fn into_network_stream(self) -> Option<NetworkStream> {
524 self.network_stream
525 }
526}
527
528struct LineStream {
530 stream: BoxBytesStream,
531 buffer: BytesMut,
532}
533
534const MAX_LINE_LENGTH: usize = 1024 * 1024;
535
536impl LineStream {
537 fn new(stream: BoxBytesStream) -> Self {
538 Self {
539 stream,
540 buffer: BytesMut::new(),
541 }
542 }
543}
544
545impl Stream for LineStream {
546 type Item = Result<String>;
547
548 fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
549 loop {
550 if let Some(pos) = self.buffer.iter().position(|&b| b == b'\n') {
554 if pos > MAX_LINE_LENGTH {
555 return Poll::Ready(Some(Err(crate::error::Error::Body(format!(
556 "response line exceeded maximum length of {MAX_LINE_LENGTH} bytes"
557 )))));
558 }
559 let line_bytes = self.buffer.split_to(pos + 1);
560 let mut line = &line_bytes[..line_bytes.len() - 1]; if line.ends_with(b"\r") {
562 line = &line[..line.len() - 1];
563 }
564 let line = std::str::from_utf8(line)
565 .map(str::to_owned)
566 .map_err(|e| crate::error::Error::Body(e.to_string()))?;
567 return Poll::Ready(Some(Ok(line)));
568 }
569
570 if self.buffer.len() > MAX_LINE_LENGTH {
572 return Poll::Ready(Some(Err(crate::error::Error::Body(format!(
573 "response line exceeded maximum length of {MAX_LINE_LENGTH} bytes"
574 )))));
575 }
576
577 match Pin::new(&mut self.stream).poll_next(cx) {
580 Poll::Ready(Some(Ok(chunk))) => {
581 if chunk.is_empty() {
582 continue;
586 }
587 if self.buffer.len().saturating_add(chunk.len()) > MAX_LINE_LENGTH {
594 let remaining = MAX_LINE_LENGTH.saturating_sub(self.buffer.len());
595 let prefix = &chunk[..remaining.min(chunk.len())];
600 if !prefix.contains(&b'\n') {
601 if let Some(pos) = chunk.iter().position(|&b| b == b'\n') {
606 if self.buffer.len() + pos > MAX_LINE_LENGTH {
607 return Poll::Ready(Some(Err(
608 crate::error::Error::Body(format!(
609 "response line exceeded maximum length of {MAX_LINE_LENGTH} bytes"
610 )),
611 )));
612 }
613 } else {
614 return Poll::Ready(Some(Err(
615 crate::error::Error::Body(format!(
616 "response line exceeded maximum length of {MAX_LINE_LENGTH} bytes"
617 )),
618 )));
619 }
620 }
621 }
622 self.buffer.extend_from_slice(&chunk);
623 }
624 Poll::Ready(Some(Err(e))) => return Poll::Ready(Some(Err(e))),
625 Poll::Ready(None) => {
626 if self.buffer.is_empty() {
628 return Poll::Ready(None);
629 }
630 let remaining = std::mem::take(&mut self.buffer);
631 if remaining.len() > MAX_LINE_LENGTH {
632 return Poll::Ready(Some(Err(crate::error::Error::Body(format!(
633 "response line exceeded maximum length of {MAX_LINE_LENGTH} bytes"
634 )))));
635 }
636 let mut line = &remaining[..remaining.len()];
637 if line.ends_with(b"\r") {
638 line = &line[..line.len() - 1];
639 }
640 let line = std::str::from_utf8(line)
641 .map(str::to_owned)
642 .map_err(|e| crate::error::Error::Body(e.to_string()))?;
643 return Poll::Ready(Some(Ok(line)));
644 }
645 Poll::Pending => return Poll::Pending,
646 }
647 }
648 }
649}
650
651#[cfg(test)]
652mod tests {
653 use super::*;
654 use http::HeaderValue;
655
656 #[test]
657 fn response_debug_redacts_sensitive_headers_and_url_parts() {
658 let mut headers = HeaderMap::new();
659 headers.insert("authorization", HeaderValue::from_static("Bearer secret"));
660 headers.insert("set-cookie", HeaderValue::from_static("session=secret"));
661 let response = Response::new(
662 StatusCode::FOUND,
663 Version::HTTP_11,
664 headers,
665 Url::parse("https://user:pass@example.com/path?token=secret#fragment").unwrap(),
666 ResponseBody::buffered(Bytes::new()),
667 );
668 let rendered = format!("{response:?}");
669 assert!(!rendered.contains("secret"));
670 assert!(!rendered.contains("user:pass"));
671 assert!(rendered.contains("https://example.com/path"));
672 }
673
674 #[test]
675 fn response_retains_wire_content_metadata_without_changing_headers() {
676 let mut headers = HeaderMap::new();
677 headers.insert("content-encoding", HeaderValue::from_static("gzip"));
678 headers.insert("content-length", HeaderValue::from_static("42"));
679 let response = Response::new(
680 StatusCode::OK,
681 Version::HTTP_11,
682 headers,
683 Url::parse("http://example.com").unwrap(),
684 ResponseBody::buffered(Bytes::new()),
685 );
686
687 assert_eq!(response.wire_content_encoding(), Some("gzip"));
688 assert_eq!(response.wire_content_length(), Some("42"));
689 assert_eq!(
690 response.headers().get("content-encoding"),
691 Some(&HeaderValue::from_static("gzip"))
692 );
693 assert_eq!(
694 response.headers().get("content-length"),
695 Some(&HeaderValue::from_static("42"))
696 );
697 assert_eq!(response.content_length(), Some(42));
698 }
699
700 #[test]
701 fn invalid_wire_content_length_is_not_inferred() {
702 let mut headers = HeaderMap::new();
703 headers.insert("content-length", HeaderValue::from_static("not-a-number"));
704 let response = Response::new(
705 StatusCode::OK,
706 Version::HTTP_11,
707 headers,
708 Url::parse("http://example.com").unwrap(),
709 ResponseBody::buffered(Bytes::from_static(b"1234")),
710 );
711 assert_eq!(response.content_length(), None);
712 }
713
714 #[cfg(feature = "json")]
715 #[tokio::test]
716 async fn response_json_deserializes_once_and_classifies_parse_errors() {
717 let mut response = Response::new(
718 StatusCode::OK,
719 Version::HTTP_11,
720 HeaderMap::new(),
721 Url::parse("http://example.com").unwrap(),
722 ResponseBody::buffered(Bytes::from_static(br#"{"key":"value"}"#)),
723 );
724 let value: serde_json::Value = response.json().await.unwrap();
725 assert_eq!(value["key"], "value");
726 assert!(matches!(response.bytes().await, Err(crate::Error::Body(_))));
727
728 let mut invalid = Response::new(
729 StatusCode::OK,
730 Version::HTTP_11,
731 HeaderMap::new(),
732 Url::parse("http://example.com").unwrap(),
733 ResponseBody::buffered(Bytes::from_static(b"{not-json")),
734 );
735 let error = invalid.json::<serde_json::Value>().await.unwrap_err();
736 assert_eq!(error.kind(), "json_deserialize");
737 assert!(!error.to_string().contains("not-json"));
738 }
739 use futures_util::StreamExt;
740
741 #[tokio::test]
742 async fn response_bytes_and_text() {
743 let mut resp = Response::new(
744 StatusCode::OK,
745 Version::HTTP_11,
746 HeaderMap::new(),
747 Url::parse("http://example.com").unwrap(),
748 ResponseBody::buffered(Bytes::from("hello")),
749 );
750 assert!(resp.is_success());
751 let text = resp.text().await.unwrap();
752 assert_eq!(text, "hello");
753 }
754
755 #[tokio::test]
756 async fn response_streaming_bytes_collect() {
757 let chunks = vec![Ok(Bytes::from("hello ")), Ok(Bytes::from("world"))];
758 let stream = Box::pin(futures_util::stream::iter(chunks));
759 let mut resp = Response::new(
760 StatusCode::OK,
761 Version::HTTP_11,
762 HeaderMap::new(),
763 Url::parse("http://example.com").unwrap(),
764 ResponseBody::streaming(stream),
765 );
766 let bytes = resp.bytes().await.unwrap();
767 assert_eq!(bytes, "hello world");
768 }
769
770 #[tokio::test]
771 async fn response_text_lines_rejects_unbounded_line() {
772 let stream = Box::pin(futures_util::stream::iter(vec![Ok(Bytes::from(vec![
773 b'a'; MAX_LINE_LENGTH + 1
774 ]))]));
775 let mut response = Response::new(
776 StatusCode::OK,
777 Version::HTTP_11,
778 HeaderMap::new(),
779 Url::parse("http://example.com").unwrap(),
780 ResponseBody::streaming(stream),
781 );
782 let mut lines = response.text_lines().unwrap();
783 let error = lines.next().await.unwrap().unwrap_err();
784 assert!(matches!(error, crate::error::Error::Body(_)));
785 }
786
787 #[tokio::test]
788 async fn response_text_lines_rejects_overlong_line_after_valid_line() {
789 let mut payload = b"ok\n".to_vec();
793 payload.extend_from_slice(&vec![b'a'; MAX_LINE_LENGTH + 1]);
794 payload.push(b'\n');
795 let stream = Box::pin(futures_util::stream::iter(vec![Ok(Bytes::from(payload))]));
796 let mut resp = Response::new(
797 StatusCode::OK,
798 Version::HTTP_11,
799 HeaderMap::new(),
800 Url::parse("http://example.com").unwrap(),
801 ResponseBody::streaming(stream),
802 );
803 let mut lines = resp.text_lines().unwrap();
804 assert_eq!(lines.next().await.unwrap().unwrap(), "ok");
805 let error = lines.next().await.unwrap().unwrap_err();
806 assert!(matches!(error, crate::error::Error::Body(_)));
807 }
808
809 #[tokio::test]
810 async fn response_text_lines_rejects_unbounded_terminal_line() {
811 let stream = Box::pin(futures_util::stream::iter(vec![Ok(Bytes::from(vec![
815 b'a'; MAX_LINE_LENGTH + 1
816 ]))]));
817 let mut resp = Response::new(
818 StatusCode::OK,
819 Version::HTTP_11,
820 HeaderMap::new(),
821 Url::parse("http://example.com").unwrap(),
822 ResponseBody::streaming(stream),
823 );
824 let mut lines = resp.text_lines().unwrap();
825 let error = lines.next().await.unwrap().unwrap_err();
826 assert!(matches!(error, crate::error::Error::Body(_)));
827 }
828
829 #[tokio::test]
830 async fn response_bytes_stream_yields_chunks() {
831 let chunks = vec![Ok(Bytes::from("a")), Ok(Bytes::from("b"))];
832 let stream = Box::pin(futures_util::stream::iter(chunks));
833 let mut resp = Response::new(
834 StatusCode::OK,
835 Version::HTTP_11,
836 HeaderMap::new(),
837 Url::parse("http://example.com").unwrap(),
838 ResponseBody::streaming(stream),
839 );
840 let mut stream = resp.bytes_stream().unwrap();
841 assert_eq!(stream.next().await.unwrap().unwrap(), "a");
842 assert_eq!(stream.next().await.unwrap().unwrap(), "b");
843 assert!(stream.next().await.is_none());
844 }
845
846 #[tokio::test]
847 async fn response_text_lines_basic() {
848 let chunks = vec![Ok(Bytes::from("line1\nline2\nline3\n"))];
849 let stream = Box::pin(futures_util::stream::iter(chunks));
850 let mut resp = Response::new(
851 StatusCode::OK,
852 Version::HTTP_11,
853 HeaderMap::new(),
854 Url::parse("http://example.com").unwrap(),
855 ResponseBody::streaming(stream),
856 );
857 let mut lines = resp.text_lines().unwrap();
858 assert_eq!(lines.next().await.unwrap().unwrap(), "line1");
859 assert_eq!(lines.next().await.unwrap().unwrap(), "line2");
860 assert_eq!(lines.next().await.unwrap().unwrap(), "line3");
861 assert!(lines.next().await.is_none());
862 }
863
864 #[tokio::test]
865 async fn response_text_lines_crlf() {
866 let chunks = vec![Ok(Bytes::from("line1\r\nline2\r\n"))];
867 let stream = Box::pin(futures_util::stream::iter(chunks));
868 let mut resp = Response::new(
869 StatusCode::OK,
870 Version::HTTP_11,
871 HeaderMap::new(),
872 Url::parse("http://example.com").unwrap(),
873 ResponseBody::streaming(stream),
874 );
875 let mut lines = resp.text_lines().unwrap();
876 assert_eq!(lines.next().await.unwrap().unwrap(), "line1");
877 assert_eq!(lines.next().await.unwrap().unwrap(), "line2");
878 assert!(lines.next().await.is_none());
879 }
880
881 #[tokio::test]
882 async fn response_text_lines_across_chunks() {
883 let chunks = vec![
884 Ok(Bytes::from("hel")),
885 Ok(Bytes::from("lo\nwor")),
886 Ok(Bytes::from("ld\n")),
887 ];
888 let stream = Box::pin(futures_util::stream::iter(chunks));
889 let mut resp = Response::new(
890 StatusCode::OK,
891 Version::HTTP_11,
892 HeaderMap::new(),
893 Url::parse("http://example.com").unwrap(),
894 ResponseBody::streaming(stream),
895 );
896 let mut lines = resp.text_lines().unwrap();
897 assert_eq!(lines.next().await.unwrap().unwrap(), "hello");
898 assert_eq!(lines.next().await.unwrap().unwrap(), "world");
899 assert!(lines.next().await.is_none());
900 }
901
902 #[tokio::test]
903 async fn response_text_lines_no_trailing_newline() {
904 let chunks = vec![Ok(Bytes::from("hello"))];
905 let stream = Box::pin(futures_util::stream::iter(chunks));
906 let mut resp = Response::new(
907 StatusCode::OK,
908 Version::HTTP_11,
909 HeaderMap::new(),
910 Url::parse("http://example.com").unwrap(),
911 ResponseBody::streaming(stream),
912 );
913 let mut lines = resp.text_lines().unwrap();
914 assert_eq!(lines.next().await.unwrap().unwrap(), "hello");
915 assert!(lines.next().await.is_none());
916 }
917
918 #[test]
919 fn trailers_absent_initially() {
920 let resp = Response::new(
921 StatusCode::OK,
922 Version::HTTP_11,
923 HeaderMap::new(),
924 Url::parse("http://example.com").unwrap(),
925 ResponseBody::buffered(Bytes::new()),
926 );
927 assert!(resp.trailers().is_none());
928 }
929
930 #[test]
931 fn trailers_preserve_duplicate_multi_value() {
932 use crate::body::SharedTrailers;
933 let shared = SharedTrailers::new();
934 let mut map = HeaderMap::new();
935 map.append("x-trailer", HeaderValue::from_static("a"));
936 map.append("x-trailer", HeaderValue::from_static("b"));
937 map.insert("x-single", HeaderValue::from_static("v"));
938 shared.store(map);
939 let mut resp = Response::new(
940 StatusCode::OK,
941 Version::HTTP_11,
942 HeaderMap::new(),
943 Url::parse("http://example.com").unwrap(),
944 ResponseBody::buffered(Bytes::new()),
945 );
946 resp.set_trailers(shared);
947 let trailers = resp.trailers().expect("trailers present");
948 let values: Vec<_> = trailers
949 .get_all("x-trailer")
950 .iter()
951 .map(|v| v.to_str().unwrap().to_owned())
952 .collect();
953 assert_eq!(values, vec!["a", "b"]);
954 assert_eq!(trailers.get("x-single").unwrap(), "v");
955 }
956
957 #[tokio::test]
958 async fn trailers_available_after_bytes_collection() {
959 use crate::body::SharedTrailers;
960 let shared = SharedTrailers::new();
963 let shared_for_stream = shared.clone();
964 let stream = Box::pin(futures_util::stream::unfold(0, move |step| {
965 let shared_for_stream = shared_for_stream.clone();
966 async move {
967 if step == 0 {
968 Some((Ok(Bytes::from("hello")), 1))
969 } else if step == 1 {
970 let mut map = HeaderMap::new();
971 map.insert("x-done", HeaderValue::from_static("yes"));
972 shared_for_stream.store(map);
973 None
974 } else {
975 None
976 }
977 }
978 }));
979 let mut resp = Response::new(
980 StatusCode::OK,
981 Version::HTTP_11,
982 HeaderMap::new(),
983 Url::parse("http://example.com").unwrap(),
984 ResponseBody::streaming(stream),
985 );
986 resp.set_trailers(shared);
987 assert!(
988 resp.trailers().is_none(),
989 "partial consumption reports None"
990 );
991 let bytes = resp.bytes().await.unwrap();
992 assert_eq!(bytes, "hello");
993 assert_eq!(
994 resp.trailers().unwrap().get("x-done").unwrap(),
995 "yes",
996 "trailers available after body completion"
997 );
998 }
999
1000 #[tokio::test]
1001 async fn partial_consumption_does_not_falsely_report_trailers() {
1002 let stream = Box::pin(futures_util::stream::iter(vec![Ok(Bytes::from("a"))]));
1003 let mut resp = Response::new(
1004 StatusCode::OK,
1005 Version::HTTP_11,
1006 HeaderMap::new(),
1007 Url::parse("http://example.com").unwrap(),
1008 ResponseBody::streaming(stream),
1009 );
1010 let mut s = resp.bytes_stream().unwrap();
1012 assert_eq!(s.next().await.unwrap().unwrap(), "a");
1013 assert!(resp.trailers().is_none());
1014 }
1015
1016 #[tokio::test]
1017 async fn body_error_before_trailers_leaves_no_trailers() {
1018 use crate::body::SharedTrailers;
1019 let shared = SharedTrailers::new();
1020 let stream = Box::pin(futures_util::stream::iter(vec![
1021 Ok(Bytes::from("a")),
1022 Err(crate::error::Error::Body("boom".into())),
1023 ]));
1024 let mut resp = Response::new(
1025 StatusCode::OK,
1026 Version::HTTP_11,
1027 HeaderMap::new(),
1028 Url::parse("http://example.com").unwrap(),
1029 ResponseBody::streaming(stream),
1030 );
1031 resp.set_trailers(shared);
1032 let err = resp.bytes().await.unwrap_err();
1033 assert!(matches!(err, crate::error::Error::Body(_)));
1034 assert!(
1035 resp.trailers().is_none(),
1036 "body errors must not fabricate trailer state"
1037 );
1038 }
1039}