foxhunt/adaptive-strategy/src/risk/tests.rs

//! Comprehensive tests for Kelly Criterion integration
//!
//! This module tests all aspects of the enhanced Kelly Criterion implementation including:
//! - Basic Kelly calculations
//! - Dynamic risk tolerance adjustment
//! - Portfolio concentration monitoring
//! - Volatility-based position optimization
//! - Market regime adjustments
//! - Integration with RiskManager

use super::*;
use crate::config::RiskConfig;
use std::collections::HashMap;
use tokio_test;

#[tokio::test]
async fn test_kelly_position_sizer_creation() {
    let config = KellyConfig::default();
    let sizer = KellyPositionSizer::new(config);
    assert!(sizer.is_ok(), "Kelly position sizer should create successfully");
}

#[tokio::test]
async fn test_kelly_config_defaults() {
    let config = KellyConfig::default();
    
    assert_eq!(config.max_fraction, 0.25);
    assert_eq!(config.min_fraction, 0.01);
    assert_eq!(config.lookback_period, 252);
    assert_eq!(config.confidence_threshold, 0.6);
    assert!(config.volatility_adjustment);
    assert!(config.drawdown_protection);
    assert!(config.dynamic_risk_scaling);
    assert_eq!(config.max_concentration, 0.20);
    assert_eq!(config.correlation_adjustment, 0.85);
}

#[tokio::test]
async fn test_basic_kelly_calculation() {
    let config = KellyConfig::default();
    let mut sizer = KellyPositionSizer::new(config).unwrap();

    let historical_returns = vec![
        0.05, -0.02, 0.08, -0.03, 0.06, -0.01, 0.04, -0.02, 0.07, -0.01,
        0.03, -0.04, 0.09, -0.02, 0.05, -0.03, 0.06, -0.01, 0.08, -0.02,
    ];
    
    let market_data = create_test_market_data("AAPL", 150.0);

    let recommendation = sizer.calculate_position_size(
        "AAPL",
        0.10, // 10% expected return
        0.8,  // 80% confidence
        &historical_returns,
        &market_data,
    ).await;

    assert!(recommendation.is_ok(), "Kelly calculation should succeed");
    let rec = recommendation.unwrap();
    
    assert!(rec.recommended_fraction >= 0.0, "Recommended fraction should be non-negative");
    assert!(rec.recommended_fraction <= 0.25, "Recommended fraction should respect max limit");
    assert!(rec.confidence > 0.0 && rec.confidence <= 1.0, "Confidence should be valid");
    assert!(rec.volatility > 0.0, "Volatility estimate should be positive");
    assert_eq!(rec.symbol, "AAPL", "Symbol should match");
}

#[tokio::test]
async fn test_kelly_with_negative_expected_return() {
    let config = KellyConfig::default();
    let mut sizer = KellyPositionSizer::new(config).unwrap();

    let historical_returns = vec![-0.05, -0.02, -0.08, 0.03, -0.06];
    let market_data = create_test_market_data("BEAR", 50.0);

    let recommendation = sizer.calculate_position_size(
        "BEAR",
        -0.05, // Negative expected return
        0.3,   // Low confidence
        &historical_returns,
        &market_data,
    ).await;

    assert!(recommendation.is_ok(), "Kelly calculation should handle negative returns");
    let rec = recommendation.unwrap();
    
    // Should recommend minimal or zero position for negative expected return
    assert!(rec.recommended_fraction <= 0.05, "Should recommend small position for negative expected return");
}

