db/tst/tests/basic_test.rs

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_secs();
    
    let path = temp_dir().join(format!("tst_test_{}", timestamp));
    fs::create_dir_all(&path).unwrap();
    
    path.to_string_lossy().to_string()
}

fn cleanup_test_db(path: &str) {
    let _ = fs::remove_dir_all(path);
}

#[test]
fn test_create_tst() {
    let path = get_test_db_path();
    
    let result = TST::new(&path, true);
    assert!(result.is_ok());
    
    cleanup_test_db(&path);
}

#[test]
fn test_set_and_get() {
    let path = get_test_db_path();
    
    let mut tree = TST::new(&path, true).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);
    
    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();
    
    let mut tree = TST::new(&path, true).unwrap();
    
    // Set a key
    let key = "delete_test";
    let value = b"to_be_deleted".to_vec();
    
    tree.set(key, value).unwrap();
    
    // 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());
    
    cleanup_test_db(&path);
}

#[test]
fn test_multiple_keys() {
    let path = get_test_db_path();
    
    let mut tree = TST::new(&path, true).unwrap();
    
    // Insert multiple keys
    let keys = ["apple", "banana", "cherry", "date", "elderberry"];
    
    for (i, key) in keys.iter().enumerate() {
        let value = format!("value_{}", i).into_bytes();
        tree.set(key, value).unwrap();
    }
    
    // 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).unwrap();
        assert_eq!(get_result, expected_value);
    }
    
    cleanup_test_db(&path);
}

#[test]
fn test_list_prefix() {
    let path = get_test_db_path();
    
    let mut tree = TST::new(&path, true).unwrap();
    
    // Insert keys with common prefixes
    let keys = [
        "apple", "application", "append",
        "banana", "bandana",
        "cherry", "chocolate"
    ];
    
    for key in &keys {
        tree.set(key, key.as_bytes().to_vec()).unwrap();
    }
    
    // Test prefix "app"
    let app_keys = tree.list("app").unwrap();
    assert_eq!(app_keys.len(), 3);
    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 ban_keys = tree.list("ban").unwrap();
    assert_eq!(ban_keys.len(), 2);
    assert!(ban_keys.contains(&"banana".to_string()));
    assert!(ban_keys.contains(&"bandana".to_string()));
    
    // Test prefix "c"
    let c_keys = tree.list("c").unwrap();
    assert_eq!(c_keys.len(), 2);
    assert!(c_keys.contains(&"cherry".to_string()));
    assert!(c_keys.contains(&"chocolate".to_string()));
    
    // Test non-existent prefix
    let z_keys = tree.list("z").unwrap();
    assert_eq!(z_keys.len(), 0);
    
    cleanup_test_db(&path);
}

#[test]
fn test_getall_prefix() {
    let path = get_test_db_path();
    
    let mut tree = TST::new(&path, true).unwrap();
    
    // Insert keys with common prefixes
    let keys = [
        "apple", "application", "append",
        "banana", "bandana",
        "cherry", "chocolate"
    ];
    
    for key in &keys {
        tree.set(key, key.as_bytes().to_vec()).unwrap();
    }
    
    // Test getall with prefix "app"
    let app_values = tree.getall("app").unwrap();
    assert_eq!(app_values.len(), 3);
    
    // 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();
    
    assert!(app_value_strings.contains(&"apple".to_string()));
    assert!(app_value_strings.contains(&"application".to_string()));
    assert!(app_value_strings.contains(&"append".to_string()));
    
    cleanup_test_db(&path);
}

#[test]
fn test_empty_prefix() {
    let path = get_test_db_path();
    
    let mut tree = TST::new(&path, true).unwrap();
    
    // Insert some keys
    let keys = ["apple", "banana", "cherry"];
    
    for key in &keys {
        tree.set(key, key.as_bytes().to_vec()).unwrap();
    }
    
    // Test list with empty prefix (should return all keys)
    let all_keys = tree.list("").unwrap();
    assert_eq!(all_keys.len(), keys.len());
    
    for key in &keys {
        assert!(all_keys.contains(&key.to_string()));
    }
    
    cleanup_test_db(&path);
}