154 lines
4.8 KiB
Rust
154 lines
4.8 KiB
Rust
use radixtree::RadixTree;
|
|
use std::collections::HashMap;
|
|
use tempfile::tempdir;
|
|
|
|
#[test]
|
|
fn test_getall() -> Result<(), radixtree::Error> {
|
|
// Create a temporary directory for the test
|
|
let temp_dir = tempdir().expect("Failed to create temp directory");
|
|
let db_path = temp_dir.path().to_str().unwrap();
|
|
|
|
// Create a new radix tree
|
|
let mut tree = RadixTree::new(db_path, true)?;
|
|
|
|
// Set up test data with common prefixes
|
|
let test_data: HashMap<&str, &str> = [
|
|
("user_1", "data1"),
|
|
("user_2", "data2"),
|
|
("user_3", "data3"),
|
|
("admin_1", "admin_data1"),
|
|
("admin_2", "admin_data2"),
|
|
("guest", "guest_data"),
|
|
].iter().cloned().collect();
|
|
|
|
// Set all test data
|
|
for (key, value) in &test_data {
|
|
tree.set(key, value.as_bytes().to_vec())?;
|
|
}
|
|
|
|
// Test getall with 'user_' prefix
|
|
let user_values = tree.getall("user_")?;
|
|
|
|
// Should return 3 values
|
|
assert_eq!(user_values.len(), 3);
|
|
|
|
// Convert byte arrays to strings for easier comparison
|
|
let user_value_strings: Vec<String> = user_values
|
|
.iter()
|
|
.map(|v| String::from_utf8_lossy(v).to_string())
|
|
.collect();
|
|
|
|
// Check all expected values are present
|
|
assert!(user_value_strings.contains(&"data1".to_string()));
|
|
assert!(user_value_strings.contains(&"data2".to_string()));
|
|
assert!(user_value_strings.contains(&"data3".to_string()));
|
|
|
|
// Test getall with 'admin_' prefix
|
|
let admin_values = tree.getall("admin_")?;
|
|
|
|
// Should return 2 values
|
|
assert_eq!(admin_values.len(), 2);
|
|
|
|
// Convert byte arrays to strings for easier comparison
|
|
let admin_value_strings: Vec<String> = admin_values
|
|
.iter()
|
|
.map(|v| String::from_utf8_lossy(v).to_string())
|
|
.collect();
|
|
|
|
// Check all expected values are present
|
|
assert!(admin_value_strings.contains(&"admin_data1".to_string()));
|
|
assert!(admin_value_strings.contains(&"admin_data2".to_string()));
|
|
|
|
// Test getall with empty prefix (should return all values)
|
|
let all_values = tree.getall("")?;
|
|
|
|
// Should return all 6 values
|
|
assert_eq!(all_values.len(), test_data.len());
|
|
|
|
// Test getall with non-existent prefix
|
|
let non_existent_values = tree.getall("xyz")?;
|
|
|
|
// Should return empty array
|
|
assert_eq!(non_existent_values.len(), 0);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_getall_with_updates() -> Result<(), radixtree::Error> {
|
|
// Create a temporary directory for the test
|
|
let temp_dir = tempdir().expect("Failed to create temp directory");
|
|
let db_path = temp_dir.path().to_str().unwrap();
|
|
|
|
// Create a new radix tree
|
|
let mut tree = RadixTree::new(db_path, true)?;
|
|
|
|
// Set initial values
|
|
tree.set("key1", b"value1".to_vec())?;
|
|
tree.set("key2", b"value2".to_vec())?;
|
|
tree.set("key3", b"value3".to_vec())?;
|
|
|
|
// Get initial values
|
|
let initial_values = tree.getall("key")?;
|
|
assert_eq!(initial_values.len(), 3);
|
|
|
|
// Update a value
|
|
tree.update("key2", b"updated_value2".to_vec())?;
|
|
|
|
// Get values after update
|
|
let updated_values = tree.getall("key")?;
|
|
assert_eq!(updated_values.len(), 3);
|
|
|
|
// Convert to strings for easier comparison
|
|
let updated_value_strings: Vec<String> = updated_values
|
|
.iter()
|
|
.map(|v| String::from_utf8_lossy(v).to_string())
|
|
.collect();
|
|
|
|
// Check the updated value is present
|
|
assert!(updated_value_strings.contains(&"value1".to_string()));
|
|
assert!(updated_value_strings.contains(&"updated_value2".to_string()));
|
|
assert!(updated_value_strings.contains(&"value3".to_string()));
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_getall_with_deletions() -> Result<(), radixtree::Error> {
|
|
// Create a temporary directory for the test
|
|
let temp_dir = tempdir().expect("Failed to create temp directory");
|
|
let db_path = temp_dir.path().to_str().unwrap();
|
|
|
|
// Create a new radix tree
|
|
let mut tree = RadixTree::new(db_path, true)?;
|
|
|
|
// Set initial values
|
|
tree.set("prefix_1", b"value1".to_vec())?;
|
|
tree.set("prefix_2", b"value2".to_vec())?;
|
|
tree.set("prefix_3", b"value3".to_vec())?;
|
|
tree.set("other", b"other_value".to_vec())?;
|
|
|
|
// Get initial values
|
|
let initial_values = tree.getall("prefix_")?;
|
|
assert_eq!(initial_values.len(), 3);
|
|
|
|
// Delete a key
|
|
tree.delete("prefix_2")?;
|
|
|
|
// Get values after deletion
|
|
let after_delete_values = tree.getall("prefix_")?;
|
|
assert_eq!(after_delete_values.len(), 2);
|
|
|
|
// Convert to strings for easier comparison
|
|
let after_delete_strings: Vec<String> = after_delete_values
|
|
.iter()
|
|
.map(|v| String::from_utf8_lossy(v).to_string())
|
|
.collect();
|
|
|
|
// Check the remaining values
|
|
assert!(after_delete_strings.contains(&"value1".to_string()));
|
|
assert!(after_delete_strings.contains(&"value3".to_string()));
|
|
|
|
Ok(())
|
|
}
|