#[tokio::test]
async fn test_market_regime_adjustments() {
    let config = KellyConfig::default();
    let mut sizer = KellyPositionSizer::new(config).unwrap();

    // Test different market regimes
    let regimes = vec![
        MarketRegime::BullLowVol,
        MarketRegime::BullHighVol,
        MarketRegime::BearLowVol,
        MarketRegime::BearHighVol,
        MarketRegime::Crisis,
    ];

    let historical_returns = vec![0.05, -0.02, 0.08, -0.03, 0.06];
    let market_data = create_test_market_data("TEST", 100.0);

    let mut recommendations = Vec::new();

    for regime in regimes {
        sizer.update_market_regime(regime.clone()).await.unwrap();
        
        let rec = sizer.calculate_position_size(
            "TEST",
            0.08,
            0.7,
            &historical_returns,
            &market_data,
        ).await.unwrap();
        
        recommendations.push((regime, rec.recommended_fraction, rec.regime_impact));
    }

    // Verify regime adjustments
    assert!(recommendations.len() == 5, "Should have recommendations for all regimes");
    
    // Crisis should have the most conservative sizing
    let crisis_rec = recommendations.iter().find(|(r, _, _)| matches!(r, MarketRegime::Crisis)).unwrap();
    let bull_low_vol_rec = recommendations.iter().find(|(r, _, _)| matches!(r, MarketRegime::BullLowVol)).unwrap();
    
    assert!(crisis_rec.1 < bull_low_vol_rec.1, "Crisis regime should recommend smaller positions");
}

#[tokio::test]
async fn test_portfolio_concentration_limits() {
    let config = KellyConfig {
        max_concentration: 0.15, // 15% max concentration
        ..KellyConfig::default()
    };
    let mut sizer = KellyPositionSizer::new(config).unwrap();

    // Set up portfolio with existing concentrations
    let mut positions = HashMap::new();
    positions.insert("AAPL".to_string(), 0.10); // Already 10% in AAPL
    positions.insert("MSFT".to_string(), 0.08);
    positions.insert("GOOGL".to_string(), 0.05);

    sizer.update_portfolio_positions(positions).await.unwrap();

    let historical_returns = vec![0.05, -0.02, 0.08, -0.03, 0.06];
    let market_data = create_test_market_data("AAPL", 150.0);

    let recommendation = sizer.calculate_position_size(
        "AAPL",
        0.12, // High expected return
        0.9,  // High confidence
        &historical_returns,
        &market_data,
    ).await.unwrap();

    // Should be limited by concentration
    assert!(recommendation.concentration_impact > 0.0, "Should show concentration impact");
    assert!(recommendation.recommended_fraction < 0.15, "Should respect concentration limits");
}

#[tokio::test]
async fn test_volatility_adjustments() {
    let config = KellyConfig::default();
    let mut sizer = KellyPositionSizer::new(config).unwrap();

    let historical_returns = vec![0.05, -0.02, 0.08, -0.03, 0.06];

    // Test with different volatility levels
    let low_vol_data = MarketData {
        prices: [("TEST".to_string(), 100.0)].iter().cloned().collect(),
        volatilities: [("TEST".to_string(), 0.10)].iter().cloned().collect(), // Low volatility
        correlations: HashMap::new(),
        timestamp: chrono::Utc::now(),
        volatility_index: Some(10.0),
        sentiment_indicators: HashMap::new(),
    };

    let high_vol_data = MarketData {
        prices: [("TEST".to_string(), 100.0)].iter().cloned().collect(),
        volatilities: [("TEST".to_string(), 0.40)].iter().cloned().collect(), // High volatility
        correlations: HashMap::new(),
        timestamp: chrono::Utc::now(),
        volatility_index: Some(40.0),
        sentiment_indicators: HashMap::new(),
    };

    let low_vol_rec = sizer.calculate_position_size(
        "TEST",
        0.08,
        0.7,
        &historical_returns,
        &low_vol_data,
    ).await.unwrap();

    let high_vol_rec = sizer.calculate_position_size(
        "TEST",
        0.08,
        0.7,
        &historical_returns,
        &high_vol_data,
    ).await.unwrap();

    // Low volatility should allow larger positions
    assert!(low_vol_rec.recommended_fraction > high_vol_rec.recommended_fraction,
            "Low volatility should allow larger position sizes");
}

