ref: add invalid block range error + test

Author: LeoPatOZ

src/error.rs

@@ -27,6 +27,9 @@ pub enum ScannerError {
 
     #[error("Event count must be greater than 0")]
     InvalidEventCount,
+
+    #[error("Max block range must be greater than 0")]
+    InvalidMaxBlockRange,
 }
 
 impl From<RobustProviderError> for ScannerError {

src/event_scanner/scanner/historic.rs

@@ -28,8 +28,9 @@ impl EventScannerBuilder<Historic> {
     /// # Errors
     ///
     /// Returns an error if:
-    /// - The provider connection fails
-    /// - The specified block range exceeds the latest block on the chain
+    /// * The provider connection fails
+    /// * The specified block range exceeds the latest block on the chain
+    /// * The max block range is zero
     pub async fn connect<N: Network>(
         self,
         provider: impl IntoRobustProvider<N>,
@@ -93,7 +94,11 @@ impl<N: Network> EventScanner<Historic, N> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use alloy::providers::{Provider, ProviderBuilder};
+    use alloy::{
+        network::Ethereum,
+        providers::{Provider, ProviderBuilder, RootProvider, mock::Asserter},
+        rpc::client::RpcClient,
+    };
     use alloy_node_bindings::Anvil;
 
     #[test]
@@ -197,4 +202,15 @@ mod tests {
             _ => panic!("Expected BlockExceedsLatest error"),
         }
     }
+
+    #[tokio::test]
+    async fn test_historic_returns_error_with_zero_max_block_range() {
+        let provider = RootProvider::<Ethereum>::new(RpcClient::mocked(Asserter::new()));
+        let result = EventScannerBuilder::historic().max_block_range(0).connect(provider).await;
+
+        match result {
+            Err(ScannerError::InvalidMaxBlockRange) => {}
+            _ => panic!("Expected InvalidMaxBlockRange error"),
+        }
+    }
 }

src/event_scanner/scanner/latest.rs

@@ -33,6 +33,7 @@ impl EventScannerBuilder<LatestEvents> {
     /// Returns an error if:
     /// * The provider connection fails
     /// * The event count is zero
+    /// * The max block range is zero
     pub async fn connect<N: Network>(
         self,
         provider: impl IntoRobustProvider<N>,
@@ -146,4 +147,15 @@ mod tests {
             _ => panic!("Expected InvalidEventCount error"),
         }
     }
+
+    #[tokio::test]
+    async fn test_latest_returns_error_with_zero_max_block_range() {
+        let provider = RootProvider::<Ethereum>::new(RpcClient::mocked(Asserter::new()));
+        let result = EventScannerBuilder::latest(10).max_block_range(0).connect(provider).await;
+
+        match result {
+            Err(ScannerError::InvalidMaxBlockRange) => {}
+            _ => panic!("Expected InvalidMaxBlockRange error"),
+        }
+    }
 }

src/event_scanner/scanner/live.rs

@@ -18,7 +18,9 @@ impl EventScannerBuilder<Live> {
     ///
     /// # Errors
     ///
-    /// Returns an error if the provider connection fails.
+    /// Returns an error if:
+    /// * The provider connection fails
+    /// * The max block range is zero
     pub async fn connect<N: Network>(
         self,
         provider: impl IntoRobustProvider<N>,
@@ -58,6 +60,12 @@ impl<N: Network> EventScanner<Live, N> {
 
 #[cfg(test)]
 mod tests {
+    use alloy::{
+        network::Ethereum,
+        providers::{RootProvider, mock::Asserter},
+        rpc::client::RpcClient,
+    };
+
     use super::*;
 
     #[test]
@@ -89,4 +97,15 @@ mod tests {
         assert_eq!(builder.block_range_scanner.max_block_range, 105);
         assert_eq!(builder.config.block_confirmations, 8);
     }
+
+    #[tokio::test]
+    async fn test_live_returns_error_with_zero_max_block_range() {
+        let provider = RootProvider::<Ethereum>::new(RpcClient::mocked(Asserter::new()));
+        let result = EventScannerBuilder::live().max_block_range(0).connect(provider).await;
+
+        match result {
+            Err(ScannerError::InvalidMaxBlockRange) => {}
+            _ => panic!("Expected InvalidMaxBlockRange error"),
+        }
+    }
 }

src/event_scanner/scanner/mod.rs

@@ -373,11 +373,7 @@ impl<M> EventScannerBuilder<M> {
     ///
     /// # Arguments
     ///
-    /// * `max_block_range` - Maximum number of blocks to process per batch.
-    ///
-    /// # Panics
-    ///
-    /// If `max_block_range` is zero
+    /// * `max_block_range` - Maximum number of blocks to process per batch (must be greater than 0)
     ///
     /// # Example
     ///
@@ -388,7 +384,6 @@ impl<M> EventScannerBuilder<M> {
     /// - Batch 4: blocks 1090–1099 (10 blocks)
     #[must_use]
     pub fn max_block_range(mut self, max_block_range: u64) -> Self {
-        assert!(max_block_range != 0, "max block range should be greater than zero");
         self.block_range_scanner.max_block_range = max_block_range;
         self
     }
@@ -400,6 +395,9 @@ impl<M> EventScannerBuilder<M> {
         self,
         provider: impl IntoRobustProvider<N>,
     ) -> Result<EventScanner<M, N>, ScannerError> {
+        if self.block_range_scanner.max_block_range == 0 {
+            return Err(ScannerError::InvalidMaxBlockRange);
+        }
         let block_range_scanner = self.block_range_scanner.connect::<N>(provider).await?;
         Ok(EventScanner { config: self.config, block_range_scanner, listeners: Vec::new() })
     }
@@ -488,21 +486,17 @@ mod tests {
 
     #[tokio::test]
     async fn test_latest_returns_error_with_zero_count() {
-        use alloy::providers::{RootProvider, mock::Asserter};
-        use alloy::rpc::client::RpcClient;
-        
+        use alloy::{
+            providers::{RootProvider, mock::Asserter},
+            rpc::client::RpcClient,
+        };
+
         let provider = RootProvider::<Ethereum>::new(RpcClient::mocked(Asserter::new()));
         let result = EventScannerBuilder::latest(0).connect(provider).await;
-        
+
         match result {
             Err(ScannerError::InvalidEventCount) => {}
             _ => panic!("Expected InvalidEventCount error"),
         }
     }
-
-    #[test]
-    #[should_panic(expected = "max block range should be greater than zero")]
-    fn test_max_block_range_panics_with_zero() {
-        let _ = EventScannerBuilder::historic().max_block_range(0);
-    }
 }

src/event_scanner/scanner/sync/from_block.rs

@@ -20,7 +20,9 @@ impl EventScannerBuilder<SyncFromBlock> {
     ///
     /// # Errors
     ///
-    /// Returns an error if the provider connection fails.
+    /// Returns an error if:
+    /// * The provider connection fails
+    /// * The max block range is zero
     pub async fn connect<N: Network>(
         self,
         provider: impl IntoRobustProvider<N>,
@@ -61,7 +63,12 @@ impl<N: Network> EventScanner<SyncFromBlock, N> {
 
 #[cfg(test)]
 mod tests {
-    use alloy::eips::BlockNumberOrTag;
+    use alloy::{
+        eips::BlockNumberOrTag,
+        network::Ethereum,
+        providers::{RootProvider, mock::Asserter},
+        rpc::client::RpcClient,
+    };
 
     use super::*;
 
@@ -111,4 +118,16 @@ mod tests {
         assert!(matches!(builder.config.from_block, BlockNumberOrTag::Number(2)));
         assert_eq!(builder.config.block_confirmations, 7);
     }
+
+    #[tokio::test]
+    async fn test_sync_from_block_returns_error_with_zero_max_block_range() {
+        let provider = RootProvider::<Ethereum>::new(RpcClient::mocked(Asserter::new()));
+        let result =
+            EventScannerBuilder::sync().from_block(100).max_block_range(0).connect(provider).await;
+
+        match result {
+            Err(ScannerError::InvalidMaxBlockRange) => {}
+            _ => panic!("Expected InvalidMaxBlockRange error"),
+        }
+    }
 }

src/event_scanner/scanner/sync/from_latest.rs

@@ -33,8 +33,9 @@ impl EventScannerBuilder<SyncFromLatestEvents> {
     /// # Errors
     ///
     /// Returns an error if:
-    /// - The provider connection fails
-    /// - The event count is zero
+    /// * The provider connection fails
+    /// * The event count is zero
+    /// * The max block range is zero
     pub async fn connect<N: Network>(
         self,
         provider: impl IntoRobustProvider<N>,
@@ -124,18 +125,34 @@ impl<N: Network> EventScanner<SyncFromLatestEvents, N> {
 
 #[cfg(test)]
 mod tests {
-    use alloy::{network::Ethereum, providers::{RootProvider, mock::Asserter}, rpc::client::RpcClient};
+    use alloy::{
+        network::Ethereum,
+        providers::{RootProvider, mock::Asserter},
+        rpc::client::RpcClient,
+    };
 
     use super::*;
 
     #[tokio::test]
     async fn test_sync_from_latest_returns_error_with_zero_count() {
         let provider = RootProvider::<Ethereum>::new(RpcClient::mocked(Asserter::new()));
         let result = EventScannerBuilder::sync().from_latest(0).connect(provider).await;
-        
+
         match result {
             Err(ScannerError::InvalidEventCount) => {}
             _ => panic!("Expected InvalidEventCount error"),
         }
     }
+
+    #[tokio::test]
+    async fn test_sync_from_latest_returns_error_with_zero_max_block_range() {
+        let provider = RootProvider::<Ethereum>::new(RpcClient::mocked(Asserter::new()));
+        let result =
+            EventScannerBuilder::sync().from_latest(10).max_block_range(0).connect(provider).await;
+
+        match result {
+            Err(ScannerError::InvalidMaxBlockRange) => {}
+            _ => panic!("Expected InvalidMaxBlockRange error"),
+        }
+    }
 }