rama-http 0.3.0-rc1

//! Set a header on the response.
//!
//! The header value to be set may be provided as a fixed value when the
//! middleware is constructed, or determined dynamically based on the response
//! by a closure. See the [`MakeHeaderValue`] trait for details.
//!
//! # Example
//!
//! Setting a header from a fixed value provided when the middleware is constructed:
//!
//! ```
//! use rama_http::layer::set_header::SetResponseHeaderLayer;
//! use rama_http::{Body, Request, Response, header::{self, HeaderValue}};
//! use rama_core::service::service_fn;
//! use rama_core::{Service, Layer};
//! use rama_core::error::BoxError;
//!
//! # #[tokio::main]
//! # async fn main() -> Result<(), BoxError> {
//! # let render_html = service_fn(async |request: Request| {
//! #     Ok::<_, std::convert::Infallible>(Response::new(request.into_body()))
//! # });
//! #
//! let mut svc = (
//!     // Layer that sets `Content-Type: text/html` on responses.
//!     //
//!     // `if_not_present` will only insert the header if it does not already
//!     // have a value.
//!     SetResponseHeaderLayer::if_not_present(
//!         header::CONTENT_TYPE,
//!         HeaderValue::from_static("text/html"),
//!     ),
//! ).into_layer(render_html);
//!
//! let request = Request::new(Body::empty());
//!
//! let response = svc.serve(request).await?;
//!
//! assert_eq!(response.headers()["content-type"], "text/html");
//! #
//! # Ok(())
//! # }
//! ```
//!
//! Setting a header based on a value determined dynamically from the response:
//!
//! ```
//! use rama_core::error::BoxError;
//! use rama_core::service::service_fn;
//! use rama_core::{Layer, Service};
//! use rama_http::StreamingBody as _;
//! use rama_http::layer::set_header::SetResponseHeaderLayer;
//! use rama_http::{
//!     header::{self, HeaderValue},
//!     Body, Request, Response,
//! };
//!
//! #[tokio::main]
//! async fn main() -> Result<(), BoxError> {
//!     let render_html = service_fn(async |_request: Request| {
//!         Ok::<_, std::convert::Infallible>(Response::new(Body::from("1234567890")))
//!     });
//!
//!     let svc = (
//!         // Layer that sets `Content-Length` if the body has a known size.
//!         // Bodies with streaming responses wont have a known size.
//!         //
//!         // `overriding` will insert the header and override any previous values it
//!         // may have.
//!         SetResponseHeaderLayer::overriding_fn(
//!             header::CONTENT_LENGTH,
//!             async |response: Response| {
//!                 let value = if let Some(size) = response.body().size_hint().exact() {
//!                     // If the response body has a known size, returning `Some` will
//!                     // set the `Content-Length` header to that value.
//!                     Some(HeaderValue::try_from(size.to_string()).unwrap())
//!                 } else {
//!                     // If the response body doesn't have a known size, return `None`
//!                     // to skip setting the header on this response.
//!                     None
//!                 };
//!                 (response, value)
//!             },
//!         ),
//!     )
//!         .into_layer(render_html);
//!
//!     let request = Request::new(Body::empty());
//!
//!     let response = svc.serve(request).await?;
//!
//!     assert_eq!(response.headers()["content-length"], "10");
//!
//!     Ok(())
//! }
//! ```
//!
//! Setting a header based on the incoming Context and response combined.
//!
//! ```
//! use rama_core::{extensions::{Extension, ExtensionsRef}, service::service_fn, Service};
//! use rama_http::{
//!     layer::set_header::{response::BoxMakeHeaderValueFn, SetResponseHeader},
//!     Body, HeaderName, HeaderValue, Request, Response,
//!     service::web::response::IntoResponse,
//! };
//! use std::convert::Infallible;
//!
//! #[tokio::main]
//! async fn main() {
//!     #[derive(Debug, Clone, Extension)]
//!     struct RequestID(String);
//!
//!     #[derive(Debug, Clone, Extension)]
//!     struct Success;
//!
//!     let svc = SetResponseHeader::overriding_fn(
//!         service_fn(async || {
//!             let mut res = ().into_response();
//!             res.extensions().insert(Success);
//!             Ok::<_, Infallible>(res)
//!         }),
//!         HeaderName::from_static("x-used-request-id"),
//!         async |req: Request| {
//!             let factory = req.extensions().get_ref::<RequestID>().cloned().map(|id| {
//!                 BoxMakeHeaderValueFn::new(async move |res: Response| {
//!                     let header_value = res.extensions().get_ref::<Success>().map(|_| {
//!                         HeaderValue::from_str(id.0.as_str()).unwrap()
//!                     });
//!                     (res, header_value)
//!                 })
//!             });
//!             (req, factory)
//!         },
//!     );
//!
//!     const FAKE_USER_ID: &str = "abc123";
//!
//!     let mut req = Request::new(Body::empty());
//!     req.extensions().insert(RequestID(FAKE_USER_ID.to_owned()));
//!
//!     let res = svc.serve(req).await.unwrap();
//!
//!     let mut values = res
//!         .headers()
//!         .get_all(HeaderName::from_static("x-used-request-id"))
//!         .iter();
//!     assert_eq!(values.next().unwrap(), FAKE_USER_ID);
//!     assert_eq!(values.next(), None);
//! }
//! ```

