feat: unit tests

Author: apskhem

rust/cardano-chain-follower/src/network.rs

@@ -173,9 +173,12 @@ impl Network {
     pub fn time_to_slot(&self, time: DateTime<Utc>) -> Option<u64> {
         let genesis = self.genesis_values();
 
-        let byron_start_time = DateTime::<Utc>::from_timestamp(genesis.byron_known_time as i64, 0)?;
-        let shelley_start_time =
-            DateTime::<Utc>::from_timestamp(genesis.shelley_known_time as i64, 0)?;
+        let byron_start_time = i64::try_from(genesis.byron_known_time)
+            .map(|time| DateTime::<Utc>::from_timestamp(time, 0))
+            .ok()??;
+        let shelley_start_time = i64::try_from(genesis.shelley_known_time)
+            .map(|time| DateTime::<Utc>::from_timestamp(time, 0))
+            .ok()??;
 
         // determine if the given time is in Byron or Shelley era.
         if time < byron_start_time {
@@ -186,12 +189,18 @@ impl Network {
             // Byron era
             let time_diff = time - byron_start_time;
             let elapsed_slots = time_diff.num_seconds() / i64::from(genesis.byron_slot_length);
-            Some(genesis.byron_known_slot + elapsed_slots as u64)
+
+            u64::try_from(elapsed_slots)
+                .map(|elapsed_slots| Some(genesis.byron_known_slot + elapsed_slots))
+                .ok()?
         } else {
             // Shelley era
             let time_diff = time - shelley_start_time;
             let elapsed_slots = time_diff.num_seconds() / i64::from(genesis.shelley_slot_length);
-            Some(genesis.shelley_known_slot + elapsed_slots as u64)
+
+            u64::try_from(elapsed_slots)
+                .map(|elapsed_slots| Some(genesis.shelley_known_slot + elapsed_slots))
+                .ok()?
         }
     }
 }
@@ -211,6 +220,7 @@ mod tests {
     use std::str::FromStr;
 
     use anyhow::Ok;
+    use chrono::{TimeZone, Utc};
 
     use super::*;
 
@@ -234,4 +244,77 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_time_to_slot_before_blockchain() {
+        let network = Network::Mainnet;
+        let genesis = network.genesis_values();
+
+        let before_blockchain = Utc
+            .timestamp_opt(i64::try_from(genesis.byron_known_time).unwrap() - 1, 0)
+            .unwrap();
+
+        // Expect None for time before the blockchain started
+        assert_eq!(network.time_to_slot(before_blockchain), None);
+    }
+
+    #[test]
+    fn test_time_to_slot_byron_era() {
+        let network = Network::Mainnet;
+        let genesis = network.genesis_values();
+
+        let byron_start_time = Utc
+            .timestamp_opt(i64::try_from(genesis.byron_known_time).unwrap(), 0)
+            .unwrap();
+        let byron_slot_length = i64::from(genesis.byron_slot_length);
+
+        // A time in the middle of the Byron era
+        let time = byron_start_time + chrono::Duration::seconds(byron_slot_length * 100);
+        let expected_slot = genesis.byron_known_slot + 100;
+
+        // Expect the correct slot for the given time
+        assert_eq!(network.time_to_slot(time), Some(expected_slot));
+    }
+
+    #[test]
+    fn test_time_to_slot_transition_to_shelley() {
+        let network = Network::Mainnet;
+        let genesis = network.genesis_values();
+
+        let shelley_start_time = Utc
+            .timestamp_opt(i64::try_from(genesis.shelley_known_time).unwrap(), 0)
+            .unwrap();
+        let byron_slot_length = i64::from(genesis.byron_slot_length);
+
+        // A time just before Shelley era starts
+        let time = shelley_start_time - chrono::Duration::seconds(1);
+        let elapsed_slots = (time
+            - Utc
+                .timestamp_opt(i64::try_from(genesis.byron_known_time).unwrap(), 0)
+                .unwrap())
+        .num_seconds()
+            / byron_slot_length;
+        let expected_slot = genesis.byron_known_slot + u64::try_from(elapsed_slots).unwrap();
+
+        // Expect the slot to be in the Byron era
+        assert_eq!(network.time_to_slot(time), Some(expected_slot));
+    }
+
+    #[test]
+    fn test_time_to_slot_shelley_era() {
+        let network = Network::Mainnet;
+        let genesis = network.genesis_values();
+
+        let shelley_start_time = Utc
+            .timestamp_opt(i64::try_from(genesis.shelley_known_time).unwrap(), 0)
+            .unwrap();
+        let shelley_slot_length = i64::from(genesis.shelley_slot_length);
+
+        // A time in the middle of the Shelley era
+        let time = shelley_start_time + chrono::Duration::seconds(shelley_slot_length * 200);
+        let expected_slot = genesis.shelley_known_slot + 200;
+
+        // Expect the correct slot for the given time
+        assert_eq!(network.time_to_slot(time), Some(expected_slot));
+    }
 }