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

feat: add compression engine test helpers and refactor tests

Browse Source 
Co-authored-by: aider (openai/andrew/openrouter/qwen/qwen3-coder) <aider@aider.chat>
This commit is contained in:
Andrew Phillips
2025-08-15 11:24:38 -03:00
parent d5c956e626
commit 5d44be21fa
4 changed files with 36 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
src/tests/common/test_helpers.rs
View File

@@ -62,3 +62,30 @@ pub fn create_test_item(conn: &Connection) -> i64 {
};
db::insert_item(conn, item).expect("Failed to insert item")
}
/// Create a test file with compression engine testing data
pub fn create_test_file_with_data(dir: &TempDir, filename: &str, data: &[u8]) -> PathBuf {
let file_path = dir.path().join(filename);
let mut file = File::create(&file_path).expect("Failed to create test file");
file.write_all(data).expect("Failed to write to test file");
file_path
}
/// Test compression and decompression with an engine
pub fn test_compression_engine(engine: &dyn crate::compression_engine::CompressionEngine, test_data: &[u8]) {
let dir = create_temp_dir();
let file_path = dir.path().join("test_compression.dat");
// Test compression
{
let mut writer = engine.create(file_path.clone()).expect("Failed to create writer");
writer.write_all(test_data).expect("Failed to write data");
}
// Test decompression
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());
}

44
src/tests/compression/gzip_tests.rs
View File

@@ -1,59 +1,21 @@
#[cfg(test)]
mod tests {
use tempfile::tempdir;
use std::io::Write;
use crate::compression_engine::gzip::CompressionEngineGZip;
use crate::compression_engine::CompressionEngine;
use crate::tests::common::test_helpers::{test_compression_engine, create_temp_dir};
#[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 {};
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_compression_engine(&engine, test_data);
}
#[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 {};
// 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_compression_engine(&engine, test_data);
}
}

43
src/tests/compression/lz4_tests.rs
View File

@@ -1,57 +1,20 @@
#[cfg(test)]
mod tests {
use tempfile::tempdir;
use std::io::Write;
use crate::compression_engine::lz4::CompressionEngineLZ4;
use crate::compression_engine::CompressionEngine;
use crate::tests::common::test_helpers::{test_compression_engine, create_temp_dir};
#[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 {};
// 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_compression_engine(&engine, test_data);
}
#[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 {};
// 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_compression_engine(&engine, &test_data);
}
}

43
src/tests/compression/none_tests.rs
View File

@@ -1,57 +1,20 @@
#[cfg(test)]
mod tests {
use tempfile::tempdir;
use std::io::Write;
use crate::compression_engine::none::CompressionEngineNone;
use crate::compression_engine::CompressionEngine;
use crate::tests::common::test_helpers::test_compression_engine;
#[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 {};
// 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_compression_engine(&engine, test_data);
}
#[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 {};
// 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_compression_engine(&engine, test_data);
}
}