use crate::{HeaderValue, Request, Response, header::HeaderName, headers::HeaderEncode};
use rama_core::{Layer, Service};
use rama_http_headers::TypedHeader;
use rama_utils::macros::define_inner_service_accessors;
use std::fmt;

mod header;
use header::InsertHeaderMode;

pub use header::{
    BoxMakeHeaderValueFactoryFn, BoxMakeHeaderValueFn, MakeHeaderValue, MakeHeaderValueDefault,
    MakeHeaderValueFactory, MakeHeaderValueFactoryFn, MakeHeaderValueFn, TypedHeaderAsMaker,
};

/// Layer that applies [`SetResponseHeader`] which adds a response header.
///
/// See [`SetResponseHeader`] for more details.
#[derive(Clone)]
pub struct SetResponseHeaderLayer<M> {
    header_name: HeaderName,
    make: M,
    mode: InsertHeaderMode,
}

impl<M> fmt::Debug for SetResponseHeaderLayer<M> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("SetResponseHeaderLayer")
            .field("header_name", &self.header_name)
            .field("mode", &self.mode)
            .field("make", &std::any::type_name::<M>())
            .finish()
    }
}

impl<M> SetResponseHeaderLayer<M> {
    /// Create a new [`SetResponseHeaderLayer`].
    ///
    /// If a previous value exists for the same header, it is removed and replaced with the new
    /// header value.
    #[inline(always)]
    pub fn overriding(header_name: HeaderName, make: M) -> Self {
        Self::new(header_name, make, InsertHeaderMode::Override)
    }

    /// Create a new [`SetResponseHeaderLayer`].
    ///
    /// The new header is always added, preserving any existing values. If previous values exist,
    /// the header will have multiple values.
    #[inline(always)]
    pub fn appending(header_name: HeaderName, make: M) -> Self {
        Self::new(header_name, make, InsertHeaderMode::Append)
    }

    /// Create a new [`SetResponseHeaderLayer`].
    ///
    /// If a previous value exists for the header, the new value is not inserted.
    #[inline(always)]
    pub fn if_not_present(header_name: HeaderName, make: M) -> Self {
        Self::new(header_name, make, InsertHeaderMode::IfNotPresent)
    }

    #[inline(always)]
    fn new(header_name: HeaderName, make: M, mode: InsertHeaderMode) -> Self {
        Self {
            make,
            header_name,
            mode,
        }
    }
}

impl SetResponseHeaderLayer<Option<HeaderValue>> {
    /// Create a new [`SetResponseHeaderLayer`] from a typed [`HeaderEncode`].
    ///
    /// See [`SetResponseHeaderLayer::overriding`] for more details.
    #[inline(always)]
    pub fn overriding_typed<H: HeaderEncode>(header: H) -> Self {
        Self::overriding(H::name().clone(), header.encode_to_value())
    }

    /// Create a new [`SetResponseHeaderLayer`] from a typed [`HeaderEncode`].
    ///
    /// See [`SetResponseHeaderLayer::appending`] for more details.
    #[inline(always)]
    pub fn appending_typed<H: HeaderEncode>(header: H) -> Self {
        Self::appending(H::name().clone(), header.encode_to_value())
    }

