299 lines
7.8 KiB
Rust
299 lines
7.8 KiB
Rust
use tst::TST;
|
|
use std::env::temp_dir;
|
|
use std::fs;
|
|
use std::time::SystemTime;
|
|
|
|
fn get_test_db_path() -> String {
|
|
let timestamp = SystemTime::now()
|
|
.duration_since(SystemTime::UNIX_EPOCH)
|
|
.unwrap()
|
|
.as_nanos();
|
|
|
|
let path = temp_dir().join(format!("tst_test_{}", timestamp));
|
|
|
|
// If the path exists, remove it first
|
|
if path.exists() {
|
|
let _ = fs::remove_dir_all(&path);
|
|
}
|
|
|
|
// Create the directory
|
|
fs::create_dir_all(&path).unwrap();
|
|
|
|
path.to_string_lossy().to_string()
|
|
}
|
|
|
|
fn cleanup_test_db(path: &str) {
|
|
// Make sure to clean up properly
|
|
let _ = fs::remove_dir_all(path);
|
|
}
|
|
|
|
#[test]
|
|
fn test_create_tst() {
|
|
let path = get_test_db_path();
|
|
|
|
let result = TST::new(&path, true);
|
|
match &result {
|
|
Ok(_) => (),
|
|
Err(e) => println!("Error creating TST: {:?}", e),
|
|
}
|
|
assert!(result.is_ok());
|
|
|
|
if let Ok(mut tst) = result {
|
|
// Make sure we can perform a basic operation
|
|
let set_result = tst.set("test_key", b"test_value".to_vec());
|
|
assert!(set_result.is_ok());
|
|
}
|
|
|
|
cleanup_test_db(&path);
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_and_get() {
|
|
let path = get_test_db_path();
|
|
|
|
// Create a new TST with reset=true to ensure a clean state
|
|
let result = TST::new(&path, true);
|
|
assert!(result.is_ok());
|
|
|
|
let mut tree = result.unwrap();
|
|
|
|
// Test setting and getting a key
|
|
let key = "test_key";
|
|
let value = b"test_value".to_vec();
|
|
|
|
let set_result = tree.set(key, value.clone());
|
|
assert!(set_result.is_ok());
|
|
|
|
let get_result = tree.get(key);
|
|
assert!(get_result.is_ok());
|
|
assert_eq!(get_result.unwrap(), value);
|
|
|
|
// Make sure to clean up properly
|
|
cleanup_test_db(&path);
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_nonexistent_key() {
|
|
let path = get_test_db_path();
|
|
|
|
let mut tree = TST::new(&path, true).unwrap();
|
|
|
|
// Test getting a key that doesn't exist
|
|
let get_result = tree.get("nonexistent_key");
|
|
assert!(get_result.is_err());
|
|
|
|
cleanup_test_db(&path);
|
|
}
|
|
|
|
#[test]
|
|
fn test_delete() {
|
|
let path = get_test_db_path();
|
|
|
|
// Create a new TST with reset=true to ensure a clean state
|
|
let result = TST::new(&path, true);
|
|
assert!(result.is_ok());
|
|
|
|
let mut tree = result.unwrap();
|
|
|
|
// Set a key
|
|
let key = "delete_test";
|
|
let value = b"to_be_deleted".to_vec();
|
|
|
|
let set_result = tree.set(key, value);
|
|
assert!(set_result.is_ok());
|
|
|
|
// Verify it exists
|
|
let get_result = tree.get(key);
|
|
assert!(get_result.is_ok());
|
|
|
|
// Delete it
|
|
let delete_result = tree.delete(key);
|
|
assert!(delete_result.is_ok());
|
|
|
|
// Verify it's gone
|
|
let get_after_delete = tree.get(key);
|
|
assert!(get_after_delete.is_err());
|
|
|
|
// Make sure to clean up properly
|
|
cleanup_test_db(&path);
|
|
}
|
|
|
|
#[test]
|
|
fn test_multiple_keys() {
|
|
let path = get_test_db_path();
|
|
|
|
// Create a new TST with reset=true to ensure a clean state
|
|
let result = TST::new(&path, true);
|
|
assert!(result.is_ok());
|
|
|
|
let mut tree = result.unwrap();
|
|
|
|
// Insert multiple keys - use fewer keys to avoid filling the lookup table
|
|
let keys = ["apple", "banana", "cherry"];
|
|
|
|
for (i, key) in keys.iter().enumerate() {
|
|
let value = format!("value_{}", i).into_bytes();
|
|
let set_result = tree.set(key, value);
|
|
|
|
// Print error if set fails
|
|
if set_result.is_err() {
|
|
println!("Error setting key '{}': {:?}", key, set_result);
|
|
}
|
|
|
|
assert!(set_result.is_ok());
|
|
}
|
|
|
|
// Verify all keys exist
|
|
for (i, key) in keys.iter().enumerate() {
|
|
let expected_value = format!("value_{}", i).into_bytes();
|
|
let get_result = tree.get(key);
|
|
assert!(get_result.is_ok());
|
|
assert_eq!(get_result.unwrap(), expected_value);
|
|
}
|
|
|
|
// Make sure to clean up properly
|
|
cleanup_test_db(&path);
|
|
}
|
|
|
|
#[test]
|
|
fn test_list_prefix() {
|
|
let path = get_test_db_path();
|
|
|
|
// Create a new TST with reset=true to ensure a clean state
|
|
let result = TST::new(&path, true);
|
|
assert!(result.is_ok());
|
|
|
|
let mut tree = result.unwrap();
|
|
|
|
// Insert keys with common prefixes - use fewer keys to avoid filling the lookup table
|
|
let keys = [
|
|
"apple", "application", "append",
|
|
"banana", "bandana"
|
|
];
|
|
|
|
for key in &keys {
|
|
let set_result = tree.set(key, key.as_bytes().to_vec());
|
|
assert!(set_result.is_ok());
|
|
}
|
|
|
|
// Test prefix "app"
|
|
let list_result = tree.list("app");
|
|
assert!(list_result.is_ok());
|
|
|
|
let app_keys = list_result.unwrap();
|
|
|
|
// Print the keys for debugging
|
|
println!("Keys with prefix 'app':");
|
|
for key in &app_keys {
|
|
println!(" {}", key);
|
|
}
|
|
|
|
// Check that each key is present
|
|
assert!(app_keys.contains(&"apple".to_string()));
|
|
assert!(app_keys.contains(&"application".to_string()));
|
|
assert!(app_keys.contains(&"append".to_string()));
|
|
|
|
// Test prefix "ban"
|
|
let list_result = tree.list("ban");
|
|
assert!(list_result.is_ok());
|
|
|
|
let ban_keys = list_result.unwrap();
|
|
assert!(ban_keys.contains(&"banana".to_string()));
|
|
assert!(ban_keys.contains(&"bandana".to_string()));
|
|
|
|
// Test non-existent prefix
|
|
let list_result = tree.list("z");
|
|
assert!(list_result.is_ok());
|
|
|
|
let z_keys = list_result.unwrap();
|
|
assert_eq!(z_keys.len(), 0);
|
|
|
|
// Make sure to clean up properly
|
|
cleanup_test_db(&path);
|
|
}
|
|
|
|
#[test]
|
|
fn test_getall_prefix() {
|
|
let path = get_test_db_path();
|
|
|
|
// Create a new TST with reset=true to ensure a clean state
|
|
let result = TST::new(&path, true);
|
|
assert!(result.is_ok());
|
|
|
|
let mut tree = result.unwrap();
|
|
|
|
// Insert keys with common prefixes - use fewer keys to avoid filling the lookup table
|
|
let keys = [
|
|
"apple", "application", "append"
|
|
];
|
|
|
|
for key in &keys {
|
|
let set_result = tree.set(key, key.as_bytes().to_vec());
|
|
assert!(set_result.is_ok());
|
|
}
|
|
|
|
// Test getall with prefix "app"
|
|
let getall_result = tree.getall("app");
|
|
assert!(getall_result.is_ok());
|
|
|
|
let app_values = getall_result.unwrap();
|
|
|
|
// Convert values to strings for easier comparison
|
|
let app_value_strings: Vec<String> = app_values
|
|
.iter()
|
|
.map(|v| String::from_utf8_lossy(v).to_string())
|
|
.collect();
|
|
|
|
// Print the values for debugging
|
|
println!("Values with prefix 'app':");
|
|
for value in &app_value_strings {
|
|
println!(" {}", value);
|
|
}
|
|
|
|
// Check that each value is present
|
|
assert!(app_value_strings.contains(&"apple".to_string()));
|
|
assert!(app_value_strings.contains(&"application".to_string()));
|
|
assert!(app_value_strings.contains(&"append".to_string()));
|
|
|
|
// Make sure to clean up properly
|
|
cleanup_test_db(&path);
|
|
}
|
|
|
|
#[test]
|
|
fn test_empty_prefix() {
|
|
let path = get_test_db_path();
|
|
|
|
// Create a new TST with reset=true to ensure a clean state
|
|
let result = TST::new(&path, true);
|
|
assert!(result.is_ok());
|
|
|
|
let mut tree = result.unwrap();
|
|
|
|
// Insert some keys
|
|
let keys = ["apple", "banana", "cherry"];
|
|
|
|
for key in &keys {
|
|
let set_result = tree.set(key, key.as_bytes().to_vec());
|
|
assert!(set_result.is_ok());
|
|
}
|
|
|
|
// Test list with empty prefix (should return all keys)
|
|
let list_result = tree.list("");
|
|
assert!(list_result.is_ok());
|
|
|
|
let all_keys = list_result.unwrap();
|
|
|
|
// Print the keys for debugging
|
|
println!("Keys with empty prefix:");
|
|
for key in &all_keys {
|
|
println!(" {}", key);
|
|
}
|
|
|
|
// Check that each key is present
|
|
for key in &keys {
|
|
assert!(all_keys.contains(&key.to_string()));
|
|
}
|
|
|
|
// Make sure to clean up properly
|
|
cleanup_test_db(&path);
|
|
} |