foxhunt/services/backtesting_service/tests/ml_backtest_integration_test.rs

//! ML Backtesting Integration Tests - TDD RED Phase
//!
//! This test suite follows strict TDD methodology:
//! 1. RED: Write failing tests (this file)
//! 2. GREEN: Implement minimal code to pass
//! 3. REFACTOR: Improve quality
//!
//! These tests will initially fail because the ML backtesting methods don't exist yet.

use anyhow::Result;
use backtesting_service::foxhunt::tli::{
    backtesting_service_server::BacktestingService,
    StartBacktestRequest, StartBacktestResponse,
    GetBacktestResultsRequest, GetBacktestResultsResponse,
    BacktestMetrics,
};
use backtesting_service::service::BacktestingServiceImpl;
use backtesting_service::repositories::DefaultRepositories;
use tokio::sync::mpsc;
use tonic::{Request, Response, Status};
use std::sync::Arc;
use chrono::Utc;

/// Helper to create test backtesting service instance
async fn create_test_backtesting_service() -> Result<BacktestingServiceImpl> {
    // Create service with mock repositories for testing
    use backtesting_service::repositories::BacktestingRepositories;
    let repositories: Arc<dyn BacktestingRepositories> = Arc::new(DefaultRepositories::mock());
    BacktestingServiceImpl::new(repositories, None).await
}

/// Helper to convert date string to Unix nanos
fn date_to_unix_nanos(date_str: &str) -> i64 {
    let date = chrono::NaiveDate::parse_from_str(date_str, "%Y-%m-%d")
        .unwrap()
        .and_hms_opt(0, 0, 0)
        .unwrap();
    date.and_utc().timestamp_nanos_opt().unwrap()
}

#[tokio::test]
async fn test_red_ml_backtest_execution() -> Result<()> {
    // RED: This test will fail because RunMLBacktest doesn't exist yet

    let service = create_test_backtesting_service().await?;
    
    let request = Request::new(StartBacktestRequest {
        strategy_name: "MLEnsemble".to_string(),
        symbols: vec!["ES.FUT".to_string()],
        start_date_unix_nanos: date_to_unix_nanos("2024-01-02"),
        end_date_unix_nanos: date_to_unix_nanos("2024-01-10"),
        initial_capital: 100000.0,
        parameters: vec![
            ("confidence_threshold".to_string(), "0.6".to_string()),
            ("use_ensemble".to_string(), "true".to_string()),
        ].into_iter().collect(),
        save_results: true,
        description: "ML ensemble backtest integration test".to_string(),
    });
    
    // This should succeed once we implement ML backtesting
    let response = service.start_backtest(request).await?;
    let result = response.into_inner();
    
    assert!(result.success, "ML backtest should start successfully");
    assert!(!result.backtest_id.is_empty(), "Should return valid backtest ID");
    
    // Wait for backtest to complete (simplified for test)
    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
    
    // Get results
    let results_request = Request::new(GetBacktestResultsRequest {
        backtest_id: result.backtest_id.clone(),
        include_trades: true,
        include_metrics: true,
    });
    
    let results_response = service.get_backtest_results(results_request).await?;
    let results = results_response.into_inner();
    
    // Verify ML backtest produced meaningful results
    assert!(results.metrics.is_some(), "Should have metrics");
    let metrics = results.metrics.unwrap();
    
    assert!(metrics.total_trades > 0, "Should have executed trades");
    assert!(metrics.sharpe_ratio > 0.0, "Should have positive Sharpe ratio");
    assert!(metrics.win_rate > 0.0 && metrics.win_rate <= 1.0, "Win rate should be 0-1");
    
    println!("✅ ML Backtest Results:");
    println!("   Total Trades: {}", metrics.total_trades);
    println!("   Sharpe Ratio: {:.2}", metrics.sharpe_ratio);
    println!("   Win Rate: {:.2}%", metrics.win_rate * 100.0);
    println!("   Total Return: {:.2}%", metrics.total_return * 100.0);
    
    Ok(())
}

