feat(tests): Add cross-platform test volume creation utilities

- Create TestVolumeManager for platform-agnostic volume creation
- Implement macOS support using disk images and RAM disks
- Implement Windows support using VHD (Virtual Hard Disk)
- Implement Linux support using loop devices and tmpfs
- Add TestVolumeBuilder for easy configuration
- Support multiple filesystems (APFS, HFS+, NTFS, FAT32, ExFAT, ext4)
- Automatic cleanup on drop to prevent resource leaks
- Fix volume tracking test issues and improve test reliability

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

core-new/tests/helpers/mod.rs

@@ -0,0 +1,5 @@
+//! Test helper modules for integration tests
+
+pub mod test_volumes;
+
+pub use test_volumes::*;

core-new/tests/helpers/test_volumes.rs

@@ -0,0 +1,845 @@
+//! Cross-platform test volume creation utilities
+//!
+//! This module provides platform-specific implementations for creating
+//! temporary volumes for testing purposes.
+
+use anyhow::{anyhow, Context, Result};
+use std::path::PathBuf;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+use tracing::{debug, info, warn};
+
+/// Supported filesystems for test volumes
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TestFileSystem {
+    /// APFS (macOS)
+    Apfs,
+    /// HFS+ (macOS)
+    HfsPlus,
+    /// NTFS (Windows)
+    Ntfs,
+    /// FAT32 (cross-platform)
+    Fat32,
+    /// ExFAT (cross-platform)
+    ExFat,
+    /// ext4 (Linux)
+    Ext4,
+    /// Platform default
+    Default,
+}
+
+impl TestFileSystem {
+    /// Get the filesystem string for the current platform
+    pub fn to_platform_string(&self) -> &'static str {
+        match self {
+            TestFileSystem::Apfs => "APFS",
+            TestFileSystem::HfsPlus => "HFS+",
+            TestFileSystem::Ntfs => "NTFS",
+            TestFileSystem::Fat32 => "FAT32",
+            TestFileSystem::ExFat => "ExFAT",
+            TestFileSystem::Ext4 => "ext4",
+            TestFileSystem::Default => {
+                #[cfg(target_os = "macos")]
+                return "APFS";
+                #[cfg(target_os = "windows")]
+                return "NTFS";
+                #[cfg(target_os = "linux")]
+                return "ext4";
+            }
+        }
+    }
+}
+
+/// Configuration for creating a test volume
+#[derive(Debug, Clone)]
+pub struct TestVolumeConfig {
+    /// Volume name
+    pub name: String,
+    /// Size in bytes
+    pub size_bytes: u64,
+    /// Filesystem type
+    pub filesystem: TestFileSystem,
+    /// Whether to create as read-only
+    pub read_only: bool,
+    /// Use RAM disk if possible
+    pub use_ram_disk: bool,
+}
+
+impl Default for TestVolumeConfig {
+    fn default() -> Self {
+        Self {
+            name: format!("TestVol_{}", chrono::Utc::now().timestamp()),
+            size_bytes: 100 * 1024 * 1024, // 100MB
+            filesystem: TestFileSystem::Default,
+            read_only: false,
+            use_ram_disk: false,
+        }
+    }
+}
+
+/// A test volume that automatically cleans up on drop
+pub struct TestVolume {
+    /// Mount point of the volume
+    pub mount_point: PathBuf,
+    /// Volume name
+    pub name: String,
+    /// Platform-specific identifier
+    pub(crate) platform_id: String,
+    /// Cleanup function
+    pub(crate) cleanup: Option<Box<dyn FnOnce() + Send>>,
+}
+
+impl TestVolume {
+    /// Get the mount point
+    pub fn path(&self) -> &PathBuf {
+        &self.mount_point
+    }
+    
+    /// Check if volume is mounted
+    pub async fn is_mounted(&self) -> bool {
+        self.mount_point.exists()
+    }
+}
+
+impl Drop for TestVolume {
+    fn drop(&mut self) {
+        if let Some(cleanup) = self.cleanup.take() {
+            cleanup();
+        }
+    }
+}
+
+/// Platform-agnostic test volume manager
+pub struct TestVolumeManager {
+    #[cfg(target_os = "macos")]
+    inner: MacOSTestVolumeManager,
+    #[cfg(target_os = "windows")]
+    inner: WindowsTestVolumeManager,
+    #[cfg(target_os = "linux")]
+    inner: LinuxTestVolumeManager,
+}
+
+impl TestVolumeManager {
+    /// Create a new test volume manager
+    pub fn new() -> Self {
+        Self {
+            #[cfg(target_os = "macos")]
+            inner: MacOSTestVolumeManager::new(),
+            #[cfg(target_os = "windows")]
+            inner: WindowsTestVolumeManager::new(),
+            #[cfg(target_os = "linux")]
+            inner: LinuxTestVolumeManager::new(),
+        }
+    }
+    
+    /// Create a test volume with the given configuration
+    pub async fn create_volume(&self, config: TestVolumeConfig) -> Result<TestVolume> {
+        self.inner.create_volume(config).await
+    }
+    
+    /// Destroy a test volume
+    pub async fn destroy_volume(&self, volume: TestVolume) -> Result<()> {
+        self.inner.destroy_volume(volume).await
+    }
+    
+    /// Check if we have required privileges for volume operations
+    pub async fn check_privileges(&self) -> Result<()> {
+        self.inner.check_privileges().await
+    }
+}
+
+// macOS implementation
+#[cfg(target_os = "macos")]
+pub struct MacOSTestVolumeManager {
+    temp_dir: PathBuf,
+    volumes: Arc<Mutex<Vec<PathBuf>>>,
+}
+
+#[cfg(target_os = "macos")]
+impl MacOSTestVolumeManager {
+    pub fn new() -> Self {
+        let temp_dir = std::env::temp_dir().join("spacedrive_test_volumes");
+        std::fs::create_dir_all(&temp_dir).ok();
+        
+        Self {
+            temp_dir,
+            volumes: Arc::new(Mutex::new(Vec::new())),
+        }
+    }
+    
+    pub async fn create_volume(&self, config: TestVolumeConfig) -> Result<TestVolume> {
+        info!("Creating test volume '{}' on macOS", config.name);
+        
+        let volume_name = config.name.clone();
+        let size_mb = config.size_bytes / (1024 * 1024);
+        
+        if config.use_ram_disk {
+            // Create RAM disk
+            self.create_ram_disk(config).await
+        } else {
+            // Create disk image
+            self.create_disk_image(config).await
+        }
+    }
+    
+    async fn create_ram_disk(&self, config: TestVolumeConfig) -> Result<TestVolume> {
+        let sectors = config.size_bytes / 512;
+        
+        // Create RAM disk
+        let output = tokio::process::Command::new("hdiutil")
+            .args(&["attach", "-nomount", &format!("ram://{}", sectors)])
+            .output()
+            .await
+            .context("Failed to create RAM disk")?;
+        
+        if !output.status.success() {
+            return Err(anyhow!("Failed to create RAM disk: {}", 
+                String::from_utf8_lossy(&output.stderr)));
+        }
+        
+        let disk_path = String::from_utf8_lossy(&output.stdout)
+            .trim()
+            .to_string();
+        
+        debug!("Created RAM disk at {}", disk_path);
+        
+        // Format the disk
+        let fs_type = match config.filesystem {
+            TestFileSystem::Apfs => "APFS",
+            TestFileSystem::HfsPlus => "HFS+",
+            TestFileSystem::ExFat => "ExFAT",
+            TestFileSystem::Fat32 => "FAT32",
+            _ => "APFS",
+        };
+        
+        let output = tokio::process::Command::new("diskutil")
+            .args(&[
+                "erasevolume",
+                fs_type,
+                &config.name,
+                &disk_path,
+            ])
+            .output()
+            .await
+            .context("Failed to format RAM disk")?;
+        
+        if !output.status.success() {
+            // Clean up RAM disk
+            tokio::process::Command::new("hdiutil")
+                .args(&["detach", &disk_path])
+                .output()
+                .await
+                .ok();
+                
+            return Err(anyhow!("Failed to format RAM disk: {}", 
+                String::from_utf8_lossy(&output.stderr)));
+        }
+        
+        let mount_point = PathBuf::from(format!("/Volumes/{}", config.name));
+        let disk_path_clone = disk_path.clone();
+        
+        Ok(TestVolume {
+            mount_point,
+            name: config.name,
+            platform_id: disk_path,
+            cleanup: Some(Box::new(move || {
+                // Detach the RAM disk
+                std::process::Command::new("hdiutil")
+                    .args(&["detach", &disk_path_clone, "-force"])
+                    .output()
+                    .ok();
+            })),
+        })
+    }
+    
+    async fn create_disk_image(&self, config: TestVolumeConfig) -> Result<TestVolume> {
+        let dmg_path = self.temp_dir.join(format!("{}.dmg", config.name));
+        let size_mb = config.size_bytes / (1024 * 1024);
+        
+        // Ensure temp directory exists
+        tokio::fs::create_dir_all(&self.temp_dir).await?;
+        
+        // Create disk image
+        let fs_type = match config.filesystem {
+            TestFileSystem::Apfs => "APFS",
+            TestFileSystem::HfsPlus => "HFS+",
+            TestFileSystem::ExFat => "ExFAT",
+            TestFileSystem::Fat32 => "MS-DOS FAT32",
+            _ => "APFS",
+        };
+        
+        let output = tokio::process::Command::new("hdiutil")
+            .args(&[
+                "create",
+                "-size", &format!("{}m", size_mb),
+                "-fs", fs_type,
+                "-volname", &config.name,
+                dmg_path.to_str().unwrap(),
+            ])
+            .output()
+            .await
+            .context("Failed to create disk image")?;
+        
+        if !output.status.success() {
+            return Err(anyhow!("Failed to create disk image: {}", 
+                String::from_utf8_lossy(&output.stderr)));
+        }
+        
+        // Mount the disk image
+        let output = tokio::process::Command::new("hdiutil")
+            .args(&["attach", dmg_path.to_str().unwrap()])
+            .output()
+            .await
+            .context("Failed to mount disk image")?;
+        
+        if !output.status.success() {
+            // Clean up disk image
+            tokio::fs::remove_file(&dmg_path).await.ok();
+            return Err(anyhow!("Failed to mount disk image: {}", 
+                String::from_utf8_lossy(&output.stderr)));
+        }
+        
+        // Parse mount info from output
+        let output_str = String::from_utf8_lossy(&output.stdout);
+        let disk_id = output_str
+            .lines()
+            .find(|line| line.contains("/dev/disk"))
+            .and_then(|line| line.split_whitespace().next())
+            .ok_or_else(|| anyhow!("Failed to parse disk identifier"))?
+            .to_string();
+        
+        let mount_point = PathBuf::from(format!("/Volumes/{}", config.name));
+        
+        // Track the volume
+        {
+            let mut volumes = self.volumes.lock().await;
+            volumes.push(dmg_path.clone());
+        }
+        
+        let dmg_path_clone = dmg_path.clone();
+        let disk_id_clone = disk_id.clone();
+        let volumes = self.volumes.clone();
+        
+        Ok(TestVolume {
+            mount_point,
+            name: config.name,
+            platform_id: disk_id,
+            cleanup: Some(Box::new(move || {
+                // Detach the disk
+                std::process::Command::new("hdiutil")
+                    .args(&["detach", &disk_id_clone, "-force"])
+                    .output()
+                    .ok();
+                
+                // Remove the disk image
+                std::fs::remove_file(&dmg_path_clone).ok();
+                
+                // Remove from tracking
+                if let Ok(mut vols) = volumes.blocking_lock() {
+                    vols.retain(|p| p != &dmg_path_clone);
+                }
+            })),
+        })
+    }
+    
+    pub async fn destroy_volume(&self, mut volume: TestVolume) -> Result<()> {
+        info!("Destroying test volume '{}'", volume.name);
+        
+        // The cleanup will be called by Drop
+        if let Some(cleanup) = volume.cleanup.take() {
+            cleanup();
+        }
+        
+        Ok(())
+    }
+    
+    pub async fn check_privileges(&self) -> Result<()> {
+        // On macOS, we don't need special privileges for disk images
+        Ok(())
+    }
+}
+
+// Windows implementation
+#[cfg(target_os = "windows")]
+pub struct WindowsTestVolumeManager {
+    temp_dir: PathBuf,
+    volumes: Arc<Mutex<Vec<PathBuf>>>,
+}
+
+#[cfg(target_os = "windows")]
+impl WindowsTestVolumeManager {
+    pub fn new() -> Self {
+        let temp_dir = std::env::temp_dir().join("spacedrive_test_volumes");
+        std::fs::create_dir_all(&temp_dir).ok();
+        
+        Self {
+            temp_dir,
+            volumes: Arc::new(Mutex::new(Vec::new())),
+        }
+    }
+    
+    pub async fn create_volume(&self, config: TestVolumeConfig) -> Result<TestVolume> {
+        info!("Creating test volume '{}' on Windows", config.name);
+        
+        // For Windows, we'll use VHD (Virtual Hard Disk)
+        self.create_vhd(config).await
+    }
+    
+    async fn create_vhd(&self, config: TestVolumeConfig) -> Result<TestVolume> {
+        let vhd_path = self.temp_dir.join(format!("{}.vhdx", config.name));
+        let size_mb = config.size_bytes / (1024 * 1024);
+        
+        // Ensure temp directory exists
+        tokio::fs::create_dir_all(&self.temp_dir).await?;
+        
+        // Create VHD using PowerShell
+        let script = format!(
+            r#"
+            $vhdPath = '{}'
+            $sizeBytes = {}
+            
+            # Create VHD
+            New-VHD -Path $vhdPath -SizeBytes $sizeBytes -Dynamic
+            
+            # Mount VHD
+            $vhd = Mount-VHD -Path $vhdPath -PassThru
+            
+            # Initialize disk
+            $disk = Initialize-Disk -Number $vhd.Number -PartitionStyle MBR -PassThru
+            
+            # Create partition
+            $partition = New-Partition -DiskNumber $disk.Number -UseMaximumSize -AssignDriveLetter
+            
+            # Format volume
+            Format-Volume -DriveLetter $partition.DriveLetter -FileSystem {} -NewFileSystemLabel '{}' -Confirm:$false
+            
+            # Output drive letter
+            Write-Output $partition.DriveLetter
+            "#,
+            vhd_path.to_str().unwrap().replace('\\', "\\\\"),
+            config.size_bytes,
+            match config.filesystem {
+                TestFileSystem::Ntfs => "NTFS",
+                TestFileSystem::Fat32 => "FAT32",
+                TestFileSystem::ExFat => "exFAT",
+                _ => "NTFS",
+            },
+            config.name
+        );
+        
+        let output = tokio::process::Command::new("powershell")
+            .args(&["-NoProfile", "-Command", &script])
+            .output()
+            .await
+            .context("Failed to create VHD")?;
+        
+        if !output.status.success() {
+            return Err(anyhow!("Failed to create VHD: {}", 
+                String::from_utf8_lossy(&output.stderr)));
+        }
+        
+        let drive_letter = String::from_utf8_lossy(&output.stdout)
+            .trim()
+            .to_string();
+        
+        if drive_letter.is_empty() {
+            return Err(anyhow!("Failed to get drive letter for VHD"));
+        }
+        
+        let mount_point = PathBuf::from(format!("{}:\\", drive_letter));
+        
+        // Track the volume
+        {
+            let mut volumes = self.volumes.lock().await;
+            volumes.push(vhd_path.clone());
+        }
+        
+        let vhd_path_clone = vhd_path.clone();
+        let volumes = self.volumes.clone();
+        
+        Ok(TestVolume {
+            mount_point,
+            name: config.name,
+            platform_id: vhd_path.to_str().unwrap().to_string(),
+            cleanup: Some(Box::new(move || {
+                // Dismount VHD using PowerShell
+                let script = format!(
+                    "Dismount-VHD -Path '{}' -Confirm:$false",
+                    vhd_path_clone.to_str().unwrap()
+                );
+                
+                std::process::Command::new("powershell")
+                    .args(&["-NoProfile", "-Command", &script])
+                    .output()
+                    .ok();
+                
+                // Remove the VHD file
+                std::fs::remove_file(&vhd_path_clone).ok();
+                
+                // Remove from tracking
+                if let Ok(mut vols) = volumes.blocking_lock() {
+                    vols.retain(|p| p != &vhd_path_clone);
+                }
+            })),
+        })
+    }
+    
+    pub async fn destroy_volume(&self, mut volume: TestVolume) -> Result<()> {
+        info!("Destroying test volume '{}'", volume.name);
+        
+        // The cleanup will be called by Drop
+        if let Some(cleanup) = volume.cleanup.take() {
+            cleanup();
+        }
+        
+        Ok(())
+    }
+    
+    pub async fn check_privileges(&self) -> Result<()> {
+        // Check if we're running as administrator
+        let output = tokio::process::Command::new("net")
+            .args(&["session"])
+            .output()
+            .await?;
+        
+        if !output.status.success() {
+            return Err(anyhow!("Administrator privileges required for creating test volumes on Windows"));
+        }
+        
+        Ok(())
+    }
+}
+
+// Linux implementation
+#[cfg(target_os = "linux")]
+pub struct LinuxTestVolumeManager {
+    temp_dir: PathBuf,
+    volumes: Arc<Mutex<Vec<PathBuf>>>,
+}
+
+#[cfg(target_os = "linux")]
+impl LinuxTestVolumeManager {
+    pub fn new() -> Self {
+        let temp_dir = std::env::temp_dir().join("spacedrive_test_volumes");
+        std::fs::create_dir_all(&temp_dir).ok();
+        
+        Self {
+            temp_dir,
+            volumes: Arc::new(Mutex::new(Vec::new())),
+        }
+    }
+    
+    pub async fn create_volume(&self, config: TestVolumeConfig) -> Result<TestVolume> {
+        info!("Creating test volume '{}' on Linux", config.name);
+        
+        if config.use_ram_disk {
+            // Use tmpfs for RAM disk
+            self.create_tmpfs(config).await
+        } else {
+            // Use loop device with file backing
+            self.create_loop_device(config).await
+        }
+    }
+    
+    async fn create_tmpfs(&self, config: TestVolumeConfig) -> Result<TestVolume> {
+        let mount_point = self.temp_dir.join(&config.name);
+        
+        // Create mount point
+        tokio::fs::create_dir_all(&mount_point).await?;
+        
+        // Mount tmpfs
+        let size_mb = config.size_bytes / (1024 * 1024);
+        let output = tokio::process::Command::new("sudo")
+            .args(&[
+                "mount",
+                "-t", "tmpfs",
+                "-o", &format!("size={}M", size_mb),
+                "tmpfs",
+                mount_point.to_str().unwrap(),
+            ])
+            .output()
+            .await
+            .context("Failed to mount tmpfs")?;
+        
+        if !output.status.success() {
+            tokio::fs::remove_dir(&mount_point).await.ok();
+            return Err(anyhow!("Failed to mount tmpfs: {}", 
+                String::from_utf8_lossy(&output.stderr)));
+        }
+        
+        let mount_point_clone = mount_point.clone();
+        
+        Ok(TestVolume {
+            mount_point: mount_point.clone(),
+            name: config.name,
+            platform_id: mount_point.to_str().unwrap().to_string(),
+            cleanup: Some(Box::new(move || {
+                // Unmount tmpfs
+                std::process::Command::new("sudo")
+                    .args(&["umount", mount_point_clone.to_str().unwrap()])
+                    .output()
+                    .ok();
+                
+                // Remove mount point
+                std::fs::remove_dir(&mount_point_clone).ok();
+            })),
+        })
+    }
+    
+    async fn create_loop_device(&self, config: TestVolumeConfig) -> Result<TestVolume> {
+        let img_path = self.temp_dir.join(format!("{}.img", config.name));
+        let mount_point = self.temp_dir.join(&config.name);
+        let size_mb = config.size_bytes / (1024 * 1024);
+        
+        // Ensure directories exist
+        tokio::fs::create_dir_all(&self.temp_dir).await?;
+        tokio::fs::create_dir_all(&mount_point).await?;
+        
+        // Create image file
+        let output = tokio::process::Command::new("dd")
+            .args(&[
+                "if=/dev/zero",
+                &format!("of={}", img_path.to_str().unwrap()),
+                "bs=1M",
+                &format!("count={}", size_mb),
+            ])
+            .output()
+            .await
+            .context("Failed to create image file")?;
+        
+        if !output.status.success() {
+            return Err(anyhow!("Failed to create image file: {}", 
+                String::from_utf8_lossy(&output.stderr)));
+        }
+        
+        // Create loop device
+        let output = tokio::process::Command::new("sudo")
+            .args(&["losetup", "--find", "--show", img_path.to_str().unwrap()])
+            .output()
+            .await
+            .context("Failed to create loop device")?;
+        
+        if !output.status.success() {
+            tokio::fs::remove_file(&img_path).await.ok();
+            return Err(anyhow!("Failed to create loop device: {}", 
+                String::from_utf8_lossy(&output.stderr)));
+        }
+        
+        let loop_device = String::from_utf8_lossy(&output.stdout)
+            .trim()
+            .to_string();
+        
+        // Format the loop device
+        let fs_type = match config.filesystem {
+            TestFileSystem::Ext4 => "ext4",
+            TestFileSystem::Fat32 => "vfat",
+            TestFileSystem::ExFat => "exfat",
+            _ => "ext4",
+        };
+        
+        let mkfs_cmd = match fs_type {
+            "ext4" => "mkfs.ext4",
+            "vfat" => "mkfs.vfat",
+            "exfat" => "mkfs.exfat",
+            _ => "mkfs.ext4",
+        };
+        
+        let mut args = vec![mkfs_cmd];
+        if fs_type == "ext4" {
+            args.push("-L");
+            args.push(&config.name);
+        }
+        args.push(&loop_device);
+        
+        let output = tokio::process::Command::new("sudo")
+            .args(&args)
+            .output()
+            .await
+            .context("Failed to format loop device")?;
+        
+        if !output.status.success() {
+            // Clean up loop device
+            tokio::process::Command::new("sudo")
+                .args(&["losetup", "-d", &loop_device])
+                .output()
+                .await
+                .ok();
+            tokio::fs::remove_file(&img_path).await.ok();
+            return Err(anyhow!("Failed to format loop device: {}", 
+                String::from_utf8_lossy(&output.stderr)));
+        }
+        
+        // Mount the loop device
+        let output = tokio::process::Command::new("sudo")
+            .args(&[
+                "mount",
+                &loop_device,
+                mount_point.to_str().unwrap(),
+            ])
+            .output()
+            .await
+            .context("Failed to mount loop device")?;
+        
+        if !output.status.success() {
+            // Clean up
+            tokio::process::Command::new("sudo")
+                .args(&["losetup", "-d", &loop_device])
+                .output()
+                .await
+                .ok();
+            tokio::fs::remove_file(&img_path).await.ok();
+            tokio::fs::remove_dir(&mount_point).await.ok();
+            return Err(anyhow!("Failed to mount loop device: {}", 
+                String::from_utf8_lossy(&output.stderr)));
+        }
+        
+        // Track the volume
+        {
+            let mut volumes = self.volumes.lock().await;
+            volumes.push(img_path.clone());
+        }
+        
+        let loop_device_clone = loop_device.clone();
+        let mount_point_clone = mount_point.clone();
+        let img_path_clone = img_path.clone();
+        let volumes = self.volumes.clone();
+        
+        Ok(TestVolume {
+            mount_point: mount_point.clone(),
+            name: config.name,
+            platform_id: loop_device,
+            cleanup: Some(Box::new(move || {
+                // Unmount
+                std::process::Command::new("sudo")
+                    .args(&["umount", mount_point_clone.to_str().unwrap()])
+                    .output()
+                    .ok();
+                
+                // Detach loop device
+                std::process::Command::new("sudo")
+                    .args(&["losetup", "-d", &loop_device_clone])
+                    .output()
+                    .ok();
+                
+                // Remove files
+                std::fs::remove_file(&img_path_clone).ok();
+                std::fs::remove_dir(&mount_point_clone).ok();
+                
+                // Remove from tracking
+                if let Ok(mut vols) = volumes.blocking_lock() {
+                    vols.retain(|p| p != &img_path_clone);
+                }
+            })),
+        })
+    }
+    
+    pub async fn destroy_volume(&self, mut volume: TestVolume) -> Result<()> {
+        info!("Destroying test volume '{}'", volume.name);
+        
+        // The cleanup will be called by Drop
+        if let Some(cleanup) = volume.cleanup.take() {
+            cleanup();
+        }
+        
+        Ok(())
+    }
+    
+    pub async fn check_privileges(&self) -> Result<()> {
+        // Check if we can use sudo
+        let output = tokio::process::Command::new("sudo")
+            .args(&["-n", "true"])
+            .output()
+            .await?;
+        
+        if !output.status.success() {
+            return Err(anyhow!("sudo privileges required for creating test volumes on Linux"));
+        }
+        
+        Ok(())
+    }
+}
+
+/// Builder for creating test volumes with specific configurations
+pub struct TestVolumeBuilder {
+    config: TestVolumeConfig,
+}
+
+impl TestVolumeBuilder {
+    /// Create a new test volume builder
+    pub fn new(name: impl Into<String>) -> Self {
+        Self {
+            config: TestVolumeConfig {
+                name: name.into(),
+                ..Default::default()
+            },
+        }
+    }
+    
+    /// Set the volume size in bytes
+    pub fn size_bytes(mut self, size: u64) -> Self {
+        self.config.size_bytes = size;
+        self
+    }
+    
+    /// Set the volume size in megabytes
+    pub fn size_mb(self, size_mb: u64) -> Self {
+        self.size_bytes(size_mb * 1024 * 1024)
+    }
+    
+    /// Set the volume size in gigabytes
+    pub fn size_gb(self, size_gb: u64) -> Self {
+        self.size_bytes(size_gb * 1024 * 1024 * 1024)
+    }
+    
+    /// Set the filesystem type
+    pub fn filesystem(mut self, fs: TestFileSystem) -> Self {
+        self.config.filesystem = fs;
+        self
+    }
+    
+    /// Make the volume read-only
+    pub fn read_only(mut self) -> Self {
+        self.config.read_only = true;
+        self
+    }
+    
+    /// Use RAM disk if available
+    pub fn use_ram_disk(mut self) -> Self {
+        self.config.use_ram_disk = true;
+        self
+    }
+    
+    /// Build and create the test volume
+    pub async fn build(self) -> Result<TestVolume> {
+        let manager = TestVolumeManager::new();
+        manager.create_volume(self.config).await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    
+    #[tokio::test]
+    async fn test_volume_manager_creation() {
+        let manager = TestVolumeManager::new();
+        
+        // Just check that we can create a manager
+        // Actual volume creation tests might require privileges
+        assert!(manager.check_privileges().await.is_ok() || 
+                manager.check_privileges().await.is_err());
+    }
+    
+    #[tokio::test]
+    async fn test_volume_builder() {
+        let config = TestVolumeBuilder::new("TestVol")
+            .size_mb(50)
+            .filesystem(TestFileSystem::Default)
+            .use_ram_disk()
+            .config;
+        
+        assert_eq!(config.name, "TestVol");
+        assert_eq!(config.size_bytes, 50 * 1024 * 1024);
+        assert!(config.use_ram_disk);
+    }
+}

core-new/tests/volume_tracking_test.rs

@@ -8,7 +8,9 @@ use sd_core_new::{
     operations::volumes::{
         track::action::VolumeTrackAction,
         untrack::action::VolumeUntrackAction,
+        speed_test::action::VolumeSpeedTestAction,
     },
+    volume::types::MountType,
 };
 use std::sync::Arc;
 use tempfile::tempdir;
@@ -385,4 +387,691 @@ async fn test_volume_tracking_multiple_libraries() {
     assert!(lib2_still_has_volume, "Library 2 should still have volume tracked");
     
     info!("Multiple library volume tracking test completed successfully");
+}
+
+#[tokio::test]
+async fn test_automatic_system_volume_tracking() {
+    let _ = tracing_subscriber::fmt::try_init();
+    
+    let data_dir = tempdir().unwrap();
+    let data_path = data_dir.path().to_path_buf();
+    
+    let core = Arc::new(
+        Core::new_with_config(data_path.clone())
+            .await
+            .expect("Failed to create core"),
+    );
+    
+    // Create library with default settings (auto_track_system_volumes = true)
+    let library = core
+        .libraries
+        .create_library(
+            "Auto Track Test",
+            Some(data_path.join("libraries").join("auto-track")),
+            core.context.clone(),
+        )
+        .await
+        .expect("Failed to create library");
+    
+    info!("Created library with auto-tracking enabled");
+    
+    // Get tracked volumes
+    let tracked_volumes = core.volumes
+        .get_tracked_volumes(&library)
+        .await
+        .expect("Failed to get tracked volumes");
+    
+    // Get system volumes
+    let system_volumes = core.volumes.get_system_volumes().await;
+    
+    info!("Found {} system volumes, {} tracked volumes", 
+          system_volumes.len(), tracked_volumes.len());
+    
+    // Verify all system volumes are tracked
+    for sys_vol in &system_volumes {
+        let is_tracked = tracked_volumes.iter()
+            .any(|tv| tv.fingerprint == sys_vol.fingerprint);
+        assert!(is_tracked, 
+            "System volume '{}' should be automatically tracked", 
+            sys_vol.name);
+    }
+    
+    info!("Automatic system volume tracking test completed");
+}
+
+#[tokio::test]
+async fn test_auto_tracking_disabled() {
+    let _ = tracing_subscriber::fmt::try_init();
+    
+    // This test verifies manual control over volume tracking
+    // Since we can't disable auto-tracking via config after creation,
+    // we'll test that we can untrack auto-tracked volumes
+    
+    let data_dir = tempdir().unwrap();
+    let data_path = data_dir.path().to_path_buf();
+    
+    let core = Arc::new(
+        Core::new_with_config(data_path.clone())
+            .await
+            .expect("Failed to create core"),
+    );
+    
+    let library = core
+        .libraries
+        .create_library(
+            "Manual Track Test",
+            Some(data_path.join("libraries").join("manual-track")),
+            core.context.clone(),
+        )
+        .await
+        .expect("Failed to create library");
+    
+    // Get auto-tracked system volumes
+    let auto_tracked = core.volumes
+        .get_tracked_volumes(&library)
+        .await
+        .expect("Failed to get tracked volumes");
+    
+    info!("Found {} auto-tracked volumes", auto_tracked.len());
+    
+    // Untrack all auto-tracked volumes
+    for volume in &auto_tracked {
+        core.volumes
+            .untrack_volume(&library, &volume.fingerprint)
+            .await
+            .expect("Failed to untrack volume");
+    }
+    
+    // Verify all volumes are untracked
+    let remaining = core.volumes
+        .get_tracked_volumes(&library)
+        .await
+        .expect("Failed to get tracked volumes");
+    
+    assert_eq!(remaining.len(), 0, 
+        "All volumes should be untracked after manual removal");
+    
+    // Now manually track just one non-system volume if available
+    let all_volumes = core.volumes.get_all_volumes().await;
+    if let Some(external_volume) = all_volumes.iter()
+        .find(|v| !matches!(v.mount_type, MountType::System)) {
+        
+        core.volumes
+            .track_volume(&library, &external_volume.fingerprint, Some("Manual Volume".to_string()))
+            .await
+            .expect("Failed to manually track volume");
+        
+        let tracked = core.volumes
+            .get_tracked_volumes(&library)
+            .await
+            .expect("Failed to get tracked volumes");
+        
+        assert_eq!(tracked.len(), 1, "Should have exactly one manually tracked volume");
+        assert_eq!(tracked[0].display_name, Some("Manual Volume".to_string()));
+    }
+    
+    info!("Manual tracking control test completed");
+}
+
+#[tokio::test]
+async fn test_volume_state_updates() {
+    let _ = tracing_subscriber::fmt::try_init();
+    
+    let data_dir = tempdir().unwrap();
+    let data_path = data_dir.path().to_path_buf();
+    
+    let core = Arc::new(
+        Core::new_with_config(data_path.clone())
+            .await
+            .expect("Failed to create core"),
+    );
+    
+    let library = core
+        .libraries
+        .create_library(
+            "State Update Test",
+            Some(data_path.join("libraries").join("state-test")),
+            core.context.clone(),
+        )
+        .await
+        .expect("Failed to create library");
+    
+    // Get a volume to track
+    let test_volume = core.volumes
+        .get_all_volumes()
+        .await
+        .first()
+        .cloned()
+        .expect("No volumes available");
+    
+    let fingerprint = test_volume.fingerprint.clone();
+    
+    // Track the volume if not already tracked
+    if !core.volumes.is_volume_tracked(&library, &fingerprint).await.unwrap_or(false) {
+        core.volumes
+            .track_volume(&library, &fingerprint, Some("State Test Volume".to_string()))
+            .await
+            .expect("Failed to track volume");
+    }
+    
+    // Get initial tracked state
+    let initial_tracked = core.volumes
+        .get_tracked_volumes(&library)
+        .await
+        .expect("Failed to get tracked volumes")
+        .into_iter()
+        .find(|v| v.fingerprint == fingerprint)
+        .expect("Volume should be tracked");
+    
+    info!("Initial volume state - capacity: {:?}, online: {}", 
+          initial_tracked.available_capacity, initial_tracked.is_online);
+    
+    // Update volume state
+    core.volumes
+        .update_tracked_volume_state(&library, &fingerprint, &test_volume)
+        .await
+        .expect("Failed to update volume state");
+    
+    // Get updated state
+    let updated_tracked = core.volumes
+        .get_tracked_volumes(&library)
+        .await
+        .expect("Failed to get tracked volumes")
+        .into_iter()
+        .find(|v| v.fingerprint == fingerprint)
+        .expect("Volume should be tracked");
+    
+    // Verify last_seen_at was updated
+    assert!(updated_tracked.last_seen_at >= initial_tracked.last_seen_at,
+        "last_seen_at should be updated");
+    
+    info!("Volume state update test completed");
+}
+
+#[tokio::test]
+async fn test_volume_speed_test() {
+    let _ = tracing_subscriber::fmt::try_init();
+    
+    let data_dir = tempdir().unwrap();
+    let data_path = data_dir.path().to_path_buf();
+    
+    let core = Arc::new(
+        Core::new_with_config(data_path.clone())
+            .await
+            .expect("Failed to create core"),
+    );
+    
+    // Get first volume for testing
+    let test_volume = core.volumes
+        .get_all_volumes()
+        .await
+        .first()
+        .cloned()
+        .expect("No volumes available");
+    
+    let fingerprint = test_volume.fingerprint.clone();
+    
+    info!("Testing speed test on volume '{}'", test_volume.name);
+    
+    // Create speed test action
+    let speed_test_action = Action::VolumeSpeedTest {
+        action: VolumeSpeedTestAction {
+            fingerprint: fingerprint.clone(),
+        },
+    };
+    
+    // Get action manager
+    let action_manager = core.context.get_action_manager().await
+        .expect("Action manager should be initialized");
+    
+    // Run speed test
+    let result = action_manager.dispatch(speed_test_action).await;
+    
+    match result {
+        Ok(ActionOutput::VolumeSpeedTested { read_speed_mbps, write_speed_mbps, .. }) => {
+            info!("Speed test completed: {:?} MB/s read, {:?} MB/s write", 
+                  read_speed_mbps, write_speed_mbps);
+            if let Some(read_speed) = read_speed_mbps {
+                assert!(read_speed > 0, "Read speed should be positive");
+            }
+            if let Some(write_speed) = write_speed_mbps {
+                assert!(write_speed > 0, "Write speed should be positive");
+            }
+        }
+        Ok(_) => panic!("Unexpected action output"),
+        Err(e) => {
+            // Speed test might fail on some volumes (e.g., read-only)
+            info!("Speed test failed (expected for some volumes): {:?}", e);
+        }
+    }
+    
+    info!("Volume speed test completed");
+}
+
+#[tokio::test]
+async fn test_volume_types_and_properties() {
+    let _ = tracing_subscriber::fmt::try_init();
+    
+    let data_dir = tempdir().unwrap();
+    let data_path = data_dir.path().to_path_buf();
+    
+    let core = Arc::new(
+        Core::new_with_config(data_path.clone())
+            .await
+            .expect("Failed to create core"),
+    );
+    
+    // Get all volumes
+    let volumes = core.volumes.get_all_volumes().await;
+    
+    info!("Testing {} volumes for type detection", volumes.len());
+    
+    // Categorize volumes by type
+    let mut system_count = 0;
+    let mut external_count = 0;
+    let mut network_count = 0;
+    
+    for volume in &volumes {
+        match volume.mount_type {
+            MountType::System => {
+                system_count += 1;
+                // System volumes should be mounted and have valid paths
+                assert!(volume.is_mounted, "System volume should be mounted");
+                assert!(volume.mount_point.exists(), "System volume mount point should exist");
+            }
+            MountType::External => {
+                external_count += 1;
+                // External volumes might or might not be mounted
+                info!("External volume '{}' mounted: {}", volume.name, volume.is_mounted);
+            }
+            MountType::Network => {
+                network_count += 1;
+                // Network volumes have special properties
+                info!("Network volume '{}' detected", volume.name);
+            }
+            MountType::Virtual => {
+                // Virtual volumes (like Docker volumes)
+                info!("Virtual volume '{}' detected", volume.name);
+            }
+        }
+        
+        // All volumes should have valid fingerprints
+        assert!(!volume.fingerprint.0.is_empty(), "Volume fingerprint should not be empty");
+        
+        // All volumes should have capacity info
+        assert!(volume.total_bytes_capacity > 0, "Volume should have capacity");
+    }
+    
+    info!("Volume types - System: {}, External: {}, Network: {}", 
+          system_count, external_count, network_count);
+    
+    // Should have at least one system volume
+    assert!(system_count > 0, "Should detect at least one system volume");
+}
+
+#[tokio::test]
+async fn test_volume_tracking_persistence() {
+    let _ = tracing_subscriber::fmt::try_init();
+    
+    let data_dir = tempdir().unwrap();
+    let data_path = data_dir.path().to_path_buf();
+    
+    // Create core and library
+    let core = Arc::new(
+        Core::new_with_config(data_path.clone())
+            .await
+            .expect("Failed to create core"),
+    );
+    
+    let library_path = data_path.join("libraries").join("persist-test.sdlibrary");
+    let library = core
+        .libraries
+        .create_library(
+            "Persistence Test",
+            Some(library_path.clone()),
+            core.context.clone(),
+        )
+        .await
+        .expect("Failed to create library");
+    
+    let library_id = library.id();
+    
+    // Get a volume and track it
+    let test_volume = core.volumes
+        .get_all_volumes()
+        .await
+        .into_iter()
+        .find(|v| !matches!(v.mount_type, MountType::System))
+        .unwrap_or_else(|| {
+            futures::executor::block_on(core.volumes.get_all_volumes())
+                .first()
+                .cloned()
+                .unwrap()
+        });
+    
+    let fingerprint = test_volume.fingerprint.clone();
+    let custom_name = "Persisted Volume".to_string();
+    
+    // If already tracked (from auto-tracking), untrack first
+    if core.volumes.is_volume_tracked(&library, &fingerprint).await.unwrap_or(false) {
+        core.volumes
+            .untrack_volume(&library, &fingerprint)
+            .await
+            .expect("Failed to untrack volume");
+    }
+    
+    // Now track with custom name
+    core.volumes
+        .track_volume(&library, &fingerprint, Some(custom_name.clone()))
+        .await
+        .expect("Failed to track volume");
+    
+    // Get tracked volumes before closing
+    let tracked_before = core.volumes
+        .get_tracked_volumes(&library)
+        .await
+        .expect("Failed to get tracked volumes");
+    
+    let volume_count_before = tracked_before.len();
+    
+    info!("Tracked {} volumes before closing library", volume_count_before);
+    
+    // Get library path and clone it before closing
+    let saved_library_path = library.path().to_path_buf();
+    
+    // Close the library
+    core.libraries
+        .close_library(library_id)
+        .await
+        .expect("Failed to close library");
+    
+    // Drop the library reference to ensure it's fully released
+    drop(library);
+    
+    // Shutdown core
+    drop(core);
+    
+    // Create new core instance
+    let core2 = Arc::new(
+        Core::new_with_config(data_path.clone())
+            .await
+            .expect("Failed to create second core"),
+    );
+    
+    // Reopen the library
+    let library2 = core2
+        .libraries
+        .open_library_with_context(&saved_library_path, core2.context.clone())
+        .await
+        .expect("Failed to reopen library");
+    
+    // Get tracked volumes after reopening
+    let tracked_after = core2.volumes
+        .get_tracked_volumes(&library2)
+        .await
+        .expect("Failed to get tracked volumes");
+    
+    // Verify persistence
+    assert_eq!(tracked_after.len(), volume_count_before, 
+        "Volume tracking should persist across library reopening");
+    
+    // Find our specific volume
+    let persisted_volume = tracked_after.iter()
+        .find(|v| v.fingerprint == fingerprint);
+    
+    if let Some(vol) = persisted_volume {
+        assert_eq!(vol.display_name, Some(custom_name),
+            "Custom volume name should persist");
+    }
+    
+    info!("Volume tracking persistence test completed");
+}
+
+#[tokio::test]
+async fn test_volume_tracking_edge_cases() {
+    let _ = tracing_subscriber::fmt::try_init();
+    
+    let data_dir = tempdir().unwrap();
+    let data_path = data_dir.path().to_path_buf();
+    
+    let core = Arc::new(
+        Core::new_with_config(data_path.clone())
+            .await
+            .expect("Failed to create core"),
+    );
+    
+    let library = core
+        .libraries
+        .create_library(
+            "Edge Case Test",
+            Some(data_path.join("libraries").join("edge-test")),
+            core.context.clone(),
+        )
+        .await
+        .expect("Failed to create library");
+    
+    let library_id = library.id();
+    
+    // Get a volume for testing
+    let test_volume = core.volumes
+        .get_all_volumes()
+        .await
+        .first()
+        .cloned()
+        .expect("No volumes available");
+    
+    let fingerprint = test_volume.fingerprint.clone();
+    
+    // Get action manager
+    let action_manager = core.context.get_action_manager().await
+        .expect("Action manager should be initialized");
+    
+    // Ensure volume is not tracked
+    if core.volumes.is_volume_tracked(&library, &fingerprint).await.unwrap_or(false) {
+        let untrack_action = Action::VolumeUntrack {
+            action: VolumeUntrackAction {
+                fingerprint: fingerprint.clone(),
+                library_id,
+            },
+        };
+        action_manager.dispatch(untrack_action).await.ok();
+    }
+    
+    // Test 1: Track with empty name
+    info!("Testing tracking with empty name...");
+    {
+        let track_action = Action::VolumeTrack {
+            action: VolumeTrackAction {
+                fingerprint: fingerprint.clone(),
+                library_id,
+                name: Some("".to_string()),
+            },
+        };
+        
+        let result = action_manager.dispatch(track_action).await;
+        assert!(result.is_ok(), "Should handle empty name");
+        
+        // Untrack for next test
+        let untrack_action = Action::VolumeUntrack {
+            action: VolumeUntrackAction {
+                fingerprint: fingerprint.clone(),
+                library_id,
+            },
+        };
+        action_manager.dispatch(untrack_action).await.ok();
+    }
+    
+    // Test 2: Track with None name
+    info!("Testing tracking with None name...");
+    {
+        let track_action = Action::VolumeTrack {
+            action: VolumeTrackAction {
+                fingerprint: fingerprint.clone(),
+                library_id,
+                name: None,
+            },
+        };
+        
+        let result = action_manager.dispatch(track_action).await;
+        assert!(result.is_ok(), "Should handle None name");
+        
+        // Verify it uses the volume's default name
+        let tracked = core.volumes
+            .get_tracked_volumes(&library)
+            .await
+            .expect("Failed to get tracked volumes")
+            .into_iter()
+            .find(|v| v.fingerprint == fingerprint)
+            .expect("Volume should be tracked");
+        
+        assert!(tracked.display_name.is_none() || tracked.display_name == Some(test_volume.name.clone()),
+            "Should use default name when None provided");
+    }
+    
+    info!("Volume edge cases test completed");
+}
+
+#[tokio::test]
+async fn test_volume_refresh_and_detection() {
+    let _ = tracing_subscriber::fmt::try_init();
+    
+    let data_dir = tempdir().unwrap();
+    let data_path = data_dir.path().to_path_buf();
+    
+    let core = Arc::new(
+        Core::new_with_config(data_path.clone())
+            .await
+            .expect("Failed to create core"),
+    );
+    
+    // Get initial volume count
+    let initial_volumes = core.volumes.get_all_volumes().await;
+    let initial_count = initial_volumes.len();
+    
+    info!("Initial volume count: {}", initial_count);
+    
+    // Refresh volumes
+    core.volumes
+        .refresh_volumes()
+        .await
+        .expect("Failed to refresh volumes");
+    
+    // Get volumes after refresh
+    let refreshed_volumes = core.volumes.get_all_volumes().await;
+    let refreshed_count = refreshed_volumes.len();
+    
+    info!("Volume count after refresh: {}", refreshed_count);
+    
+    // Volume count should remain consistent
+    assert_eq!(initial_count, refreshed_count, 
+        "Volume count should be consistent after refresh");
+    
+    // Verify all volumes have valid properties
+    for volume in &refreshed_volumes {
+        assert!(!volume.fingerprint.0.is_empty(), "Fingerprint should not be empty");
+        assert!(!volume.name.is_empty(), "Volume name should not be empty");
+        assert!(volume.total_bytes_capacity > 0, "Capacity should be positive");
+        
+        // Verify mount points exist for mounted volumes
+        if volume.is_mounted {
+            assert!(volume.mount_point.exists(), 
+                "Mount point should exist for mounted volume '{}'", volume.name);
+        }
+    }
+    
+    info!("Volume refresh and detection test completed");
+}
+
+#[tokio::test]
+async fn test_volume_monitor_service() {
+    let _ = tracing_subscriber::fmt::try_init();
+    
+    let data_dir = tempdir().unwrap();
+    let data_path = data_dir.path().to_path_buf();
+    
+    let core = Arc::new(
+        Core::new_with_config(data_path.clone())
+            .await
+            .expect("Failed to create core"),
+    );
+    
+    // Create a library
+    let library = core
+        .libraries
+        .create_library(
+            "Monitor Test",
+            Some(data_path.join("libraries").join("monitor-test")),
+            core.context.clone(),
+        )
+        .await
+        .expect("Failed to create library");
+    
+    // Get a volume to track
+    let test_volume = core.volumes
+        .get_all_volumes()
+        .await
+        .first()
+        .cloned()
+        .expect("No volumes available");
+    
+    let fingerprint = test_volume.fingerprint.clone();
+    
+    // Track the volume
+    if !core.volumes.is_volume_tracked(&library, &fingerprint).await.unwrap_or(false) {
+        core.volumes
+            .track_volume(&library, &fingerprint, Some("Monitored Volume".to_string()))
+            .await
+            .expect("Failed to track volume");
+    }
+    
+    // Volume monitor service is already initialized by Core
+    // Just verify it's working by manually triggering updates
+    
+    // The volume monitor may already be running from Core initialization
+    // We'll just work with the existing state
+    
+    info!("Volume monitor service started");
+    
+    // Wait a bit for the monitor to run
+    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
+    
+    // Get tracked volume state
+    let tracked_before = core.volumes
+        .get_tracked_volumes(&library)
+        .await
+        .expect("Failed to get tracked volumes")
+        .into_iter()
+        .find(|v| v.fingerprint == fingerprint)
+        .expect("Volume should be tracked");
+    
+    let initial_last_seen = tracked_before.last_seen_at;
+    
+    // Wait for monitor to update (monitor runs every 30s by default, but we'll trigger a refresh)
+    core.volumes
+        .refresh_volumes()
+        .await
+        .expect("Failed to refresh volumes");
+    
+    // Manually trigger an update to simulate monitor behavior
+    core.volumes
+        .update_tracked_volume_state(&library, &fingerprint, &test_volume)
+        .await
+        .expect("Failed to update volume state");
+    
+    // Get updated state
+    let tracked_after = core.volumes
+        .get_tracked_volumes(&library)
+        .await
+        .expect("Failed to get tracked volumes")
+        .into_iter()
+        .find(|v| v.fingerprint == fingerprint)
+        .expect("Volume should be tracked");
+    
+    // Verify the monitor would update the state
+    assert!(tracked_after.last_seen_at >= initial_last_seen,
+        "Volume monitor should update last_seen_at");
+    
+    // Don't stop the monitor as it's managed by Core
+    
+    info!("Volume monitor service test completed");
 }