fetch 0.13.0

HTTP client with resilience, observability, and Tokio runtime support.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

use std::fmt::Debug;

use layered::{Layer, Service};

use crate::{HttpRequest, HttpResponse, RequestHandler, Result};

/// Buffers the entire HTTP response body into memory.
///
/// Wraps any [`RequestHandler`] to transparently buffer response bodies.
/// After the inner handler produces a response, this handler calls
/// [`HttpBody::into_buffered`][crate::HttpBody::into_buffered] to load the full body into memory,
/// freeing the underlying network connection.
///
/// This is useful when downstream consumers need to read the body
/// multiple times (e.g. for cloning, retries, or inspecting the payload)
/// or when you want to release the connection back to the pool as early
/// as possible.
#[derive(Debug)]
pub struct Buffering<T> {
    inner: T,
}

/// Layer for creating [`Buffering`] instances.
#[derive(Debug, Clone, Copy)]
pub struct BufferingLayer;

impl Buffering<()> {
    /// Creates a new buffering handler layer.
    #[must_use]
    pub fn layer() -> BufferingLayer {
        BufferingLayer
    }
}

impl<S> Layer<S> for BufferingLayer {
    type Service = Buffering<S>;

    fn layer(&self, inner: S) -> Self::Service {
        Buffering { inner }
    }
}

impl<T: RequestHandler> Service<HttpRequest> for Buffering<T> {
    type Out = Result<HttpResponse>;

    async fn execute(&self, input: HttpRequest) -> Result<HttpResponse> {
        let response = self.inner.execute(input).await?;

        let (parts, body) = response.into_parts();
        let body = body.into_buffered().await?;

        Ok(HttpResponse::from_parts(parts, body))
    }
}

#[cfg(test)]
#[cfg_attr(coverage_nightly, coverage(off))]
mod tests {
    use http::{StatusCode, Uri};
    use http_extensions::{FakeHandler, HttpBodyBuilder, HttpRequestBuilder};

    use super::*;
    use crate::error_labels::collect_error_labels;
    use crate::handlers::Dispatch;

    #[cfg_attr(miri, ignore)]
    #[tokio::test]
    async fn buffers_response_body() {
        let inner = Dispatch::new_fake(FakeHandler::from(StatusCode::OK));
        let handler = Buffering { inner };

        let request = HttpRequestBuilder::new_fake().uri("https://example.com/path").build().unwrap();

        let response = handler.execute(request).await.unwrap();
        assert_eq!(response.status(), StatusCode::OK);

        // A buffered body should be cloneable.
        assert!(response.body().try_clone().is_some());
    }

    #[cfg_attr(miri, ignore)]
    #[tokio::test]
    async fn propagates_inner_handler_error() {
        let inner = Dispatch::new_fake(FakeHandler::never_completes());
        let handler = Buffering { inner };

        // Request without scheme/authority triggers a validation error in Dispatch.
        let request = http::Request::get(Uri::from_static("/no-authority"))
            .body(HttpBodyBuilder::new_fake().empty())
            .unwrap();

        let result: Result<HttpResponse> = handler.execute(request).await;
        let error = result.unwrap_err();
        assert_eq!(collect_error_labels(&error), "uri_origin_missing");
    }

    #[cfg_attr(miri, ignore)]
    #[tokio::test]
    async fn layer_constructs_handler() {
        let layer = Buffering::layer();
        let inner = Dispatch::new_fake(FakeHandler::from(StatusCode::NO_CONTENT));
        let handler = layer.layer(inner);

        let request = HttpRequestBuilder::new_fake().uri("https://example.com/test").build().unwrap();

        let response = handler.execute(request).await.unwrap();
        assert_eq!(response.status(), StatusCode::NO_CONTENT);
    }
}