#[tokio::test]
async fn test_red_ml_vs_rule_based_comparison() -> Result<()> {
    // RED: This test will fail because strategy comparison doesn't exist yet
    
    let service = create_test_backtesting_service().await?;
    
    // Run ML backtest
    let ml_request = Request::new(StartBacktestRequest {
        strategy_name: "MLEnsemble".to_string(),
        symbols: vec!["ES.FUT".to_string()],
        start_date_unix_nanos: date_to_unix_nanos("2024-01-02"),
        end_date_unix_nanos: date_to_unix_nanos("2024-01-10"),
        initial_capital: 100000.0,
        parameters: vec![
            ("confidence_threshold".to_string(), "0.6".to_string()),
        ].into_iter().collect(),
        save_results: true,
        description: "ML backtest for comparison".to_string(),
    });
    
    let ml_response = service.start_backtest(ml_request).await?;
    let ml_id = ml_response.into_inner().backtest_id;
    
    // Run rule-based backtest for comparison
    let rule_request = Request::new(StartBacktestRequest {
        strategy_name: "MovingAverageCrossover".to_string(),
        symbols: vec!["ES.FUT".to_string()],
        start_date_unix_nanos: date_to_unix_nanos("2024-01-02"),
        end_date_unix_nanos: date_to_unix_nanos("2024-01-10"),
        initial_capital: 100000.0,
        parameters: vec![
            ("fast_period".to_string(), "10".to_string()),
            ("slow_period".to_string(), "20".to_string()),
        ].into_iter().collect(),
        save_results: true,
        description: "Rule-based backtest for comparison".to_string(),
    });
    
    let rule_response = service.start_backtest(rule_request).await?;
    let rule_id = rule_response.into_inner().backtest_id;
    
    // Wait for both to complete
    tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
    
    // Get ML results
    let ml_results = service.get_backtest_results(Request::new(GetBacktestResultsRequest {
        backtest_id: ml_id.clone(),
        include_trades: false,
        include_metrics: true,
    })).await?.into_inner();
    
    // Get rule-based results
    let rule_results = service.get_backtest_results(Request::new(GetBacktestResultsRequest {
        backtest_id: rule_id.clone(),
        include_trades: false,
        include_metrics: true,
    })).await?.into_inner();
    
    let ml_metrics = ml_results.metrics.unwrap();
    let rule_metrics = rule_results.metrics.unwrap();
    
    println!("📊 Strategy Comparison:");
    println!("   ML Sharpe: {:.2} | Rule Sharpe: {:.2}", ml_metrics.sharpe_ratio, rule_metrics.sharpe_ratio);
    println!("   ML Win Rate: {:.2}% | Rule Win Rate: {:.2}%", ml_metrics.win_rate * 100.0, rule_metrics.win_rate * 100.0);
    println!("   ML Return: {:.2}% | Rule Return: {:.2}%", ml_metrics.total_return * 100.0, rule_metrics.total_return * 100.0);
    
    // ML should generally outperform rule-based (but not guaranteed in all periods)
    // We just verify both produce valid results
    assert!(ml_metrics.sharpe_ratio > 0.0, "ML should have positive Sharpe");
    assert!(rule_metrics.sharpe_ratio > 0.0, "Rule-based should have positive Sharpe");
    
    Ok(())
}

