salvo_oapi/extract/parameter/
cookie.rs

1use std::fmt::{self, Debug, Display, Formatter};
2use std::ops::{Deref, DerefMut};
3
4use salvo_core::Depot;
5use salvo_core::extract::{Extractible, Metadata};
6use salvo_core::http::{ParseError, Request};
7use salvo_core::serde::from_str_val;
8use serde::{Deserialize, Deserializer};
9
10use crate::endpoint::EndpointArgRegister;
11use crate::{Components, Operation, Parameter, ParameterIn, ToSchema};
12
13/// Represents the parameters passed by Cookie.
14pub struct CookieParam<T, const REQUIRED: bool = true>(Option<T>);
15impl<T> CookieParam<T, true> {
16    /// Consumes self and returns the value of the parameter.
17    pub fn into_inner(self) -> T {
18        self.0
19            .expect("`CookieParam<T, true>` into_inner get `None`")
20    }
21}
22impl<T> CookieParam<T, false> {
23    /// Consumes self and returns the value of the parameter.
24    pub fn into_inner(self) -> Option<T> {
25        self.0
26    }
27}
28
29impl<T> Deref for CookieParam<T, true> {
30    type Target = T;
31
32    fn deref(&self) -> &Self::Target {
33        self.0
34            .as_ref()
35            .expect("`CookieParam<T, true>` deref get `None`")
36    }
37}
38impl<T> Deref for CookieParam<T, false> {
39    type Target = Option<T>;
40
41    fn deref(&self) -> &Self::Target {
42        &self.0
43    }
44}
45
46impl<T> DerefMut for CookieParam<T, true> {
47    fn deref_mut(&mut self) -> &mut Self::Target {
48        self.0
49            .as_mut()
50            .expect("`CookieParam<T, true>` deref_mut get `None`")
51    }
52}
53impl<T> DerefMut for CookieParam<T, false> {
54    fn deref_mut(&mut self) -> &mut Self::Target {
55        &mut self.0
56    }
57}
58
59impl<'de, T, const R: bool> Deserialize<'de> for CookieParam<T, R>
60where
61    T: Deserialize<'de>,
62{
63    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
64    where
65        D: Deserializer<'de>,
66    {
67        T::deserialize(deserializer).map(|value| Self(Some(value)))
68    }
69}
70
71impl<T: Debug, const R: bool> fmt::Debug for CookieParam<T, R> {
72    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
73        self.0.fmt(f)
74    }
75}
76
77impl<T: Display> Display for CookieParam<T, true> {
78    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
79        self.0
80            .as_ref()
81            .expect("`CookieParam<T, true>` value should not be None.")
82            .fmt(f)
83    }
84}
85
86impl<'ex, T> Extractible<'ex> for CookieParam<T, true>
87where
88    T: Deserialize<'ex>,
89{
90    fn metadata() -> &'static Metadata {
91        static METADATA: Metadata = Metadata::new("");
92        &METADATA
93    }
94    #[allow(refining_impl_trait)]
95    async fn extract(_req: &'ex mut Request, _depot: &'ex mut Depot) -> Result<Self, ParseError> {
96        unimplemented!("cookie parameter can not be extracted from request");
97    }
98    #[allow(refining_impl_trait)]
99    async fn extract_with_arg(
100        req: &'ex mut Request,
101        _depot: &'ex mut Depot,
102        arg: &str,
103    ) -> Result<Self, ParseError> {
104        let value = req
105            .cookies()
106            .get(arg)
107            .and_then(|v| from_str_val(v.value()).ok())
108            .ok_or_else(|| {
109                ParseError::other(format!(
110                    "cookie parameter {arg} not found or convert to type failed"
111                ))
112            })?;
113        Ok(Self(value))
114    }
115}
116
117impl<'ex, T> Extractible<'ex> for CookieParam<T, false>
118where
119    T: Deserialize<'ex>,
120{
121    fn metadata() -> &'static Metadata {
122        static METADATA: Metadata = Metadata::new("");
123        &METADATA
124    }
125    #[allow(refining_impl_trait)]
126    async fn extract(_req: &'ex mut Request, _depot: &'ex mut Depot) -> Result<Self, ParseError> {
127        unimplemented!("cookie parameter can not be extracted from request")
128    }
129    #[allow(refining_impl_trait)]
130    async fn extract_with_arg(
131        req: &'ex mut Request,
132        _depot: &'ex mut Depot,
133        arg: &str,
134    ) -> Result<Self, ParseError> {
135        let value = req
136            .cookies()
137            .get(arg)
138            .and_then(|v| from_str_val(v.value()).ok());
139        Ok(Self(value))
140    }
141}
142
143impl<T, const R: bool> EndpointArgRegister for CookieParam<T, R>
144where
145    T: ToSchema,
146{
147    fn register(components: &mut Components, operation: &mut Operation, arg: &str) {
148        let parameter = Parameter::new(arg)
149            .parameter_in(ParameterIn::Cookie)
150            .description(format!("Get parameter `{arg}` from request cookie."))
151            .schema(T::to_schema(components))
152            .required(R);
153        operation.parameters.insert(parameter);
154    }
155}
156
157#[cfg(test)]
158mod tests {
159    use assert_json_diff::assert_json_eq;
160    use http::header::HeaderValue;
161    use salvo_core::test::TestClient;
162    use serde_json::json;
163
164    use super::*;
165
166    #[test]
167    fn test_required_cookie_param_into_inner() {
168        let param = CookieParam::<String, true>(Some("param".to_owned()));
169        assert_eq!("param".to_owned(), param.into_inner());
170    }
171
172    #[test]
173    fn test_required_cookie_param_deref() {
174        let param = CookieParam::<String, true>(Some("param".to_owned()));
175        assert_eq!(&"param".to_owned(), param.deref())
176    }
177
178    #[test]
179    fn test_required_cookie_param_deref_mut() {
180        let mut param = CookieParam::<String, true>(Some("param".to_owned()));
181        assert_eq!(&mut "param".to_owned(), param.deref_mut())
182    }
183
184    #[test]
185    fn test_cookie_param_into_inner() {
186        let param = CookieParam::<String, false>(Some("param".to_owned()));
187        assert_eq!(Some("param".to_owned()), param.into_inner());
188    }
189
190    #[test]
191    fn test_cookie_param_deref() {
192        let param = CookieParam::<String, false>(Some("param".to_owned()));
193        assert_eq!(&Some("param".to_owned()), param.deref())
194    }
195
196    #[test]
197    fn test_cookie_param_deref_mut() {
198        let mut param = CookieParam::<String, false>(Some("param".to_owned()));
199        assert_eq!(&mut Some("param".to_owned()), param.deref_mut())
200    }
201
202    #[test]
203    fn test_cookie_param_deserialize() {
204        let param = serde_json::from_str::<CookieParam<String, true>>(r#""param""#).unwrap();
205        assert_eq!(param.0.unwrap(), "param");
206    }
207
208    #[test]
209    fn test_cookie_param_debug() {
210        let param = CookieParam::<String, true>(Some("param".to_owned()));
211        assert_eq!(format!("{param:?}"), r#"Some("param")"#);
212    }
213
214    #[test]
215    fn test_cookie_param_display() {
216        let param = CookieParam::<String, true>(Some("param".to_owned()));
217        assert_eq!(format!("{param}"), "param");
218    }
219
220    #[test]
221    fn test_required_cookie_param_metadata() {
222        let metadata = CookieParam::<String, true>::metadata();
223        assert_eq!("", metadata.name);
224    }
225
226    #[tokio::test]
227    #[should_panic]
228    async fn test_required_cookie_prarm_extract() {
229        let mut req = Request::new();
230        let mut depot = Depot::new();
231        let _ = CookieParam::<String, true>::extract(&mut req, &mut depot).await;
232    }
233
234    #[tokio::test]
235    async fn test_required_cookie_prarm_extract_with_value() {
236        let mut req = TestClient::get("http://127.0.0.1:5801").build_hyper();
237        req.headers_mut()
238            .append("cookie", HeaderValue::from_static("param=param"));
239        let schema = req.uri().scheme().cloned().unwrap();
240        let mut req = Request::from_hyper(req, schema);
241        let mut depot = Depot::new();
242        let result =
243            CookieParam::<String, true>::extract_with_arg(&mut req, &mut depot, "param").await;
244        assert_eq!(result.unwrap().0.unwrap(), "param");
245    }
246
247    #[tokio::test]
248    #[should_panic]
249    async fn test_required_cookie_prarm_extract_with_value_panic() {
250        let req = TestClient::get("http://127.0.0.1:5801").build_hyper();
251        let schema = req.uri().scheme().cloned().unwrap();
252        let mut req = Request::from_hyper(req, schema);
253        let mut depot = Depot::new();
254        let result =
255            CookieParam::<String, true>::extract_with_arg(&mut req, &mut depot, "param").await;
256        assert_eq!(result.unwrap().0.unwrap(), "param");
257    }
258
259    #[test]
260    fn test_cookie_param_metadata() {
261        let metadata = CookieParam::<String, false>::metadata();
262        assert_eq!("", metadata.name);
263    }
264
265    #[tokio::test]
266    #[should_panic]
267    async fn test_cookie_prarm_extract() {
268        let mut req = Request::new();
269        let mut depot = Depot::new();
270        let _ = CookieParam::<String, false>::extract(&mut req, &mut depot).await;
271    }
272
273    #[tokio::test]
274    async fn test_cookie_prarm_extract_with_value() {
275        let mut req = TestClient::get("http://127.0.0.1:5801").build_hyper();
276        req.headers_mut()
277            .append("cookie", HeaderValue::from_static("param=param"));
278        let schema = req.uri().scheme().cloned().unwrap();
279        let mut req = Request::from_hyper(req, schema);
280        let mut depot = Depot::new();
281        let result =
282            CookieParam::<String, false>::extract_with_arg(&mut req, &mut depot, "param").await;
283        assert_eq!(result.unwrap().0.unwrap(), "param");
284    }
285
286    #[tokio::test]
287    #[should_panic]
288    async fn test_cookie_prarm_extract_with_value_panic() {
289        let req = TestClient::get("http://127.0.0.1:5801").build_hyper();
290        let schema = req.uri().scheme().cloned().unwrap();
291        let mut req = Request::from_hyper(req, schema);
292        let mut depot = Depot::new();
293        let result =
294            CookieParam::<String, false>::extract_with_arg(&mut req, &mut depot, "param").await;
295        assert_eq!(result.unwrap().0.unwrap(), "param");
296    }
297
298    #[test]
299    fn test_cookie_param_register() {
300        let mut components = Components::new();
301        let mut operation = Operation::new();
302        CookieParam::<String, false>::register(&mut components, &mut operation, "arg");
303
304        assert_json_eq!(
305            operation,
306            json!({
307                "parameters": [
308                    {
309                        "name": "arg",
310                        "in": "cookie",
311                        "description": "Get parameter `arg` from request cookie.",
312                        "required": false,
313                        "schema": {
314                            "type": "string"
315                        }
316                    }
317                ],
318                "responses": {}
319            })
320        )
321    }
322}
salvo_oapi/extract/parameter/cookie.rs

salvo_oapi/extract/parameter/
cookie.rs
