foxhunt/ml/tests/action_loader_real_csv_test.rs

// ml/tests/action_loader_real_csv_test.rs
// Test loading the real DQN actions CSV file

use ml::backtesting::load_actions_from_csv;

#[test]
fn test_load_real_csv_file() {
    // Test loading the real CSV file with 13,552 actions
    let csv_path = "/tmp/dqn_actions_wave3.csv";

    // Skip test if CSV file doesn't exist
    if !std::path::Path::new(csv_path).exists() {
        eprintln!("Skipping test: {} not found", csv_path);
        return;
    }

    let actions = load_actions_from_csv(csv_path).unwrap();

    // Verify count (13,552 actions)
    assert_eq!(actions.len(), 13_552, "Expected 13,552 actions from CSV");

    // Verify first action
    assert_eq!(actions[0].action, 2, "First action should be 2 (Hold)");
    assert_eq!(actions[0].q_buy, -658.8440);
    assert_eq!(actions[0].q_sell, 355.0268);
    assert_eq!(actions[0].q_hold, 538.5875);
    assert_eq!(actions[0].open, 5914.50);
    assert_eq!(actions[0].high, 5914.75);
    assert_eq!(actions[0].low, 5914.25);
    assert_eq!(actions[0].close, 5914.25);
    assert_eq!(actions[0].volume, 27);

    // Verify all actions have valid bounds (0-2)
    for (i, action) in actions.iter().enumerate() {
        assert!(
            action.action <= 2,
            "Action {} at index {} exceeds bounds",
            action.action,
            i
        );
    }

    // Verify all Q-values are finite
    for (i, action) in actions.iter().enumerate() {
        assert!(
            action.q_buy.is_finite(),
            "q_buy at index {} is not finite",
            i
        );
        assert!(
            action.q_sell.is_finite(),
            "q_sell at index {} is not finite",
            i
        );
        assert!(
            action.q_hold.is_finite(),
            "q_hold at index {} is not finite",
            i
        );
    }

    // Verify timestamp ordering (monotonically increasing)
    for i in 1..actions.len() {
        assert!(
            actions[i].timestamp >= actions[i - 1].timestamp,
            "Timestamp ordering violation at index {}: {} < {}",
            i,
            actions[i].timestamp,
            actions[i - 1].timestamp
        );
    }

    // Verify action distribution (sanity check)
    let mut buy_count = 0;
    let mut sell_count = 0;
    let mut hold_count = 0;
    for action in &actions {
        match action.action {
            0 => buy_count += 1,
            1 => sell_count += 1,
            2 => hold_count += 1,
            _ => panic!("Invalid action: {}", action.action),
        }
    }

    // Note: Buy count might be 0 for certain datasets (DQN-specific behavior)
    assert_eq!(
        buy_count + sell_count + hold_count,
        13_552,
        "Action counts must sum to total"
    );

    println!("Action distribution:");
    println!(
        "  Buy: {} ({:.2}%)",
        buy_count,
        100.0 * buy_count as f64 / actions.len() as f64
    );
    println!(
        "  Sell: {} ({:.2}%)",
        sell_count,
        100.0 * sell_count as f64 / actions.len() as f64
    );
    println!(
        "  Hold: {} ({:.2}%)",
        hold_count,
        100.0 * hold_count as f64 / actions.len() as f64
    );

    // Verify expected distribution for this specific CSV (no buy actions)
    assert_eq!(buy_count, 0, "Expected 0 buy actions for this dataset");
    assert_eq!(sell_count, 7_668, "Expected 7,668 sell actions");
    assert_eq!(hold_count, 5_884, "Expected 5,884 hold actions");
}