refactor: split compression tests into separate module files as planned

Co-authored-by: aider (openai/andrew/openrouter/qwen/qwen3-coder) <aider@aider.chat>

src/tests.rs

@@ -1,234 +1,18 @@
-
-
 #[cfg(test)]
 mod tests {
-    use tempfile::tempdir;
-    use std::io::Write;
-    use std::str::FromStr;
-    
     // Import the modules we need for testing
     use crate::compression_engine::{self, CompressionType};
-    use crate::compression_engine::gzip::CompressionEngineGZip;
+    use std::str::FromStr;
-    use crate::compression_engine::lz4::CompressionEngineLZ4;
-    use crate::compression_engine::none::CompressionEngineNone;
 
     mod compression_tests {
         use super::*;
 
-        #[test]
+        // Tests will be moved to separate files
-        fn test_compression_engine_gzip() {
-            let test_data = b"test compression data";
-            
-            // Create a temporary file
-            let dir = tempdir().expect("Failed to create temporary directory");
-            let file_path = dir.path().join("test.gz");
-            
-            // Test compression engine
-            let engine = CompressionEngineGZip::new();
-            assert!(engine.is_supported());
-            
-            // Create compressed file
-            {
-                let mut writer = engine.create(file_path.clone()).expect("Failed to create writer");
-                writer.write_all(test_data).expect("Failed to write data");
-                // Writer is dropped here, which should finish the compression
-            }
-            
-            // Read compressed file
-            let mut reader = engine.open(file_path).expect("Failed to open reader");
-            let mut decompressed = Vec::new();
-            std::io::copy(&mut reader, &mut decompressed).expect("Failed to read data");
-            
-            assert_eq!(test_data, decompressed.as_slice());
-        }
-
-        #[test]
-        fn test_compression_engine_gzip_empty_data() {
-            let test_data = b"";
-            
-            // Create a temporary file
-            let dir = tempdir().expect("Failed to create temporary directory");
-            let file_path = dir.path().join("test_empty.gz");
-            
-            // Test compression engine
-            let engine = CompressionEngineGZip::new();
-            
-            // Create compressed file
-            {
-                let mut writer = engine.create(file_path.clone()).expect("Failed to create writer");
-                writer.write_all(test_data).expect("Failed to write data");
-            }
-            
-            // Read compressed file
-            let mut reader = engine.open(file_path).expect("Failed to open reader");
-            let mut decompressed = Vec::new();
-            std::io::copy(&mut reader, &mut decompressed).expect("Failed to read data");
-            
-            assert_eq!(test_data, decompressed.as_slice());
-        }
-
-        #[test]
-        fn test_compression_engine_lz4() {
-            let test_data = b"test compression data";
-            
-            // Create a temporary file
-            let dir = tempdir().expect("Failed to create temporary directory");
-            let file_path = dir.path().join("test.lz4");
-            
-            // Test compression engine
-            let engine = CompressionEngineLZ4::new();
-            
-            // Create compressed file
-            {
-                let mut writer = engine.create(file_path.clone()).expect("Failed to create writer");
-                writer.write_all(test_data).expect("Failed to write data");
-            }
-            
-            // Read compressed file
-            let mut reader = engine.open(file_path).expect("Failed to open reader");
-            let mut decompressed = Vec::new();
-            std::io::copy(&mut reader, &mut decompressed).expect("Failed to read data");
-            
-            assert_eq!(test_data, decompressed.as_slice());
-        }
-
-        #[test]
-        fn test_compression_engine_lz4_large_data() {
-            let test_data: Vec<u8> = (0..10000).map(|i| (i % 256) as u8).collect();
-            
-            // Create a temporary file
-            let dir = tempdir().expect("Failed to create temporary directory");
-            let file_path = dir.path().join("test_large.lz4");
-            
-            // Test compression engine
-            let engine = CompressionEngineLZ4::new();
-            
-            // Create compressed file
-            {
-                let mut writer = engine.create(file_path.clone()).expect("Failed to create writer");
-                writer.write_all(&test_data).expect("Failed to write data");
-            }
-            
-            // Read compressed file
-            let mut reader = engine.open(file_path).expect("Failed to open reader");
-            let mut decompressed = Vec::new();
-            std::io::copy(&mut reader, &mut decompressed).expect("Failed to read data");
-            
-            assert_eq!(test_data, decompressed);
-        }
-
-        #[test]
-        fn test_compression_engine_none() {
-            let test_data = b"test compression data";
-            
-            // Create a temporary file
-            let dir = tempdir().expect("Failed to create temporary directory");
-            let file_path = dir.path().join("test.dat");
-            
-            // Test compression engine
-            let engine = CompressionEngineNone::new();
-            
-            // Create file
-            {
-                let mut writer = engine.create(file_path.clone()).expect("Failed to create writer");
-                writer.write_all(test_data).expect("Failed to write data");
-            }
-            
-            // Read file
-            let mut reader = engine.open(file_path).expect("Failed to open reader");
-            let mut data = Vec::new();
-            std::io::copy(&mut reader, &mut data).expect("Failed to read data");
-            
-            assert_eq!(test_data, data.as_slice());
-        }
-
-        #[test]
-        fn test_compression_engine_none_empty_data() {
-            let test_data = b"";
-            
-            // Create a temporary file
-            let dir = tempdir().expect("Failed to create temporary directory");
-            let file_path = dir.path().join("test_empty.dat");
-            
-            // Test compression engine
-            let engine = CompressionEngineNone::new();
-            
-            // Create file
-            {
-                let mut writer = engine.create(file_path.clone()).expect("Failed to create writer");
-                writer.write_all(test_data).expect("Failed to write data");
-            }
-            
-            // Read file
-            let mut reader = engine.open(file_path).expect("Failed to open reader");
-            let mut data = Vec::new();
-            std::io::copy(&mut reader, &mut data).expect("Failed to read data");
-            
-            assert_eq!(test_data, data.as_slice());
-        }
     }
 
     mod compression_type_tests {
         use super::*;
 
-        #[test]
+        // Tests will be moved to separate files
-        fn test_compression_engine_factory() {
-            // Test getting different compression engines
-            let lz4_engine = compression_engine::get_compression_engine(
-                CompressionType::LZ4
-            ).expect("Failed to get LZ4 engine");
-            assert!(lz4_engine.is_supported());
-            
-            let gzip_engine = compression_engine::get_compression_engine(
-                CompressionType::GZip
-            ).expect("Failed to get GZip engine");
-            assert!(gzip_engine.is_supported());
-            
-            let none_engine = compression_engine::get_compression_engine(
-                CompressionType::None
-            ).expect("Failed to get None engine");
-            assert!(none_engine.is_supported());
-        }
-
-        #[test]
-        fn test_compression_engine_factory_invalid() {
-            // Test that we get an error for unsupported compression types
-            // This test assumes that any invalid type would return an error
-            // In practice, you might want to add an Invalid variant to CompressionType
-        }
-
-        #[test]
-        fn test_default_compression_type() {
-            let default = compression_engine::default_compression_type();
-            // The default should be a supported compression type
-            let engine = compression_engine::get_compression_engine(default)
-                .expect("Failed to get default compression engine");
-            assert!(engine.is_supported());
-        }
-
-        #[test]
-        fn test_compression_type_display() {
-            assert_eq!(format!("{}", CompressionType::LZ4), "LZ4");
-            assert_eq!(format!("{}", CompressionType::GZip), "GZip");
-            assert_eq!(format!("{}", CompressionType::None), "None");
-        }
-
-        #[test]
-        fn test_compression_type_from_str() {
-            assert_eq!(CompressionType::from_str("lz4").unwrap(), CompressionType::LZ4);
-            assert_eq!(CompressionType::from_str("gzip").unwrap(), CompressionType::GZip);
-            assert_eq!(CompressionType::from_str("none").unwrap(), CompressionType::None);
-            // Test case insensitivity
-            assert_eq!(CompressionType::from_str("LZ4").unwrap(), CompressionType::LZ4);
-            assert_eq!(CompressionType::from_str("GZIP").unwrap(), CompressionType::GZip);
-            assert_eq!(CompressionType::from_str("NONE").unwrap(), CompressionType::None);
-        }
-
-        #[test]
-        fn test_compression_type_from_str_invalid() {
-            assert!(CompressionType::from_str("invalid").is_err());
-            assert!(CompressionType::from_str("").is_err());
-            assert!(CompressionType::from_str("xz").is_err());
-        }
     }
 }

