foxhunt/ml/tests/dqn_adapter_paths_test.rs

//! Test: DQN adapter uses configurable TrainingPaths (no hardcoded paths)
//!
//! This test verifies that:
//! 1. DQNTrainer accepts TrainingPaths configuration
//! 2. Training directories are created correctly
//! 3. No hardcoded checkpoint directories are used
//!
//! ## CRITICAL
//!
//! NO GPU training - only compilation and path verification

use ml::hyperopt::adapters::dqn::DQNTrainer;
use ml::hyperopt::paths::TrainingPaths;
use std::path::PathBuf;
use tempfile::TempDir;

#[test]
fn test_dqn_trainer_accepts_training_paths() {
    // Create temporary directories
    let temp_dir = TempDir::new().expect("Failed to create temp dir");
    let base_dir = temp_dir.path().to_path_buf();
    let dbn_data_dir = temp_dir.path().join("dbn_data");
    std::fs::create_dir(&dbn_data_dir).expect("Failed to create DBN data dir");

    // Create a dummy DBN file (empty is fine for this test)
    std::fs::write(dbn_data_dir.join("dummy.dbn.zst"), b"dummy")
        .expect("Failed to write dummy file");

    // Create TrainingPaths
    let training_paths = TrainingPaths::new(&base_dir, "dqn", "test_run_001");

    // Create DQN trainer with training paths
    let trainer = DQNTrainer::new(&dbn_data_dir, 1)
        .expect("Failed to create DQN trainer")
        .with_training_paths(training_paths.clone());

    // Verify trainer was created (compilation test)
    drop(trainer);

    // Verify expected paths exist after TrainingPaths::create_all()
    training_paths
        .create_all()
        .expect("Failed to create directories");

    let expected_run_dir = base_dir.join("training_runs/dqn/run_test_run_001");
    let expected_checkpoints = expected_run_dir.join("checkpoints");
    let expected_logs = expected_run_dir.join("logs");
    let expected_hyperopt = expected_run_dir.join("hyperopt");

    assert!(expected_run_dir.exists(), "Run directory should exist");
    assert!(
        expected_checkpoints.exists(),
        "Checkpoints directory should exist"
    );
    assert!(expected_logs.exists(), "Logs directory should exist");
    assert!(
        expected_hyperopt.exists(),
        "Hyperopt directory should exist"
    );

    println!("✅ DQN adapter accepts TrainingPaths configuration");
    println!("  Run directory: {:?}", expected_run_dir);
    println!("  Checkpoints: {:?}", expected_checkpoints);
}

#[test]
fn test_dqn_trainer_default_paths() {
    // Create temporary directories
    let temp_dir = TempDir::new().expect("Failed to create temp dir");
    let dbn_data_dir = temp_dir.path().join("dbn_data");
    std::fs::create_dir(&dbn_data_dir).expect("Failed to create DBN data dir");

    // Create a dummy DBN file
    std::fs::write(dbn_data_dir.join("dummy.dbn.zst"), b"dummy")
        .expect("Failed to write dummy file");

    // Create DQN trainer without setting training paths (uses /tmp/ml_training default)
    let trainer = DQNTrainer::new(&dbn_data_dir, 1).expect("Failed to create DQN trainer");

    // Verify trainer was created with default paths
    drop(trainer);

    println!(
        "✅ DQN adapter uses /tmp/ml_training as default (should be overridden in production)"
    );
}

#[test]
fn test_dqn_training_paths_structure() {
    let base_dir = PathBuf::from("/runpod-volume");
    let training_paths = TrainingPaths::new(&base_dir, "dqn", "20251028_120000_hyperopt");

    // Verify path structure
    assert_eq!(
        training_paths.run_dir(),
        PathBuf::from("/runpod-volume/training_runs/dqn/run_20251028_120000_hyperopt")
    );
    assert_eq!(
        training_paths.checkpoints_dir(),
        PathBuf::from("/runpod-volume/training_runs/dqn/run_20251028_120000_hyperopt/checkpoints")
    );
    assert_eq!(
        training_paths.logs_dir(),
        PathBuf::from("/runpod-volume/training_runs/dqn/run_20251028_120000_hyperopt/logs")
    );
    assert_eq!(
        training_paths.hyperopt_dir(),
        PathBuf::from("/runpod-volume/training_runs/dqn/run_20251028_120000_hyperopt/hyperopt")
    );

    println!("✅ DQN training paths structure matches expected layout");
}

#[test]
fn test_no_hardcoded_paths_in_dqn_adapter() {
    // This is a compile-time check - if the code compiles, it means:
    // 1. DQNTrainer has a training_paths field
    // 2. with_training_paths() method exists
    // 3. TrainingPaths is properly integrated

    // Try to read the source file from multiple possible locations
    let possible_paths = vec![
        "ml/src/hyperopt/adapters/dqn.rs",
        "src/hyperopt/adapters/dqn.rs",
        "../src/hyperopt/adapters/dqn.rs",
    ];

    let source_path = possible_paths
        .iter()
        .find(|p| std::path::Path::new(p).exists())
        .expect("Could not find DQN adapter source file");

    let source = std::fs::read_to_string(source_path).expect("Failed to read DQN adapter source");

    // Check for forbidden patterns (except in comments/docs)
    let forbidden_patterns = vec![
        "/tmp/dqn",           // Hardcoded temp paths
        "/runpod-volume/dqn", // Hardcoded production paths
        "checkpoint_dir:",    // Old hardcoded field (should be training_paths now)
    ];

    for pattern in forbidden_patterns {
        // Count occurrences (allow in comments)
        let count = source.matches(pattern).count();
        if count > 0 {
            // Check if it's only in comments
            let lines_with_pattern: Vec<_> = source
                .lines()
                .filter(|line| line.contains(pattern))
                .collect();

            let real_occurrences: Vec<_> = lines_with_pattern
                .iter()
                .filter(|line| !line.trim_start().starts_with("//"))
                .collect();

            if !real_occurrences.is_empty() {
                let lines_str = real_occurrences
                    .iter()
                    .map(|s| s.to_string())
                    .collect::<Vec<_>>()
                    .join("\n");
                panic!(
                    "Found hardcoded pattern '{}' in DQN adapter:\n{}",
                    pattern, lines_str
                );
            }
        }
    }

    println!("✅ No hardcoded paths found in DQN adapter");
}