foxhunt/ml/tests/wave2_a3_risk_metrics_test.rs

//! Wave 2-A3: Position Risk Metrics Tests
//! Standalone test file to verify risk calculation functions

use ml::dqn::reward::{
    calculate_max_drawdown, calculate_risk_penalty, calculate_rolling_sharpe, calculate_var_95,
    RiskMetrics,
};

#[test]
fn test_var_calculation_accuracy() -> anyhow::Result<()> {
    // Test VaR with known distribution
    let returns = vec![
        -0.05, -0.04, -0.03, -0.02, -0.01, // 5 negative returns
        0.00, 0.01, 0.02, 0.03, 0.04, // 5 positive returns
        0.05, 0.06, 0.07, 0.08, 0.09, // 5 more positive
        0.10, 0.11, 0.12, 0.13, 0.14, // 5 more positive
    ];
    let portfolio_value = 100_000.0;

    let var = calculate_var_95(&returns, portfolio_value);

    // 95% VaR = 5th percentile = index 1 (5% of 20 = 1)
    // Sorted: -0.05, -0.04, ... → percentile = -0.04
    // VaR = -(-0.04) * 100,000 = 4,000
    assert!(
        var >= 3_900.0 && var <= 4_100.0,
        "VaR should be ~$4,000, got {}",
        var
    );
    Ok(())
}

#[test]
fn test_var_insufficient_data() -> anyhow::Result<()> {
    // Test with < 10 returns (should return 0)
    let returns = vec![0.01, 0.02, 0.03];
    let portfolio_value = 100_000.0;

    let var = calculate_var_95(&returns, portfolio_value);
    assert_eq!(var, 0.0, "VaR should be 0 with insufficient data");
    Ok(())
}

#[test]
fn test_sharpe_ratio_positive_negative() -> anyhow::Result<()> {
    // Test Sharpe with positive returns
    let positive_returns = vec![0.01; 20]; // 1% daily return
    let sharpe_pos = calculate_rolling_sharpe(&positive_returns, 0.04);

    assert!(
        sharpe_pos > 0.0,
        "Positive returns should have positive Sharpe"
    );

    // Test Sharpe with negative returns
    let negative_returns = vec![-0.01; 20]; // -1% daily return
    let sharpe_neg = calculate_rolling_sharpe(&negative_returns, 0.04);

    assert!(
        sharpe_neg < 0.0,
        "Negative returns should have negative Sharpe"
    );
    Ok(())
}

#[test]
fn test_sharpe_ratio_zero_volatility() -> anyhow::Result<()> {
    // Test Sharpe with zero volatility (should return 0 to avoid division by zero)
    let constant_returns = vec![0.0; 20];
    let sharpe = calculate_rolling_sharpe(&constant_returns, 0.04);

    assert_eq!(sharpe, 0.0, "Zero volatility should return 0 Sharpe");
    Ok(())
}

#[test]
fn test_drawdown_from_peak() -> anyhow::Result<()> {
    // Test drawdown calculation from peak
    let portfolio_history = vec![
        100_000.0, // Initial value (peak)
        105_000.0, // +5% gain (new peak)
        95_000.0,  // -9.5% from peak (drawdown)
        98_000.0,  // -6.7% from peak
        110_000.0, // New peak
        100_000.0, // -9.1% from new peak
    ];

    let max_dd = calculate_max_drawdown(&portfolio_history);

    // Max drawdown = (105,000 - 95,000) / 105,000 = 0.095 (9.5%)
    assert!(
        max_dd >= 0.094 && max_dd <= 0.096,
        "Max drawdown should be ~9.5%, got {:.2}%",
        max_dd * 100.0
    );
    Ok(())
}

#[test]
fn test_drawdown_no_decline() -> anyhow::Result<()> {
    // Test drawdown with no decline (monotonically increasing)
    let portfolio_history = vec![100_000.0, 105_000.0, 110_000.0, 115_000.0];

    let max_dd = calculate_max_drawdown(&portfolio_history);

    assert_eq!(max_dd, 0.0, "No decline should have 0% drawdown");
    Ok(())
}

