feat: update test configurations for improved initialization

Author: QuantumExplorer

dash-spv/src/bloom/tests.rs

@@ -1,6 +1,7 @@
 //! Comprehensive unit tests for bloom filter module
 
 #[cfg(test)]
+#[allow(clippy::module_inception)]
 mod tests {
     use crate::bloom::{
         builder::BloomFilterBuilder,
@@ -667,16 +668,16 @@ mod tests {
 
     #[test]
     fn test_config_validation() {
-        let mut config = BloomFilterConfig::default();
+        // Construct with desired custom fields instead of reassigning after Default
+        let config = BloomFilterConfig {
+            false_positive_rate: 0.0001,
+            elements: 1,
+            max_false_positive_rate: 0.1,
+            ..Default::default()
+        };
 
-        // Valid configurations
-        config.false_positive_rate = 0.0001;
         assert!(config.false_positive_rate > 0.0 && config.false_positive_rate < 1.0);
-
-        config.elements = 1;
         assert!(config.elements > 0);
-
-        config.max_false_positive_rate = 0.1;
         assert!(config.max_false_positive_rate > config.false_positive_rate);
     }
 

dash-spv/src/chain/chain_tip.rs

@@ -272,7 +272,7 @@ mod tests {
         let new_work = ChainWork::from_bytes(work_bytes);
 
         // The extend operation should succeed
-        let result = manager.extend_tip(&tip1_hash, new_header.clone(), new_work);
+        let result = manager.extend_tip(&tip1_hash, new_header, new_work);
         assert!(result.is_ok());
 
         // The old tip should be gone
@@ -315,7 +315,7 @@ mod tests {
         work_bytes[31] = 6;
         let new_work = ChainWork::from_bytes(work_bytes);
 
-        let result = manager.extend_tip(&tip1_hash, new_header.clone(), new_work);
+        let result = manager.extend_tip(&tip1_hash, new_header, new_work);
         assert!(result.is_ok());
 
         // Verify final state - old tip gone, new tip present

dash-spv/src/chain/chainlock_test.rs

@@ -97,7 +97,9 @@ mod tests {
             chainlock_manager
                 .process_chain_lock(chainlock, &chain_state, &mut storage)
                 .await
-                .expect(&format!("ChainLock at height {} should process successfully", height));
+                .unwrap_or_else(|_| {
+                    panic!("ChainLock at height {} should process successfully", height)
+                });
         }
 
         // Test reorganization protection

dash-spv/src/chain/checkpoints.rs

@@ -424,6 +424,7 @@ fn parse_block_hash_safe(s: &str) -> BlockHash {
 }
 
 /// Helper to create a checkpoint with common defaults
+#[allow(clippy::too_many_arguments)]
 fn create_checkpoint(
     height: u32,
     hash: &str,

dash-spv/src/chain/fork_detector.rs

@@ -257,7 +257,7 @@ mod tests {
         // Add genesis
         let genesis = genesis_block(Network::Dash).header;
         storage.store_header(&genesis, 0).expect("Failed to store genesis header");
-        chain_state.add_header(genesis.clone());
+        chain_state.add_header(genesis);
 
         // Header that extends main chain
         let header1 = create_test_header(genesis.block_hash(), 1);
@@ -266,7 +266,7 @@ mod tests {
 
         // Add header1 to chain
         storage.store_header(&header1, 1).expect("Failed to store header1");
-        chain_state.add_header(header1.clone());
+        chain_state.add_header(header1);
 
         // Header that creates a fork from genesis
         let fork_header = create_test_header(genesis.block_hash(), 2);
@@ -307,12 +307,12 @@ mod tests {
         // Add genesis
         let genesis = genesis_block(Network::Dash).header;
         storage.store_header(&genesis, 0).expect("Failed to store genesis header");
-        chain_state.add_header(genesis.clone());
+        chain_state.add_header(genesis);
 
         // Add a header to extend the main chain past genesis
         let header1 = create_test_header(genesis.block_hash(), 1);
         storage.store_header(&header1, 1).expect("Failed to store header1");
-        chain_state.add_header(header1.clone());
+        chain_state.add_header(header1);
 
         // Create 3 forks from genesis, should only keep 2
         for i in 0..3 {

dash-spv/src/chain/fork_detector_test.rs

@@ -38,14 +38,14 @@ mod tests {
         // Add a checkpoint header at height 1000
         let checkpoint_header = create_test_header(BlockHash::from([0u8; 32]), 1000);
         storage.store_header(&checkpoint_header, 1000).expect("Failed to store checkpoint");
-        chain_state.add_header(checkpoint_header.clone());
+        chain_state.add_header(checkpoint_header);
 
         // Add more headers building on checkpoint
         let mut prev_hash = checkpoint_header.block_hash();
         for i in 1..5 {
             let header = create_test_header(prev_hash, 1000 + i);
             storage.store_header(&header, 1000 + i).expect("Failed to store header");
-            chain_state.add_header(header.clone());
+            chain_state.add_header(header);
             prev_hash = header.block_hash();
         }
 
@@ -70,14 +70,14 @@ mod tests {
         // Setup genesis and main chain
         let genesis = genesis_block(Network::Dash).header;
         storage.store_header(&genesis, 0).expect("Failed to store genesis");
-        chain_state.add_header(genesis.clone());
+        chain_state.add_header(genesis);
 
         // Build main chain
         let mut main_chain_tip = genesis.block_hash();
         for i in 1..10 {
             let header = create_test_header(main_chain_tip, i);
             storage.store_header(&header, i).expect("Failed to store header");
-            chain_state.add_header(header.clone());
+            chain_state.add_header(header);
             main_chain_tip = header.block_hash();
         }
 
@@ -122,12 +122,12 @@ mod tests {
         // Setup genesis and build a main chain
         let genesis = genesis_block(Network::Dash).header;
         storage.store_header(&genesis, 0).expect("Failed to store genesis");
-        chain_state.add_header(genesis.clone());
+        chain_state.add_header(genesis);
 
         // Build main chain past genesis
         let header1 = create_test_header(genesis.block_hash(), 1);
         storage.store_header(&header1, 1).expect("Failed to store header");
-        chain_state.add_header(header1.clone());
+        chain_state.add_header(header1);
 
         // Create more forks than the limit from genesis (not tip)
         let mut created_forks = Vec::new();
@@ -149,7 +149,7 @@ mod tests {
         // Since all forks have equal work, eviction order is not guaranteed
         // Just verify we have 3 unique forks
         assert_eq!(fork_nonces.len(), 3);
-        assert!(fork_nonces.iter().all(|&n| n >= 100 && n <= 104));
+        assert!(fork_nonces.iter().all(|&n| (100..=104).contains(&n)));
     }
 
     #[test]
@@ -161,12 +161,12 @@ mod tests {
         // Setup genesis and build a main chain
         let genesis = genesis_block(Network::Dash).header;
         storage.store_header(&genesis, 0).expect("Failed to store genesis");
-        chain_state.add_header(genesis.clone());
+        chain_state.add_header(genesis);
 
         // Build main chain past genesis
         let header1 = create_test_header(genesis.block_hash(), 1);
         storage.store_header(&header1, 1).expect("Failed to store header");
-        chain_state.add_header(header1.clone());
+        chain_state.add_header(header1);
 
         // Create two forks from genesis (not tip)
         let fork1_header = create_test_header(genesis.block_hash(), 100);
@@ -207,14 +207,14 @@ mod tests {
         // Setup genesis
         let genesis = genesis_block(Network::Dash).header;
         storage.store_header(&genesis, 0).expect("Failed to store genesis");
-        chain_state.lock().unwrap().add_header(genesis.clone());
+        chain_state.lock().unwrap().add_header(genesis);
 
         // Build a base chain
         let mut prev_hash = genesis.block_hash();
         for i in 1..20 {
             let header = create_test_header(prev_hash, i);
             storage.store_header(&header, i).expect("Failed to store header");
-            chain_state.lock().unwrap().add_header(header.clone());
+            chain_state.lock().unwrap().add_header(header);
             prev_hash = header.block_hash();
         }
 
@@ -229,7 +229,7 @@ mod tests {
             let handle = thread::spawn(move || {
                 // Each thread creates forks at different heights
                 for i in 0..10 {
-                    let fork_height = (thread_id * 3 + i % 3) as u32;
+                    let fork_height = thread_id * 3 + i % 3;
                     let chain_state_lock = chain_state_clone.lock().unwrap();
 
                     if let Some(fork_point_header) = chain_state_lock.header_at_height(fork_height)
@@ -262,12 +262,12 @@ mod tests {
         let forks = detector_lock.get_forks();
 
         // Should have multiple forks but within the limit
-        assert!(forks.len() > 0);
+        assert!(!forks.is_empty());
         assert!(forks.len() <= 50);
 
         // All forks should have valid structure
         for fork in forks {
-            assert!(fork.headers.len() > 0);
+            assert!(!fork.headers.is_empty());
             assert_eq!(fork.tip_hash, fork.headers.last().unwrap().block_hash());
             assert_eq!(fork.tip_height, fork.fork_height + fork.headers.len() as u32);
         }
@@ -287,7 +287,7 @@ mod tests {
         // Add genesis
         let genesis = genesis_block(Network::Dash).header;
         storage.store_header(&genesis, 0).expect("Failed to store genesis");
-        chain_state.add_header(genesis.clone());
+        chain_state.add_header(genesis);
 
         // Test 2: Header connecting to non-existent block
         let phantom_hash = BlockHash::from_raw_hash(dashcore_hashes::hash_x11::Hash::hash(&[42u8]));
@@ -310,12 +310,12 @@ mod tests {
         // Setup genesis and build a main chain
         let genesis = genesis_block(Network::Dash).header;
         storage.store_header(&genesis, 0).expect("Failed to store genesis");
-        chain_state.add_header(genesis.clone());
+        chain_state.add_header(genesis);
 
         // Build main chain past genesis
         let header1 = create_test_header(genesis.block_hash(), 1);
         storage.store_header(&header1, 1).expect("Failed to store header");
-        chain_state.add_header(header1.clone());
+        chain_state.add_header(header1);
 
         // Create multiple forks from genesis (not tip)
         let mut fork_tips = Vec::new();
@@ -328,16 +328,16 @@ mod tests {
         assert_eq!(detector.get_forks().len(), 5);
 
         // Remove specific forks
-        for i in 0..3 {
-            let removed = detector.remove_fork(&fork_tips[i]);
+        for tip in fork_tips.iter().take(3) {
+            let removed = detector.remove_fork(tip);
             assert!(removed.is_some());
         }
 
         assert_eq!(detector.get_forks().len(), 2);
 
         // Verify removed forks can't be found
-        for i in 0..3 {
-            assert!(detector.get_fork(&fork_tips[i]).is_none());
+        for tip in fork_tips.iter().take(3) {
+            assert!(detector.get_fork(tip).is_none());
         }
 
         // Clear all remaining forks
@@ -355,7 +355,7 @@ mod tests {
         // Add genesis to storage and chain state
         let genesis = genesis_block(Network::Dash).header;
         storage.store_header(&genesis, 0).expect("Failed to store genesis");
-        chain_state.add_header(genesis.clone());
+        chain_state.add_header(genesis);
 
         // Chain state tip is at genesis (height 0)
         assert_eq!(chain_state.tip_height(), 0);
@@ -374,13 +374,13 @@ mod tests {
 
         // Add headers to chain state but not storage (simulating sync issue)
         let genesis = genesis_block(Network::Dash).header;
-        chain_state.add_header(genesis.clone());
+        chain_state.add_header(genesis);
 
         let header1 = create_test_header(genesis.block_hash(), 1);
-        chain_state.add_header(header1.clone());
+        chain_state.add_header(header1);
 
         let header2 = create_test_header(header1.block_hash(), 2);
-        chain_state.add_header(header2.clone());
+        chain_state.add_header(header2);
 
         // Try to extend from header1 (in chain state but not storage)
         let header3 = create_test_header(header1.block_hash(), 3);

dash-spv/src/chain/orphan_pool.rs

@@ -254,7 +254,7 @@ mod tests {
         let header = create_test_header(genesis, 1);
         let block_hash = header.block_hash();
 
-        assert!(pool.add_orphan(header.clone()));
+        assert!(pool.add_orphan(header));
         assert!(pool.contains(&block_hash));
         assert_eq!(pool.len(), 1);
 
@@ -269,7 +269,7 @@ mod tests {
         let header = create_test_header(BlockHash::from([0u8; 32]), 1);
         let block_hash = header.block_hash();
 
-        pool.add_orphan(header.clone());
+        pool.add_orphan(header);
         assert!(pool.contains(&block_hash));
 
         let removed = pool.remove_orphan(&block_hash);
@@ -300,7 +300,7 @@ mod tests {
         let mut pool = OrphanPool::new();
         let header = create_test_header(BlockHash::from([0u8; 32]), 1);
 
-        assert!(pool.add_orphan(header.clone()));
+        assert!(pool.add_orphan(header));
         assert!(!pool.add_orphan(header)); // Should not add duplicate
         assert_eq!(pool.len(), 1);
     }
@@ -317,8 +317,8 @@ mod tests {
         let hash2 = header2.block_hash();
         let header3 = create_test_header(hash2, 3);
 
-        pool.add_orphan(header1.clone());
-        pool.add_orphan(header2.clone());
+        pool.add_orphan(header1);
+        pool.add_orphan(header2);
         pool.add_orphan(header3);
 
         assert_eq!(pool.len(), 3);

dash-spv/src/chain/orphan_pool_test.rs

@@ -72,9 +72,9 @@ mod tests {
         let header_d = create_test_header(hash_c, 4);
 
         // Add them out of order (A is not an orphan since it connects to genesis)
-        pool.add_orphan(header_d.clone());
-        pool.add_orphan(header_b.clone());
-        pool.add_orphan(header_c.clone());
+        pool.add_orphan(header_d);
+        pool.add_orphan(header_b);
+        pool.add_orphan(header_c);
 
         assert_eq!(pool.len(), 3);
 
@@ -151,13 +151,13 @@ mod tests {
         assert_eq!(pool.len(), 5);
 
         // First 5 should have been evicted
-        for i in 0..5 {
-            assert!(!pool.contains(&all_hashes[i]));
+        for h in all_hashes.iter().take(5) {
+            assert!(!pool.contains(h));
         }
 
         // Last 5 should still be present
-        for i in 5..10 {
-            assert!(pool.contains(&all_hashes[i]));
+        for h in all_hashes.iter().skip(5).take(5) {
+            assert!(pool.contains(h));
         }
     }
 
@@ -170,7 +170,7 @@ mod tests {
         let mut headers = Vec::new();
         for i in 0..5 {
             let header = create_test_header(parent, i);
-            headers.push(header.clone());
+            headers.push(header);
             pool.add_orphan(header);
         }
 
@@ -349,7 +349,7 @@ mod tests {
         let hash = header.block_hash();
         let original_time = Instant::now();
 
-        pool.add_orphan(header.clone());
+        pool.add_orphan(header);
 
         // Process a few times to increment attempts
         for _ in 0..3 {