#[tokio::test]
async fn test_risk_manager_kelly_integration() {
    let mut risk_config = RiskConfig {
        max_portfolio_var: 0.02,
        var_confidence_level: 0.95,
        max_drawdown_threshold: 0.05,
        position_sizing_method: PositionSizingMethod::Kelly, // Use Kelly method
        kelly_fraction: 0.25,
        max_leverage: 2.0,
        stop_loss_pct: 0.02,
        take_profit_pct: 0.04,
    };

    let mut risk_manager = RiskManager::new(risk_config).unwrap();

    // Test that Kelly sizer is initialized
    assert!(risk_manager.kelly_sizer.is_some(), "Kelly sizer should be initialized for Kelly method");

    // Test position size calculation
    let recommendation = risk_manager.calculate_position_size(
        "AAPL",
        0.10,
        0.8,
        150.0,
    ).await;

    assert!(recommendation.is_ok(), "Position size calculation should succeed");
    let rec = recommendation.unwrap();
    
    assert_eq!(rec.method, "Enhanced Kelly Criterion", "Should use enhanced Kelly method");
    assert!(rec.size > 0.0, "Should recommend positive position size");
}

#[tokio::test]
async fn test_risk_manager_fallback_to_standard() {
    let risk_config = RiskConfig {
        max_portfolio_var: 0.02,
        var_confidence_level: 0.95,
        max_drawdown_threshold: 0.05,
        position_sizing_method: PositionSizingMethod::FixedFraction, // Not Kelly
        kelly_fraction: 0.25,
        max_leverage: 2.0,
        stop_loss_pct: 0.02,
        take_profit_pct: 0.04,
    };

    let mut risk_manager = RiskManager::new(risk_config).unwrap();

    // Kelly sizer should not be initialized
    assert!(risk_manager.kelly_sizer.is_none(), "Kelly sizer should not be initialized for non-Kelly methods");

    let recommendation = risk_manager.calculate_position_size(
        "AAPL",
        0.10,
        0.8,
        150.0,
    ).await;

    assert!(recommendation.is_ok(), "Should fallback to standard position sizing");
    let rec = recommendation.unwrap();
    
    assert_ne!(rec.method, "Enhanced Kelly Criterion", "Should not use Kelly method");
}

#[tokio::test]
async fn test_kelly_performance_tracking() {
    let config = KellyConfig::default();
    let sizer = KellyPositionSizer::new(config).unwrap();

    let performance_metrics = sizer.get_performance_metrics().await;
    assert!(performance_metrics.is_ok(), "Should be able to get performance metrics");
    
    let metrics = performance_metrics.unwrap();
    
    // Check that metrics are initialized
    assert_eq!(metrics.sharpe_ratio, 0.0, "Initial Sharpe ratio should be 0");
    assert_eq!(metrics.win_rate, 0.0, "Initial win rate should be 0");
    assert_eq!(metrics.kelly_effectiveness, 0.0, "Initial Kelly effectiveness should be 0");
}

#[tokio::test]
async fn test_concentration_metrics() {
    let config = KellyConfig::default();
    let sizer = KellyPositionSizer::new(config).unwrap();

    let concentration_metrics = sizer.get_concentration_metrics().await;
    assert!(concentration_metrics.is_ok(), "Should be able to get concentration metrics");
    
    let metrics = concentration_metrics.unwrap();
    
    // Check initial state
    assert_eq!(metrics.position_count, 0, "Should start with no positions");
    assert_eq!(metrics.hhi, 0.0, "HHI should be 0 with no positions");
    assert_eq!(metrics.max_concentration, 0.0, "Max concentration should be 0");
}