#[test]
fn test_risk_penalty_thresholds() -> anyhow::Result<()> {
    // Test risk penalty with different threshold violations

    // Case 1: High VaR (> 5% of portfolio)
    let mut risk_metrics = RiskMetrics::default();
    risk_metrics.portfolio_value = 100_000.0;
    risk_metrics.var_95 = 8_000.0; // 8% > 5% threshold
    risk_metrics.max_drawdown = 0.10; // 10% < 20% threshold
    risk_metrics.leverage = 1.5; // 1.5 < 2.0 threshold
    risk_metrics.sharpe_ratio = 0.5; // 0.5 < 1.0 threshold

    let penalty = calculate_risk_penalty(&risk_metrics);
    assert!(
        penalty > 0.0,
        "High VaR should trigger penalty, got {}",
        penalty
    );

    // Case 2: High drawdown (> 20%)
    risk_metrics.var_95 = 2_000.0; // 2% < 5% threshold
    risk_metrics.max_drawdown = 0.30; // 30% > 20% threshold
    risk_metrics.leverage = 1.5;

    let penalty = calculate_risk_penalty(&risk_metrics);
    assert!(
        penalty > 0.0,
        "High drawdown should trigger penalty, got {}",
        penalty
    );

    // Case 3: High leverage (> 2.0)
    risk_metrics.var_95 = 2_000.0;
    risk_metrics.max_drawdown = 0.10;
    risk_metrics.leverage = 3.0; // 3.0 > 2.0 threshold

    let penalty = calculate_risk_penalty(&risk_metrics);
    assert!(
        penalty > 0.0,
        "High leverage should trigger penalty, got {}",
        penalty
    );

    Ok(())
}

#[test]
fn test_sharpe_bonus_application() -> anyhow::Result<()> {
    // Test Sharpe bonus (negative penalty = bonus)
    let mut risk_metrics = RiskMetrics::default();
    risk_metrics.portfolio_value = 100_000.0;
    risk_metrics.var_95 = 2_000.0; // 2% < 5% threshold (no penalty)
    risk_metrics.max_drawdown = 0.10; // 10% < 20% threshold (no penalty)
    risk_metrics.leverage = 1.5; // 1.5 < 2.0 threshold (no penalty)
    risk_metrics.sharpe_ratio = 2.0; // 2.0 > 1.0 threshold (bonus!)

    let penalty = calculate_risk_penalty(&risk_metrics);

    // Sharpe bonus: -0.005 × (2.0 - 1.0) = -0.005 (negative = bonus)
    assert!(
        penalty < 0.0,
        "High Sharpe should trigger bonus (negative penalty), got {}",
        penalty
    );
    assert!(
        (penalty - (-0.005)).abs() < 0.001,
        "Sharpe bonus should be ~-0.005, got {}",
        penalty
    );
    Ok(())
}

#[test]
fn test_risk_penalty_multiple_violations() -> anyhow::Result<()> {
    // Test penalty with multiple simultaneous violations
    let mut risk_metrics = RiskMetrics::default();
    risk_metrics.portfolio_value = 100_000.0;
    risk_metrics.var_95 = 10_000.0; // 10% > 5% threshold
    risk_metrics.max_drawdown = 0.30; // 30% > 20% threshold
    risk_metrics.leverage = 2.5; // 2.5 > 2.0 threshold
    risk_metrics.sharpe_ratio = 0.5; // 0.5 < 1.0 threshold (no bonus)

    let penalty = calculate_risk_penalty(&risk_metrics);

    // Expected penalties:
    // VaR: 0.01 × (10,000 / 5,000 - 1) = 0.01 × 1.0 = 0.01
    // Drawdown: 0.02 × (0.30 - 0.20) = 0.02 × 0.10 = 0.002
    // Leverage: 0.01 × (2.5 - 2.0) = 0.01 × 0.5 = 0.005
    // Total: 0.01 + 0.002 + 0.005 = 0.017
    assert!(
        penalty >= 0.016 && penalty <= 0.018,
        "Multiple penalties should sum to ~0.017, got {}",
        penalty
    );
    Ok(())
}