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 let wire_content_encoding = headers
212 .get("content-encoding")
213 .and_then(|value| value.to_str().ok())
214 .map(ToOwned::to_owned);
215 let wire_content_length = headers
216 .get("content-length")
217 .and_then(|value| value.to_str().ok())
218 .map(ToOwned::to_owned);
219 Self {
220 status,
221 version,
222 headers,
223 url,
224 wire_content_encoding,
225 wire_content_length,
226 wire_reason_phrase: None,
227 body,
228 history: Vec::new(),
229 trailers: SharedTrailers::new(),
230 network_stream: None,
231 }
232 }
233
234 pub(crate) fn set_body(&mut self, body: ResponseBody) {
237 self.body = body;
238 }
239
240 pub(crate) fn set_trailers(&mut self, trailers: SharedTrailers) {
246 self.trailers = trailers;
247 }
248
249 #[must_use]
259 pub fn trailers(&self) -> Option<HeaderMap> {
260 self.trailers.get()
261 }
262
263 #[allow(dead_code)]
265 pub(crate) fn into_body(self) -> ResponseBody {
266 self.body
267 }
268
269 #[must_use]
271 pub fn status(&self) -> StatusCode {
272 self.status
273 }
274
275 #[must_use]
277 pub fn version(&self) -> Version {
278 self.version
279 }
280
281 #[must_use]
283 pub fn headers(&self) -> &HeaderMap {
284 &self.headers
285 }
286
287 pub fn headers_mut(&mut self) -> &mut HeaderMap {
289 &mut self.headers
290 }
291
292 #[must_use]
298 pub fn wire_content_encoding(&self) -> Option<&str> {
299 self.wire_content_encoding.as_deref()
300 }
301
302 #[must_use]
307 pub fn wire_content_length(&self) -> Option<&str> {
308 self.wire_content_length.as_deref()
309 }
310
311 #[must_use]
317 pub fn content_length(&self) -> Option<u64> {
318 self.wire_content_length.as_deref()?.parse().ok()
319 }
320
321 #[must_use]
327 pub fn wire_reason_phrase(&self) -> Option<&str> {
328 self.wire_reason_phrase.as_deref()
329 }
330
331 #[allow(dead_code)]
336 pub(crate) fn set_wire_reason_phrase(&mut self, reason: Option<String>) {
337 self.wire_reason_phrase = reason;
338 }
339
340 #[must_use]
342 pub fn url(&self) -> &Url {
343 &self.url
344 }
345
346 #[must_use]
348 pub fn history(&self) -> &[HistoryEntry] {
349 &self.history
350 }
351
352 pub fn history_mut(&mut self) -> &mut Vec<HistoryEntry> {
354 &mut self.history
355 }
356
357 #[cfg(feature = "redirects")]
362 pub(crate) fn set_history(&mut self, history: Vec<HistoryEntry>) {
363 self.history = history;
364 }
365
366 #[must_use]
368 pub fn is_success(&self) -> bool {
369 self.status.is_success()
370 }
371
372 #[must_use]
374 pub fn body(&self) -> &ResponseBody {
375 &self.body
376 }
377
378 pub fn body_mut(&mut self) -> &mut ResponseBody {
380 &mut self.body
381 }
382
383 pub async fn bytes(&mut self) -> Result<Bytes> {
393 self.body.bytes().await
394 }
395
396 pub async fn text(&mut self) -> Result<String> {
403 self.body.text().await
404 }
405
406 #[cfg(feature = "json")]
418 pub async fn json<T: serde::de::DeserializeOwned>(&mut self) -> Result<T> {
419 let bytes = self.bytes().await?;
420 serde_json::from_slice(&bytes).map_err(|error| {
421 crate::Error::JsonDeserialize(format!(
422 "invalid JSON at line {}, column {}",
423 error.line(),
424 error.column()
425 ))
426 })
427 }
428
429 pub fn bytes_stream(&mut self) -> Result<BoxBytesStream> {
438 self.body.bytes_stream()
439 }
440
441 pub fn raw_bytes_stream(&mut self) -> Result<BoxBytesStream> {
451 self.body.raw_bytes_stream()
452 }
453
454 pub fn text_lines(&mut self) -> Result<impl Stream<Item = Result<String>>> {
465 let byte_stream = self.bytes_stream()?;
466 Ok(LineStream::new(byte_stream))
467 }
468
469 #[must_use]
475 pub fn network_stream(&self) -> Option<&NetworkStream> {
476 self.network_stream.as_ref()
477 }
478
479 pub fn network_stream_mut(&mut self) -> Option<&mut NetworkStream> {
481 self.network_stream.as_mut()
482 }
483
484 #[must_use]
488 pub fn take_network_stream(&mut self) -> Option<NetworkStream> {
489 self.network_stream.take()
490 }
491
492 pub(crate) fn set_network_stream(&mut self, stream: NetworkStream) {
494 self.network_stream = Some(stream);
495 }
496
497 #[must_use]
502 pub fn into_network_stream(self) -> Option<NetworkStream> {
503 self.network_stream
504 }
505}
506
507struct LineStream {
509 stream: BoxBytesStream,
510 buffer: BytesMut,
511}
512
513const MAX_LINE_LENGTH: usize = 1024 * 1024;
514
515impl LineStream {
516 fn new(stream: BoxBytesStream) -> Self {
517 Self {
518 stream,
519 buffer: BytesMut::new(),
520 }
521 }
522}
523
524impl Stream for LineStream {
525 type Item = Result<String>;
526
527 fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
528 loop {
529 if let Some(pos) = self.buffer.iter().position(|&b| b == b'\n') {
533 if pos > MAX_LINE_LENGTH {
534 return Poll::Ready(Some(Err(crate::error::Error::Body(format!(
535 "response line exceeded maximum length of {MAX_LINE_LENGTH} bytes"
536 )))));
537 }
538 let line_bytes = self.buffer.split_to(pos + 1);
539 let mut line = &line_bytes[..line_bytes.len() - 1]; if line.ends_with(b"\r") {
541 line = &line[..line.len() - 1];
542 }
543 let line = std::str::from_utf8(line)
544 .map(str::to_owned)
545 .map_err(|e| crate::error::Error::Body(e.to_string()))?;
546 return Poll::Ready(Some(Ok(line)));
547 }
548
549 if self.buffer.len() > MAX_LINE_LENGTH {
551 return Poll::Ready(Some(Err(crate::error::Error::Body(format!(
552 "response line exceeded maximum length of {MAX_LINE_LENGTH} bytes"
553 )))));
554 }
555
556 match Pin::new(&mut self.stream).poll_next(cx) {
559 Poll::Ready(Some(Ok(chunk))) => {
560 if chunk.is_empty() {
561 continue;
565 }
566 if self.buffer.len().saturating_add(chunk.len()) > MAX_LINE_LENGTH {
573 let remaining = MAX_LINE_LENGTH.saturating_sub(self.buffer.len());
574 let prefix = &chunk[..remaining.min(chunk.len())];
579 if !prefix.contains(&b'\n') {
580 if let Some(pos) = chunk.iter().position(|&b| b == b'\n') {
585 if self.buffer.len() + pos > MAX_LINE_LENGTH {
586 return Poll::Ready(Some(Err(
587 crate::error::Error::Body(format!(
588 "response line exceeded maximum length of {MAX_LINE_LENGTH} bytes"
589 )),
590 )));
591 }
592 } else {
593 return Poll::Ready(Some(Err(
594 crate::error::Error::Body(format!(
595 "response line exceeded maximum length of {MAX_LINE_LENGTH} bytes"
596 )),
597 )));
598 }
599 }
600 }
601 self.buffer.extend_from_slice(&chunk);
602 }
603 Poll::Ready(Some(Err(e))) => return Poll::Ready(Some(Err(e))),
604 Poll::Ready(None) => {
605 if self.buffer.is_empty() {
607 return Poll::Ready(None);
608 }
609 let remaining = std::mem::take(&mut self.buffer);
610 if remaining.len() > MAX_LINE_LENGTH {
611 return Poll::Ready(Some(Err(crate::error::Error::Body(format!(
612 "response line exceeded maximum length of {MAX_LINE_LENGTH} bytes"
613 )))));
614 }
615 let mut line = &remaining[..remaining.len()];
616 if line.ends_with(b"\r") {
617 line = &line[..line.len() - 1];
618 }
619 let line = std::str::from_utf8(line)
620 .map(str::to_owned)
621 .map_err(|e| crate::error::Error::Body(e.to_string()))?;
622 return Poll::Ready(Some(Ok(line)));
623 }
624 Poll::Pending => return Poll::Pending,
625 }
626 }
627 }
628}
629
630#[cfg(test)]
631mod tests {
632 use super::*;
633 use http::HeaderValue;
634
635 #[test]
636 fn response_debug_redacts_sensitive_headers_and_url_parts() {
637 let mut headers = HeaderMap::new();
638 headers.insert("authorization", HeaderValue::from_static("Bearer secret"));
639 headers.insert("set-cookie", HeaderValue::from_static("session=secret"));
640 let response = Response::new(
641 StatusCode::FOUND,
642 Version::HTTP_11,
643 headers,
644 Url::parse("https://user:pass@example.com/path?token=secret#fragment").unwrap(),
645 ResponseBody::buffered(Bytes::new()),
646 );
647 let rendered = format!("{response:?}");
648 assert!(!rendered.contains("secret"));
649 assert!(!rendered.contains("user:pass"));
650 assert!(rendered.contains("https://example.com/path"));
651 }
652
653 #[test]
654 fn response_retains_wire_content_metadata_without_changing_headers() {
655 let mut headers = HeaderMap::new();
656 headers.insert("content-encoding", HeaderValue::from_static("gzip"));
657 headers.insert("content-length", HeaderValue::from_static("42"));
658 let response = Response::new(
659 StatusCode::OK,
660 Version::HTTP_11,
661 headers,
662 Url::parse("http://example.com").unwrap(),
663 ResponseBody::buffered(Bytes::new()),
664 );
665
666 assert_eq!(response.wire_content_encoding(), Some("gzip"));
667 assert_eq!(response.wire_content_length(), Some("42"));
668 assert_eq!(
669 response.headers().get("content-encoding"),
670 Some(&HeaderValue::from_static("gzip"))
671 );
672 assert_eq!(
673 response.headers().get("content-length"),
674 Some(&HeaderValue::from_static("42"))
675 );
676 assert_eq!(response.content_length(), Some(42));
677 }
678
679 #[test]
680 fn invalid_wire_content_length_is_not_inferred() {
681 let mut headers = HeaderMap::new();
682 headers.insert("content-length", HeaderValue::from_static("not-a-number"));
683 let response = Response::new(
684 StatusCode::OK,
685 Version::HTTP_11,
686 headers,
687 Url::parse("http://example.com").unwrap(),
688 ResponseBody::buffered(Bytes::from_static(b"1234")),
689 );
690 assert_eq!(response.content_length(), None);
691 }
692
693 #[cfg(feature = "json")]
694 #[tokio::test]
695 async fn response_json_deserializes_once_and_classifies_parse_errors() {
696 let mut response = Response::new(
697 StatusCode::OK,
698 Version::HTTP_11,
699 HeaderMap::new(),
700 Url::parse("http://example.com").unwrap(),
701 ResponseBody::buffered(Bytes::from_static(br#"{"key":"value"}"#)),
702 );
703 let value: serde_json::Value = response.json().await.unwrap();
704 assert_eq!(value["key"], "value");
705 assert!(matches!(response.bytes().await, Err(crate::Error::Body(_))));
706
707 let mut invalid = Response::new(
708 StatusCode::OK,
709 Version::HTTP_11,
710 HeaderMap::new(),
711 Url::parse("http://example.com").unwrap(),
712 ResponseBody::buffered(Bytes::from_static(b"{not-json")),
713 );
714 let error = invalid.json::<serde_json::Value>().await.unwrap_err();
715 assert_eq!(error.kind(), "json_deserialize");
716 assert!(!error.to_string().contains("not-json"));
717 }
718 use futures_util::StreamExt;
719
720 #[tokio::test]
721 async fn response_bytes_and_text() {
722 let mut resp = Response::new(
723 StatusCode::OK,
724 Version::HTTP_11,
725 HeaderMap::new(),
726 Url::parse("http://example.com").unwrap(),
727 ResponseBody::buffered(Bytes::from("hello")),
728 );
729 assert!(resp.is_success());
730 let text = resp.text().await.unwrap();
731 assert_eq!(text, "hello");
732 }
733
734 #[tokio::test]
735 async fn response_streaming_bytes_collect() {
736 let chunks = vec![Ok(Bytes::from("hello ")), Ok(Bytes::from("world"))];
737 let stream = Box::pin(futures_util::stream::iter(chunks));
738 let mut resp = Response::new(
739 StatusCode::OK,
740 Version::HTTP_11,
741 HeaderMap::new(),
742 Url::parse("http://example.com").unwrap(),
743 ResponseBody::streaming(stream),
744 );
745 let bytes = resp.bytes().await.unwrap();
746 assert_eq!(bytes, "hello world");
747 }
748
749 #[tokio::test]
750 async fn response_text_lines_rejects_unbounded_line() {
751 let stream = Box::pin(futures_util::stream::iter(vec![Ok(Bytes::from(vec![
752 b'a'; MAX_LINE_LENGTH + 1
753 ]))]));
754 let mut response = Response::new(
755 StatusCode::OK,
756 Version::HTTP_11,
757 HeaderMap::new(),
758 Url::parse("http://example.com").unwrap(),
759 ResponseBody::streaming(stream),
760 );
761 let mut lines = response.text_lines().unwrap();
762 let error = lines.next().await.unwrap().unwrap_err();
763 assert!(matches!(error, crate::error::Error::Body(_)));
764 }
765
766 #[tokio::test]
767 async fn response_text_lines_rejects_overlong_line_after_valid_line() {
768 let mut payload = b"ok\n".to_vec();
772 payload.extend_from_slice(&vec![b'a'; MAX_LINE_LENGTH + 1]);
773 payload.push(b'\n');
774 let stream = Box::pin(futures_util::stream::iter(vec![Ok(Bytes::from(payload))]));
775 let mut resp = 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 = resp.text_lines().unwrap();
783 assert_eq!(lines.next().await.unwrap().unwrap(), "ok");
784 let error = lines.next().await.unwrap().unwrap_err();
785 assert!(matches!(error, crate::error::Error::Body(_)));
786 }
787
788 #[tokio::test]
789 async fn response_text_lines_rejects_unbounded_terminal_line() {
790 let stream = Box::pin(futures_util::stream::iter(vec![Ok(Bytes::from(vec![
794 b'a'; MAX_LINE_LENGTH + 1
795 ]))]));
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 let error = lines.next().await.unwrap().unwrap_err();
805 assert!(matches!(error, crate::error::Error::Body(_)));
806 }
807
808 #[tokio::test]
809 async fn response_bytes_stream_yields_chunks() {
810 let chunks = vec![Ok(Bytes::from("a")), Ok(Bytes::from("b"))];
811 let stream = Box::pin(futures_util::stream::iter(chunks));
812 let mut resp = Response::new(
813 StatusCode::OK,
814 Version::HTTP_11,
815 HeaderMap::new(),
816 Url::parse("http://example.com").unwrap(),
817 ResponseBody::streaming(stream),
818 );
819 let mut stream = resp.bytes_stream().unwrap();
820 assert_eq!(stream.next().await.unwrap().unwrap(), "a");
821 assert_eq!(stream.next().await.unwrap().unwrap(), "b");
822 assert!(stream.next().await.is_none());
823 }
824
825 #[tokio::test]
826 async fn response_text_lines_basic() {
827 let chunks = vec![Ok(Bytes::from("line1\nline2\nline3\n"))];
828 let stream = Box::pin(futures_util::stream::iter(chunks));
829 let mut resp = Response::new(
830 StatusCode::OK,
831 Version::HTTP_11,
832 HeaderMap::new(),
833 Url::parse("http://example.com").unwrap(),
834 ResponseBody::streaming(stream),
835 );
836 let mut lines = resp.text_lines().unwrap();
837 assert_eq!(lines.next().await.unwrap().unwrap(), "line1");
838 assert_eq!(lines.next().await.unwrap().unwrap(), "line2");
839 assert_eq!(lines.next().await.unwrap().unwrap(), "line3");
840 assert!(lines.next().await.is_none());
841 }
842
843 #[tokio::test]
844 async fn response_text_lines_crlf() {
845 let chunks = vec![Ok(Bytes::from("line1\r\nline2\r\n"))];
846 let stream = Box::pin(futures_util::stream::iter(chunks));
847 let mut resp = Response::new(
848 StatusCode::OK,
849 Version::HTTP_11,
850 HeaderMap::new(),
851 Url::parse("http://example.com").unwrap(),
852 ResponseBody::streaming(stream),
853 );
854 let mut lines = resp.text_lines().unwrap();
855 assert_eq!(lines.next().await.unwrap().unwrap(), "line1");
856 assert_eq!(lines.next().await.unwrap().unwrap(), "line2");
857 assert!(lines.next().await.is_none());
858 }
859
860 #[tokio::test]
861 async fn response_text_lines_across_chunks() {
862 let chunks = vec![
863 Ok(Bytes::from("hel")),
864 Ok(Bytes::from("lo\nwor")),
865 Ok(Bytes::from("ld\n")),
866 ];
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(), "hello");
877 assert_eq!(lines.next().await.unwrap().unwrap(), "world");
878 assert!(lines.next().await.is_none());
879 }
880
881 #[tokio::test]
882 async fn response_text_lines_no_trailing_newline() {
883 let chunks = vec![Ok(Bytes::from("hello"))];
884 let stream = Box::pin(futures_util::stream::iter(chunks));
885 let mut resp = Response::new(
886 StatusCode::OK,
887 Version::HTTP_11,
888 HeaderMap::new(),
889 Url::parse("http://example.com").unwrap(),
890 ResponseBody::streaming(stream),
891 );
892 let mut lines = resp.text_lines().unwrap();
893 assert_eq!(lines.next().await.unwrap().unwrap(), "hello");
894 assert!(lines.next().await.is_none());
895 }
896
897 #[test]
898 fn trailers_absent_initially() {
899 let resp = Response::new(
900 StatusCode::OK,
901 Version::HTTP_11,
902 HeaderMap::new(),
903 Url::parse("http://example.com").unwrap(),
904 ResponseBody::buffered(Bytes::new()),
905 );
906 assert!(resp.trailers().is_none());
907 }
908
909 #[test]
910 fn trailers_preserve_duplicate_multi_value() {
911 use crate::body::SharedTrailers;
912 let shared = SharedTrailers::new();
913 let mut map = HeaderMap::new();
914 map.append("x-trailer", HeaderValue::from_static("a"));
915 map.append("x-trailer", HeaderValue::from_static("b"));
916 map.insert("x-single", HeaderValue::from_static("v"));
917 shared.store(map);
918 let mut resp = Response::new(
919 StatusCode::OK,
920 Version::HTTP_11,
921 HeaderMap::new(),
922 Url::parse("http://example.com").unwrap(),
923 ResponseBody::buffered(Bytes::new()),
924 );
925 resp.set_trailers(shared);
926 let trailers = resp.trailers().expect("trailers present");
927 let values: Vec<_> = trailers
928 .get_all("x-trailer")
929 .iter()
930 .map(|v| v.to_str().unwrap().to_owned())
931 .collect();
932 assert_eq!(values, vec!["a", "b"]);
933 assert_eq!(trailers.get("x-single").unwrap(), "v");
934 }
935
936 #[tokio::test]
937 async fn trailers_available_after_bytes_collection() {
938 use crate::body::SharedTrailers;
939 let shared = SharedTrailers::new();
942 let shared_for_stream = shared.clone();
943 let stream = Box::pin(futures_util::stream::unfold(0, move |step| {
944 let shared_for_stream = shared_for_stream.clone();
945 async move {
946 if step == 0 {
947 Some((Ok(Bytes::from("hello")), 1))
948 } else if step == 1 {
949 let mut map = HeaderMap::new();
950 map.insert("x-done", HeaderValue::from_static("yes"));
951 shared_for_stream.store(map);
952 None
953 } else {
954 None
955 }
956 }
957 }));
958 let mut resp = Response::new(
959 StatusCode::OK,
960 Version::HTTP_11,
961 HeaderMap::new(),
962 Url::parse("http://example.com").unwrap(),
963 ResponseBody::streaming(stream),
964 );
965 resp.set_trailers(shared);
966 assert!(
967 resp.trailers().is_none(),
968 "partial consumption reports None"
969 );
970 let bytes = resp.bytes().await.unwrap();
971 assert_eq!(bytes, "hello");
972 assert_eq!(
973 resp.trailers().unwrap().get("x-done").unwrap(),
974 "yes",
975 "trailers available after body completion"
976 );
977 }
978
979 #[tokio::test]
980 async fn partial_consumption_does_not_falsely_report_trailers() {
981 let stream = Box::pin(futures_util::stream::iter(vec![Ok(Bytes::from("a"))]));
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 let mut s = resp.bytes_stream().unwrap();
991 assert_eq!(s.next().await.unwrap().unwrap(), "a");
992 assert!(resp.trailers().is_none());
993 }
994
995 #[tokio::test]
996 async fn body_error_before_trailers_leaves_no_trailers() {
997 use crate::body::SharedTrailers;
998 let shared = SharedTrailers::new();
999 let stream = Box::pin(futures_util::stream::iter(vec![
1000 Ok(Bytes::from("a")),
1001 Err(crate::error::Error::Body("boom".into())),
1002 ]));
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 resp.set_trailers(shared);
1011 let err = resp.bytes().await.unwrap_err();
1012 assert!(matches!(err, crate::error::Error::Body(_)));
1013 assert!(
1014 resp.trailers().is_none(),
1015 "body errors must not fabricate trailer state"
1016 );
1017 }
1018}