#[tokio::test]
async fn test_market_regime_updates() {
    let config = KellyConfig::default();
    let mut sizer = KellyPositionSizer::new(config).unwrap();

    let regimes = vec![
        MarketRegime::BullLowVol,
        MarketRegime::Crisis,
        MarketRegime::Sideways,
    ];

    for regime in regimes {
        let result = sizer.update_market_regime(regime).await;
        assert!(result.is_ok(), "Market regime update should succeed");
    }
}

#[tokio::test]
async fn test_volatility_estimates_update() {
    let config = KellyConfig::default();
    let mut sizer = KellyPositionSizer::new(config).unwrap();

    let mut estimates = HashMap::new();
    estimates.insert("AAPL".to_string(), kelly_position_sizer::VolatilityEstimate {
        current: 0.18,
        forecast_1d: 0.19,
        forecast_5d: 0.20,
        confidence_interval: (0.15, 0.22),
        model_type: kelly_position_sizer::VolatilityModelType::Garch,
        last_update: chrono::Utc::now(),
    });

    let result = sizer.update_volatility_estimates(estimates).await;
    assert!(result.is_ok(), "Volatility estimates update should succeed");
}

#[tokio::test]
async fn test_win_loss_statistics() {
    let config = KellyConfig::default();
    let sizer = KellyPositionSizer::new(config).unwrap();

    // Test with various return patterns
    let all_wins = vec![0.05, 0.03, 0.08, 0.02, 0.06];
    let (win_rate, avg_win, avg_loss) = sizer.calculate_win_loss_stats(&all_wins);
    assert_eq!(win_rate, 1.0, "Should have 100% win rate for all positive returns");
    assert!(avg_win > 0.0, "Average win should be positive");
    assert_eq!(avg_loss, 0.0, "Average loss should be 0 with no losses");

    let mixed_returns = vec![0.05, -0.02, 0.08, -0.03, 0.06, -0.01];
    let (win_rate, avg_win, avg_loss) = sizer.calculate_win_loss_stats(&mixed_returns);
    assert!(win_rate == 0.5, "Should have 50% win rate");
    assert!(avg_win > 0.0, "Average win should be positive");
    assert!(avg_loss > 0.0, "Average loss should be positive");
}

#[tokio::test]
async fn test_kelly_with_empty_returns() {
    let config = KellyConfig::default();
    let mut sizer = KellyPositionSizer::new(config).unwrap();

    let empty_returns = vec![];
    let market_data = create_test_market_data("TEST", 100.0);

    let recommendation = sizer.calculate_position_size(
        "TEST",
        0.08,
        0.7,
        &empty_returns,
        &market_data,
    ).await;

    assert!(recommendation.is_ok(), "Should handle empty returns gracefully");
    let rec = recommendation.unwrap();
    
    assert_eq!(rec.recommended_fraction, 0.0, "Should recommend 0 position with no historical data");
}

#[tokio::test]
async fn test_risk_adjustments_structure() {
    let config = KellyConfig::default();
    let mut sizer = KellyPositionSizer::new(config).unwrap();

    let historical_returns = vec![0.05, -0.02, 0.08, -0.03, 0.06];
    let market_data = create_test_market_data("TEST", 100.0);

    let recommendation = sizer.calculate_position_size(
        "TEST",
        0.10,
        0.8,
        &historical_returns,
        &market_data,
    ).await.unwrap();

    let adjustments = &recommendation.risk_adjustments;
    
    assert!(adjustments.base_kelly >= 0.0, "Base Kelly should be non-negative");
    assert!(adjustments.volatility_adjustment > 0.0, "Volatility adjustment should be positive");
    assert!(adjustments.drawdown_adjustment > 0.0, "Drawdown adjustment should be positive");
    assert!(adjustments.concentration_adjustment > 0.0, "Concentration adjustment should be positive");
    assert!(adjustments.correlation_adjustment > 0.0, "Correlation adjustment should be positive");
    assert!(adjustments.regime_adjustment > 0.0, "Regime adjustment should be positive");
    assert!(adjustments.total_adjustment > 0.0, "Total adjustment should be positive");
}

