From 9142cdde2d0f311aed87f88e9b3df0f4902b3abb Mon Sep 17 00:00:00 2001 From: Andrew Phillips Date: Thu, 14 Aug 2025 11:57:56 -0300 Subject: [PATCH] refactor: split compression tests into separate module files as planned Co-authored-by: aider (openai/andrew/openrouter/qwen/qwen3-coder) --- src/tests.rs | 222 +----------------- src/tests/common/mod.rs | 1 + src/tests/compression/gzip_tests.rs | 58 +++++ src/tests/compression/lz4_tests.rs | 56 +++++ src/tests/compression/mod.rs | 17 ++ src/tests/compression/none_tests.rs | 56 +++++ .../compression/types/conversion_tests.rs | 30 +++ src/tests/compression/types/factory_tests.rs | 39 +++ src/tests/compression/types/mod.rs | 10 + src/tests/mod.rs | 12 + 10 files changed, 282 insertions(+), 219 deletions(-) create mode 100644 src/tests/common/mod.rs create mode 100644 src/tests/compression/gzip_tests.rs create mode 100644 src/tests/compression/lz4_tests.rs create mode 100644 src/tests/compression/mod.rs create mode 100644 src/tests/compression/none_tests.rs create mode 100644 src/tests/compression/types/conversion_tests.rs create mode 100644 src/tests/compression/types/factory_tests.rs create mode 100644 src/tests/compression/types/mod.rs create mode 100644 src/tests/mod.rs diff --git a/src/tests.rs b/src/tests.rs index 38c26c6..711e744 100644 --- a/src/tests.rs +++ b/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 crate::compression_engine::lz4::CompressionEngineLZ4; - use crate::compression_engine::none::CompressionEngineNone; + use std::str::FromStr; mod compression_tests { use super::*; - #[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()); - } - - #[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 = (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()); - } + // Tests will be moved to separate files } mod compression_type_tests { use super::*; - #[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()); - } - - #[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()); - } + // Tests will be moved to separate files } } diff --git a/src/tests/common/mod.rs b/src/tests/common/mod.rs new file mode 100644 index 0000000..ffbeae5 --- /dev/null +++ b/src/tests/common/mod.rs @@ -0,0 +1 @@ +// Common test utilities and shared test code will go here diff --git a/src/tests/compression/gzip_tests.rs b/src/tests/compression/gzip_tests.rs new file mode 100644 index 0000000..efdb3fc --- /dev/null +++ b/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()); + } +} diff --git a/src/tests/compression/lz4_tests.rs b/src/tests/compression/lz4_tests.rs new file mode 100644 index 0000000..7eacd53 --- /dev/null +++ b/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 = (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); + } +} diff --git a/src/tests/compression/mod.rs b/src/tests/compression/mod.rs new file mode 100644 index 0000000..c274057 --- /dev/null +++ b/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; +} diff --git a/src/tests/compression/none_tests.rs b/src/tests/compression/none_tests.rs new file mode 100644 index 0000000..06276f5 --- /dev/null +++ b/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()); + } +} diff --git a/src/tests/compression/types/conversion_tests.rs b/src/tests/compression/types/conversion_tests.rs new file mode 100644 index 0000000..28d49c8 --- /dev/null +++ b/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()); + } +} diff --git a/src/tests/compression/types/factory_tests.rs b/src/tests/compression/types/factory_tests.rs new file mode 100644 index 0000000..dd246de --- /dev/null +++ b/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()); + } +} diff --git a/src/tests/compression/types/mod.rs b/src/tests/compression/types/mod.rs new file mode 100644 index 0000000..3f8af63 --- /dev/null +++ b/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; +} diff --git a/src/tests/mod.rs b/src/tests/mod.rs new file mode 100644 index 0000000..32fb38b --- /dev/null +++ b/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;