    /// Create a new [`SetResponseHeaderLayer`] from a typed [`HeaderEncode`].
    ///
    /// See [`SetResponseHeaderLayer::if_not_present`] for more details.
    #[inline(always)]
    pub fn if_not_present_typed<H: HeaderEncode>(header: H) -> Self {
        Self::if_not_present(H::name().clone(), header.encode_to_value())
    }
}

impl<F, A> SetResponseHeaderLayer<BoxMakeHeaderValueFactoryFn<F, A>> {
    /// Create a new [`SetResponseHeaderLayer`] from a [`header::MakeHeaderValueFn`].
    ///
    /// See [`SetResponseHeaderLayer::overriding`] for more details.
    #[inline(always)]
    pub fn overriding_fn(header_name: HeaderName, make_fn: F) -> Self {
        Self::new(
            header_name,
            BoxMakeHeaderValueFactoryFn::new(make_fn),
            InsertHeaderMode::Override,
        )
    }

    /// Create a new [`SetResponseHeaderLayer`] from a [`header::MakeHeaderValueFn`].
    ///
    /// See [`SetResponseHeaderLayer::appending`] for more details.
    #[inline(always)]
    pub fn appending_fn(header_name: HeaderName, make_fn: F) -> Self {
        Self::new(
            header_name,
            BoxMakeHeaderValueFactoryFn::new(make_fn),
            InsertHeaderMode::Append,
        )
    }

    /// Create a new [`SetResponseHeaderLayer`] from a [`header::MakeHeaderValueFn`].
    ///
    /// See [`SetResponseHeaderLayer::if_not_present`] for more details.
    #[inline(always)]
    pub fn if_not_present_fn(header_name: HeaderName, make_fn: F) -> Self {
        Self::new(
            header_name,
            BoxMakeHeaderValueFactoryFn::new(make_fn),
            InsertHeaderMode::IfNotPresent,
        )
    }
}

impl<M> SetResponseHeaderLayer<M> {
    /// Create a new [`SetResponseHeaderLayer`] from a [`Default`] [`MakeHeaderValue`].
    ///
    /// See [`SetResponseHeaderLayer::overriding`] for more details.
    #[inline(always)]
    pub fn overriding_default(
        header_name: HeaderName,
    ) -> SetResponseHeaderLayer<MakeHeaderValueDefault<M>> {
        SetResponseHeaderLayer::new(
            header_name,
            MakeHeaderValueDefault::new(),
            InsertHeaderMode::Override,
        )
    }

    /// Create a new [`SetResponseHeaderLayer`] from a [`Default`] [`MakeHeaderValue`].
    ///
    /// See [`SetResponseHeaderLayer::appending`] for more details.
    #[inline(always)]
    pub fn appending_default(
        header_name: HeaderName,
    ) -> SetResponseHeaderLayer<MakeHeaderValueDefault<M>> {
        SetResponseHeaderLayer::new(
            header_name,
            MakeHeaderValueDefault::new(),
            InsertHeaderMode::Append,
        )
    }

    /// Create a new [`SetResponseHeaderLayer`] from a [`Default`] [`MakeHeaderValue`].
    ///
    /// See [`SetResponseHeaderLayer::if_not_present`] for more details.
    #[inline(always)]
    pub fn if_not_present_default(
        header_name: HeaderName,
    ) -> SetResponseHeaderLayer<MakeHeaderValueDefault<M>> {
        SetResponseHeaderLayer::new(
            header_name,
            MakeHeaderValueDefault::new(),
            InsertHeaderMode::IfNotPresent,
        )
    }
}

impl<M: TypedHeader> SetResponseHeaderLayer<M> {
    /// Create a new [`SetResponseHeaderLayer`] from a [`Default`] [`TypedHeader`].
    ///
    /// See [`SetResponseHeaderLayer::overriding`] for more details.
    #[inline(always)]
    #[must_use]
    pub fn overriding_default_typed()
    -> SetResponseHeaderLayer<MakeHeaderValueDefault<TypedHeaderAsMaker<M>>> {
        SetResponseHeaderLayer::new(
            M::name().clone(),
            MakeHeaderValueDefault::new(),
            InsertHeaderMode::Override,
        )
    }

