tests related to on memory storage removed, we understand that it taste the same operations as the diskstoragemanager. next time use generics pls

Author: ZocoLini

dash-spv/src/main.rs

@@ -307,65 +307,29 @@ async fn run() -> Result<(), Box<dyn std::error::Error>> {
         }
     };
 
-    // Create and start the client based on storage type
-    if config.enable_persistence {
-        if let Some(path) = &config.storage_path {
-            let storage_manager =
-                match dash_spv::storage::DiskStorageManager::new(path.clone()).await {
-                    Ok(sm) => sm,
-                    Err(e) => {
-                        eprintln!("Failed to create disk storage manager: {}", e);
-                        process::exit(1);
-                    }
-                };
-            run_client(
-                config,
-                network_manager,
-                storage_manager,
-                wallet,
-                enable_terminal_ui,
-                &matches,
-                wallet_id,
-            )
-            .await?;
-        } else {
-            let storage_manager = match dash_spv::storage::DiskStorageManager::new_tmp().awai {
-                Ok(sm) => sm,
-                Err(e) => {
-                    eprintln!("Failed to create memory storage manager: {}", e);
-                    process::exit(1);
-                }
-            };
-            run_client(
-                config,
-                network_manager,
-                storage_manager,
-                wallet,
-                enable_terminal_ui,
-                &matches,
-                wallet_id,
-            )
-            .await?;
-        }
+    let path = if let Some(path) = &config.storage_path {
+        path.clone()
     } else {
-        let storage_manager = match dash_spv::storage::DiskStorageManager::new_tmp().awai {
-            Ok(sm) => sm,
-            Err(e) => {
-                eprintln!("Failed to create memory storage manager: {}", e);
-                process::exit(1);
-            }
-        };
-        run_client(
-            config,
-            network_manager,
-            storage_manager,
-            wallet,
-            enable_terminal_ui,
-            &matches,
-            wallet_id,
-        )
-        .await?;
-    }
+        "./.tmp/main-exec-storage"
+    };
+
+    let storage_manager = match dash_spv::storage::DiskStorageManager::new(path.clone()).await {
+        Ok(sm) => sm,
+        Err(e) => {
+            eprintln!("Failed to create disk storage manager: {}", e);
+            process::exit(1);
+        }
+    };
+    run_client(
+        config,
+        network_manager,
+        storage_manager,
+        wallet,
+        enable_terminal_ui,
+        &matches,
+        wallet_id,
+    )
+    .await?;
 
     Ok(())
 }

dash-spv/tests/block_download_test.rs

@@ -9,6 +9,7 @@
 
 use std::collections::HashSet;
 use std::sync::Arc;
+use tempfile::TempDir;
 use tokio::sync::Mutex;
 use tokio::sync::RwLock;
 