#[tokio::test]
async fn test_red_ml_confidence_threshold_impact() -> Result<()> {
    // RED: This test will fail because confidence threshold filtering doesn't exist yet
    
    let service = create_test_backtesting_service().await?;
    
    // Run with low confidence threshold (more trades)
    let low_threshold_request = Request::new(StartBacktestRequest {
        strategy_name: "MLEnsemble".to_string(),
        symbols: vec!["ES.FUT".to_string()],
        start_date_unix_nanos: date_to_unix_nanos("2024-01-02"),
        end_date_unix_nanos: date_to_unix_nanos("2024-01-10"),
        initial_capital: 100000.0,
        parameters: vec![
            ("confidence_threshold".to_string(), "0.5".to_string()),
        ].into_iter().collect(),
        save_results: true,
        description: "Low confidence threshold test".to_string(),
    });
    
    let low_response = service.start_backtest(low_threshold_request).await?;
    let low_id = low_response.into_inner().backtest_id;
    
    // Run with high confidence threshold (fewer trades)
    let high_threshold_request = Request::new(StartBacktestRequest {
        strategy_name: "MLEnsemble".to_string(),
        symbols: vec!["ES.FUT".to_string()],
        start_date_unix_nanos: date_to_unix_nanos("2024-01-02"),
        end_date_unix_nanos: date_to_unix_nanos("2024-01-10"),
        initial_capital: 100000.0,
        parameters: vec![
            ("confidence_threshold".to_string(), "0.8".to_string()),
        ].into_iter().collect(),
        save_results: true,
        description: "High confidence threshold test".to_string(),
    });
    
    let high_response = service.start_backtest(high_threshold_request).await?;
    let high_id = high_response.into_inner().backtest_id;
    
    // Wait for both to complete
    tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
    
    // Get results
    let low_results = service.get_backtest_results(Request::new(GetBacktestResultsRequest {
        backtest_id: low_id,
        include_trades: false,
        include_metrics: true,
    })).await?.into_inner();
    
    let high_results = service.get_backtest_results(Request::new(GetBacktestResultsRequest {
        backtest_id: high_id,
        include_trades: false,
        include_metrics: true,
    })).await?.into_inner();
    
    let low_metrics = low_results.metrics.unwrap();
    let high_metrics = high_results.metrics.unwrap();
    
    // Higher threshold should result in fewer trades
    assert!(low_metrics.total_trades > high_metrics.total_trades,
            "Low threshold should produce more trades than high threshold");
    
    // Higher threshold might have better win rate (filtering low-confidence trades)
    println!("📈 Confidence Threshold Impact:");
    println!("   Low (0.5) - Trades: {}, Win Rate: {:.2}%", low_metrics.total_trades, low_metrics.win_rate * 100.0);
    println!("   High (0.8) - Trades: {}, Win Rate: {:.2}%", high_metrics.total_trades, high_metrics.win_rate * 100.0);
    
    Ok(())
}

#[tokio::test]
async fn test_red_ml_target_metrics() -> Result<()> {
    // RED: This test verifies we meet target metrics once implemented
    
    let service = create_test_backtesting_service().await?;
    
    let request = Request::new(StartBacktestRequest {
        strategy_name: "MLEnsemble".to_string(),
        symbols: vec!["ES.FUT".to_string()],
        start_date_unix_nanos: date_to_unix_nanos("2024-01-02"),
        end_date_unix_nanos: date_to_unix_nanos("2024-01-10"),
        initial_capital: 100000.0,
        parameters: vec![
            ("confidence_threshold".to_string(), "0.6".to_string()),
        ].into_iter().collect(),
        save_results: true,
        description: "Target metrics validation".to_string(),
    });
    
    let response = service.start_backtest(request).await?;
    let backtest_id = response.into_inner().backtest_id;
    
    // Wait for completion
    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
    
    let results = service.get_backtest_results(Request::new(GetBacktestResultsRequest {
        backtest_id,
        include_trades: false,
        include_metrics: true,
    })).await?.into_inner();
    
    let metrics = results.metrics.unwrap();
    
    // Target metrics from CLAUDE.md
    println!("🎯 Target Metrics Validation:");
    println!("   Sharpe Ratio: {:.2} (target: >1.5)", metrics.sharpe_ratio);
    println!("   Win Rate: {:.2}% (target: >55%)", metrics.win_rate * 100.0);
    println!("   Max Drawdown: {:.2}% (target: <20%)", metrics.max_drawdown * 100.0);
    
    // These are aggressive targets - we'll verify reasonable values for now
    assert!(metrics.sharpe_ratio > 0.0, "Sharpe should be positive");
    assert!(metrics.win_rate > 0.4, "Win rate should be >40%");
    assert!(metrics.max_drawdown < 0.5, "Max drawdown should be <50%");
    
    // Goal: Eventually achieve these targets with trained models
    if metrics.sharpe_ratio > 1.5 {
        println!("   ✅ ACHIEVED Sharpe target!");
    }
    if metrics.win_rate > 0.55 {
        println!("   ✅ ACHIEVED Win rate target!");
    }
    
    Ok(())
}