test: add unit tests for rpc config and fix missing IndexStats (#19)

Amp-Thread-ID: https://ampcode.com/threads/T-019c1732-abef-7495-a2ca-b51abb5ab3ec

Co-authored-by: Amp <amp@ampcode.com>

Author: refcell

crates/node/rpc/src/config.rs

@@ -145,3 +145,166 @@ impl RateLimitConfig {
         Self { requests_per_second: u64::MAX, burst_size: u64::MAX }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rpc_server_config_default() {
+        let config = RpcServerConfig::default();
+        assert_eq!(config.http_addr, "127.0.0.1:8545".parse().unwrap());
+        assert_eq!(config.jsonrpc_addr, "127.0.0.1:8545".parse().unwrap());
+        assert_eq!(config.chain_id, 1);
+        assert_eq!(config.max_connections, 100);
+    }
+
+    #[test]
+    fn rpc_server_config_new() {
+        let http: SocketAddr = "127.0.0.1:8080".parse().unwrap();
+        let jsonrpc: SocketAddr = "127.0.0.1:8545".parse().unwrap();
+        let config = RpcServerConfig::new(http, jsonrpc, 42);
+
+        assert_eq!(config.http_addr, http);
+        assert_eq!(config.jsonrpc_addr, jsonrpc);
+        assert_eq!(config.chain_id, 42);
+        assert_eq!(config.max_connections, 100);
+    }
+
+    #[test]
+    fn rpc_server_config_single_addr() {
+        let addr: SocketAddr = "0.0.0.0:9000".parse().unwrap();
+        let config = RpcServerConfig::single_addr(addr, 137);
+
+        assert_eq!(config.http_addr, addr);
+        assert_eq!(config.jsonrpc_addr, addr);
+        assert_eq!(config.chain_id, 137);
+    }
+
+    #[test]
+    fn rpc_server_config_with_cors_origins() {
+        let config =
+            RpcServerConfig::default().with_cors_origins(vec!["https://example.com".to_string()]);
+        assert_eq!(config.cors.allowed_origins, vec!["https://example.com"]);
+    }
+
+    #[test]
+    fn rpc_server_config_with_rate_limit() {
+        let config = RpcServerConfig::default().with_rate_limit(500);
+        assert_eq!(config.rate_limit.requests_per_second, 500);
+    }
+
+    #[test]
+    fn rpc_server_config_with_max_connections() {
+        let config = RpcServerConfig::default().with_max_connections(200);
+        assert_eq!(config.max_connections, 200);
+    }
+
+    #[test]
+    fn rpc_server_config_chained_builder() {
+        let config = RpcServerConfig::default()
+            .with_cors_origins(vec!["*".to_string()])
+            .with_rate_limit(1000)
+            .with_max_connections(50);
+
+        assert_eq!(config.cors.allowed_origins, vec!["*"]);
+        assert_eq!(config.rate_limit.requests_per_second, 1000);
+        assert_eq!(config.max_connections, 50);
+    }
+
+    #[test]
+    fn cors_config_default() {
+        let config = CorsConfig::default();
+        assert_eq!(config.allowed_origins, vec!["http://localhost:3000"]);
+        assert_eq!(config.allowed_methods, vec!["GET", "POST", "OPTIONS"]);
+        assert_eq!(config.allowed_headers, vec!["Content-Type"]);
+        assert_eq!(config.max_age, 3600);
+    }
+
+    #[test]
+    fn cors_config_none() {
+        let config = CorsConfig::none();
+        assert!(config.allowed_origins.is_empty());
+        assert!(config.allowed_methods.is_empty());
+        assert!(config.allowed_headers.is_empty());
+        assert_eq!(config.max_age, 0);
+    }
+
+    #[test]
+    fn cors_config_permissive() {
+        let config = CorsConfig::permissive();
+        assert_eq!(config.allowed_origins, vec!["*"]);
+        assert!(config.allowed_methods.contains(&"GET".to_string()));
+        assert!(config.allowed_methods.contains(&"POST".to_string()));
+        assert!(config.allowed_methods.contains(&"PUT".to_string()));
+        assert!(config.allowed_methods.contains(&"DELETE".to_string()));
+        assert!(config.allowed_methods.contains(&"OPTIONS".to_string()));
+        assert_eq!(config.allowed_headers, vec!["*"]);
+        assert_eq!(config.max_age, 86400);
+    }
+
+    #[test]
+    fn rate_limit_config_default() {
+        let config = RateLimitConfig::default();
+        assert_eq!(config.requests_per_second, 100);
+        assert_eq!(config.burst_size, 200);
+    }
+
+    #[test]
+    fn rate_limit_config_disabled() {
+        let config = RateLimitConfig::disabled();
+        assert_eq!(config.requests_per_second, u64::MAX);
+        assert_eq!(config.burst_size, u64::MAX);
+    }
+
+    #[test]
+    fn rpc_server_config_clone() {
+        let original = RpcServerConfig::default().with_rate_limit(250).with_max_connections(75);
+        let cloned = original.clone();
+
+        assert_eq!(cloned.rate_limit.requests_per_second, 250);
+        assert_eq!(cloned.max_connections, 75);
+    }
+
+    #[test]
+    fn cors_config_clone() {
+        let original = CorsConfig::permissive();
+        let cloned = original.clone();
+
+        assert_eq!(cloned.allowed_origins, vec!["*"]);
+        assert_eq!(cloned.max_age, 86400);
+    }
+
+    #[test]
+    fn rate_limit_config_clone() {
+        let original = RateLimitConfig { requests_per_second: 500, burst_size: 1000 };
+        let cloned = original.clone();
+
+        assert_eq!(cloned.requests_per_second, 500);
+        assert_eq!(cloned.burst_size, 1000);
+    }
+
+    #[test]
+    fn rpc_server_config_debug() {
+        let config = RpcServerConfig::default();
+        let debug_str = format!("{:?}", config);
+        assert!(debug_str.contains("RpcServerConfig"));
+        assert!(debug_str.contains("chain_id"));
+    }
+
+    #[test]
+    fn cors_config_debug() {
+        let config = CorsConfig::default();
+        let debug_str = format!("{:?}", config);
+        assert!(debug_str.contains("CorsConfig"));
+        assert!(debug_str.contains("allowed_origins"));
+    }
+
+    #[test]
+    fn rate_limit_config_debug() {
+        let config = RateLimitConfig::default();
+        let debug_str = format!("{:?}", config);
+        assert!(debug_str.contains("RateLimitConfig"));
+        assert!(debug_str.contains("requests_per_second"));
+    }
+}

crates/storage/indexer/src/lib.rs

@@ -13,4 +13,4 @@ mod store;
 pub use store::BlockIndex;
 
 mod types;
-pub use types::{IndexedBlock, IndexedLog, IndexedReceipt, IndexedTransaction};
+pub use types::{IndexStats, IndexedBlock, IndexedLog, IndexedReceipt, IndexedTransaction};

crates/storage/indexer/src/store.rs

@@ -11,7 +11,7 @@ use tracing::debug;
 
 use crate::{
     filter::LogFilter,
-    types::{IndexedBlock, IndexedLog, IndexedReceipt, IndexedTransaction},
+    types::{IndexStats, IndexedBlock, IndexedLog, IndexedReceipt, IndexedTransaction},
 };
 
 /// In-memory storage for indexed blocks, transactions, receipts, and logs.
@@ -161,6 +161,36 @@ impl BlockIndex {
         result
     }
 
+    /// Returns the total number of indexed blocks.
+    pub fn block_count(&self) -> usize {
+        self.blocks_by_hash.read().len()
+    }
+
+    /// Returns the total number of indexed transactions.
+    pub fn transaction_count(&self) -> usize {
+        self.transactions.read().len()
+    }
+
+    /// Returns the total number of indexed receipts.
+    pub fn receipt_count(&self) -> usize {
+        self.receipts.read().len()
+    }
+
+    /// Returns true if the index is empty (no blocks indexed).
+    pub fn is_empty(&self) -> bool {
+        self.blocks_by_hash.read().is_empty()
+    }
+
+    /// Returns statistics about the index.
+    pub fn stats(&self) -> IndexStats {
+        IndexStats {
+            block_count: self.block_count(),
+            transaction_count: self.transaction_count(),
+            receipt_count: self.receipt_count(),
+            head_block_number: self.head_block_number(),
+        }
+    }
+
     fn matches_filter(log: &IndexedLog, filter: &LogFilter) -> bool {
         if let Some(addresses) = &filter.address
             && !addresses.contains(&log.address)
@@ -239,7 +269,7 @@ mod tests {
         let block_hash = B256::repeat_byte(1);
         let block = create_test_block(1, block_hash);
 
-        index.insert_block(block.clone(), vec![], vec![]);
+        index.insert_block(block, vec![], vec![]);
 
         let retrieved = index.get_block_by_hash(&block_hash).unwrap();
         assert_eq!(retrieved.number, 1);
@@ -258,7 +288,7 @@ mod tests {
         let tx = create_test_tx(tx_hash, block_hash, 1);
         let receipt = create_test_receipt(tx_hash, block_hash, 1);
 
-        index.insert_block(block, vec![tx], vec![receipt.clone()]);
+        index.insert_block(block, vec![tx], vec![receipt]);
 
         let retrieved_tx = index.get_transaction(&tx_hash).unwrap();
         assert_eq!(retrieved_tx.hash, tx_hash);
@@ -325,4 +355,75 @@ mod tests {
         let logs = index.get_logs(&filter);
         assert!(logs.is_empty());
     }
+
+    #[test]
+    fn test_is_empty() {
+        let index = BlockIndex::new();
+        assert!(index.is_empty());
+
+        index.insert_block(create_test_block(1, B256::repeat_byte(1)), vec![], vec![]);
+        assert!(!index.is_empty());
+    }
+
+    #[test]
+    fn test_block_count() {
+        let index = BlockIndex::new();
+        assert_eq!(index.block_count(), 0);
+
+        index.insert_block(create_test_block(1, B256::repeat_byte(1)), vec![], vec![]);
+        assert_eq!(index.block_count(), 1);
+
+        index.insert_block(create_test_block(2, B256::repeat_byte(2)), vec![], vec![]);
+        assert_eq!(index.block_count(), 2);
+    }
+
+    #[test]
+    fn test_transaction_count() {
+        let index = BlockIndex::new();
+        assert_eq!(index.transaction_count(), 0);
+
+        let block_hash = B256::repeat_byte(1);
+        let tx1 = create_test_tx(B256::repeat_byte(2), block_hash, 1);
+        let tx2 = create_test_tx(B256::repeat_byte(3), block_hash, 1);
+
+        index.insert_block(create_test_block(1, block_hash), vec![tx1, tx2], vec![]);
+        assert_eq!(index.transaction_count(), 2);
+    }
+
+    #[test]
+    fn test_receipt_count() {
+        let index = BlockIndex::new();
+        assert_eq!(index.receipt_count(), 0);
+
+        let block_hash = B256::repeat_byte(1);
+        let tx_hash = B256::repeat_byte(2);
+        let receipt = create_test_receipt(tx_hash, block_hash, 1);
+
+        index.insert_block(create_test_block(1, block_hash), vec![], vec![receipt]);
+        assert_eq!(index.receipt_count(), 1);
+    }
+
+    #[test]
+    fn test_stats() {
+        let index = BlockIndex::new();
+
+        let stats = index.stats();
+        assert_eq!(stats.block_count, 0);
+        assert_eq!(stats.transaction_count, 0);
+        assert_eq!(stats.receipt_count, 0);
+        assert_eq!(stats.head_block_number, 0);
+
+        let block_hash = B256::repeat_byte(1);
+        let tx_hash = B256::repeat_byte(2);
+        let tx = create_test_tx(tx_hash, block_hash, 5);
+        let receipt = create_test_receipt(tx_hash, block_hash, 5);
+
+        index.insert_block(create_test_block(5, block_hash), vec![tx], vec![receipt]);
+
+        let stats = index.stats();
+        assert_eq!(stats.block_count, 1);
+        assert_eq!(stats.transaction_count, 1);
+        assert_eq!(stats.receipt_count, 1);
+        assert_eq!(stats.head_block_number, 5);
+    }
 }

crates/storage/indexer/src/types.rs

@@ -91,3 +91,16 @@ pub struct IndexedLog {
     /// Log index within the block.
     pub log_index: u64,
 }
+
+/// Statistics about the block index.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct IndexStats {
+    /// Total number of indexed blocks.
+    pub block_count: usize,
+    /// Total number of indexed transactions.
+    pub transaction_count: usize,
+    /// Total number of indexed receipts.
+    pub receipt_count: usize,
+    /// Current head block number.
+    pub head_block_number: u64,
+}