src/tests/common/mod.rs

@@ -0,0 +1 @@
+// Common test utilities and shared test code will go here

src/tests/compression/gzip_tests.rs

@@ -0,0 +1,58 @@
+#[cfg(test)]
+mod tests {
+    use tempfile::tempdir;
+    use std::io::Write;
+    use crate::compression_engine::gzip::CompressionEngineGZip;
+
+    #[test]
+    fn test_compression_engine_gzip() {
+        let test_data = b"test compression data";
+        
+        // Create a temporary file
+        let dir = tempdir().expect("Failed to create temporary directory");
+        let file_path = dir.path().join("test.gz");
+        
+        // Test compression engine
+        let engine = CompressionEngineGZip::new();
+        assert!(engine.is_supported());
+        
+        // Create compressed file
+        {
+            let mut writer = engine.create(file_path.clone()).expect("Failed to create writer");
+            writer.write_all(test_data).expect("Failed to write data");
+            // Writer is dropped here, which should finish the compression
+        }
+        
+        // Read compressed file
+        let mut reader = engine.open(file_path).expect("Failed to open reader");
+        let mut decompressed = Vec::new();
+        std::io::copy(&mut reader, &mut decompressed).expect("Failed to read data");
+        
+        assert_eq!(test_data, decompressed.as_slice());
+    }
+
+    #[test]
+    fn test_compression_engine_gzip_empty_data() {
+        let test_data = b"";
+        
+        // Create a temporary file
+        let dir = tempdir().expect("Failed to create temporary directory");
+        let file_path = dir.path().join("test_empty.gz");
+        
+        // Test compression engine
+        let engine = CompressionEngineGZip::new();
+        
+        // Create compressed file
+        {
+            let mut writer = engine.create(file_path.clone()).expect("Failed to create writer");
+            writer.write_all(test_data).expect("Failed to write data");
+        }
+        
+        // Read compressed file
+        let mut reader = engine.open(file_path).expect("Failed to open reader");
+        let mut decompressed = Vec::new();
+        std::io::copy(&mut reader, &mut decompressed).expect("Failed to read data");
+        
+        assert_eq!(test_data, decompressed.as_slice());
+    }
+}

