Upgrade dependencies (base64 and serde_with).

Cargo.toml

@@ -15,13 +15,13 @@ keywords = ["lambda", "aws", "amazon", "events", "S3"]
 categories = ["api-bindings", "encoding", "web-programming"]
 
 [dependencies]
-base64 = "0.13"
+base64 = "0.21"
 http = "0.2"
 http-body = "0.4"
 http-serde = "^1"
 serde = "^1"
 serde_derive = "^1"
-serde_with = { version = "^2", features = ["json"], optional = true }
+serde_with = { version = "^3", features = ["json"], optional = true }
 serde_json = "^1"
 serde_dynamo = { version = "^4.1", optional = true }
 bytes = { version = "1", features = ["serde"] }

src/cloudwatch_logs/mod.rs

@@ -54,6 +54,8 @@ impl<'de> Deserialize<'de> for AwsLogs {
     where
         D: Deserializer<'de>,
     {
+        use base64::Engine;
+
         struct AwsLogsVisitor;
 
         impl<'de> Visitor<'de> for AwsLogsVisitor {
@@ -72,7 +74,9 @@ impl<'de> Deserialize<'de> for AwsLogs {
                     match key {
                         "data" => {
                             let bytes = map.next_value::<String>().and_then(|string| {
-                                base64::decode(&string).map_err(Error::custom)
+                                base64::engine::general_purpose::STANDARD
+                                    .decode(&string)
+                                    .map_err(Error::custom)
                             })?;
 
                             let bytes = flate2::read::GzDecoder::new(&bytes[..]);
@@ -99,7 +103,10 @@ impl Serialize for AwsLogs {
     where
         S: Serializer,
     {
-        let base = base64::write::EncoderWriter::new(Vec::new(), base64::STANDARD_NO_PAD);
+        let base = base64::write::EncoderWriter::new(
+            Vec::new(),
+            &base64::engine::general_purpose::STANDARD_NO_PAD,
+        );
         let mut gzip = flate2::write::GzEncoder::new(base, flate2::Compression::default());
 
         serde_json::to_writer(&mut gzip, &self.data).map_err(SeError::custom)?;

src/custom_serde/mod.rs

@@ -1,5 +1,5 @@
 #[allow(unused)]
-use base64::{decode, encode};
+use base64::{engine::general_purpose::STANDARD, Engine};
 use chrono::{DateTime, Duration, TimeZone, Utc};
 use serde;
 use serde::de::{Deserialize, Deserializer, Error as DeError};
@@ -125,14 +125,14 @@ where
     D: Deserializer<'de>,
 {
     let s: String = String::deserialize(deserializer)?;
-    decode(&s).map_err(DeError::custom)
+    STANDARD.decode(&s).map_err(DeError::custom)
 }
 
 pub(crate) fn serialize_base64<S>(value: &[u8], serializer: S) -> Result<S::Ok, S::Error>
 where
     S: Serializer,
 {
-    serializer.serialize_str(&encode(value))
+    serializer.serialize_str(&STANDARD.encode(value))
 }
 
 /// Deserializes `HashMap<_>`, mapping JSON `null` to an empty map.
@@ -217,7 +217,7 @@ where
 #[cfg(test)]
 mod test {
     use super::*;
-    use chrono::TimeZone;
+    use chrono::{TimeZone, Timelike};
     use serde_json;
 
     #[test]
@@ -258,7 +258,11 @@ mod test {
             #[serde(deserialize_with = "deserialize_milliseconds")]
             v: DateTime<Utc>,
         }
-        let expected = Utc.ymd(2017, 10, 05).and_hms_nano(15, 33, 44, 302_000_000);
+        let expected = Utc
+            .with_ymd_and_hms(2017, 10, 05, 15, 33, 44)
+            .unwrap()
+            .with_nanosecond(302_000_000)
+            .unwrap();
 
         // Test parsing strings.
         let data = json!({
@@ -285,7 +289,11 @@ mod test {
             v: DateTime<Utc>,
         }
         let instance = Test {
-            v: Utc.ymd(1983, 7, 22).and_hms_nano(1, 0, 0, 99_888_777),
+            v: Utc
+                .with_ymd_and_hms(1983, 7, 22, 1, 0, 0)
+                .unwrap()
+                .with_nanosecond(99_888_777)
+                .unwrap(),
         };
         let encoded = serde_json::to_string(&instance).unwrap();
         assert_eq!(encoded, String::from(r#"{"v":"427683600099"}"#));
@@ -301,21 +309,33 @@ mod test {
 
         // Make sure nanoseconds are chopped off.
         let instance = Test {
-            v: Utc.ymd(1983, 7, 22).and_hms_nano(1, 0, 0, 99),
+            v: Utc
+                .with_ymd_and_hms(1983, 7, 22, 1, 0, 0)
+                .unwrap()
+                .with_nanosecond(99)
+                .unwrap(),
         };
         let encoded = serde_json::to_string(&instance).unwrap();
         assert_eq!(encoded, String::from(r#"{"v":"427683600"}"#));
 
         // Make sure milliseconds are included.
         let instance = Test {
-            v: Utc.ymd(1983, 7, 22).and_hms_nano(1, 0, 0, 2_000_000),
+            v: Utc
+                .with_ymd_and_hms(1983, 7, 22, 1, 0, 0)
+                .unwrap()
+                .with_nanosecond(2_000_000)
+                .unwrap(),
         };
         let encoded = serde_json::to_string(&instance).unwrap();
         assert_eq!(encoded, String::from(r#"{"v":"427683600.002"}"#));
 
         // Make sure milliseconds are included.
         let instance = Test {
-            v: Utc.ymd(1983, 7, 22).and_hms_nano(1, 0, 0, 1_234_000_000),
+            v: Utc
+                .with_ymd_and_hms(1983, 7, 22, 1, 0, 0)
+                .unwrap()
+                .with_nanosecond(1_234_000_000)
+                .unwrap(),
         };
         let encoded = serde_json::to_string(&instance).unwrap();
         assert_eq!(encoded, String::from(r#"{"v":"427683601.234"}"#));

src/dynamodb/attributes.rs

@@ -1,3 +1,4 @@
+use base64::Engine;
 use serde_dynamo::AttributeValue;
 use std::collections::HashMap;
 
@@ -62,7 +63,9 @@ mod test {
         let attr: AttributeValue = serde_json::from_value(value.clone()).unwrap();
         match attr {
             AttributeValue::B(ref b) => {
-                let expected = base64::decode("dGhpcyB0ZXh0IGlzIGJhc2U2NC1lbmNvZGVk").unwrap();
+                let expected = base64::engine::general_purpose::STANDARD
+                    .decode("dGhpcyB0ZXh0IGlzIGJhc2U2NC1lbmNvZGVk")
+                    .unwrap();
                 assert_eq!(&expected, b)
             }
             other => panic!("unexpected value {:?}", other),
@@ -137,7 +140,7 @@ mod test {
             AttributeValue::Bs(ref s) => {
                 let expected = vec!["U3Vubnk=", "UmFpbnk=", "U25vd3k="]
                     .into_iter()
-                    .flat_map(|s| base64::decode(&s))
+                    .flat_map(|s| base64::engine::general_purpose::STANDARD.decode(&s))
                     .collect::<Vec<_>>();
                 assert_eq!(&expected, s);
             }

src/dynamodb/mod.rs

@@ -263,7 +263,7 @@ mod test {
         assert_eq!(parsed, reparsed);
 
         let event = parsed.records.pop().unwrap();
-        let date = Utc.ymd(2016, 12, 2).and_hms(1, 27, 0);
+        let date = Utc.with_ymd_and_hms(2016, 12, 2, 1, 27, 0).unwrap();
         assert_eq!(date, event.change.approximate_creation_date_time);
     }
 

src/encodings.rs

@@ -192,8 +192,14 @@ impl Body {
     /// Panics when aws communicates to handler that request is base64 encoded but
     /// it can not be base64 decoded
     pub fn from_maybe_encoded(is_base64_encoded: bool, body: &str) -> Body {
+        use base64::Engine;
+
         if is_base64_encoded {
-            Body::from(::base64::decode(body).expect("failed to decode aws base64 encoded body"))
+            Body::from(
+                ::base64::engine::general_purpose::STANDARD
+                    .decode(body)
+                    .expect("failed to decode aws base64 encoded body"),
+            )
         } else {
             Body::from(body)
         }
@@ -288,9 +294,10 @@ impl Serialize for Body {
         match self {
             Body::Text(data) => serializer
                 .serialize_str(::std::str::from_utf8(data.as_ref()).map_err(S::Error::custom)?),
-            Body::Binary(data) => {
-                serializer.collect_str(&Base64Display::with_config(data, base64::STANDARD))
-            }
+            Body::Binary(data) => serializer.collect_str(&Base64Display::new(
+                data,
+                &base64::engine::general_purpose::STANDARD,
+            )),
             Body::Empty => serializer.serialize_unit(),
         }
     }