add test to each scanner

Author: LeoPatOZ

src/event_lib/modes/historic.rs

@@ -117,3 +117,48 @@ impl<N: Network> HistoricEventScanner<N> {
         self.inner.stream_historical(self.config.from_block, self.config.to_block).await
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_historic_scanner_config_defaults() {
+        let config = HistoricScannerConfig::new();
+
+        assert!(matches!(config.from_block, BlockNumberOrTag::Earliest));
+        assert!(matches!(config.to_block, BlockNumberOrTag::Latest));
+    }
+
+    #[test]
+    fn test_historic_scanner_builder_pattern() {
+        let config = HistoricScannerConfig::new().from_block(100u64).to_block(200u64).max_reads(50);
+
+        assert!(matches!(config.from_block, BlockNumberOrTag::Number(100)));
+        assert!(matches!(config.to_block, BlockNumberOrTag::Number(200)));
+        assert_eq!(config.base.block_range_scanner.max_read_per_epoch, 50);
+    }
+
+    #[test]
+    fn test_historic_scanner_builder_pattern_chaining() {
+        let config = HistoricScannerConfig::new()
+            .max_reads(25)
+            .from_block(BlockNumberOrTag::Number(50))
+            .to_block(BlockNumberOrTag::Number(150));
+
+        assert_eq!(config.base.block_range_scanner.max_read_per_epoch, 25);
+        assert!(matches!(config.from_block, BlockNumberOrTag::Number(50)));
+        assert!(matches!(config.to_block, BlockNumberOrTag::Number(150)));
+    }
+
+    #[test]
+    fn test_historic_scanner_builder_with_different_block_types() {
+        let config = HistoricScannerConfig::new()
+            .from_block(BlockNumberOrTag::Earliest)
+            .to_block(BlockNumberOrTag::Latest);
+
+        assert!(matches!(config.from_block, BlockNumberOrTag::Earliest));
+        assert!(matches!(config.to_block, BlockNumberOrTag::Latest));
+    }
+}
+

src/event_lib/modes/latest.rs

@@ -191,3 +191,80 @@ impl<N: Network> LatestEventScanner<N> {
         unimplemented!()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_latest_scanner_config_defaults() {
+        let config = LatestScannerConfig::new();
+
+        assert_eq!(config.count, 1);
+        assert!(matches!(config.from_block, BlockNumberOrTag::Earliest));
+        assert!(matches!(config.to_block, BlockNumberOrTag::Latest));
+        assert_eq!(config.block_confirmations, DEFAULT_BLOCK_CONFIRMATIONS);
+        assert!(!config.switch_to_live);
+    }
+
+    #[test]
+    fn test_latest_scanner_builder_pattern() {
+        let config = LatestScannerConfig::new()
+            .count(5)
+            .from_block(100)
+            .to_block(200)
+            .block_confirmations(10)
+            .then_live()
+            .max_reads(50);
+
+        assert_eq!(config.count, 5);
+        assert!(matches!(config.from_block, BlockNumberOrTag::Number(100)));
+        assert!(matches!(config.to_block, BlockNumberOrTag::Number(200)));
+        assert_eq!(config.block_confirmations, 10);
+        assert!(config.switch_to_live);
+        assert_eq!(config.base.block_range_scanner.max_read_per_epoch, 50);
+    }
+
+    #[test]
+    fn test_latest_scanner_builder_pattern_chaining() {
+        let config = LatestScannerConfig::new()
+            .max_reads(25)
+            .block_confirmations(5)
+            .count(3)
+            .from_block(BlockNumberOrTag::Number(50))
+            .to_block(BlockNumberOrTag::Number(150))
+            .then_live();
+
+        assert_eq!(config.base.block_range_scanner.max_read_per_epoch, 25);
+        assert_eq!(config.block_confirmations, 5);
+        assert_eq!(config.count, 3);
+        assert!(matches!(config.from_block, BlockNumberOrTag::Number(50)));
+        assert!(matches!(config.to_block, BlockNumberOrTag::Number(150)));
+        assert!(config.switch_to_live);
+    }
+
+    #[test]
+    fn test_latest_scanner_builder_with_different_block_types() {
+        let config = LatestScannerConfig::new()
+            .from_block(BlockNumberOrTag::Earliest)
+            .to_block(BlockNumberOrTag::Latest)
+            .count(10)
+            .block_confirmations(20);
+
+        assert!(matches!(config.from_block, BlockNumberOrTag::Earliest));
+        assert!(matches!(config.to_block, BlockNumberOrTag::Latest));
+        assert_eq!(config.count, 10);
+        assert_eq!(config.block_confirmations, 20);
+        assert!(!config.switch_to_live);
+    }
+
+    #[test]
+    fn test_latest_scanner_then_live_method() {
+        let config = LatestScannerConfig::new().then_live();
+        assert!(config.switch_to_live);
+
+        let config_without_live = LatestScannerConfig::new();
+        assert!(!config_without_live.switch_to_live);
+    }
+}
+

