salvo_oapi/extract/parameter/
cookie.rs

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

salvo_oapi/extract/parameter/
cookie.rs
