foxhunt/services/ml_training_service/tests/ensemble_training_basic_tests.rs

//! Basic TDD Tests for Ensemble Training Coordinator
//!
//! Simplified tests to verify core ensemble training functionality

use std::collections::HashMap;
use uuid::Uuid;

/// Test 1: Can create ensemble training config with 4 models
#[test]
fn test_create_ensemble_config() {
    let config = EnsembleTrainingConfig::new();

    assert_eq!(config.model_count(), 4, "Should have 4 models");
    assert!(config.has_model("DQN"), "Should have DQN");
    assert!(config.has_model("PPO"), "Should have PPO");
    assert!(config.has_model("MAMBA2"), "Should have MAMBA2");
    assert!(config.has_model("TFT"), "Should have TFT");
}

/// Test 2: Weights must sum to 1.0
#[test]
fn test_ensemble_weights_sum() {
    let config = EnsembleTrainingConfig::new();
    let weight_sum = config.total_weight();

    assert!(
        (weight_sum - 1.0).abs() < 1e-6,
        "Weights must sum to 1.0, got {}",
        weight_sum
    );
}

/// Test 3: Each model has both config and weight
#[test]
fn test_model_config_completeness() {
    let config = EnsembleTrainingConfig::new();

    for model_name in &["DQN", "PPO", "MAMBA2", "TFT"] {
        assert!(
            config.has_model_config(model_name),
            "Missing config for {}",
            model_name
        );
        assert!(
            config.has_model_weight(model_name),
            "Missing weight for {}",
            model_name
        );
    }
}

// Placeholder implementation (to be replaced with real implementation)

#[derive(Debug, Clone)]
struct EnsembleTrainingConfig {
    model_weights: HashMap<String, f64>,
    model_names: Vec<String>,
}

impl EnsembleTrainingConfig {
    fn new() -> Self {
        let mut model_weights = HashMap::new();
        model_weights.insert("DQN".to_string(), 0.33);
        model_weights.insert("PPO".to_string(), 0.33);
        model_weights.insert("MAMBA2".to_string(), 0.17);
        model_weights.insert("TFT".to_string(), 0.17);

        Self {
            model_weights,
            model_names: vec![
                "DQN".to_string(),
                "PPO".to_string(),
                "MAMBA2".to_string(),
                "TFT".to_string(),
            ],
        }
    }

    fn model_count(&self) -> usize {
        self.model_names.len()
    }

    fn has_model(&self, name: &str) -> bool {
        self.model_names.contains(&name.to_string())
    }

    fn total_weight(&self) -> f64 {
        self.model_weights.values().sum()
    }

    fn has_model_config(&self, name: &str) -> bool {
        self.model_names.contains(&name.to_string())
    }

    fn has_model_weight(&self, name: &str) -> bool {
        self.model_weights.contains_key(name)
    }
}