foxhunt/ml/tests/dqn_hyperopt_fixes_test.rs

//! Test suite for DQN hyperopt adapter fixes (P1/P2)
//!
//! This test suite validates:
//! 1. P1: Buffer size clamping (4GB GPU constraint)
//! 2. P1: CUDA OOM handling (panic recovery)
//! 3. P2: Tokio runtime optimization (reuse existing runtime)

use ml::hyperopt::adapters::dqn::{DQNMetrics, DQNParams, DQNTrainer};
use ml::hyperopt::traits::{HyperparameterOptimizable, ParameterSpace};
use std::path::PathBuf;

/// Test 1: Buffer size clamping for 4GB GPU
#[test]
fn test_buffer_size_clamping() {
    // Create trainer with 100k buffer max (4GB GPU)
    let data_dir = PathBuf::from("test_data/real/databento/ml_training");
    if !data_dir.exists() {
        eprintln!("Skipping test: data directory not found");
        return;
    }

    let mut trainer = DQNTrainer::with_buffer_max(data_dir, 10, 100_000).unwrap();

    // Test 1: Large buffer (1M) should clamp to 100k
    let params_large = DQNParams {
        learning_rate: 1e-4,
        batch_size: 64,
        gamma: 0.99,
        epsilon_decay: 0.995,
        buffer_size: 1_000_000, // 900MB VRAM
    };

    // This would OOM on 4GB GPU, but we're testing the clamping logic
    // We'll use a small epoch count to avoid actually running out of memory
    let result = trainer.train_with_params(params_large);

    // Should succeed (either trained or returned penalty)
    assert!(result.is_ok(), "Training should not crash with large buffer");

    // Test 2: Small buffer (10k) should pass through unchanged
    let params_small = DQNParams {
        learning_rate: 1e-4,
        batch_size: 64,
        gamma: 0.99,
        epsilon_decay: 0.995,
        buffer_size: 10_000, // 9MB VRAM
    };

    let result = trainer.train_with_params(params_small);
    assert!(result.is_ok(), "Training should succeed with small buffer");
}

/// Test 2: Runtime handle optimization (reuse existing runtime)
#[test]
fn test_runtime_reuse() {
    let data_dir = PathBuf::from("test_data/real/databento/ml_training");
    if !data_dir.exists() {
        eprintln!("Skipping test: data directory not found");
        return;
    }

    // Create runtime context
    let runtime = tokio::runtime::Runtime::new().unwrap();

    runtime.block_on(async {
        // Create trainer inside existing runtime
        let mut trainer = DQNTrainer::new(data_dir, 5).unwrap();

        let params = DQNParams {
            learning_rate: 1e-4,
            batch_size: 32,
            gamma: 0.99,
            epsilon_decay: 0.995,
            buffer_size: 10_000,
        };

        // Should reuse existing runtime (logged in trainer constructor)
        let result = trainer.train_with_params(params);
        assert!(
            result.is_ok(),
            "Training should succeed with existing runtime"
        );
    });
}

/// Test 3: CUDA OOM penalty metrics
#[test]
fn test_oom_penalty_metrics() {
    // We can't easily trigger a real OOM in tests, but we can verify
    // the penalty metrics structure is correct
    let penalty_metrics = DQNMetrics {
        train_loss: 1000.0,
        avg_q_value: 0.0,
        final_epsilon: 1.0,
        epochs_completed: 0,
    };

    // Verify penalty loss is high (optimizer will avoid this config)
    assert_eq!(penalty_metrics.train_loss, 1000.0);
    assert_eq!(penalty_metrics.epochs_completed, 0);

    // Verify extraction works
    use ml::hyperopt::traits::HyperparameterOptimizable;
    let objective = DQNTrainer::extract_objective(&penalty_metrics);
    assert_eq!(objective, 1000.0, "Penalty should be 1000.0");
}

/// Test 4: Buffer size max setter
#[test]
fn test_buffer_size_max_setter() {
    let data_dir = PathBuf::from("test_data/real/databento/ml_training");
    if !data_dir.exists() {
        eprintln!("Skipping test: data directory not found");
        return;
    }

    let mut trainer = DQNTrainer::new(data_dir.clone(), 10).unwrap();

    // Update buffer max
    trainer.with_buffer_size_max(50_000);

    // Test with buffer larger than new max
    let params = DQNParams {
        learning_rate: 1e-4,
        batch_size: 32,
        gamma: 0.99,
        epsilon_decay: 0.995,
        buffer_size: 100_000, // Should clamp to 50k
    };

    let result = trainer.train_with_params(params);
    assert!(result.is_ok(), "Training should succeed with updated max");
}

/// Test 5: Parameter space bounds (no regression)
#[test]
fn test_parameter_space_bounds() {
    let bounds = DQNParams::continuous_bounds();
    assert_eq!(bounds.len(), 5);

    // Buffer size bounds (log scale)
    assert_eq!(bounds[4], (10_000_f64.ln(), 1_000_000_f64.ln()));

    // Verify we can create params at extremes
    let min_continuous = vec![
        1e-5_f64.ln(),
        32.0,
        0.95,
        0.990_f64.ln(),
        10_000_f64.ln(),
    ];
    let params_min = DQNParams::from_continuous(&min_continuous).unwrap();
    assert_eq!(params_min.buffer_size, 10_000);

    let max_continuous = vec![
        1e-3_f64.ln(),
        230.0,
        0.99,
        0.999_f64.ln(),
        1_000_000_f64.ln(),
    ];
    let params_max = DQNParams::from_continuous(&max_continuous).unwrap();
    assert_eq!(params_max.buffer_size, 1_000_000);
}

/// Integration test: Multiple trials with varying buffer sizes
#[test]
fn test_multiple_trials_varying_buffers() {
    let data_dir = PathBuf::from("test_data/real/databento/ml_training");
    if !data_dir.exists() {
        eprintln!("Skipping test: data directory not found");
        return;
    }

    let mut trainer = DQNTrainer::with_buffer_max(data_dir, 5, 50_000).unwrap();

    let test_configs = vec![
        (10_000, "small buffer"),
        (50_000, "at max"),
        (100_000, "above max, should clamp"),
        (1_000_000, "very large, should clamp"),
    ];

    for (buffer_size, description) in test_configs {
        let params = DQNParams {
            learning_rate: 1e-4,
            batch_size: 32,
            gamma: 0.99,
            epsilon_decay: 0.995,
            buffer_size,
        };

        let result = trainer.train_with_params(params);
        assert!(
            result.is_ok(),
            "Trial with {} should not crash",
            description
        );
    }
}