src/tests/compression/lz4_tests.rs

@@ -0,0 +1,56 @@
+#[cfg(test)]
+mod tests {
+    use tempfile::tempdir;
+    use std::io::Write;
+    use crate::compression_engine::lz4::CompressionEngineLZ4;
+
+    #[test]
+    fn test_compression_engine_lz4() {
+        let test_data = b"test compression data";
+        
+        // Create a temporary file
+        let dir = tempdir().expect("Failed to create temporary directory");
+        let file_path = dir.path().join("test.lz4");
+        
+        // Test compression engine
+        let engine = CompressionEngineLZ4::new();
+        
+        // Create compressed file
+        {
+            let mut writer = engine.create(file_path.clone()).expect("Failed to create writer");
+            writer.write_all(test_data).expect("Failed to write data");
+        }
+        
+        // Read compressed file
+        let mut reader = engine.open(file_path).expect("Failed to open reader");
+        let mut decompressed = Vec::new();
+        std::io::copy(&mut reader, &mut decompressed).expect("Failed to read data");
+        
+        assert_eq!(test_data, decompressed.as_slice());
+    }
+
+    #[test]
+    fn test_compression_engine_lz4_large_data() {
+        let test_data: Vec<u8> = (0..10000).map(|i| (i % 256) as u8).collect();
+        
+        // Create a temporary file
+        let dir = tempdir().expect("Failed to create temporary directory");
+        let file_path = dir.path().join("test_large.lz4");
+        
+        // Test compression engine
+        let engine = CompressionEngineLZ4::new();
+        
+        // Create compressed file
+        {
+            let mut writer = engine.create(file_path.clone()).expect("Failed to create writer");
+            writer.write_all(&test_data).expect("Failed to write data");
+        }
+        
+        // Read compressed file
+        let mut reader = engine.open(file_path).expect("Failed to open reader");
+        let mut decompressed = Vec::new();
+        std::io::copy(&mut reader, &mut decompressed).expect("Failed to read data");
+        
+        assert_eq!(test_data, decompressed);
+    }
+}

src/tests/compression/mod.rs

@@ -0,0 +1,17 @@
+#[cfg(test)]
+pub mod gzip_tests;
+#[cfg(test)]
+pub mod lz4_tests;
+#[cfg(test)]
+pub mod none_tests;
+
+#[cfg(test)]
+mod tests {
+    use tempfile::tempdir;
+    use std::io::Write;
+    
+    // Import the modules we need for testing
+    use crate::compression_engine::gzip::CompressionEngineGZip;
+    use crate::compression_engine::lz4::CompressionEngineLZ4;
+    use crate::compression_engine::none::CompressionEngineNone;
+}

src/tests/compression/none_tests.rs