#[tokio::test]
async fn test_position_size_scaling() {
    let config = KellyConfig::default();
    let mut sizer = KellyPositionSizer::new(config).unwrap();

    let historical_returns = vec![0.05, -0.02, 0.08, -0.03, 0.06];
    
    // Test with different expected returns
    let low_return_data = create_test_market_data("LOW", 100.0);
    let high_return_data = create_test_market_data("HIGH", 100.0);

    let low_rec = sizer.calculate_position_size(
        "LOW",
        0.02, // Low expected return
        0.7,
        &historical_returns,
        &low_return_data,
    ).await.unwrap();

    let high_rec = sizer.calculate_position_size(
        "HIGH",
        0.15, // High expected return
        0.7,
        &historical_returns,
        &high_return_data,
    ).await.unwrap();

    assert!(high_rec.recommended_fraction >= low_rec.recommended_fraction,
            "Higher expected return should allow larger position size");
}

// Helper function to create test market data
fn create_test_market_data(symbol: &str, price: f64) -> MarketData {
    let mut prices = HashMap::new();
    prices.insert(symbol.to_string(), price);
    
    let mut volatilities = HashMap::new();
    volatilities.insert(symbol.to_string(), 0.20); // 20% default volatility
    
    MarketData {
        prices,
        volatilities,
        correlations: HashMap::new(),
        timestamp: chrono::Utc::now(),
        volatility_index: Some(20.0),
        sentiment_indicators: HashMap::new(),
    }
}

#[tokio::test]
async fn test_edge_case_very_high_confidence() {
    let config = KellyConfig::default();
    let mut sizer = KellyPositionSizer::new(config).unwrap();

    let historical_returns = vec![0.05, 0.03, 0.08, 0.02, 0.06]; // All positive
    let market_data = create_test_market_data("CONFIDENT", 100.0);

    let recommendation = sizer.calculate_position_size(
        "CONFIDENT",
        0.12,
        0.99, // Very high confidence
        &historical_returns,
        &market_data,
    ).await.unwrap();

    assert!(recommendation.recommended_fraction <= 0.25, "Should still respect max fraction limit");
    assert!(recommendation.confidence == 0.99, "Confidence should be preserved");
}

#[tokio::test]
async fn test_edge_case_very_low_confidence() {
    let config = KellyConfig::default();
    let mut sizer = KellyPositionSizer::new(config).unwrap();

    let historical_returns = vec![0.05, -0.02, 0.08, -0.03, 0.06];
    let market_data = create_test_market_data("UNCERTAIN", 100.0);

    let recommendation = sizer.calculate_position_size(
        "UNCERTAIN",
        0.08,
        0.1, // Very low confidence
        &historical_returns,
        &market_data,
    ).await.unwrap();

    assert!(recommendation.recommended_fraction <= 0.05, "Low confidence should result in small position");
}

#[tokio::test]
async fn test_serialization_of_recommendation() {
    let config = KellyConfig::default();
    let mut sizer = KellyPositionSizer::new(config).unwrap();

    let historical_returns = vec![0.05, -0.02, 0.08, -0.03, 0.06];
    let market_data = create_test_market_data("SERIALIZE", 100.0);

    let recommendation = sizer.calculate_position_size(
        "SERIALIZE",
        0.08,
        0.7,
        &historical_returns,
        &market_data,
    ).await.unwrap();

    // Test that recommendation can be serialized and deserialized
    let json = serde_json::to_string(&recommendation).unwrap();
    assert!(!json.is_empty(), "Should serialize to non-empty JSON");

    let deserialized: KellyPositionRecommendation = serde_json::from_str(&json).unwrap();
    assert_eq!(deserialized.symbol, recommendation.symbol, "Symbol should match after deserialization");
    assert_eq!(deserialized.recommended_fraction, recommendation.recommended_fraction, "Fraction should match");
}