    /// Create a new [`SetResponseHeaderLayer`] from a [`Default`] [`TypedHeader`].
    ///
    /// See [`SetResponseHeaderLayer::appending`] for more details.
    #[inline(always)]
    #[must_use]
    pub fn appending_default_typed()
    -> SetResponseHeaderLayer<MakeHeaderValueDefault<TypedHeaderAsMaker<M>>> {
        SetResponseHeaderLayer::new(
            M::name().clone(),
            MakeHeaderValueDefault::new(),
            InsertHeaderMode::Append,
        )
    }

    /// Create a new [`SetResponseHeaderLayer`] from a [`Default`] [`TypedHeader`].
    ///
    /// See [`SetResponseHeaderLayer::if_not_present`] for more details.
    #[inline(always)]
    #[must_use]
    pub fn if_not_present_default_typed()
    -> SetResponseHeaderLayer<MakeHeaderValueDefault<TypedHeaderAsMaker<M>>> {
        SetResponseHeaderLayer::new(
            M::name().clone(),
            MakeHeaderValueDefault::new(),
            InsertHeaderMode::IfNotPresent,
        )
    }
}

impl<S, M> Layer<S> for SetResponseHeaderLayer<M>
where
    M: Clone,
{
    type Service = SetResponseHeader<S, M>;

    fn layer(&self, inner: S) -> Self::Service {
        SetResponseHeader {
            inner,
            header_name: self.header_name.clone(),
            make: self.make.clone(),
            mode: self.mode,
        }
    }

    fn into_layer(self, inner: S) -> Self::Service {
        SetResponseHeader {
            inner,
            header_name: self.header_name,
            make: self.make,
            mode: self.mode,
        }
    }
}

/// Middleware that sets a header on the response.
#[derive(Clone)]
pub struct SetResponseHeader<S, M> {
    inner: S,
    header_name: HeaderName,
    make: M,
    mode: InsertHeaderMode,
}

impl<S, H: HeaderEncode> SetResponseHeader<S, TypedHeaderAsMaker<H>> {
    /// Create a new [`SetResponseHeader`] from a typed [`HeaderEncode`].
    ///
    /// See [`SetResponseHeader::overriding`] for more details.
    pub fn overriding_typed(inner: S, header: H) -> Self {
        Self::overriding(inner, H::name().clone(), TypedHeaderAsMaker(header))
    }

    /// Create a new [`SetResponseHeader`] from a typed [`HeaderEncode`].
    ///
    /// See [`SetResponseHeader::appending`] for more details.
    pub fn appending_typed(inner: S, header: H) -> Self {
        Self::appending(inner, H::name().clone(), TypedHeaderAsMaker(header))
    }

    /// Create a new [`SetResponseHeader`] from a typed [`HeaderEncode`].
    ///
    /// See [`SetResponseHeader::if_not_present`] for more details.
    pub fn if_not_present_typed(inner: S, header: H) -> Self {
        Self::if_not_present(inner, H::name().clone(), TypedHeaderAsMaker(header))
    }
}

impl<S, M> SetResponseHeader<S, M> {
    /// Create a new [`SetResponseHeader`].
    ///
    /// If a previous value exists for the same header, it is removed and replaced with the new
    /// header value.
    #[inline(always)]
    pub fn overriding(inner: S, header_name: HeaderName, make: M) -> Self {
        Self::new(inner, header_name, make, InsertHeaderMode::Override)
    }

    /// Create a new [`SetResponseHeader`].
    ///
    /// The new header is always added, preserving any existing values. If previous values exist,
    /// the header will have multiple values.
    #[inline(always)]
    pub fn appending(inner: S, header_name: HeaderName, make: M) -> Self {
        Self::new(inner, header_name, make, InsertHeaderMode::Append)
    }

    /// Create a new [`SetResponseHeader`].
    ///
    /// If a previous value exists for the header, the new value is not inserted.
    #[inline(always)]
    pub fn if_not_present(inner: S, header_name: HeaderName, make: M) -> Self {
        Self::new(inner, header_name, make, InsertHeaderMode::IfNotPresent)
    }

    fn new(inner: S, header_name: HeaderName, make: M, mode: InsertHeaderMode) -> Self {
        Self {
            inner,
            header_name,
            make,
            mode,
        }
    }

    define_inner_service_accessors!();
}

