asp/keep
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor: split compression tests into separate module files as planned

Browse Source 
Co-authored-by: aider (openai/andrew/openrouter/qwen/qwen3-coder) <aider@aider.chat>
This commit is contained in:
Andrew Phillips
2025-08-14 11:57:56 -03:00
parent 9e10b1b497
commit 9142cdde2d
10 changed files with 282 additions and 219 deletions
Download Patch File Download Diff File Expand all files Collapse all files

222
src/tests.rs
View File

@@ -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<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());
}
// 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
}
}

1
src/tests/common/mod.rs Normal file
View File

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

58
src/tests/compression/gzip_tests.rs Normal file
View File

@@ -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());
}
}

56
src/tests/compression/lz4_tests.rs Normal file
View File

@@ -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);
}
}

17
src/tests/compression/mod.rs Normal file
View File

@@ -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;
}

56
src/tests/compression/none_tests.rs Normal file
View File

@@ -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());
}
}

30
src/tests/compression/types/conversion_tests.rs Normal file
View File

@@ -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());
}
}

39
src/tests/compression/types/factory_tests.rs Normal file
View File

@@ -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());
}
}

10
src/tests/compression/types/mod.rs Normal file
View File

@@ -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;
}

12
src/tests/mod.rs Normal file
View File

@@ -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;