vidsage-core 0.1.0

#[cfg(test)]
mod tests {
    use std::collections::HashMap;
    use std::path::Path;
    use tempfile::tempdir;
    use super::*;
    use serde_json::json;
    
    #[tokio::test]
    async fn test_config_manager_new() {
        let config_manager = ConfigManagerImpl::new();
        assert_eq!(config_manager.list_keys().await.unwrap().len(), 0);
    }
    
    #[tokio::test]
    async fn test_config_manager_with_defaults() {
        let mut defaults = HashMap::new();
        defaults.insert("key1".to_string(), json!("value1"));
        defaults.insert("key2".to_string(), json!(42));
        
        let config_manager = ConfigManagerImpl::with_defaults(defaults);
        let keys = config_manager.list_keys().await.unwrap();
        
        assert_eq!(keys.len(), 2);
        assert!(keys.contains(&"key1".to_string()));
        assert!(keys.contains(&"key2".to_string()));
        
        let value1: String = config_manager.get("key1").await.unwrap();
        let value2: i64 = config_manager.get("key2").await.unwrap();
        
        assert_eq!(value1, "value1");
        assert_eq!(value2, 42);
    }
    
    #[tokio::test]
    async fn test_config_manager_set_get() {
        let config_manager = ConfigManagerImpl::new();
        
        // Set values
        config_manager.set("string_key", "test_value").await.unwrap();
        config_manager.set("int_key", 123).await.unwrap();
        config_manager.set("bool_key", true).await.unwrap();
        
        // Get values
        let string_value: String = config_manager.get("string_key").await.unwrap();
        let int_value: i64 = config_manager.get("int_key").await.unwrap();
        let bool_value: bool = config_manager.get("bool_key").await.unwrap();
        
        // Verify values
        assert_eq!(string_value, "test_value");
        assert_eq!(int_value, 123);
        assert_eq!(bool_value, true);
    }
    
    #[tokio::test]
    async fn test_config_manager_delete() {
        let config_manager = ConfigManagerImpl::new();
        
        // Set a value
        config_manager.set("test_key", "test_value").await.unwrap();
        
        // Verify it exists
        let exists_before = config_manager.exists("test_key").await.unwrap();
        assert!(exists_before);
        
        // Delete it
        let deleted = config_manager.delete("test_key").await.unwrap();
        assert!(deleted);
        
        // Verify it's gone
        let exists_after = config_manager.exists("test_key").await.unwrap();
        assert!(!exists_after);
        
        // Try to delete it again
        let deleted_again = config_manager.delete("test_key").await.unwrap();
        assert!(!deleted_again);
    }
    
    #[tokio::test]
    async fn test_config_manager_load_save_file() {
        let temp_dir = tempdir().unwrap();
        let config_path = temp_dir.path().join("config.json");
        
        // Create config manager with some values
        let config_manager = ConfigManagerImpl::new();
        config_manager.set("test_key", "test_value").await.unwrap();
        config_manager.set("another_key", 42).await.unwrap();
        
        // Save to file
        config_manager.save_to_file(&config_path).await.unwrap();
        
        // Create a new config manager and load from file
        let config_manager2 = ConfigManagerImpl::new();
        config_manager2.load_from_file(&config_path).await.unwrap();
        
        // Verify values are loaded correctly
        let value1: String = config_manager2.get("test_key").await.unwrap();
        let value2: i64 = config_manager2.get("another_key").await.unwrap();
        
        assert_eq!(value1, "test_value");
        assert_eq!(value2, 42);
    }
    
    #[tokio::test]
    async fn test_config_manager_reload() {
        let mut defaults = HashMap::new();
        defaults.insert("default_key".to_string(), json!("default_value"));
        
        let config_manager = ConfigManagerImpl::with_defaults(defaults);
        
        // Set some values
        config_manager.set("test_key", "test_value").await.unwrap();
        config_manager.set("default_key", "modified_value").await.unwrap();
        
        // Reload
        config_manager.reload().await.unwrap();
        
        // Verify values are reset to defaults
        let default_value: String = config_manager.get("default_key").await.unwrap();
        assert_eq!(default_value, "default_value");
        
        // Verify non-default values are removed
        let exists = config_manager.exists("test_key").await.unwrap();
        assert!(!exists);
    }
    
    #[tokio::test]
    async fn test_config_manager_env_vars() {
        // Set an environment variable for testing
        std::env::set_var("TEST_ENV_VAR", "env_value");
        
        let temp_dir = tempdir().unwrap();
        let config_path = temp_dir.path().join("config.json");
        
        // Create a config file with environment variable
        let config_content = r#"{
            "env_key": "${TEST_ENV_VAR}",
            "regular_key": "regular_value"
        }"#;
        std::fs::write(&config_path, config_content).unwrap();
        
        // Load from file
        let config_manager = ConfigManagerImpl::new();
        config_manager.load_from_file(&config_path).await.unwrap();
        
        // Verify values
        let env_value: String = config_manager.get("env_key").await.unwrap();
        let regular_value: String = config_manager.get("regular_key").await.unwrap();
        
        assert_eq!(env_value, "env_value");
        assert_eq!(regular_value, "regular_value");
        
        // Clean up environment variable
        std::env::remove_var("TEST_ENV_VAR");
    }
}