impl<S, F, A> SetResponseHeader<S, BoxMakeHeaderValueFactoryFn<F, A>> {
    /// Create a new [`SetResponseHeader`] from a [`header::MakeHeaderValueFn`].
    ///
    /// See [`SetResponseHeader::overriding`] for more details.
    #[inline(always)]
    pub fn overriding_fn(inner: S, header_name: HeaderName, make_fn: F) -> Self {
        Self::new(
            inner,
            header_name,
            BoxMakeHeaderValueFactoryFn::new(make_fn),
            InsertHeaderMode::Override,
        )
    }

    /// Create a new [`SetResponseHeader`] from a [`header::MakeHeaderValueFn`].
    ///
    /// See [`SetResponseHeader::appending`] for more details.
    #[inline(always)]
    pub fn appending_fn(inner: S, header_name: HeaderName, make_fn: F) -> Self {
        Self::new(
            inner,
            header_name,
            BoxMakeHeaderValueFactoryFn::new(make_fn),
            InsertHeaderMode::Append,
        )
    }

    /// Create a new [`SetResponseHeader`] from a [`header::MakeHeaderValueFn`].
    ///
    /// See [`SetResponseHeader::if_not_present`] for more details.
    #[inline(always)]
    pub fn if_not_present_fn(inner: S, header_name: HeaderName, make_fn: F) -> Self {
        Self::new(
            inner,
            header_name,
            BoxMakeHeaderValueFactoryFn::new(make_fn),
            InsertHeaderMode::IfNotPresent,
        )
    }
}

impl<S, M> SetResponseHeader<S, M> {
    /// Create a new [`SetResponseHeader`] from a [`Default`] [`MakeHeaderValue`].
    ///
    /// See [`SetResponseHeader::overriding`] for more details.
    #[inline(always)]
    pub fn overriding_default(
        inner: S,
        header_name: HeaderName,
    ) -> SetResponseHeader<S, MakeHeaderValueDefault<M>> {
        SetResponseHeader::new(
            inner,
            header_name,
            MakeHeaderValueDefault::new(),
            InsertHeaderMode::Override,
        )
    }

    /// Create a new [`SetResponseHeader`] from a [`Default`] [`MakeHeaderValue`].
    ///
    /// See [`SetResponseHeader::appending`] for more details.
    #[inline(always)]
    pub fn appending_default(
        inner: S,
        header_name: HeaderName,
    ) -> SetResponseHeader<S, MakeHeaderValueDefault<M>> {
        SetResponseHeader::new(
            inner,
            header_name,
            MakeHeaderValueDefault::new(),
            InsertHeaderMode::Append,
        )
    }

    /// Create a new [`SetResponseHeader`] from a [`Default`] [`MakeHeaderValue`].
    ///
    /// See [`SetResponseHeader::if_not_present`] for more details.
    #[inline(always)]
    pub fn if_not_present_default(
        inner: S,
        header_name: HeaderName,
    ) -> SetResponseHeader<S, MakeHeaderValueDefault<M>> {
        SetResponseHeader::new(
            inner,
            header_name,
            MakeHeaderValueDefault::new(),
            InsertHeaderMode::IfNotPresent,
        )
    }
}

impl<S, M: TypedHeader> SetResponseHeader<S, M> {
    /// Create a new [`SetResponseHeader`] from a [`Default`] [`TypedHeader`].
    ///
    /// See [`SetResponseHeader::overriding`] for more details.
    #[inline(always)]
    pub fn overriding_default_typed(
        inner: S,
    ) -> SetResponseHeader<S, MakeHeaderValueDefault<TypedHeaderAsMaker<M>>> {
        SetResponseHeader::new(
            inner,
            M::name().clone(),
            MakeHeaderValueDefault::new(),
            InsertHeaderMode::Override,
        )
    }

    /// Create a new [`SetResponseHeader`] from a [`Default`] [`TypedHeader`].
    ///
    /// See [`SetResponseHeader::appending`] for more details.
    #[inline(always)]
    pub fn appending_default_typed(
        inner: S,
    ) -> SetResponseHeader<S, MakeHeaderValueDefault<TypedHeaderAsMaker<M>>> {
        SetResponseHeader::new(
            inner,
            M::name().clone(),
            MakeHeaderValueDefault::new(),
            InsertHeaderMode::Append,
        )
    }

