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| Self(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() -> &'static 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 {arg} not found or convert to type failed"
106                ))
107            })?;
108        Ok(Self(value))
109    }
110}
111
112impl<'ex, T> Extractible<'ex> for CookieParam<T, false>
113where
114    T: Deserialize<'ex>,
115{
116    fn metadata() -> &'static Metadata {
117        static METADATA: Metadata = Metadata::new("");
118        &METADATA
119    }
120    #[allow(refining_impl_trait)]
121    async fn extract(_req: &'ex mut Request) -> Result<Self, ParseError> {
122        unimplemented!("cookie parameter can not be extracted from request")
123    }
124    #[allow(refining_impl_trait)]
125    async fn extract_with_arg(req: &'ex mut Request, arg: &str) -> Result<Self, ParseError> {
126        let value = req
127            .cookies()
128            .get(arg)
129            .and_then(|v| from_str_val(v.value()).ok());
130        Ok(Self(value))
131    }
132}
133
134impl<T, const R: bool> EndpointArgRegister for CookieParam<T, R>
135where
136    T: ToSchema,
137{
138    fn register(components: &mut Components, operation: &mut Operation, arg: &str) {
139        let parameter = Parameter::new(arg)
140            .parameter_in(ParameterIn::Cookie)
141            .description(format!("Get parameter `{arg}` from request cookie."))
142            .schema(T::to_schema(components))
143            .required(R);
144        operation.parameters.insert(parameter);
145    }
146}
147
148#[cfg(test)]
149mod tests {
150    use assert_json_diff::assert_json_eq;
151    use http::header::HeaderValue;
152    use salvo_core::test::TestClient;
153    use serde_json::json;
154
155    use super::*;
156
157    #[test]
158    fn test_required_cookie_param_into_inner() {
159        let param = CookieParam::<String, true>(Some("param".to_owned()));
160        assert_eq!("param".to_owned(), param.into_inner());
161    }
162
163    #[test]
164    fn test_required_cookie_param_deref() {
165        let param = CookieParam::<String, true>(Some("param".to_owned()));
166        assert_eq!(&"param".to_owned(), param.deref())
167    }
168
169    #[test]
170    fn test_required_cookie_param_deref_mut() {
171        let mut param = CookieParam::<String, true>(Some("param".to_owned()));
172        assert_eq!(&mut "param".to_owned(), param.deref_mut())
173    }
174
175    #[test]
176    fn test_cookie_param_into_inner() {
177        let param = CookieParam::<String, false>(Some("param".to_owned()));
178        assert_eq!(Some("param".to_owned()), param.into_inner());
179    }
180
181    #[test]
182    fn test_cookie_param_deref() {
183        let param = CookieParam::<String, false>(Some("param".to_owned()));
184        assert_eq!(&Some("param".to_owned()), param.deref())
185    }
186
187    #[test]
188    fn test_cookie_param_deref_mut() {
189        let mut param = CookieParam::<String, false>(Some("param".to_owned()));
190        assert_eq!(&mut Some("param".to_owned()), param.deref_mut())
191    }
192
193    #[test]
194    fn test_cookie_param_deserialize() {
195        let param = serde_json::from_str::<CookieParam<String, true>>(r#""param""#).unwrap();
196        assert_eq!(param.0.unwrap(), "param");
197    }
198
199    #[test]
200    fn test_cookie_param_debug() {
201        let param = CookieParam::<String, true>(Some("param".to_owned()));
202        assert_eq!(format!("{param:?}"), r#"Some("param")"#);
203    }
204
205    #[test]
206    fn test_cookie_param_display() {
207        let param = CookieParam::<String, true>(Some("param".to_owned()));
208        assert_eq!(format!("{param}"), "param");
209    }
210
211    #[test]
212    fn test_required_cookie_param_metadata() {
213        let metadata = CookieParam::<String, true>::metadata();
214        assert_eq!("", metadata.name);
215    }
216
217    #[tokio::test]
218    #[should_panic]
219    async fn test_required_cookie_prarm_extract() {
220        let mut req = Request::new();
221        let _ = CookieParam::<String, true>::extract(&mut req).await;
222    }
223
224    #[tokio::test]
225    async fn test_required_cookie_prarm_extract_with_value() {
226        let mut req = TestClient::get("http://127.0.0.1:5801").build_hyper();
227        req.headers_mut()
228            .append("cookie", HeaderValue::from_static("param=param"));
229        let schema = req.uri().scheme().cloned().unwrap();
230        let mut req = Request::from_hyper(req, schema);
231        let result = CookieParam::<String, true>::extract_with_arg(&mut req, "param").await;
232        assert_eq!(result.unwrap().0.unwrap(), "param");
233    }
234
235    #[tokio::test]
236    #[should_panic]
237    async fn test_required_cookie_prarm_extract_with_value_panic() {
238        let req = TestClient::get("http://127.0.0.1:5801").build_hyper();
239        let schema = req.uri().scheme().cloned().unwrap();
240        let mut req = Request::from_hyper(req, schema);
241        let result = CookieParam::<String, true>::extract_with_arg(&mut req, "param").await;
242        assert_eq!(result.unwrap().0.unwrap(), "param");
243    }
244
245    #[test]
246    fn test_cookie_param_metadata() {
247        let metadata = CookieParam::<String, false>::metadata();
248        assert_eq!("", metadata.name);
249    }
250
251    #[tokio::test]
252    #[should_panic]
253    async fn test_cookie_prarm_extract() {
254        let mut req = Request::new();
255        let _ = CookieParam::<String, false>::extract(&mut req).await;
256    }
257
258    #[tokio::test]
259    async fn test_cookie_prarm_extract_with_value() {
260        let mut req = TestClient::get("http://127.0.0.1:5801").build_hyper();
261        req.headers_mut()
262            .append("cookie", HeaderValue::from_static("param=param"));
263        let schema = req.uri().scheme().cloned().unwrap();
264        let mut req = Request::from_hyper(req, schema);
265        let result = CookieParam::<String, false>::extract_with_arg(&mut req, "param").await;
266        assert_eq!(result.unwrap().0.unwrap(), "param");
267    }
268
269    #[tokio::test]
270    #[should_panic]
271    async fn test_cookie_prarm_extract_with_value_panic() {
272        let req = TestClient::get("http://127.0.0.1:5801").build_hyper();
273        let schema = req.uri().scheme().cloned().unwrap();
274        let mut req = Request::from_hyper(req, schema);
275        let result = CookieParam::<String, false>::extract_with_arg(&mut req, "param").await;
276        assert_eq!(result.unwrap().0.unwrap(), "param");
277    }
278
279    #[test]
280    fn test_cookie_param_register() {
281        let mut components = Components::new();
282        let mut operation = Operation::new();
283        CookieParam::<String, false>::register(&mut components, &mut operation, "arg");
284
285        assert_json_eq!(
286            operation,
287            json!({
288                "parameters": [
289                    {
290                        "name": "arg",
291                        "in": "cookie",
292                        "description": "Get parameter `arg` from request cookie.",
293                        "required": false,
294                        "schema": {
295                            "type": "string"
296                        }
297                    }
298                ],
299                "responses": {}
300            })
301        )
302    }
303}
salvo_oapi/extract/parameter/cookie.rs

salvo_oapi/extract/parameter/
cookie.rs
