Wrong parsing made by serde_urlencoded for Option, replacing with serde_qs

Cargo.toml

@@ -102,7 +102,7 @@ pin-project = "1.0.0"
 regex = "1.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-serde_urlencoded = "0.7"
+serde_qs = "0.8.1"
 time = { version = "0.2.7", default-features = false, features = ["std"] }
 url = "2.1"
 open-ssl = { package = "openssl", version = "0.10", optional = true }

actix-http-test/Cargo.toml

@@ -47,7 +47,7 @@ socket2 = "0.3"
 serde = "1.0"
 serde_json = "1.0"
 slab = "0.4"
-serde_urlencoded = "0.7"
+serde_qs = "0.8.1"
 time = { version = "0.2.7", default-features = false, features = ["std"] }
 open-ssl = { version = "0.10", package = "openssl", optional = true }
 

actix-http/Cargo.toml

@@ -78,7 +78,7 @@ serde = "1.0"
 serde_json = "1.0"
 sha-1 = "0.9"
 slab = "0.4"
-serde_urlencoded = "0.7"
+serde_qs = "0.8.1"
 time = { version = "0.2.7", default-features = false, features = ["std"] }
 
 # compression

actix-http/src/error.rs

@@ -17,7 +17,7 @@ use http::uri::InvalidUri;
 use http::{header, Error as HttpError, StatusCode};
 use serde::de::value::Error as DeError;
 use serde_json::error::Error as JsonError;
-use serde_urlencoded::ser::Error as FormError;
+use serde_qs::Error as FormError;
 
 // re-export for convenience
 use crate::body::Body;

awc/Cargo.toml

@@ -53,7 +53,7 @@ percent-encoding = "2.1"
 rand = "0.7"
 serde = "1.0"
 serde_json = "1.0"
-serde_urlencoded = "0.7"
+serde_qs = "0.8.1"
 open-ssl = { version = "0.10", package = "openssl", optional = true }
 rust-tls = { version = "0.18.0", package = "rustls", optional = true, features = ["dangerous_configuration"] }
 

awc/src/request.rs

@@ -383,14 +383,11 @@ impl ClientRequest {
     }
 
     /// Sets the query part of the request
-    pub fn query<T: Serialize>(
+    pub fn query<T: Serialize>(mut self, query: &T) -> Result<Self, serde_qs::Error> {
-        mut self,
-        query: &T,
-    ) -> Result<Self, serde_urlencoded::ser::Error> {
         let mut parts = self.head.uri.clone().into_parts();
 
         if let Some(path_and_query) = parts.path_and_query {
-            let query = serde_urlencoded::to_string(query)?;
+            let query = serde_qs::to_string(query)?;
             let path = path_and_query.path();
             parts.path_and_query = format!("{}?{}", path, query).parse().ok();
 

awc/src/sender.rs

@@ -231,7 +231,7 @@ impl RequestSender {
         config: &ClientConfig,
         value: &T,
     ) -> SendClientRequest {
-        let body = match serde_urlencoded::to_string(value) {
+        let body = match serde_qs::to_string(value) {
             Ok(body) => body,
             Err(e) => return Error::from(e).into(),
         };

src/error.rs

@@ -120,7 +120,7 @@ impl ResponseError for PathError {
 pub enum QueryPayloadError {
     /// Deserialize error
     #[display(fmt = "Query deserialize error: {}", _0)]
-    Deserialize(serde::de::value::Error),
+    Deserialize(serde_qs::Error),
 }
 
 impl std::error::Error for QueryPayloadError {}
@@ -188,7 +188,7 @@ mod tests {
     #[test]
     fn test_query_payload_error() {
         let resp: HttpResponse = QueryPayloadError::Deserialize(
-            serde_urlencoded::from_str::<i32>("bad query").unwrap_err(),
+            serde_qs::from_str::<i32>("bad query").unwrap_err(),
         )
         .error_response();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);

src/test.rs

@@ -496,7 +496,7 @@ impl TestRequest {
     /// Serialize `data` to a URL encoded form and set it as the request payload. The `Content-Type`
     /// header is set to `application/x-www-form-urlencoded`.
     pub fn set_form<T: Serialize>(mut self, data: &T) -> Self {
-        let bytes = serde_urlencoded::to_string(data)
+        let bytes = serde_qs::to_string(data)
             .expect("Failed to serialize test data as a urlencoded form");
         self.req.set_payload(bytes);
         self.req.set(ContentType::form_url_encoded());

src/types/form.rs

@@ -162,7 +162,7 @@ impl<T: Serialize> Responder for Form<T> {
     type Future = Ready<Result<Response, Error>>;
 
     fn respond_to(self, _: &HttpRequest) -> Self::Future {
-        let body = match serde_urlencoded::to_string(&self.0) {
+        let body = match serde_qs::to_string(&self.0) {
             Ok(body) => body,
             Err(e) => return err(e.into()),
         };
@@ -359,15 +359,13 @@ where
                 }
 
                 if encoding == UTF_8 {
-                    serde_urlencoded::from_bytes::<U>(&body)
+                    serde_qs::from_bytes::<U>(&body).map_err(|_| UrlencodedError::Parse)
-                        .map_err(|_| UrlencodedError::Parse)
                 } else {
                     let body = encoding
                         .decode_without_bom_handling_and_without_replacement(&body)
                         .map(|s| s.into_owned())
                         .ok_or(UrlencodedError::Parse)?;
-                    serde_urlencoded::from_str::<U>(&body)
+                    serde_qs::from_str::<U>(&body).map_err(|_| UrlencodedError::Parse)
-                        .map_err(|_| UrlencodedError::Parse)
                 }
             }
             .boxed_local(),

src/types/query.rs

@@ -64,7 +64,7 @@ impl<T> Query<T> {
     where
         T: de::DeserializeOwned,
     {
-        serde_urlencoded::from_str::<T>(query_str)
+        serde_qs::from_str::<T>(query_str)
             .map(|val| Ok(Query(val)))
             .unwrap_or_else(move |e| Err(QueryPayloadError::Deserialize(e)))
     }
@@ -144,7 +144,7 @@ where
             .map(|c| c.ehandler.clone())
             .unwrap_or(None);
 
-        serde_urlencoded::from_str::<T>(req.query_string())
+        serde_qs::from_str::<T>(req.query_string())
             .map(|val| ok(Query(val)))
             .unwrap_or_else(move |e| {
                 let e = QueryPayloadError::Deserialize(e);