    /// Create a new [`SetResponseHeader`] from a [`Default`] [`TypedHeader`].
    ///
    /// See [`SetResponseHeader::if_not_present`] for more details.
    #[inline(always)]
    pub fn if_not_present_default_typed(
        inner: S,
    ) -> SetResponseHeader<S, MakeHeaderValueDefault<TypedHeaderAsMaker<M>>> {
        SetResponseHeader::new(
            inner,
            M::name().clone(),
            MakeHeaderValueDefault::new(),
            InsertHeaderMode::IfNotPresent,
        )
    }
}

impl<S, M> fmt::Debug for SetResponseHeader<S, M>
where
    S: fmt::Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("SetResponseHeader")
            .field("inner", &self.inner)
            .field("header_name", &self.header_name)
            .field("mode", &self.mode)
            .field("make", &std::any::type_name::<M>())
            .finish()
    }
}

impl<ReqBody, ResBody, S, M> Service<Request<ReqBody>> for SetResponseHeader<S, M>
where
    ReqBody: Send + 'static,
    ResBody: Send + 'static,
    S: Service<Request<ReqBody>, Output = Response<ResBody>>,
    M: MakeHeaderValueFactory<ReqBody, ResBody>,
{
    type Output = S::Output;
    type Error = S::Error;

    async fn serve(&self, req: Request<ReqBody>) -> Result<Self::Output, Self::Error> {
        let (req, header_maker) = self.make.make_header_value_maker(req).await;
        let res = self.inner.serve(req).await?;
        let res = self.mode.apply(&self.header_name, res, header_maker).await;
        Ok(res)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    use crate::{Body, HeaderValue, Request, Response, header};
    use rama_core::service::service_fn;
    use std::convert::Infallible;

    #[tokio::test]
    async fn test_override_mode() {
        let svc = SetResponseHeader::overriding(
            service_fn(async || {
                let res = Response::builder()
                    .header(header::CONTENT_TYPE, "good-content")
                    .body(Body::empty())
                    .unwrap();
                Ok::<_, Infallible>(res)
            }),
            header::CONTENT_TYPE,
            HeaderValue::from_static("text/html"),
        );

        let res = svc.serve(Request::new(Body::empty())).await.unwrap();

        let mut values = res.headers().get_all(header::CONTENT_TYPE).iter();
        assert_eq!(values.next().unwrap(), "text/html");
        assert_eq!(values.next(), None);
    }

    #[tokio::test]
    async fn test_append_mode() {
        let svc = SetResponseHeader::appending(
            service_fn(async || {
                let res = Response::builder()
                    .header(header::CONTENT_TYPE, "good-content")
                    .body(Body::empty())
                    .unwrap();
                Ok::<_, Infallible>(res)
            }),
            header::CONTENT_TYPE,
            HeaderValue::from_static("text/html"),
        );

        let res = svc.serve(Request::new(Body::empty())).await.unwrap();

        let mut values = res.headers().get_all(header::CONTENT_TYPE).iter();
        assert_eq!(values.next().unwrap(), "good-content");
        assert_eq!(values.next().unwrap(), "text/html");
        assert_eq!(values.next(), None);
    }

    #[tokio::test]
    async fn test_skip_if_present_mode() {
        let svc = SetResponseHeader::if_not_present(
            service_fn(async || {
                let res = Response::builder()
                    .header(header::CONTENT_TYPE, "good-content")
                    .body(Body::empty())
                    .unwrap();
                Ok::<_, Infallible>(res)
            }),
            header::CONTENT_TYPE,
            HeaderValue::from_static("text/html"),
        );

        let res = svc.serve(Request::new(Body::empty())).await.unwrap();

        let mut values = res.headers().get_all(header::CONTENT_TYPE).iter();
        assert_eq!(values.next().unwrap(), "good-content");
        assert_eq!(values.next(), None);
    }

    #[tokio::test]
    async fn test_skip_if_present_mode_when_not_present() {
        let svc = SetResponseHeader::if_not_present(
            service_fn(async || {
                let res = Response::builder().body(Body::empty()).unwrap();
                Ok::<_, Infallible>(res)
            }),
            header::CONTENT_TYPE,
            HeaderValue::from_static("text/html"),
        );

        let res = svc.serve(Request::new(Body::empty())).await.unwrap();

        let mut values = res.headers().get_all(header::CONTENT_TYPE).iter();
        assert_eq!(values.next().unwrap(), "text/html");
        assert_eq!(values.next(), None);
    }
}