fix: update test files to use correct compression engine initialization and add compression_types tests

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

src/tests/compression/gzip_tests.rs

@@ -3,6 +3,7 @@ mod tests {
     use tempfile::tempdir;
     use std::io::Write;
     use keep::compression_engine::gzip::CompressionEngineGZip;
+    use keep::compression_engine::CompressionEngine;
 
     #[test]
     fn test_compression_engine_gzip() {
@@ -13,7 +14,7 @@ mod tests {
         let file_path = dir.path().join("test.gz");
         
         // Test compression engine
-        let engine = CompressionEngineGZip::new();
+        let engine = CompressionEngineGZip {};
         assert!(engine.is_supported());
         
         // Create compressed file
@@ -40,7 +41,7 @@ mod tests {
         let file_path = dir.path().join("test_empty.gz");
         
         // Test compression engine
-        let engine = CompressionEngineGZip::new();
+        let engine = CompressionEngineGZip {};
         
         // Create compressed file
         {

src/tests/compression/lz4_tests.rs

@@ -3,6 +3,7 @@ mod tests {
     use tempfile::tempdir;
     use std::io::Write;
     use keep::compression_engine::lz4::CompressionEngineLZ4;
+    use keep::compression_engine::CompressionEngine;
 
     #[test]
     fn test_compression_engine_lz4() {
@@ -13,7 +14,7 @@ mod tests {
         let file_path = dir.path().join("test.lz4");
         
         // Test compression engine
-        let engine = CompressionEngineLZ4::new();
+        let engine = CompressionEngineLZ4 {};
         
         // Create compressed file
         {
@@ -38,7 +39,7 @@ mod tests {
         let file_path = dir.path().join("test_large.lz4");
         
         // Test compression engine
-        let engine = CompressionEngineLZ4::new();
+        let engine = CompressionEngineLZ4 {};
         
         // Create compressed file
         {

src/tests/compression/none_tests.rs

@@ -3,6 +3,7 @@ mod tests {
     use tempfile::tempdir;
     use std::io::Write;
     use keep::compression_engine::none::CompressionEngineNone;
+    use keep::compression_engine::CompressionEngine;
 
     #[test]
     fn test_compression_engine_none() {
@@ -13,7 +14,7 @@ mod tests {
         let file_path = dir.path().join("test.dat");
         
         // Test compression engine
-        let engine = CompressionEngineNone::new();
+        let engine = CompressionEngineNone {};
         
         // Create file
         {
@@ -38,7 +39,7 @@ mod tests {
         let file_path = dir.path().join("test_empty.dat");
         
         // Test compression engine
-        let engine = CompressionEngineNone::new();
+        let engine = CompressionEngineNone {};
         
         // Create file
         {

src/tests/compression_types/conversion_tests.rs

@@ -0,0 +1,31 @@
+#[cfg(test)]
+mod tests {
+    use keep::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());
+        // Note: xz is not supported in this implementation
+        assert!(CompressionType::from_str("xz").is_err());
+    }
+}

src/tests/compression_types/factory_tests.rs

@@ -0,0 +1,32 @@
+#[cfg(test)]
+mod tests {
+    use keep::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_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,2 @@
+pub mod factory_tests;
+pub mod conversion_tests;

src/tests/mod.rs

@@ -1,6 +1,8 @@
 #[cfg(test)]
 pub mod compression;
 #[cfg(test)]
+pub mod compression_types;
+#[cfg(test)]
 pub mod compression_engine;
 #[cfg(test)]
 pub mod meta_plugin;