Fix serialization issues with the AWS Console test requests.

aws_lambda_events/Cargo.toml

@@ -26,7 +26,7 @@ serde_derive = "^1"
 serde_json = "^1"
 bytes = { version = "1", features = ["serde"] }
 chrono = { version = "^0.4.4", features = ["serde"] }
-query_map = { version = "^0.3", features = ["serde"] }
+query_map = { version = "^0.4", features = ["serde"] }
 
 [dev-dependencies]
 pretty_assertions = "0.7"

aws_lambda_events/src/apigw/mod.rs

@@ -25,15 +25,15 @@ where
     pub path: Option<String>,
     #[serde(with = "http_method")]
     pub http_method: Method,
-    #[serde(deserialize_with = "http_serde::header_map::deserialize", default)]
+    #[serde(deserialize_with = "deserialize_headers", default)]
     #[serde(serialize_with = "serialize_headers")]
     pub headers: HeaderMap,
-    #[serde(deserialize_with = "http_serde::header_map::deserialize", default)]
+    #[serde(deserialize_with = "deserialize_headers", default)]
     #[serde(serialize_with = "serialize_multi_value_headers")]
     pub multi_value_headers: HeaderMap,
-    #[serde(default)]
+    #[serde(default, deserialize_with = "query_map::deserialize_empty")]
     pub query_string_parameters: QueryMap,
-    #[serde(default)]
+    #[serde(default, deserialize_with = "query_map::deserialize_empty")]
     pub multi_value_query_string_parameters: QueryMap,
     #[serde(deserialize_with = "deserialize_lambda_map")]
     #[serde(default)]
