RUST-815 Truncate bson::DateTimes to millisecond precision (#257)

Author: vkill

src/bson.rs

@@ -23,7 +23,7 @@
 
 use std::fmt::{self, Debug, Display};
 
-use chrono::{Datelike, SecondsFormat, TimeZone, Utc};
+use chrono::{Datelike, NaiveDateTime, SecondsFormat, TimeZone, Utc};
 use serde_json::{json, Value};
 
 pub use crate::document::Document;
@@ -287,7 +287,7 @@ impl From<oid::ObjectId> for Bson {
 
 impl From<chrono::DateTime<Utc>> for Bson {
     fn from(a: chrono::DateTime<Utc>) -> Bson {
-        Bson::DateTime(DateTime(a))
+        Bson::DateTime(DateTime::from(a))
     }
 }
 
@@ -1019,12 +1019,6 @@ impl crate::DateTime {
     pub fn timestamp_millis(&self) -> i64 {
         self.0.timestamp_millis()
     }
-
-    /// If this DateTime is sub-millisecond precision. BSON only supports millisecond precision, so
-    /// this should be checked before serializing to BSON.
-    pub(crate) fn is_sub_millis_precision(&self) -> bool {
-        self.0.timestamp_subsec_micros() % 1000 != 0
-    }
 }
 
 impl Display for crate::DateTime {
@@ -1041,7 +1035,12 @@ impl From<crate::DateTime> for chrono::DateTime<Utc> {
 
 impl<T: chrono::TimeZone> From<chrono::DateTime<T>> for crate::DateTime {
     fn from(x: chrono::DateTime<T>) -> Self {
-        DateTime(x.with_timezone(&Utc))
+        let dt = x.with_timezone(&Utc);
+
+        DateTime(chrono::DateTime::<Utc>::from_utc(
+            NaiveDateTime::from_timestamp(dt.timestamp(), dt.timestamp_subsec_millis() * 1_000_000),
+            Utc,
+        ))
     }
 }
 

src/ser/error.rs

@@ -14,9 +14,6 @@ pub enum Error {
     /// A key could not be serialized to a BSON string.
     InvalidDocumentKey(Bson),
 
-    /// Attempted to serialize a sub-millisecond precision datetime, which BSON does not support.
-    SubMillisecondPrecisionDateTime(crate::DateTime),
-
     /// A general error that ocurred during serialization.
     /// See: https://docs.rs/serde/1.0.110/serde/ser/trait.Error.html#tymethod.custom
     #[non_exhaustive]
@@ -66,12 +63,6 @@ impl fmt::Display for Error {
                  size.",
                 value
             ),
-            Error::SubMillisecondPrecisionDateTime(dt) => write!(
-                fmt,
-                "BSON supports millisecond-precision datetimes, could not serialize datetime with \
-                 greater precision losslessly: {}",
-                dt
-            ),
         }
     }
 }

src/ser/mod.rs

@@ -153,12 +153,7 @@ pub(crate) fn serialize_bson<W: Write + ?Sized>(
 
             writer.write_all(bytes).map_err(From::from)
         }
-        Bson::DateTime(ref v) => {
-            if v.is_sub_millis_precision() {
-                return Err(Error::SubMillisecondPrecisionDateTime(*v));
-            }
-            write_i64(writer, v.timestamp_millis())
-        }
+        Bson::DateTime(ref v) => write_i64(writer, v.timestamp_millis()),
         Bson::Null => Ok(()),
         Bson::Symbol(ref v) => write_string(writer, &v),
         #[cfg(not(feature = "decimal128"))]

src/tests/modules/bson.rs

@@ -7,6 +7,7 @@ use crate::{
     tests::LOCK,
     Binary,
     Bson,
+    DateTime,
     Document,
     JavaScriptCodeWithScope,
     Regex,
@@ -169,3 +170,47 @@ fn timestamp_ordering() {
     assert!(ts1 < ts3);
     assert!(ts2 < ts3);
 }
+
+#[test]
+fn from_chrono_datetime() {
+    fn assert_precision(dt: DateTime) {
+        assert_eq!(
+            chrono::DateTime::<chrono::Utc>::from(dt).timestamp_subsec_micros() % 1000 != 0,
+            false
+        )
+    }
+    fn assert_millis(dt: DateTime, millis: u32) {
+        assert_eq!(
+            chrono::DateTime::<chrono::Utc>::from(dt).timestamp_subsec_millis(),
+            millis
+        )
+    }
+
+    let now = chrono::Utc::now();
+    let dt = DateTime::from(now);
+    assert_precision(dt);
+    let bson = Bson::from(now);
+    assert_precision(bson.as_datetime().unwrap().to_owned());
+
+    let chrono_dt: chrono::DateTime<chrono::Utc> = "2014-11-28T12:00:09Z".parse().unwrap();
+    let dt = DateTime::from(chrono_dt);
+    assert_precision(dt);
+    assert_millis(dt, 0);
+    let bson = Bson::from(chrono_dt);
+    assert_precision(bson.as_datetime().unwrap().to_owned());
+    assert_millis(bson.as_datetime().unwrap().to_owned(), 0);
+
+    for s in &[
+        "2014-11-28T12:00:09.123Z",
+        "2014-11-28T12:00:09.123456Z",
+        "2014-11-28T12:00:09.123456789Z",
+    ] {
+        let chrono_dt: chrono::DateTime<chrono::Utc> = s.parse().unwrap();
+        let dt = DateTime::from(chrono_dt);
+        assert_precision(dt);
+        assert_millis(dt, 123);
+        let bson = Bson::from(chrono_dt);
+        assert_precision(bson.as_datetime().unwrap().to_owned());
+        assert_millis(bson.as_datetime().unwrap().to_owned(), 123);
+    }
+}

src/tests/modules/macros.rs

@@ -45,7 +45,7 @@ fn standard_format() {
         base64::encode("thingies"),
         base64::encode("secret"),
         hex::encode(id_string),
-        date
+        date.format("%Y-%m-%d %H:%M:%S%.3f %Z")
     );
 
     assert_eq!(expected, format!("{}", doc));