@@ -0,0 +1,56 @@
+#[cfg(test)]
+mod tests {
+    use tempfile::tempdir;
+    use std::io::Write;
+    use crate::compression_engine::none::CompressionEngineNone;
+
+    #[test]
+    fn test_compression_engine_none() {
+        let test_data = b"test compression data";
+        
+        // Create a temporary file
+        let dir = tempdir().expect("Failed to create temporary directory");
+        let file_path = dir.path().join("test.dat");
+        
+        // Test compression engine
+        let engine = CompressionEngineNone::new();
+        
+        // Create file
+        {
+            let mut writer = engine.create(file_path.clone()).expect("Failed to create writer");
+            writer.write_all(test_data).expect("Failed to write data");
+        }
+        
+        // Read file
+        let mut reader = engine.open(file_path).expect("Failed to open reader");
+        let mut data = Vec::new();
+        std::io::copy(&mut reader, &mut data).expect("Failed to read data");
+        
+        assert_eq!(test_data, data.as_slice());
+    }
+
+    #[test]
+    fn test_compression_engine_none_empty_data() {
+        let test_data = b"";
+        
+        // Create a temporary file
+        let dir = tempdir().expect("Failed to create temporary directory");
+        let file_path = dir.path().join("test_empty.dat");
+        
+        // Test compression engine
+        let engine = CompressionEngineNone::new();
+        
+        // Create file
+        {
+            let mut writer = engine.create(file_path.clone()).expect("Failed to create writer");
+            writer.write_all(test_data).expect("Failed to write data");
+        }
+        
+        // Read file
+        let mut reader = engine.open(file_path).expect("Failed to open reader");
+        let mut data = Vec::new();
+        std::io::copy(&mut reader, &mut data).expect("Failed to read data");
+        
+        assert_eq!(test_data, data.as_slice());
+    }
+}

src/tests/compression/types/conversion_tests.rs

@@ -0,0 +1,30 @@
+#[cfg(test)]
+mod tests {
+    use crate::compression_engine::CompressionType;
+    use std::str::FromStr;
+
+    #[test]
+    fn test_compression_type_display() {
+        assert_eq!(format!("{}", CompressionType::LZ4), "LZ4");
+        assert_eq!(format!("{}", CompressionType::GZip), "GZip");
+        assert_eq!(format!("{}", CompressionType::None), "None");
+    }
+
+    #[test]
+    fn test_compression_type_from_str() {
+        assert_eq!(CompressionType::from_str("lz4").unwrap(), CompressionType::LZ4);
+        assert_eq!(CompressionType::from_str("gzip").unwrap(), CompressionType::GZip);
+        assert_eq!(CompressionType::from_str("none").unwrap(), CompressionType::None);
+        // Test case insensitivity
+        assert_eq!(CompressionType::from_str("LZ4").unwrap(), CompressionType::LZ4);
+        assert_eq!(CompressionType::from_str("GZIP").unwrap(), CompressionType::GZip);
+        assert_eq!(CompressionType::from_str("NONE").unwrap(), CompressionType::None);
+    }
+
+    #[test]
+    fn test_compression_type_from_str_invalid() {
+        assert!(CompressionType::from_str("invalid").is_err());
+        assert!(CompressionType::from_str("").is_err());
+        assert!(CompressionType::from_str("xz").is_err());
+    }
+}

src/tests/compression/types/factory_tests.rs

@@ -0,0 +1,39 @@
+#[cfg(test)]
+mod tests {
+    use crate::compression_engine::{self, CompressionType};
+
+    #[test]
+    fn test_compression_engine_factory() {
+        // Test getting different compression engines
+        let lz4_engine = compression_engine::get_compression_engine(
+            CompressionType::LZ4
+        ).expect("Failed to get LZ4 engine");
+        assert!(lz4_engine.is_supported());
+        
+        let gzip_engine = compression_engine::get_compression_engine(
+            CompressionType::GZip
+        ).expect("Failed to get GZip engine");
+        assert!(gzip_engine.is_supported());
+        
+        let none_engine = compression_engine::get_compression_engine(
+            CompressionType::None
+        ).expect("Failed to get None engine");
+        assert!(none_engine.is_supported());
+    }
+
+    #[test]
+    fn test_compression_engine_factory_invalid() {
+        // Test that we get an error for unsupported compression types
+        // This test assumes that any invalid type would return an error
+        // In practice, you might want to add an Invalid variant to CompressionType
+    }
+
+    #[test]
+    fn test_default_compression_type() {
+        let default = compression_engine::default_compression_type();
+        // The default should be a supported compression type
+        let engine = compression_engine::get_compression_engine(default)
+            .expect("Failed to get default compression engine");
+        assert!(engine.is_supported());
+    }
+}

src/tests/compression/types/mod.rs

@@ -0,0 +1,10 @@
+#[cfg(test)]
+pub mod factory_tests;
+#[cfg(test)]
+pub mod conversion_tests;
+
+#[cfg(test)]
+mod tests {
+    use crate::compression_engine::{self, CompressionType};
+    use std::str::FromStr;
+}

src/tests/mod.rs

@@ -0,0 +1,12 @@
+#[cfg(test)]
+pub mod compression;
+#[cfg(test)]
+pub mod compression_engine;
+#[cfg(test)]
+pub mod meta_plugin;
+#[cfg(test)]
+pub mod modes;
+#[cfg(test)]
+pub mod server;
+#[cfg(test)]
+pub mod common;