87 lines
2.9 KiB
Rust
87 lines
2.9 KiB
Rust
use herodb::rpc::{BackendType, DatabaseConfig};
|
|
use herodb::admin_meta;
|
|
use herodb::options::BackendType as OptionsBackendType;
|
|
use std::path::Path;
|
|
|
|
#[tokio::test]
|
|
async fn test_rpc_server_basic() {
|
|
// This test would require starting the RPC server in a separate thread
|
|
// For now, we'll just test that the types compile correctly
|
|
|
|
// Test serialization of types
|
|
let backend = BackendType::Redb;
|
|
let config = DatabaseConfig {
|
|
name: Some("test_db".to_string()),
|
|
storage_path: Some("/tmp/test".to_string()),
|
|
max_size: Some(1024 * 1024),
|
|
redis_version: Some("7.0".to_string()),
|
|
};
|
|
|
|
let backend_json = serde_json::to_string(&backend).unwrap();
|
|
let config_json = serde_json::to_string(&config).unwrap();
|
|
|
|
assert_eq!(backend_json, "\"Redb\"");
|
|
assert!(config_json.contains("test_db"));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_database_config_serialization() {
|
|
let config = DatabaseConfig {
|
|
name: Some("my_db".to_string()),
|
|
storage_path: None,
|
|
max_size: Some(1000000),
|
|
redis_version: Some("7.0".to_string()),
|
|
};
|
|
|
|
let json = serde_json::to_value(&config).unwrap();
|
|
assert_eq!(json["name"], "my_db");
|
|
assert_eq!(json["max_size"], 1000000);
|
|
assert_eq!(json["redis_version"], "7.0");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_backend_type_serialization() {
|
|
// Test that both Redb and Sled backends serialize correctly
|
|
let redb_backend = BackendType::Redb;
|
|
let sled_backend = BackendType::Sled;
|
|
|
|
let redb_json = serde_json::to_string(&redb_backend).unwrap();
|
|
let sled_json = serde_json::to_string(&sled_backend).unwrap();
|
|
|
|
assert_eq!(redb_json, "\"Redb\"");
|
|
assert_eq!(sled_json, "\"Sled\"");
|
|
|
|
// Test deserialization
|
|
let redb_deserialized: BackendType = serde_json::from_str(&redb_json).unwrap();
|
|
let sled_deserialized: BackendType = serde_json::from_str(&sled_json).unwrap();
|
|
|
|
assert!(matches!(redb_deserialized, BackendType::Redb));
|
|
assert!(matches!(sled_deserialized, BackendType::Sled));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_database_name_persistence() {
|
|
let base_dir = "/tmp/test_db_name_persistence";
|
|
let admin_secret = "test-admin-secret";
|
|
let backend = OptionsBackendType::Redb;
|
|
let db_id = 1;
|
|
let test_name = "test-database-name";
|
|
|
|
// Clean up any existing test data
|
|
let _ = std::fs::remove_dir_all(base_dir);
|
|
|
|
// Set the database name
|
|
admin_meta::set_database_name(Path::new(base_dir), backend.clone(), admin_secret, db_id, test_name)
|
|
.expect("Failed to set database name");
|
|
|
|
// Retrieve the database name
|
|
let retrieved_name = admin_meta::get_database_name(Path::new(base_dir), backend, admin_secret, db_id)
|
|
.expect("Failed to get database name");
|
|
|
|
// Verify the name matches
|
|
assert_eq!(retrieved_name, Some(test_name.to_string()));
|
|
|
|
// Clean up
|
|
let _ = std::fs::remove_dir_all(base_dir);
|
|
}
|