foxhunt/ml/tests/dqn_rainbow_config_test.rs

//! Unit tests for DQN Rainbow Configuration
//!
//! Tests configuration defaults, serialization, and validation for Rainbow DQN.

use ml::dqn::rainbow_config::RainbowAgentConfig;

#[test]
fn test_rainbow_config_default() {
    let config = RainbowAgentConfig::default();

    // Verify device defaults
    assert_eq!(config.device, "cpu");

    // Verify replay buffer settings
    assert_eq!(config.min_replay_size, 10000);
    assert_eq!(config.replay_buffer_size, 100000);
    assert_eq!(config.batch_size, 32);

    // Verify learning parameters
    assert_eq!(config.learning_rate, 0.0001);
    assert!(config.gamma > 0.0 && config.gamma <= 1.0);

    // Verify update frequencies
    assert!(config.target_update_freq > 0);
    assert!(config.train_freq > 0);
    assert!(config.noise_reset_freq > 0);

    // Verify priority replay parameters
    assert!(config.priority_alpha >= 0.0);
    assert!(config.priority_beta >= 0.0 && config.priority_beta <= 1.0);
    assert!(config.priority_beta_increment >= 0.0);
}

#[test]
fn test_rainbow_config_serialization() {
    let config = RainbowAgentConfig::default();

    // Test JSON serialization
    let json = serde_json::to_string(&config).expect("Should serialize to JSON");
    assert!(json.contains("device"));
    assert!(json.contains("batch_size"));
    assert!(json.contains("learning_rate"));

    // Test deserialization
    let deserialized: RainbowAgentConfig =
        serde_json::from_str(&json).expect("Should deserialize from JSON");

    assert_eq!(deserialized.device, config.device);
    assert_eq!(deserialized.batch_size, config.batch_size);
    assert_eq!(deserialized.learning_rate, config.learning_rate);
}

#[test]
fn test_rainbow_config_custom_values() {
    let mut config = RainbowAgentConfig::default();

    // Modify configuration
    config.device = "cuda".to_string();
    config.batch_size = 64;
    config.learning_rate = 0.001;
    config.gamma = 0.95;

    // Verify changes
    assert_eq!(config.device, "cuda");
    assert_eq!(config.batch_size, 64);
    assert_eq!(config.learning_rate, 0.001);
    assert_eq!(config.gamma, 0.95);
}

#[test]
fn test_rainbow_config_priority_replay_params() {
    let config = RainbowAgentConfig::default();

    // Verify priority replay parameters are valid
    assert!(
        config.priority_alpha >= 0.0 && config.priority_alpha <= 1.0,
        "priority_alpha should be in [0, 1]"
    );

    assert!(
        config.priority_beta >= 0.0 && config.priority_beta <= 1.0,
        "priority_beta should be in [0, 1]"
    );

    assert!(
        config.priority_beta_increment >= 0.0 && config.priority_beta_increment <= 0.01,
        "priority_beta_increment should be small positive value"
    );
}

#[test]
fn test_rainbow_config_multi_step_settings() {
    let config = RainbowAgentConfig::default();

    // Verify multi-step config exists - just verify it's accessible
    // The actual fields are implementation details
    let _multi_step = &config.multi_step;
}

#[test]
fn test_rainbow_config_network_settings() {
    let config = RainbowAgentConfig::default();

    // Verify network config exists
    let _network = &config.network_config;
}

#[test]
fn test_rainbow_config_cloneable() {
    let config = RainbowAgentConfig::default();
    let cloned = config.clone();

    assert_eq!(cloned.device, config.device);
    assert_eq!(cloned.batch_size, config.batch_size);
    assert_eq!(cloned.learning_rate, config.learning_rate);
}

#[test]
fn test_rainbow_config_debuggable() {
    let config = RainbowAgentConfig::default();
    let debug_str = format!("{:?}", config);

    assert!(debug_str.contains("RainbowAgentConfig"));
    assert!(debug_str.contains("device"));
}