From 8ce0fe1bbc767e5cd02a2562b72f12b3c9ff8309 Mon Sep 17 00:00:00 2001
From: muzarski <mikolaj.uzarski@scylladb.com>
Date: Thu, 22 Feb 2024 16:33:38 +0100
Subject: [PATCH] cargo: rename `chrono` feature to `chrono-04`

---
 .github/workflows/rust.yml                   |  4 +-
 examples/Cargo.toml                          |  2 +-
 scylla-cql/Cargo.toml                        |  6 +-
 scylla-cql/src/frame/response/cql_to_rust.rs | 35 +++++-----
 scylla-cql/src/frame/response/result.rs      | 33 +++++-----
 scylla-cql/src/frame/value.rs                | 67 ++++++++++----------
 scylla-cql/src/frame/value_tests.rs          | 18 +++---
 scylla-cql/src/types/serialize/value.rs      | 17 ++---
 scylla/Cargo.toml                            |  4 +-
 scylla/src/transport/cql_types_test.rs       | 12 ++--
 10 files changed, 94 insertions(+), 104 deletions(-)

diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index 9dd9cc2f96..c211c859b2 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -46,8 +46,8 @@ jobs:
       run: cargo check --all-targets --manifest-path "scylla/Cargo.toml" --all-features
     - name: Cargo check with secrecy-08 feature
       run: cargo check --all-targets --manifest-path "scylla/Cargo.toml" --features "secrecy-08"
-    - name: Cargo check with chrono feature
-      run: cargo check --all-targets --manifest-path "scylla/Cargo.toml" --features "chrono"
+    - name: Cargo check with chrono-04 feature
+      run: cargo check --all-targets --manifest-path "scylla/Cargo.toml" --features "chrono-04"
     - name: Cargo check with time-03 feature
       run: cargo check --all-targets --manifest-path "scylla/Cargo.toml" --features "time-03"
     - name: Cargo check with num-bigint-03 feature