@@ -56,10 +56,10 @@ where
 #[serde(rename_all = "camelCase")]
 pub struct ApiGatewayProxyResponse {
     pub status_code: i64,
-    #[serde(deserialize_with = "http_serde::header_map::deserialize", default)]
+    #[serde(deserialize_with = "deserialize_headers", default)]
     #[serde(serialize_with = "serialize_headers")]
     pub headers: HeaderMap,
-    #[serde(deserialize_with = "http_serde::header_map::deserialize", default)]
+    #[serde(deserialize_with = "deserialize_headers", default)]
     #[serde(serialize_with = "serialize_multi_value_headers")]
     pub multi_value_headers: HeaderMap,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -138,10 +138,10 @@ pub struct ApiGatewayV2httpRequest {
     #[serde(default)]
     pub raw_query_string: Option<String>,
     pub cookies: Option<Vec<String>>,
-    #[serde(deserialize_with = "http_serde::header_map::deserialize", default)]
+    #[serde(deserialize_with = "deserialize_headers", default)]
     #[serde(serialize_with = "serialize_headers")]
     pub headers: HeaderMap,
-    #[serde(default)]
+    #[serde(default, deserialize_with = "query_map::deserialize_empty")]
     pub query_string_parameters: QueryMap,
     #[serde(deserialize_with = "deserialize_lambda_map")]
     #[serde(default)]
@@ -284,10 +284,10 @@ pub struct ApiGatewayV2httpRequestContextHttpDescription {
 #[serde(rename_all = "camelCase")]
 pub struct ApiGatewayV2httpResponse {
     pub status_code: i64,
-    #[serde(deserialize_with = "http_serde::header_map::deserialize", default)]
+    #[serde(deserialize_with = "deserialize_headers", default)]
     #[serde(serialize_with = "serialize_headers")]
     pub headers: HeaderMap,
-    #[serde(deserialize_with = "http_serde::header_map::deserialize", default)]
+    #[serde(deserialize_with = "deserialize_headers", default)]
     #[serde(serialize_with = "serialize_multi_value_headers")]
     pub multi_value_headers: HeaderMap,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -365,15 +365,15 @@ where
     #[serde(serialize_with = "http_method::serialize_optional")]
     #[serde(skip_serializing_if = "Option::is_none")]
     pub http_method: Option<Method>,
-    #[serde(deserialize_with = "http_serde::header_map::deserialize", default)]
+    #[serde(deserialize_with = "deserialize_headers", default)]
     #[serde(serialize_with = "serialize_headers")]
     pub headers: HeaderMap,
-    #[serde(deserialize_with = "http_serde::header_map::deserialize", default)]
+    #[serde(deserialize_with = "deserialize_headers", default)]
     #[serde(serialize_with = "serialize_multi_value_headers")]
     pub multi_value_headers: HeaderMap,
-    #[serde(default)]
+    #[serde(default, deserialize_with = "query_map::deserialize_empty")]
     pub query_string_parameters: QueryMap,
-    #[serde(default)]
+    #[serde(default, deserialize_with = "query_map::deserialize_empty")]
     pub multi_value_query_string_parameters: QueryMap,
     #[serde(deserialize_with = "deserialize_lambda_map")]
     #[serde(default)]
@@ -630,15 +630,15 @@ pub struct ApiGatewayCustomAuthorizerRequestTypeRequest {
     pub path: Option<String>,
     #[serde(with = "http_method")]
     pub http_method: Method,
-    #[serde(deserialize_with = "http_serde::header_map::deserialize", default)]
+    #[serde(deserialize_with = "deserialize_headers", default)]
     #[serde(serialize_with = "serialize_headers")]
     pub headers: HeaderMap,
-    #[serde(deserialize_with = "http_serde::header_map::deserialize", default)]
+    #[serde(deserialize_with = "deserialize_headers", default)]
     #[serde(serialize_with = "serialize_multi_value_headers")]
     pub multi_value_headers: HeaderMap,
-    #[serde(default)]
+    #[serde(default, deserialize_with = "query_map::deserialize_empty")]
     pub query_string_parameters: QueryMap,
-    #[serde(default)]
+    #[serde(default, deserialize_with = "query_map::deserialize_empty")]
     pub multi_value_query_string_parameters: QueryMap,
     #[serde(deserialize_with = "deserialize_lambda_map")]
     #[serde(default)]
@@ -831,4 +831,14 @@ mod test {
             serde_json::from_slice(output.as_bytes()).unwrap();
         assert_eq!(parsed, reparsed);
     }
+
+    #[test]
+    #[cfg(feature = "apigw")]
+    fn example_apigw_console_test_request() {
+        let data = include_bytes!("../generated/fixtures/example-apigw-console-test-request.json");
+        let parsed: ApiGatewayProxyRequest = serde_json::from_slice(data).unwrap();
+        let output: String = serde_json::to_string(&parsed).unwrap();
+        let reparsed: ApiGatewayProxyRequest = serde_json::from_slice(output.as_bytes()).unwrap();
+        assert_eq!(parsed, reparsed);
+    }
 }

aws_lambda_events/src/custom_serde/codebuild_time.rs

@@ -0,0 +1,108 @@
+use chrono::{DateTime, TimeZone, Utc};
+use serde::de::{Deserialize, Deserializer, Error as DeError, Visitor};
+use serde::ser::Serializer;
+use std::fmt;
+
+// Jan 2, 2006 3:04:05 PM
+const CODEBUILD_TIME_FORMAT: &str = "%b %e, %Y %l:%M:%S %p";
+
+struct TimeVisitor;
+impl<'de> Visitor<'de> for TimeVisitor {
+    type Value = DateTime<Utc>;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "valid codebuild time: {}", CODEBUILD_TIME_FORMAT)
+    }
+
+    fn visit_str<E: DeError>(self, val: &str) -> Result<Self::Value, E> {
+        Utc.datetime_from_str(val, CODEBUILD_TIME_FORMAT)
+            .map_err(|e| DeError::custom(format!("Parse error {} for {}", e, val)))
+    }
+}
+
+pub(crate) mod str_time {
+    use super::*;
+
+    pub(crate) fn deserialize<'de, D>(d: D) -> Result<DateTime<Utc>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        d.deserialize_str(TimeVisitor)
+    }
+
+    pub fn serialize<S: Serializer>(date: &DateTime<Utc>, ser: S) -> Result<S::Ok, S::Error> {
+        let s = format!("{}", date.format(CODEBUILD_TIME_FORMAT));
+        ser.serialize_str(&s)
+    }
+}
+
+pub(crate) mod optional_time {
+    use super::*;
+
+    pub(crate) fn deserialize<'de, D>(deserializer: D) -> Result<Option<DateTime<Utc>>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: Option<String> = Option::deserialize(deserializer)?;
+        if let Some(val) = s {
+            let visitor = TimeVisitor {};
+            return visitor.visit_str(&val).map(Some);
+        }
+
+        Ok(None)
+    }
+
+    pub fn serialize<S: Serializer>(
+        date: &Option<DateTime<Utc>>,
+        ser: S,
+    ) -> Result<S::Ok, S::Error> {
+        if let Some(date) = date {
+            return str_time::serialize(date, ser);
+        }
+
+        ser.serialize_none()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    type TestTime = DateTime<Utc>;
+
+    #[test]
+    fn test_deserialize_codebuild_time() {
+        #[derive(Deserialize)]
+        struct Test {
+            #[serde(with = "str_time")]
+            pub date: TestTime,
+        }
+        let data = json!({
+            "date": "Sep 1, 2017 4:12:29 PM"
+        });
+
+        let expected = Utc
+            .datetime_from_str("Sep 1, 2017 4:12:29 PM", CODEBUILD_TIME_FORMAT)
+            .unwrap();
+        let decoded: Test = serde_json::from_value(data).unwrap();
+        assert_eq!(expected, decoded.date);
+    }
+
+    #[test]
+    fn test_deserialize_codebuild_optional_time() {
+        #[derive(Deserialize)]
+        struct Test {
+            #[serde(with = "optional_time")]
+            pub date: Option<TestTime>,
+        }
+        let data = json!({
+            "date": "Sep 1, 2017 4:12:29 PM"
+        });
+
+        let expected = Utc
+            .datetime_from_str("Sep 1, 2017 4:12:29 PM", CODEBUILD_TIME_FORMAT)
+            .unwrap();
+        let decoded: Test = serde_json::from_value(data).unwrap();
+        assert_eq!(Some(expected), decoded.date);
+    }
+}