Fix error when deserializing datatypes from number (#506)

Co-authored-by: Jacob Pratt <jacob@jhpratt.dev>

Author: Aegonek

src/serde/visitor.rs

@@ -194,7 +194,7 @@ impl<'a> de::Visitor<'a> for Visitor<Weekday> {
         }
     }
 
-    fn visit_u8<E: de::Error>(self, value: u8) -> Result<Weekday, E> {
+    fn visit_u64<E: de::Error>(self, value: u64) -> Result<Weekday, E> {
         match value {
             1 => Ok(Weekday::Monday),
             2 => Ok(Weekday::Tuesday),
@@ -204,7 +204,7 @@ impl<'a> de::Visitor<'a> for Visitor<Weekday> {
             6 => Ok(Weekday::Saturday),
             7 => Ok(Weekday::Sunday),
             _ => Err(E::invalid_value(
-                de::Unexpected::Unsigned(value.into()),
+                de::Unexpected::Unsigned(value),
                 &"a value in the range 1..=7",
             )),
         }
@@ -236,7 +236,7 @@ impl<'a> de::Visitor<'a> for Visitor<Month> {
         }
     }
 
-    fn visit_u8<E: de::Error>(self, value: u8) -> Result<Month, E> {
+    fn visit_u64<E: de::Error>(self, value: u64) -> Result<Month, E> {
         match value {
             1 => Ok(Month::January),
             2 => Ok(Month::February),
@@ -251,7 +251,7 @@ impl<'a> de::Visitor<'a> for Visitor<Month> {
             11 => Ok(Month::November),
             12 => Ok(Month::December),
             _ => Err(E::invalid_value(
-                de::Unexpected::Unsigned(value.into()),
+                de::Unexpected::Unsigned(value),
                 &"a value in the range 1..=12",
             )),
         }

tests/integration/serde/json.rs

@@ -0,0 +1,148 @@
+use std::error::Error;
+
+use serde::{Deserialize, Serialize};
+use serde_test::Configure;
+use time::macros::{date, datetime, time};
+use time::{Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time, Weekday};
+
+enum Format {
+    Compact,
+    Readable,
+}
+
+use Format::*;
+
+fn serialize<T: Serialize>(val: T) -> Result<String, Box<dyn Error>> {
+    let mut buf: Vec<u8> = Vec::new();
+    let mut ser = serde_json::Serializer::new(&mut buf);
+    val.serialize(&mut ser)?;
+    let str = String::from_utf8(buf)?;
+    Ok(str)
+}
+
+fn deserialize<'a, T: Deserialize<'a>>(from: &'a str, fmt: Format) -> serde_json::Result<T> {
+    let mut de = serde_json::Deserializer::from_str(from);
+    match fmt {
+        Compact => T::deserialize((&mut de).compact()),
+        Readable => T::deserialize((&mut de).readable()),
+    }
+}
+
+#[test]
+fn weekday_json() -> Result<(), Box<dyn Error>> {
+    use Weekday::*;
+
+    assert_eq!(serialize(Monday.compact())?, "1");
+    assert_eq!(deserialize::<Weekday>("1", Compact)?, Monday);
+
+    assert_eq!(serialize(Monday.readable())?, "\"Monday\"");
+    assert_eq!(deserialize::<Weekday>("\"Monday\"", Readable)?, Monday);
+    assert_eq!(deserialize::<Weekday>("1", Readable)?, Monday);
+
+    Ok(())
+}
+
+#[test]
+fn month_json() -> Result<(), Box<dyn Error>> {
+    use Month::*;
+
+    assert_eq!(serialize(March.compact())?, "3");
+    assert_eq!(deserialize::<Month>("3", Compact)?, March);
+
+    assert_eq!(serialize(March.readable())?, "\"March\"");
+    assert_eq!(deserialize::<Month>("\"March\"", Readable)?, March);
+    assert_eq!(deserialize::<Month>("3", Readable)?, March);
+
+    Ok(())
+}
+
+#[test]
+fn time_json() -> Result<(), Box<dyn Error>> {
+    let time = time!(12:40:20);
+
+    assert_eq!(serialize(time.compact())?, "[12,40,20,0]");
+    assert_eq!(deserialize::<Time>("[12,40,20,0]", Compact)?, time);
+
+    assert_eq!(serialize(time.readable())?, "\"12:40:20.0\"");
+    assert_eq!(deserialize::<Time>("\"12:40:20.0\"", Readable)?, time);
+    assert_eq!(deserialize::<Time>("[12,40,20,0]", Readable)?, time);
+
+    Ok(())
+}
+
+#[test]
+fn primitive_datetime_json() -> Result<(), Box<dyn Error>> {
+    let dt = datetime!(2022-05-20 12:40:20);
+
+    assert_eq!(serialize(dt.compact())?, "[2022,140,12,40,20,0]");
+    assert_eq!(
+        deserialize::<PrimitiveDateTime>("[2022,140,12,40,20,0]", Compact)?,
+        dt
+    );
+
+    assert_eq!(serialize(dt.readable())?, "\"2022-05-20 12:40:20.0\"");
+    assert_eq!(
+        deserialize::<PrimitiveDateTime>("\"2022-05-20 12:40:20.0\"", Readable)?,
+        dt
+    );
+    assert_eq!(
+        deserialize::<PrimitiveDateTime>("[2022,140,12,40,20,0]", Readable)?,
+        dt
+    );
+
+    Ok(())
+}
+
+#[test]
+fn offset_datetime_json() -> Result<(), Box<dyn Error>> {
+    let dt = datetime!(2022-05-20 12:40:20).assume_utc();
+
+    assert_eq!(serialize(dt.compact())?, "[2022,140,12,40,20,0,0,0,0]");
+    assert_eq!(
+        deserialize::<OffsetDateTime>("[2022,140,12,40,20,0,0,0,0]", Compact)?,
+        dt
+    );
+
+    assert_eq!(
+        serialize(dt.readable())?,
+        "\"2022-05-20 12:40:20.0 +00:00:00\""
+    );
+    assert_eq!(
+        deserialize::<OffsetDateTime>("\"2022-05-20 12:40:20.0 +00:00:00\"", Readable)?,
+        dt
+    );
+    assert_eq!(
+        deserialize::<OffsetDateTime>("[2022,140,12,40,20,0,0,0,0]", Readable)?,
+        dt
+    );
+
+    Ok(())
+}
+
+#[test]
+fn duration_json() -> Result<(), Box<dyn Error>> {
+    let dur = Duration::new(50, 0);
+
+    assert_eq!(serialize(dur.compact())?, "[50,0]");
+    assert_eq!(deserialize::<Duration>("[50,0]", Compact)?, dur);
+
+    assert_eq!(serialize(dur.readable())?, "\"50.000000000\"");
+    assert_eq!(deserialize::<Duration>("\"50.000000000\"", Readable)?, dur);
+    assert_eq!(deserialize::<Duration>("[50,0]", Readable)?, dur);
+
+    Ok(())
+}
+
+#[test]
+fn date_json() -> Result<(), Box<dyn Error>> {
+    let date = date!(2022 - 04 - 05);
+
+    assert_eq!(serialize(date.compact())?, "[2022,95]");
+    assert_eq!(deserialize::<Date>("[2022,95]", Compact)?, date);
+
+    assert_eq!(serialize(date.readable())?, "\"2022-04-05\"");
+    assert_eq!(deserialize::<Date>("\"2022-04-05\"", Readable)?, date);
+    assert_eq!(deserialize::<Date>("[2022,95]", Readable)?, date);
+
+    Ok(())
+}

tests/integration/serde/mod.rs

@@ -4,6 +4,7 @@ use time::{Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcOf
 
 mod error_conditions;
 mod iso8601;
+mod json;
 mod macros;
 mod rfc2822;
 mod rfc3339;