diff --git a/examples/Cargo.toml b/examples/Cargo.toml
index 0ddc1ec99e..bd44695aae 100644
--- a/examples/Cargo.toml
+++ b/examples/Cargo.toml
@@ -13,7 +13,7 @@ rustyline-derive = "0.6"
 scylla = { path = "../scylla", features = [
     "ssl",
     "cloud",
-    "chrono",
+    "chrono-04",
     "time-03",
     "num-bigint-03",
     "num-bigint-04",
diff --git a/scylla-cql/Cargo.toml b/scylla-cql/Cargo.toml
index 2c17478cf5..2dae50d09f 100644
--- a/scylla-cql/Cargo.toml
+++ b/scylla-cql/Cargo.toml
@@ -22,7 +22,7 @@ thiserror = "1.0"
 num-bigint-03 = { package = "num-bigint", version = "0.3", optional = true }
 num-bigint-04 = { package = "num-bigint", version = "0.4", optional = true }
 bigdecimal-04 = { package = "bigdecimal", version = "0.4", optional = true }
-chrono = { version = "0.4.32", default-features = false, optional = true }
+chrono-04 = { package = "chrono", version = "0.4.32", default-features = false, optional = true }
 lz4_flex = { version = "0.11.1" }
 async-trait = "0.1.57"
 serde = { version = "1.0", features = ["derive"], optional = true }
@@ -42,12 +42,12 @@ harness = false
 [features]
 secrecy-08 = ["dep:secrecy-08"]
 time-03 = ["dep:time-03"]
-chrono = ["dep:chrono"]
+chrono-04 = ["dep:chrono-04"]
 num-bigint-03 = ["dep:num-bigint-03"]
 num-bigint-04 = ["dep:num-bigint-04"]
 bigdecimal-04 = ["dep:bigdecimal-04"]
 full-serialization = [
-    "chrono",
+    "chrono-04",
     "time-03",
     "secrecy-08",
     "num-bigint-03",
diff --git a/scylla-cql/src/frame/response/cql_to_rust.rs b/scylla-cql/src/frame/response/cql_to_rust.rs
index e0283953d6..c984d749c3 100644
--- a/scylla-cql/src/frame/response/cql_to_rust.rs
+++ b/scylla-cql/src/frame/response/cql_to_rust.rs
@@ -8,9 +8,6 @@ use std::net::IpAddr;
 use thiserror::Error;
 use uuid::Uuid;
 
-#[cfg(feature = "chrono")]
-use chrono::{DateTime, NaiveDate, NaiveTime, Utc};
-
 #[cfg(feature = "secrecy-08")]
 use secrecy_08::{Secret, Zeroize};
 
@@ -178,8 +175,8 @@ impl FromCqlVal<CqlValue> for bigdecimal_04::BigDecimal {
     }
 }
 
-#[cfg(feature = "chrono")]
-impl FromCqlVal<CqlValue> for NaiveDate {
+#[cfg(feature = "chrono-04")]
+impl FromCqlVal<CqlValue> for chrono_04::NaiveDate {
     fn from_cql(cql_val: CqlValue) -> Result<Self, FromCqlValError> {
         match cql_val {
             CqlValue::Date(cql_date) => cql_date.try_into().map_err(|_| FromCqlValError::BadVal),
@@ -198,8 +195,8 @@ impl FromCqlVal<CqlValue> for time_03::Date {
     }
 }
 
-#[cfg(feature = "chrono")]
-impl FromCqlVal<CqlValue> for NaiveTime {
+#[cfg(feature = "chrono-04")]
+impl FromCqlVal<CqlValue> for chrono_04::NaiveTime {
     fn from_cql(cql_val: CqlValue) -> Result<Self, FromCqlValError> {
         match cql_val {
             CqlValue::Time(cql_time) => cql_time.try_into().map_err(|_| FromCqlValError::BadVal),
@@ -218,8 +215,8 @@ impl FromCqlVal<CqlValue> for time_03::Time {
     }
 }
 
-#[cfg(feature = "chrono")]
-impl FromCqlVal<CqlValue> for DateTime<Utc> {
+#[cfg(feature = "chrono-04")]
+impl FromCqlVal<CqlValue> for chrono_04::DateTime<chrono_04::Utc> {
     fn from_cql(cql_val: CqlValue) -> Result<Self, FromCqlValError> {
         cql_val
             .as_cql_timestamp()
@@ -526,10 +523,10 @@ mod tests {
         assert_eq!(Ok(counter), Counter::from_cql(CqlValue::Counter(counter)));
     }
 
-    #[cfg(feature = "chrono")]
+    #[cfg(feature = "chrono-04")]
     #[test]
-    fn naive_date_from_cql() {
-        use chrono::NaiveDate;
+    fn naive_date_04_from_cql() {
+        use chrono_04::NaiveDate;
 
         let unix_epoch: CqlValue = CqlValue::Date(CqlDate(2_u32.pow(31)));
         assert_eq!(
@@ -634,10 +631,10 @@ mod tests {
         assert_eq!(time_ns, CqlTime::from_cql(cql_value).unwrap().0);
     }
 
-    #[cfg(feature = "chrono")]
+    #[cfg(feature = "chrono-04")]
     #[test]
-    fn naive_time_from_cql() {
-        use chrono::NaiveTime;
+    fn naive_time_04_from_cql() {
+        use chrono_04::NaiveTime;
 
         // Midnight
         let midnight = CqlValue::Time(CqlTime(0));
@@ -661,7 +658,7 @@ mod tests {
             NaiveTime::from_cql(late_night)
         );
 
-        // Bad values. Since value is out of `chrono::NaiveTime` range, it should return `BadVal` error
+        // Bad values. Since value is out of `chrono_04::NaiveTime` range, it should return `BadVal` error
         let bad_time1 = CqlValue::Time(CqlTime(-1));
         assert_eq!(Err(FromCqlValError::BadVal), NaiveTime::from_cql(bad_time1));
         let bad_time2 = CqlValue::Time(CqlTime(i64::MAX));
@@ -734,10 +731,10 @@ mod tests {
         );
     }
 
-    #[cfg(feature = "chrono")]
+    #[cfg(feature = "chrono-04")]
     #[test]
-    fn datetime_from_cql() {
-        use chrono::{DateTime, NaiveDate, Utc};
+    fn datetime_04_from_cql() {
+        use chrono_04::{DateTime, NaiveDate, Utc};
         let naivedatetime_utc = NaiveDate::from_ymd_opt(2022, 12, 31)
             .unwrap()
             .and_hms_opt(2, 0, 0)
diff --git a/scylla-cql/src/frame/response/result.rs b/scylla-cql/src/frame/response/result.rs
index 29479cbefb..6f28e3f475 100644
--- a/scylla-cql/src/frame/response/result.rs
+++ b/scylla-cql/src/frame/response/result.rs
@@ -12,9 +12,6 @@ use std::borrow::Cow;
 use std::{convert::TryInto, net::IpAddr, result::Result as StdResult, str};
 use uuid::Uuid;
 
-#[cfg(feature = "chrono")]
-use chrono::{DateTime, NaiveDate, Utc};
-
 #[derive(Debug)]
 pub struct SetKeyspace {
     pub keyspace_name: String,
@@ -187,8 +184,8 @@ impl CqlValue {
         }
     }
 
-    #[cfg(feature = "chrono")]
-    pub fn as_naive_date(&self) -> Option<NaiveDate> {
+    #[cfg(feature = "chrono-04")]
+    pub fn as_naive_date(&self) -> Option<chrono_04::NaiveDate> {
         self.as_cql_date().and_then(|date| date.try_into().ok())
     }
 
@@ -205,8 +202,8 @@ impl CqlValue {
         }
     }
 
-    #[cfg(feature = "chrono")]
-    pub fn as_datetime(&self) -> Option<DateTime<Utc>> {
+    #[cfg(feature = "chrono-04")]
+    pub fn as_datetime(&self) -> Option<chrono_04::DateTime<chrono_04::Utc>> {
         self.as_cql_timestamp().and_then(|ts| ts.try_into().ok())
     }
 
@@ -223,8 +220,8 @@ impl CqlValue {
         }
     }
 
-    #[cfg(feature = "chrono")]
-    pub fn as_naive_time(&self) -> Option<chrono::NaiveTime> {
+    #[cfg(feature = "chrono-04")]
+    pub fn as_naive_time(&self) -> Option<chrono_04::NaiveTime> {
         self.as_cql_time().and_then(|ts| ts.try_into().ok())
     }
 
@@ -1272,10 +1269,10 @@ mod tests {
         assert_eq!(date.as_cql_date(), Some(max_date));
     }
 
-    #[cfg(feature = "chrono")]
+    #[cfg(feature = "chrono-04")]
     #[test]
-    fn test_naive_date_from_cql() {
-        use chrono::NaiveDate;
+    fn test_naive_date_04_from_cql() {
+        use chrono_04::NaiveDate;
 
         // 2^31 when converted to NaiveDate is 1970-01-01
         let unix_epoch = NaiveDate::from_ymd_opt(1970, 1, 1).unwrap();
@@ -1395,10 +1392,10 @@ mod tests {
         }
     }
 
-    #[cfg(feature = "chrono")]
+    #[cfg(feature = "chrono-04")]
     #[test]
-    fn test_naive_time_from_cql() {
-        use chrono::NaiveTime;
+    fn test_naive_time_04_from_cql() {
+        use chrono_04::NaiveTime;
 
         // 0 when converted to NaiveTime is 0:0:0.0
         let midnight = NaiveTime::from_hms_nano_opt(0, 0, 0, 0).unwrap();
@@ -1487,10 +1484,10 @@ mod tests {
         }
     }
 
-    #[cfg(feature = "chrono")]
+    #[cfg(feature = "chrono-04")]
     #[test]
-    fn test_datetime_from_cql() {
-        use chrono::{DateTime, NaiveDate, NaiveDateTime, NaiveTime};
+    fn test_datetime_04_from_cql() {
+        use chrono_04::{DateTime, NaiveDate, NaiveDateTime, NaiveTime};
 
         // 0 when converted to DateTime is 1970-01-01 0:00:00.00
         let unix_epoch = DateTime::from_timestamp(0, 0).unwrap();
diff --git a/scylla-cql/src/frame/value.rs b/scylla-cql/src/frame/value.rs
index d92dae8369..f594a6a310 100644
--- a/scylla-cql/src/frame/value.rs
+++ b/scylla-cql/src/frame/value.rs
@@ -9,9 +9,6 @@ use std::net::IpAddr;
 use thiserror::Error;
 use uuid::Uuid;
 
-#[cfg(feature = "chrono")]
-use chrono::{DateTime, NaiveDate, NaiveTime, TimeZone, Utc};
-
 use super::response::result::CqlValue;
 use super::types::vint_encode;
 use super::types::RawValue;
@@ -467,10 +464,10 @@ pub struct CqlTimestamp(pub i64);
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub struct CqlTime(pub i64);
 
-#[cfg(feature = "chrono")]
-impl From<NaiveDate> for CqlDate {
-    fn from(value: NaiveDate) -> Self {
-        let unix_epoch = NaiveDate::from_yo_opt(1970, 1).unwrap();
+#[cfg(feature = "chrono-04")]
+impl From<chrono_04::NaiveDate> for CqlDate {
+    fn from(value: chrono_04::NaiveDate) -> Self {
+        let unix_epoch = chrono_04::NaiveDate::from_yo_opt(1970, 1).unwrap();
 
         // `NaiveDate` range is -262145-01-01 to 262143-12-31
         // Both values are well within supported range
@@ -480,50 +477,52 @@ impl From<NaiveDate> for CqlDate {
     }
 }
 
-#[cfg(feature = "chrono")]
-impl TryInto<NaiveDate> for CqlDate {
+#[cfg(feature = "chrono-04")]
+impl TryInto<chrono_04::NaiveDate> for CqlDate {
     type Error = ValueOverflow;
 
-    fn try_into(self) -> Result<NaiveDate, Self::Error> {
+    fn try_into(self) -> Result<chrono_04::NaiveDate, Self::Error> {
         let days_since_unix_epoch = self.0 as i64 - (1 << 31);
 
         // date_days is u32 then converted to i64 then we subtract 2^31;
         // Max value is 2^31, min value is -2^31. Both values can safely fit in chrono::Duration, this call won't panic
-        let duration_since_unix_epoch = chrono::Duration::try_days(days_since_unix_epoch).unwrap();
+        let duration_since_unix_epoch =
+            chrono_04::Duration::try_days(days_since_unix_epoch).unwrap();
 
-        NaiveDate::from_yo_opt(1970, 1)
+        chrono_04::NaiveDate::from_yo_opt(1970, 1)
             .unwrap()
             .checked_add_signed(duration_since_unix_epoch)
             .ok_or(ValueOverflow)
     }
 }
 
-#[cfg(feature = "chrono")]
-impl From<DateTime<Utc>> for CqlTimestamp {
-    fn from(value: DateTime<Utc>) -> Self {
+#[cfg(feature = "chrono-04")]
+impl From<chrono_04::DateTime<chrono_04::Utc>> for CqlTimestamp {
+    fn from(value: chrono_04::DateTime<chrono_04::Utc>) -> Self {
         Self(value.timestamp_millis())
     }
 }
 
-#[cfg(feature = "chrono")]
-impl TryInto<DateTime<Utc>> for CqlTimestamp {
+#[cfg(feature = "chrono-04")]
+impl TryInto<chrono_04::DateTime<chrono_04::Utc>> for CqlTimestamp {
     type Error = ValueOverflow;
 
-    fn try_into(self) -> Result<DateTime<Utc>, Self::Error> {
-        match Utc.timestamp_millis_opt(self.0) {
-            chrono::LocalResult::Single(datetime) => Ok(datetime),
+    fn try_into(self) -> Result<chrono_04::DateTime<chrono_04::Utc>, Self::Error> {
+        use chrono_04::TimeZone;
+        match chrono_04::Utc.timestamp_millis_opt(self.0) {
+            chrono_04::LocalResult::Single(datetime) => Ok(datetime),
             _ => Err(ValueOverflow),
         }
     }
 }
 
-#[cfg(feature = "chrono")]
-impl TryFrom<NaiveTime> for CqlTime {
+#[cfg(feature = "chrono-04")]
+impl TryFrom<chrono_04::NaiveTime> for CqlTime {
     type Error = ValueOverflow;
 
-    fn try_from(value: NaiveTime) -> Result<Self, Self::Error> {
+    fn try_from(value: chrono_04::NaiveTime) -> Result<Self, Self::Error> {
         let nanos = value
-            .signed_duration_since(chrono::NaiveTime::MIN)
+            .signed_duration_since(chrono_04::NaiveTime::MIN)
             .num_nanoseconds()
             .unwrap();
 
@@ -536,18 +535,18 @@ impl TryFrom<NaiveTime> for CqlTime {
     }
 }
 
-#[cfg(feature = "chrono")]
-impl TryInto<NaiveTime> for CqlTime {
+#[cfg(feature = "chrono-04")]
+impl TryInto<chrono_04::NaiveTime> for CqlTime {
     type Error = ValueOverflow;
 
-    fn try_into(self) -> Result<NaiveTime, Self::Error> {
+    fn try_into(self) -> Result<chrono_04::NaiveTime, Self::Error> {
         let secs = (self.0 / 1_000_000_000)
             .try_into()
             .map_err(|_| ValueOverflow)?;
         let nanos = (self.0 % 1_000_000_000)
             .try_into()
             .map_err(|_| ValueOverflow)?;
-        NaiveTime::from_num_seconds_from_midnight_opt(secs, nanos).ok_or(ValueOverflow)
+        chrono_04::NaiveTime::from_num_seconds_from_midnight_opt(secs, nanos).ok_or(ValueOverflow)
     }
 }
 
@@ -1010,8 +1009,8 @@ impl Value for bigdecimal_04::BigDecimal {
     }
 }
 
-#[cfg(feature = "chrono")]
-impl Value for NaiveDate {
+#[cfg(feature = "chrono-04")]
+impl Value for chrono_04::NaiveDate {
     fn serialize(&self, buf: &mut Vec<u8>) -> Result<(), ValueTooBig> {
         CqlDate::from(*self).serialize(buf)
     }
@@ -1048,8 +1047,8 @@ impl Value for CqlTime {
     }
 }
 
-#[cfg(feature = "chrono")]
-impl Value for DateTime<Utc> {
+#[cfg(feature = "chrono-04")]
+impl Value for chrono_04::DateTime<chrono_04::Utc> {
     fn serialize(&self, buf: &mut Vec<u8>) -> Result<(), ValueTooBig> {
         CqlTimestamp::from(*self).serialize(buf)
     }
@@ -1062,8 +1061,8 @@ impl Value for time_03::OffsetDateTime {
     }
 }
 
-#[cfg(feature = "chrono")]
-impl Value for NaiveTime {
+#[cfg(feature = "chrono-04")]
+impl Value for chrono_04::NaiveTime {
     fn serialize(&self, buf: &mut Vec<u8>) -> Result<(), ValueTooBig> {
         CqlTime::try_from(*self)
             .map_err(|_| ValueTooBig)?
diff --git a/scylla-cql/src/frame/value_tests.rs b/scylla-cql/src/frame/value_tests.rs
index 2f0b9a92c6..d71db263de 100644
--- a/scylla-cql/src/frame/value_tests.rs
+++ b/scylla-cql/src/frame/value_tests.rs
@@ -306,10 +306,10 @@ fn ipaddr_serialization() {
     );
 }
 
-#[cfg(feature = "chrono")]
+#[cfg(feature = "chrono-04")]
 #[test]
-fn naive_date_serialization() {
-    use chrono::NaiveDate;
+fn naive_date_04_serialization() {
+    use chrono_04::NaiveDate;
     // 1970-01-31 is 2^31
     let unix_epoch: NaiveDate = NaiveDate::from_ymd_opt(1970, 1, 1).unwrap();
     assert_eq!(
@@ -412,10 +412,10 @@ fn cql_time_serialization() {
     }
 }
 
-#[cfg(feature = "chrono")]
+#[cfg(feature = "chrono-04")]
 #[test]
-fn naive_time_serialization() {
-    use chrono::NaiveTime;
+fn naive_time_04_serialization() {
+    use chrono_04::NaiveTime;
 
     let midnight_time: i64 = 0;
     let max_time: i64 = 24 * 60 * 60 * 1_000_000_000 - 1;
@@ -492,10 +492,10 @@ fn cql_timestamp_serialization() {
     }
 }
 
-#[cfg(feature = "chrono")]
+#[cfg(feature = "chrono-04")]
 #[test]
-fn date_time_serialization() {
-    use chrono::{DateTime, Utc};
+fn date_time_04_serialization() {
+    use chrono_04::{DateTime, Utc};
     let test_cases: [(DateTime<Utc>, [u8; 8]); 7] = [
         (
             // Max time serialized without error
diff --git a/scylla-cql/src/types/serialize/value.rs b/scylla-cql/src/types/serialize/value.rs
index 3f52c8c83b..7adb4fefd0 100644
--- a/scylla-cql/src/types/serialize/value.rs
+++ b/scylla-cql/src/types/serialize/value.rs
@@ -9,9 +9,6 @@ use std::sync::Arc;
 use thiserror::Error;
 use uuid::Uuid;
 
-#[cfg(feature = "chrono")]
-use chrono::{DateTime, NaiveDate, NaiveTime, Utc};
-
 #[cfg(feature = "secrecy-08")]
 use secrecy_08::{ExposeSecret, Secret, Zeroize};
 
@@ -22,7 +19,7 @@ use crate::frame::value::{
     MaybeUnset, Unset, Value,
 };
 
-#[cfg(feature = "chrono")]
+#[cfg(feature = "chrono-04")]
 use crate::frame::value::ValueOverflow;
 
 use super::writers::WrittenCellProof;
@@ -160,22 +157,22 @@ impl SerializeValue for CqlTime {
         writer.set_value(me.0.to_be_bytes().as_slice()).unwrap()
     });
 }
-#[cfg(feature = "chrono")]
-impl SerializeValue for NaiveDate {
+#[cfg(feature = "chrono-04")]
+impl SerializeValue for chrono_04::NaiveDate {
     impl_serialize_via_writer!(|me, typ, writer| {
         exact_type_check!(typ, Date);
         <CqlDate as SerializeValue>::serialize(&(*me).into(), typ, writer)?
     });
 }
-#[cfg(feature = "chrono")]
-impl SerializeValue for DateTime<Utc> {
+#[cfg(feature = "chrono-04")]
+impl SerializeValue for chrono_04::DateTime<chrono_04::Utc> {
     impl_serialize_via_writer!(|me, typ, writer| {
         exact_type_check!(typ, Timestamp);
         <CqlTimestamp as SerializeValue>::serialize(&(*me).into(), typ, writer)?
     });
 }
-#[cfg(feature = "chrono")]
-impl SerializeValue for NaiveTime {
+#[cfg(feature = "chrono-04")]
+impl SerializeValue for chrono_04::NaiveTime {
     impl_serialize_via_writer!(|me, typ, writer| {
         exact_type_check!(typ, Time);
         let cql_time = CqlTime::try_from(*me).map_err(|_: ValueOverflow| {
diff --git a/scylla/Cargo.toml b/scylla/Cargo.toml
index a49aff72d4..3096ff7d6d 100644
--- a/scylla/Cargo.toml
+++ b/scylla/Cargo.toml
@@ -25,13 +25,13 @@ cloud = [
     "dep:base64",
 ]
 secrecy-08 = ["scylla-cql/secrecy-08"]
-chrono = ["scylla-cql/chrono"]
+chrono-04 = ["scylla-cql/chrono-04"]
 time-03 = ["scylla-cql/time-03"]
 num-bigint-03 = ["scylla-cql/num-bigint-03"]
 num-bigint-04 = ["scylla-cql/num-bigint-04"]
 bigdecimal-04 = ["scylla-cql/bigdecimal-04"]
 full-serialization = [
-    "chrono",
+    "chrono-04",
     "time-03",
     "secrecy-08",
     "num-bigint-03",
diff --git a/scylla/src/transport/cql_types_test.rs b/scylla/src/transport/cql_types_test.rs
index 3e253f233e..1beea8b3fd 100644
--- a/scylla/src/transport/cql_types_test.rs
+++ b/scylla/src/transport/cql_types_test.rs
@@ -293,9 +293,9 @@ async fn test_counter() {
     }
 }
 
-#[cfg(feature = "chrono")]
+#[cfg(feature = "chrono-04")]
 #[tokio::test]
-async fn test_naive_date() {
+async fn test_naive_date_04() {
     setup_tracing();
     use chrono::Datelike;
     use chrono::NaiveDate;
@@ -620,9 +620,9 @@ async fn test_cql_time() {
     }
 }
 
-#[cfg(feature = "chrono")]
+#[cfg(feature = "chrono-04")]
 #[tokio::test]
-async fn test_naive_time() {
+async fn test_naive_time_04() {
     setup_tracing();
     use chrono::NaiveTime;
 
@@ -842,9 +842,9 @@ async fn test_cql_timestamp() {
     }
 }
 
-#[cfg(feature = "chrono")]
+#[cfg(feature = "chrono-04")]
 #[tokio::test]
-async fn test_date_time() {
+async fn test_date_time_04() {
     setup_tracing();
     use chrono::{DateTime, NaiveDate, NaiveDateTime, NaiveTime, Utc};