test: add missing scanner tests

Author: 0xNeshi

src/event_scanner/scanner/historic.rs

@@ -146,7 +146,7 @@ mod tests {
     }
 
     #[test]
-    fn test_historic_scanner_builder_default_values() {
+    fn test_historic_scanner_builder_with_default_values() {
         let builder = EventScannerBuilder::historic();
 
         assert_eq!(builder.config.from_block, BlockNumberOrTag::Earliest.into());

src/event_scanner/scanner/latest.rs

@@ -125,6 +125,11 @@ impl<N: Network> EventScanner<LatestEvents, N> {
 
 #[cfg(test)]
 mod tests {
+    use crate::{
+        block_range_scanner::DEFAULT_BLOCK_CONFIRMATIONS,
+        event_scanner::scanner::DEFAULT_MAX_CONCURRENT_FETCHES,
+    };
+
     use super::*;
     use alloy::{
         eips::BlockNumberOrTag,
@@ -141,26 +146,26 @@ mod tests {
             .max_block_range(25)
             .block_confirmations(5)
             .from_block(BlockNumberOrTag::Number(50))
-            .to_block(BlockNumberOrTag::Number(150));
+            .to_block(BlockNumberOrTag::Number(150))
+            .max_concurrent_fetches(10);
 
         assert_eq!(builder.block_range_scanner.max_block_range, 25);
         assert_eq!(builder.config.block_confirmations, 5);
+        assert_eq!(builder.config.max_concurrent_fetches, 10);
         assert_eq!(builder.config.count, 3);
         assert_eq!(builder.config.from_block, BlockNumberOrTag::Number(50).into());
         assert_eq!(builder.config.to_block, BlockNumberOrTag::Number(150).into());
     }
 
     #[test]
-    fn test_latest_scanner_builder_with_different_block_types() {
-        let builder = EventScannerBuilder::latest(10)
-            .from_block(BlockNumberOrTag::Earliest)
-            .to_block(BlockNumberOrTag::Latest)
-            .block_confirmations(20);
-
-        assert_eq!(builder.config.from_block, BlockNumberOrTag::Earliest.into());
-        assert_eq!(builder.config.to_block, BlockNumberOrTag::Latest.into());
+    fn test_latest_scanner_builder_with_default_values() {
+        let builder = EventScannerBuilder::latest(10);
+
+        assert_eq!(builder.config.from_block, BlockNumberOrTag::Latest.into());
+        assert_eq!(builder.config.to_block, BlockNumberOrTag::Earliest.into());
         assert_eq!(builder.config.count, 10);
-        assert_eq!(builder.config.block_confirmations, 20);
+        assert_eq!(builder.config.max_concurrent_fetches, DEFAULT_MAX_CONCURRENT_FETCHES);
+        assert_eq!(builder.config.block_confirmations, DEFAULT_BLOCK_CONFIRMATIONS);
     }
 
     #[test]
@@ -173,12 +178,15 @@ mod tests {
             .block_confirmations(5)
             .block_confirmations(7)
             .max_block_range(50)
-            .max_block_range(60);
+            .max_block_range(60)
+            .max_concurrent_fetches(10)
+            .max_concurrent_fetches(20);
 
         assert_eq!(builder.config.count, 3);
         assert_eq!(builder.config.from_block, BlockNumberOrTag::Number(20).into());
         assert_eq!(builder.config.to_block, BlockNumberOrTag::Number(200).into());
         assert_eq!(builder.config.block_confirmations, 7);
+        assert_eq!(builder.config.max_concurrent_fetches, 20);
         assert_eq!(builder.block_range_scanner.max_block_range, 60);
     }
 
@@ -204,6 +212,15 @@ mod tests {
         }
     }
 
+    #[tokio::test]
+    async fn returns_error_with_zero_max_concurrent_fetches() {
+        let provider = RootProvider::<Ethereum>::new(RpcClient::mocked(Asserter::new()));
+        let result =
+            EventScannerBuilder::latest(10).max_concurrent_fetches(0).connect(provider).await;
+
+        assert!(matches!(result, Err(ScannerError::InvalidMaxConcurrentFetches)));
+    }
+
     #[tokio::test]
     async fn test_latest_scanner_with_valid_block_hash() {
         let anvil = Anvil::new().try_spawn().unwrap();
@@ -283,6 +300,17 @@ mod tests {
         }
     }
 
+    #[tokio::test]
+    async fn accepts_zero_confirmations() -> anyhow::Result<()> {
+        let provider = RootProvider::<Ethereum>::new(RpcClient::mocked(Asserter::new()));
+        let scanner =
+            EventScannerBuilder::latest(1).block_confirmations(0).connect(provider).await?;
+
+        assert_eq!(scanner.config.block_confirmations, 0);
+
+        Ok(())
+    }
+
     #[tokio::test]
     async fn test_latest_scanner_with_mixed_block_types() {
         let anvil = Anvil::new().try_spawn().unwrap();

src/event_scanner/scanner/live.rs

@@ -84,22 +84,31 @@ mod tests {
         rpc::client::RpcClient,
     };
 
+    use crate::{
+        block_range_scanner::DEFAULT_BLOCK_CONFIRMATIONS,
+        event_scanner::scanner::DEFAULT_MAX_CONCURRENT_FETCHES,
+    };
+
     use super::*;
 
     #[test]
     fn test_live_scanner_builder_pattern() {
-        let builder = EventScannerBuilder::live().max_block_range(25).block_confirmations(5);
+        let builder = EventScannerBuilder::live()
+            .max_block_range(25)
+            .block_confirmations(5)
+            .max_concurrent_fetches(10);
 
         assert_eq!(builder.block_range_scanner.max_block_range, 25);
         assert_eq!(builder.config.block_confirmations, 5);
+        assert_eq!(builder.config.max_concurrent_fetches, 10);
     }
 
     #[test]
-    fn test_live_scanner_builder_with_zero_confirmations() {
-        let builder = EventScannerBuilder::live().block_confirmations(0).max_block_range(100);
+    fn test_historic_scanner_builder_default_values() {
+        let builder = EventScannerBuilder::live();
 
-        assert_eq!(builder.config.block_confirmations, 0);
-        assert_eq!(builder.block_range_scanner.max_block_range, 100);
+        assert_eq!(builder.config.block_confirmations, DEFAULT_BLOCK_CONFIRMATIONS);
+        assert_eq!(builder.config.max_concurrent_fetches, DEFAULT_MAX_CONCURRENT_FETCHES);
     }
 
     #[test]
@@ -110,10 +119,23 @@ mod tests {
             .max_block_range(105)
             .block_confirmations(2)
             .block_confirmations(4)
-            .block_confirmations(8);
+            .block_confirmations(8)
+            .max_concurrent_fetches(10)
+            .max_concurrent_fetches(20);
 
         assert_eq!(builder.block_range_scanner.max_block_range, 105);
         assert_eq!(builder.config.block_confirmations, 8);
+        assert_eq!(builder.config.max_concurrent_fetches, 20);
+    }
+
+    #[tokio::test]
+    async fn test_live_scanner_accepts_zero_confirmations() -> anyhow::Result<()> {
+        let provider = RootProvider::<Ethereum>::new(RpcClient::mocked(Asserter::new()));
+        let scanner = EventScannerBuilder::live().block_confirmations(0).connect(provider).await?;
+
+        assert_eq!(scanner.config.block_confirmations, 0);
+
+        Ok(())
     }
 
     #[tokio::test]
@@ -126,4 +148,12 @@ mod tests {
             _ => panic!("Expected InvalidMaxBlockRange error"),
         }
     }
+
+    #[tokio::test]
+    async fn returns_error_with_zero_max_concurrent_fetches() {
+        let provider = RootProvider::<Ethereum>::new(RpcClient::mocked(Asserter::new()));
+        let result = EventScannerBuilder::live().max_concurrent_fetches(0).connect(provider).await;
+
+        assert!(matches!(result, Err(ScannerError::InvalidMaxConcurrentFetches)));
+    }
 }

src/event_scanner/scanner/sync/from_block.rs

@@ -98,38 +98,49 @@ mod tests {
     };
     use alloy_node_bindings::Anvil;
 
+    use crate::{
+        block_range_scanner::{DEFAULT_BLOCK_CONFIRMATIONS, DEFAULT_MAX_BLOCK_RANGE},
+        event_scanner::scanner::DEFAULT_MAX_CONCURRENT_FETCHES,
+    };
+
     use super::*;
 
     #[test]
     fn sync_scanner_builder_pattern() {
-        let builder =
-            EventScannerBuilder::sync().from_block(50).max_block_range(25).block_confirmations(5);
+        let builder = EventScannerBuilder::sync()
+            .from_block(50)
+            .max_block_range(25)
+            .block_confirmations(5)
+            .max_concurrent_fetches(10);
 
         assert_eq!(builder.block_range_scanner.max_block_range, 25);
         assert_eq!(builder.config.block_confirmations, 5);
+        assert_eq!(builder.config.max_concurrent_fetches, 10);
         assert_eq!(builder.config.from_block, BlockNumberOrTag::Number(50).into());
     }
 
     #[test]
-    fn sync_scanner_builder_with_different_block_types() {
-        let builder = EventScannerBuilder::sync()
-            .from_block(BlockNumberOrTag::Earliest)
-            .block_confirmations(20)
-            .max_block_range(100);
+    fn sync_scanner_builder_default_values() {
+        let builder = EventScannerBuilder::sync().from_block(BlockNumberOrTag::Earliest);
 
         assert_eq!(builder.config.from_block, BlockNumberOrTag::Earliest.into());
-        assert_eq!(builder.config.block_confirmations, 20);
-        assert_eq!(builder.block_range_scanner.max_block_range, 100);
+        assert_eq!(builder.config.block_confirmations, DEFAULT_BLOCK_CONFIRMATIONS);
+        assert_eq!(builder.config.max_concurrent_fetches, DEFAULT_MAX_CONCURRENT_FETCHES);
+        assert_eq!(builder.block_range_scanner.max_block_range, DEFAULT_MAX_BLOCK_RANGE);
     }
 
-    #[test]
-    fn sync_scanner_builder_with_zero_confirmations() {
-        let builder =
-            EventScannerBuilder::sync().from_block(0).block_confirmations(0).max_block_range(75);
+    #[tokio::test]
+    async fn accepts_zero_confirmations() -> anyhow::Result<()> {
+        let provider = RootProvider::<Ethereum>::new(RpcClient::mocked(Asserter::new()));
+        let scanner = EventScannerBuilder::sync()
+            .from_block(BlockNumberOrTag::Earliest)
+            .block_confirmations(0)
+            .connect(provider)
+            .await?;
+
+        assert_eq!(scanner.config.block_confirmations, 0);
 
-        assert_eq!(builder.config.from_block, BlockNumberOrTag::Number(0).into());
-        assert_eq!(builder.config.block_confirmations, 0);
-        assert_eq!(builder.block_range_scanner.max_block_range, 75);
+        Ok(())
     }
 
     #[test]
@@ -140,11 +151,26 @@ mod tests {
             .max_block_range(55)
             .max_block_range(105)
             .block_confirmations(5)
-            .block_confirmations(7);
+            .block_confirmations(7)
+            .max_concurrent_fetches(10)
+            .max_concurrent_fetches(20);
 
         assert_eq!(builder.block_range_scanner.max_block_range, 105);
         assert_eq!(builder.config.from_block, BlockNumberOrTag::Number(2).into());
         assert_eq!(builder.config.block_confirmations, 7);
+        assert_eq!(builder.config.max_concurrent_fetches, 20);
+    }
+
+    #[tokio::test]
+    async fn returns_error_with_zero_max_concurrent_fetches() {
+        let provider = RootProvider::<Ethereum>::new(RpcClient::mocked(Asserter::new()));
+        let result = EventScannerBuilder::sync()
+            .from_block(0)
+            .max_concurrent_fetches(0)
+            .connect(provider)
+            .await;
+
+        assert!(matches!(result, Err(ScannerError::InvalidMaxConcurrentFetches)));
     }
 
     #[tokio::test]

src/event_scanner/scanner/sync/from_latest.rs

@@ -134,8 +134,81 @@ mod tests {
         rpc::client::RpcClient,
     };
 
+    use crate::{
+        block_range_scanner::{DEFAULT_BLOCK_CONFIRMATIONS, DEFAULT_MAX_BLOCK_RANGE},
+        event_scanner::scanner::DEFAULT_MAX_CONCURRENT_FETCHES,
+    };
+
     use super::*;
 
+    #[test]
+    fn builder_pattern() {
+        let builder = EventScannerBuilder::sync()
+            .from_latest(1)
+            .block_confirmations(2)
+            .max_block_range(50)
+            .max_concurrent_fetches(10);
+
+        assert_eq!(builder.config.count, 1);
+        assert_eq!(builder.config.block_confirmations, 2);
+        assert_eq!(builder.block_range_scanner.max_block_range, 50);
+        assert_eq!(builder.config.max_concurrent_fetches, 10);
+    }
+
+    #[test]
+    fn builder_with_default_values() {
+        let builder = EventScannerBuilder::sync().from_latest(1);
+
+        assert_eq!(builder.config.count, 1);
+        assert_eq!(builder.config.block_confirmations, DEFAULT_BLOCK_CONFIRMATIONS);
+        assert_eq!(builder.block_range_scanner.max_block_range, DEFAULT_MAX_BLOCK_RANGE);
+        assert_eq!(builder.config.max_concurrent_fetches, DEFAULT_MAX_CONCURRENT_FETCHES);
+    }
+
+    #[test]
+    fn builder_last_call_wins() {
+        let builder = EventScannerBuilder::sync()
+            .from_latest(1)
+            .max_block_range(25)
+            .max_block_range(55)
+            .max_block_range(105)
+            .block_confirmations(2)
+            .block_confirmations(3)
+            .max_concurrent_fetches(10)
+            .max_concurrent_fetches(20);
+
+        assert_eq!(builder.config.count, 1);
+        assert_eq!(builder.block_range_scanner.max_block_range, 105);
+        assert_eq!(builder.config.block_confirmations, 3);
+        assert_eq!(builder.config.max_concurrent_fetches, 20);
+    }
+
+    #[tokio::test]
+    async fn accepts_zero_confirmations() -> anyhow::Result<()> {
+        let provider = RootProvider::<Ethereum>::new(RpcClient::mocked(Asserter::new()));
+        let scanner = EventScannerBuilder::sync()
+            .from_latest(1)
+            .block_confirmations(0)
+            .connect(provider)
+            .await?;
+
+        assert_eq!(scanner.config.block_confirmations, 0);
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn returns_error_with_zero_max_concurrent_fetches() {
+        let provider = RootProvider::<Ethereum>::new(RpcClient::mocked(Asserter::new()));
+        let result = EventScannerBuilder::sync()
+            .from_latest(1)
+            .max_concurrent_fetches(0)
+            .connect(provider)
+            .await;
+
+        assert!(matches!(result, Err(ScannerError::InvalidMaxConcurrentFetches)));
+    }
+
     #[tokio::test]
     async fn test_sync_from_latest_returns_error_with_zero_count() {
         let provider = RootProvider::<Ethereum>::new(RpcClient::mocked(Asserter::new()));