ref: make count assertion return err + test

Author: LeoPatOZ

src/error.rs

@@ -24,6 +24,9 @@ pub enum ScannerError {
 
     #[error("Block number {0} exceeds latest block {1}")]
     BlockExceedsLatest(u64, u64),
+
+    #[error("Event count must be greater than 0")]
+    InvalidEventCount,
 }
 
 impl From<RobustProviderError> for ScannerError {

src/event_scanner/scanner/latest.rs

@@ -30,11 +30,16 @@ impl EventScannerBuilder<LatestEvents> {
     ///
     /// # Errors
     ///
-    /// Returns an error if the provider connection fails.
+    /// Returns an error if:
+    /// * The provider connection fails
+    /// * The event count is zero
     pub async fn connect<N: Network>(
         self,
         provider: impl IntoRobustProvider<N>,
     ) -> Result<EventScanner<LatestEvents, N>, ScannerError> {
+        if self.config.count == 0 {
+            return Err(ScannerError::InvalidEventCount);
+        }
         self.build(provider).await
     }
 }
@@ -76,6 +81,12 @@ impl<N: Network> EventScanner<LatestEvents, N> {
 
 #[cfg(test)]
 mod tests {
+    use alloy::{
+        network::Ethereum,
+        providers::{RootProvider, mock::Asserter},
+        rpc::client::RpcClient,
+    };
+
     use super::*;
 
     #[test]
@@ -124,4 +135,15 @@ mod tests {
         assert_eq!(builder.config.block_confirmations, 7);
         assert_eq!(builder.block_range_scanner.max_block_range, 60);
     }
+
+    #[tokio::test]
+    async fn test_latest_returns_error_with_zero_count() {
+        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"),
+        }
+    }
 }

src/event_scanner/scanner/mod.rs

@@ -228,10 +228,6 @@ impl EventScannerBuilder<Unspecified> {
 
     /// Streams the latest `count` matching events per registered listener.
     ///
-    /// # Panics
-    ///
-    /// If `count` is zero
-    ///
     /// # Example
     ///
     /// ```no_run
@@ -302,7 +298,7 @@ impl EventScannerBuilder<Unspecified> {
     ///
     /// # Arguments
     ///
-    /// * `count` - Maximum number of recent events to collect per listener
+    /// * `count` - Maximum number of recent events to collect per listener (must be greater than 0)
     ///
     /// # Reorg behavior
     ///
@@ -326,7 +322,6 @@ impl EventScannerBuilder<Unspecified> {
     /// [reorg]: crate::ScannerStatus::ReorgDetected
     #[must_use]
     pub fn latest(count: usize) -> EventScannerBuilder<LatestEvents> {
-        assert!(count != 0, "count must be greater than 0");
         EventScannerBuilder::<LatestEvents>::new(count)
     }
 }
@@ -491,10 +486,18 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    #[should_panic(expected = "count must be greater than 0")]
-    fn test_latest_panics_with_zero_count() {
-        let _ = EventScannerBuilder::latest(0);
+    #[tokio::test]
+    async fn test_latest_returns_error_with_zero_count() {
+        use alloy::providers::{RootProvider, mock::Asserter};
+        use alloy::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]

src/event_scanner/scanner/sync/from_latest.rs

@@ -32,11 +32,16 @@ impl EventScannerBuilder<SyncFromLatestEvents> {
     ///
     /// # Errors
     ///
-    /// Returns an error if the provider connection fails.
+    /// Returns an error if:
+    /// - The provider connection fails
+    /// - The event count is zero
     pub async fn connect<N: Network>(
         self,
         provider: impl IntoRobustProvider<N>,
     ) -> Result<EventScanner<SyncFromLatestEvents, N>, ScannerError> {
+        if self.config.count == 0 {
+            return Err(ScannerError::InvalidEventCount);
+        }
         self.build(provider).await
     }
 }
@@ -116,3 +121,21 @@ impl<N: Network> EventScanner<SyncFromLatestEvents, N> {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    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"),
+        }
+    }
+}

src/event_scanner/scanner/sync/mod.rs

@@ -82,7 +82,7 @@ impl EventScannerBuilder<Synchronize> {
     /// # Arguments
     ///
     /// * `count` - Maximum number of recent events to collect per listener before switching to live
-    ///   streaming
+    ///   streaming (must be greater than 0)
     ///
     /// # Important notes
     ///