@@ -340,7 +341,9 @@ async fn test_sync_manager_integration() {}
 #[tokio::test]
 async fn test_filter_match_and_download_workflow() {
     let config = create_test_config();
-    let _storage = DiskStorageManager::new_tmp().await.expect("Failed to create tmp storage");
+    let _storage = DiskStorageManager::new(TempDir::new().unwrap().path().to_path_buf())
+        .await
+        .expect("Failed to create tmp storage");
     let received_heights = Arc::new(Mutex::new(HashSet::new()));
     let mut filter_sync: FilterSyncManager<DiskStorageManager, MockNetworkManager> =
         FilterSyncManager::new(&config, received_heights);

dash-spv/tests/edge_case_filter_sync_test.rs

@@ -9,6 +9,7 @@
 
 use std::collections::HashSet;
 use std::sync::Arc;
+use tempfile::TempDir;
 use tokio::sync::Mutex;
 
 use dash_spv::{
@@ -121,7 +122,9 @@ async fn test_filter_sync_at_tip_edge_case() {
     let mut filter_sync: FilterSyncManager<DiskStorageManager, MockNetworkManager> =
         FilterSyncManager::new(&config, received_heights);
 
-    let mut storage = DiskStorageManager::new_tmp().await.expect("Failed to create tmp storage");
+    let mut storage = DiskStorageManager::new(TempDir::new().unwrap().path().to_path_buf())
+        .await
+        .expect("Failed to create tmp storage");
     let mut network = MockNetworkManager::new();
 
     // Set up storage with headers and filter headers at the same height (tip)
@@ -164,7 +167,9 @@ async fn test_no_invalid_getcfheaders_at_tip() {
     let mut filter_sync: FilterSyncManager<DiskStorageManager, MockNetworkManager> =
         FilterSyncManager::new(&config, received_heights);
 
-    let mut storage = DiskStorageManager::new_tmp().await.expect("Failed to create tmp storage");
+    let mut storage = DiskStorageManager::new(TempDir::new().unwrap().path().to_path_buf())
+        .await
+        .expect("Failed to create tmp storage");
     let mut network = MockNetworkManager::new();
 
     // Create a scenario where we're one block behind

dash-spv/tests/filter_header_verification_test.rs

@@ -33,6 +33,7 @@ use dashcore::{
 use dashcore_hashes::{sha256d, Hash};
 use std::collections::HashSet;
 use std::sync::Arc;
+use tempfile::TempDir;
 use tokio::sync::Mutex;
 
 /// Mock network manager for testing filter sync
@@ -181,7 +182,9 @@ async fn test_filter_header_verification_failure_reproduction() {
     println!("=== Testing Filter Header Chain Verification Failure ===");
 
     // Create storage and sync manager
-    let mut storage = DiskStorageManager::new_tmp().await.expect("Failed to create tmp storage");
+    let mut storage = DiskStorageManager::new(TempDir::new().unwrap().path().to_path_buf())
+        .await
+        .expect("Failed to create tmp storage");
     let mut network = MockNetworkManager::new();
 
     let config = ClientConfig::new(Network::Dash);
@@ -343,7 +346,9 @@ async fn test_overlapping_batches_from_different_peers() {
     // The system should handle this gracefully, but currently it crashes.
     // This test will FAIL until we implement the fix.
 
-    let mut storage = DiskStorageManager::new_tmp().await.expect("Failed to create tmp storage");
+    let mut storage = DiskStorageManager::new(TempDir::new().unwrap().path().to_path_buf())
+        .await
+        .expect("Failed to create tmp storage");
     let mut network = MockNetworkManager::new();
 
     let config = ClientConfig::new(Network::Dash);
@@ -517,7 +522,9 @@ async fn test_filter_header_verification_overlapping_batches() {
     // This test simulates what happens when we receive overlapping filter header batches
     // due to recovery/retry mechanisms or multiple peers
 
-    let mut storage = DiskStorageManager::new_tmp().await.expect("Failed to create tmp storage");
+    let mut storage = DiskStorageManager::new(TempDir::new().unwrap().path().to_path_buf())
+        .await
+        .expect("Failed to create tmp storage");
     let mut network = MockNetworkManager::new();
 
     let config = ClientConfig::new(Network::Dash);
@@ -613,7 +620,9 @@ async fn test_filter_header_verification_race_condition_simulation() {
     // This test simulates the race condition that might occur when multiple
     // filter header requests are in flight simultaneously
 
-    let mut storage = DiskStorageManager::new_tmp().await.expect("Failed to create tmp storage");
+    let mut storage = DiskStorageManager::new(TempDir::new().unwrap().path().to_path_buf())
+        .await
+        .expect("Failed to create tmp storage");
     let mut network = MockNetworkManager::new();
 
     let config = ClientConfig::new(Network::Dash);

dash-spv/tests/reverse_index_test.rs

@@ -4,36 +4,6 @@ use dashcore_hashes::Hash;
 use std::path::PathBuf;
 use tempfile::TempDir;
 
-#[tokio::test]
-async fn test_reverse_index_memory_storage() {
-    let mut storage =
-        DiskStorageManager::new(TempDir::new().expect("Failed to create tmp dir").path().into())
-            .await
-            .expect("Failed to create tmp storage");
-
-    // Create some test headers
-    let mut headers = Vec::new();
-    for i in 0..10 {
-        let header = create_test_header(i);
-        headers.push(header);
-    }
-
-    // Store headers
-    storage.store_headers(&headers).await.unwrap();
-
-    // Test reverse lookups
-    for (i, header) in headers.iter().enumerate() {
-        let hash = header.block_hash();
-        let height = storage.get_header_height_by_hash(&hash).await.unwrap();
-        assert_eq!(height, Some(i as u32), "Height mismatch for header {}", i);
-    }
-
-    // Test non-existent hash
-    let fake_hash = dashcore::BlockHash::from_byte_array([0xFF; 32]);
-    let height = storage.get_header_height_by_hash(&fake_hash).await.unwrap();
-    assert_eq!(height, None, "Should return None for non-existent hash");
-}
-
 #[tokio::test]
 async fn test_reverse_index_disk_storage() {
     let temp_dir = tempfile::tempdir().unwrap();