src/event_lib/modes/live.rs

@@ -18,6 +18,7 @@ use super::{BaseConfig, BaseConfigBuilder};
 
 pub struct LiveScannerConfig {
     base: BaseConfig,
+    // Defaults to 0
     block_confirmations: u64,
 }
 
@@ -103,3 +104,40 @@ impl<N: Network> LiveEventScanner<N> {
         self.inner.stream_live(self.config.block_confirmations).await
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_live_scanner_config_defaults() {
+        let config = LiveScannerConfig::new();
+
+        assert_eq!(config.block_confirmations, DEFAULT_BLOCK_CONFIRMATIONS);
+    }
+
+    #[test]
+    fn test_live_scanner_builder_pattern() {
+        let config = LiveScannerConfig::new().block_confirmations(10).max_reads(50);
+
+        assert_eq!(config.block_confirmations, 10);
+        assert_eq!(config.base.block_range_scanner.max_read_per_epoch, 50);
+    }
+
+    #[test]
+    fn test_live_scanner_builder_pattern_chaining() {
+        let config = LiveScannerConfig::new().max_reads(25).block_confirmations(5);
+
+        assert_eq!(config.base.block_range_scanner.max_read_per_epoch, 25);
+        assert_eq!(config.block_confirmations, 5);
+    }
+
+    #[test]
+    fn test_live_scanner_builder_with_zero_confirmations() {
+        let config = LiveScannerConfig::new().block_confirmations(0).max_reads(100);
+
+        assert_eq!(config.block_confirmations, 0);
+        assert_eq!(config.base.block_range_scanner.max_read_per_epoch, 100);
+    }
+}
+

src/event_lib/modes/sync.rs

@@ -117,3 +117,59 @@ impl<N: Network> SyncEventScanner<N> {
         self.inner.stream_from(self.config.from_block, self.config.block_confirmations).await
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sync_scanner_config_defaults() {
+        let config = SyncScannerConfig::new();
+
+        assert!(matches!(config.from_block, BlockNumberOrTag::Earliest));
+        assert_eq!(config.block_confirmations, DEFAULT_BLOCK_CONFIRMATIONS);
+    }
+
+    #[test]
+    fn test_sync_scanner_builder_pattern() {
+        let config = SyncScannerConfig::new().from_block(100).block_confirmations(10).max_reads(50);
+
+        assert!(matches!(config.from_block, BlockNumberOrTag::Number(100)));
+        assert_eq!(config.block_confirmations, 10);
+        assert_eq!(config.base.block_range_scanner.max_read_per_epoch, 50);
+    }
+
+    #[test]
+    fn test_sync_scanner_builder_pattern_chaining() {
+        let config = SyncScannerConfig::new()
+            .max_reads(25)
+            .block_confirmations(5)
+            .from_block(BlockNumberOrTag::Number(50));
+
+        assert_eq!(config.base.block_range_scanner.max_read_per_epoch, 25);
+        assert_eq!(config.block_confirmations, 5);
+        assert!(matches!(config.from_block, BlockNumberOrTag::Number(50)));
+    }
+
+    #[test]
+    fn test_sync_scanner_builder_with_different_block_types() {
+        let config = SyncScannerConfig::new()
+            .from_block(BlockNumberOrTag::Earliest)
+            .block_confirmations(20)
+            .max_reads(100);
+
+        assert!(matches!(config.from_block, BlockNumberOrTag::Earliest));
+        assert_eq!(config.block_confirmations, 20);
+        assert_eq!(config.base.block_range_scanner.max_read_per_epoch, 100);
+    }
+
+    #[test]
+    fn test_sync_scanner_builder_with_zero_confirmations() {
+        let config = SyncScannerConfig::new().from_block(0).block_confirmations(0).max_reads(75);
+
+        assert!(matches!(config.from_block, BlockNumberOrTag::Number(0)));
+        assert_eq!(config.block_confirmations, 0);
+        assert_eq!(config.base.block_range_scanner.max_read_per_epoch, 75);
+    }
+}
+