1 pub(crate) mod request;
2 pub(crate) mod request_parts;
3 
4 #[cfg(test)]
5 mod tests {
6     use std::convert::Infallible;
7 
8     use crate::extract::{FromRef, FromRequestParts};
9     use async_trait::async_trait;
10     use http::request::Parts;
11 
12     #[derive(Debug, Default, Clone, Copy)]
13     pub(crate) struct State<S>(pub(crate) S);
14 
15     #[async_trait]
16     impl<OuterState, InnerState> FromRequestParts<OuterState> for State<InnerState>
17     where
18         InnerState: FromRef<OuterState>,
19         OuterState: Send + Sync,
20     {
21         type Rejection = Infallible;
22 
from_request_parts( _parts: &mut Parts, state: &OuterState, ) -> Result<Self, Self::Rejection>23         async fn from_request_parts(
24             _parts: &mut Parts,
25             state: &OuterState,
26         ) -> Result<Self, Self::Rejection> {
27             let inner_state = InnerState::from_ref(state);
28             Ok(Self(inner_state))
29         }
30     }
31 
32     // some extractor that requires the state, such as `SignedCookieJar`
33     pub(crate) struct RequiresState(pub(crate) String);
34 
35     #[async_trait]
36     impl<S> FromRequestParts<S> for RequiresState
37     where
38         S: Send + Sync,
39         String: FromRef<S>,
40     {
41         type Rejection = Infallible;
42 
from_request_parts( _parts: &mut Parts, state: &S, ) -> Result<Self, Self::Rejection>43         async fn from_request_parts(
44             _parts: &mut Parts,
45             state: &S,
46         ) -> Result<Self, Self::Rejection> {
47             Ok(Self(String::from_ref(state)))
48         }
49     }
50 }
51