foxhunt/services/backtesting_service/tests/integration_tests.rs

//! Integration tests for Backtesting Service
//!
//! Comprehensive tests covering:
//! - Backtest execution lifecycle
//! - Strategy loading and validation
//! - Performance analysis
//! - Historical model versioning
//! - Progress streaming
//! - Error handling
//! - Concurrent backtests

use anyhow::Result;
use std::sync::Arc;
use std::collections::HashMap;
use tonic::{Request, Response, Status};
use backtesting_service::foxhunt::tli::{
    backtesting_service_server::BacktestingService,
    StartBacktestRequest, StopBacktestRequest, GetBacktestStatusRequest,
    GetBacktestResultsRequest, ListBacktestsRequest,
    BacktestStatus, BacktestConfig, StrategyConfig,
};
use backtesting_service::{
    service::BacktestingServiceImpl,
    repositories::BacktestingRepositories,
    model_loader_stub::backtesting_cache::BacktestingModelCache,
};

/// Mock repository implementation for testing
struct MockBacktestingRepositories;

#[async_trait::async_trait]
impl BacktestingRepositories for MockBacktestingRepositories {
    async fn save_backtest_result(
        &self,
        _id: &str,
        _results: &[u8],
    ) -> Result<()> {
        Ok(())
    }

    async fn load_backtest_result(&self, _id: &str) -> Result<Option<Vec<u8>>> {
        Ok(None)
    }

    async fn list_backtests(&self, _limit: usize) -> Result<Vec<String>> {
        Ok(vec![])
    }
}

/// Setup test backtesting service
async fn setup_backtesting_service() -> Result<BacktestingServiceImpl> {
    let repositories = Arc::new(MockBacktestingRepositories);
    let model_cache = None; // For basic tests, no model cache needed

    BacktestingServiceImpl::new(repositories, model_cache).await
}

#[tokio::test]
async fn test_start_backtest_simple_strategy() -> Result<()> {
    println!("\n=== Test: Start Backtest with Simple Strategy ===");

    let service = setup_backtesting_service().await?;

    let request = Request::new(StartBacktestRequest {
        config: Some(BacktestConfig {
            start_date: "2024-01-01".to_string(),
            end_date: "2024-03-31".to_string(),
            initial_capital: 100000.0,
            symbols: vec!["AAPL".to_string(), "GOOGL".to_string()],
            commission_rate: 0.001,
            slippage_model: Some("fixed".to_string()),
            slippage_bps: 5.0,
        }),
        strategy: Some(StrategyConfig {
            strategy_name: "momentum".to_string(),
            parameters: {
                let mut params = HashMap::new();
                params.insert("lookback_days".to_string(), "20".to_string());
                params.insert("threshold".to_string(), "0.02".to_string());
                params
            },
            model_configs: vec![],
        }),
    });

    let response = service.start_backtest(request).await?;
    let backtest = response.into_inner();

    println!("✓ Backtest started: {}", backtest.backtest_id);
    assert!(!backtest.backtest_id.is_empty());
    assert_eq!(backtest.status, BacktestStatus::Pending as i32);

    Ok(())
}

#[tokio::test]
async fn test_start_backtest_invalid_date_range() -> Result<()> {
    println!("\n=== Test: Reject Invalid Date Range ===");

    let service = setup_backtesting_service().await?;

    // End date before start date
    let request = Request::new(StartBacktestRequest {
        config: Some(BacktestConfig {
            start_date: "2024-06-01".to_string(),
            end_date: "2024-01-01".to_string(), // Invalid: before start
            initial_capital: 100000.0,
            symbols: vec!["AAPL".to_string()],
            commission_rate: 0.001,
            slippage_model: Some("fixed".to_string()),
            slippage_bps: 5.0,
        }),
        strategy: Some(StrategyConfig {
            strategy_name: "simple".to_string(),
            parameters: HashMap::new(),
            model_configs: vec![],
        }),
    });

    let result = service.start_backtest(request).await;

    assert!(result.is_err(), "Invalid date range should be rejected");
    if let Err(status) = result {
        println!("✓ Rejected with: {}", status.message());
        assert_eq!(status.code(), tonic::Code::InvalidArgument);
    }

    Ok(())
}

#[tokio::test]
async fn test_start_backtest_zero_capital() -> Result<()> {
    println!("\n=== Test: Reject Zero Initial Capital ===");

    let service = setup_backtesting_service().await?;

    let request = Request::new(StartBacktestRequest {
        config: Some(BacktestConfig {
            start_date: "2024-01-01".to_string(),
            end_date: "2024-03-31".to_string(),
            initial_capital: 0.0, // Invalid: zero capital
            symbols: vec!["AAPL".to_string()],
            commission_rate: 0.001,
            slippage_model: Some("fixed".to_string()),
            slippage_bps: 5.0,
        }),
        strategy: Some(StrategyConfig {
            strategy_name: "simple".to_string(),
            parameters: HashMap::new(),
            model_configs: vec![],
        }),
    });

    let result = service.start_backtest(request).await;

    assert!(result.is_err(), "Zero capital should be rejected");
    if let Err(status) = result {
        println!("✓ Rejected with: {}", status.message());
        assert!(status.message().contains("capital"));
    }

    Ok(())
}

#[tokio::test]
async fn test_start_backtest_empty_symbols() -> Result<()> {
    println!("\n=== Test: Reject Empty Symbol List ===");

    let service = setup_backtesting_service().await?;

    let request = Request::new(StartBacktestRequest {
        config: Some(BacktestConfig {
            start_date: "2024-01-01".to_string(),
            end_date: "2024-03-31".to_string(),
            initial_capital: 100000.0,
            symbols: vec![], // Invalid: empty list
            commission_rate: 0.001,
            slippage_model: Some("fixed".to_string()),
            slippage_bps: 5.0,
        }),
        strategy: Some(StrategyConfig {
            strategy_name: "simple".to_string(),
            parameters: HashMap::new(),
            model_configs: vec![],
        }),
    });

    let result = service.start_backtest(request).await;

    assert!(result.is_err(), "Empty symbols should be rejected");
    if let Err(status) = result {
        println!("✓ Rejected with: {}", status.message());
        assert!(status.message().contains("symbols"));
    }

    Ok(())
}

#[tokio::test]
async fn test_stop_backtest() -> Result<()> {
    println!("\n=== Test: Stop Running Backtest ===");

    let service = setup_backtesting_service().await?;

    // Start a backtest first
    let start_request = Request::new(StartBacktestRequest {
        config: Some(BacktestConfig {
            start_date: "2024-01-01".to_string(),
            end_date: "2024-12-31".to_string(), // Long period
            initial_capital: 100000.0,
            symbols: vec!["AAPL".to_string()],
            commission_rate: 0.001,
            slippage_model: Some("fixed".to_string()),
            slippage_bps: 5.0,
        }),
        strategy: Some(StrategyConfig {
            strategy_name: "long_running".to_string(),
            parameters: HashMap::new(),
            model_configs: vec![],
        }),
    });

    let start_response = service.start_backtest(start_request).await?;
    let backtest_id = start_response.into_inner().backtest_id;
    println!("  Backtest started: {}", backtest_id);

    // Now stop it
    let stop_request = Request::new(StopBacktestRequest {
        backtest_id: backtest_id.clone(),
    });

    let stop_response = service.stop_backtest(stop_request).await?;
    let stop_result = stop_response.into_inner();

    println!("✓ Backtest stopped: {}", backtest_id);
    assert!(stop_result.success);

    Ok(())
}

#[tokio::test]
async fn test_stop_nonexistent_backtest() -> Result<()> {
    println!("\n=== Test: Stop Nonexistent Backtest ===");

    let service = setup_backtesting_service().await?;

    let request = Request::new(StopBacktestRequest {
        backtest_id: "nonexistent_backtest_12345".to_string(),
    });

    let result = service.stop_backtest(request).await;

    // Should return error or failure indicator
    match result {
        Ok(response) => {
            let stop_result = response.into_inner();
            assert!(!stop_result.success, "Stopping nonexistent backtest should fail");
            println!("✓ Stop failed as expected: {}", stop_result.message);
        }
        Err(status) => {
            println!("✓ Rejected with: {}", status.message());
            assert_eq!(status.code(), tonic::Code::NotFound);
        }
    }

    Ok(())
}

#[tokio::test]
async fn test_get_backtest_status() -> Result<()> {
    println!("\n=== Test: Get Backtest Status ===");

    let service = setup_backtesting_service().await?;

    // Start a backtest
    let start_request = Request::new(StartBacktestRequest {
        config: Some(BacktestConfig {
            start_date: "2024-01-01".to_string(),
            end_date: "2024-03-31".to_string(),
            initial_capital: 100000.0,
            symbols: vec!["MSFT".to_string()],
            commission_rate: 0.001,
            slippage_model: Some("fixed".to_string()),
            slippage_bps: 5.0,
        }),
        strategy: Some(StrategyConfig {
            strategy_name: "status_test".to_string(),
            parameters: HashMap::new(),
            model_configs: vec![],
        }),
    });

    let start_response = service.start_backtest(start_request).await?;
    let backtest_id = start_response.into_inner().backtest_id;

    // Get status
    let status_request = Request::new(GetBacktestStatusRequest {
        backtest_id: backtest_id.clone(),
    });

    let status_response = service.get_backtest_status(status_request).await?;
    let status = status_response.into_inner();

    println!("✓ Status retrieved for: {}", backtest_id);
    assert!(!status.backtest_id.is_empty());
    println!("  Status: {:?}", status.status);
    println!("  Progress: {}%", status.progress);

    Ok(())
}

#[tokio::test]
async fn test_get_backtest_results() -> Result<()> {
    println!("\n=== Test: Get Backtest Results ===");

    let service = setup_backtesting_service().await?;

    // Start a simple backtest
    let start_request = Request::new(StartBacktestRequest {
        config: Some(BacktestConfig {
            start_date: "2024-01-01".to_string(),
            end_date: "2024-01-31".to_string(), // Short period for quick completion
            initial_capital: 100000.0,
            symbols: vec!["AAPL".to_string()],
            commission_rate: 0.001,
            slippage_model: Some("fixed".to_string()),
            slippage_bps: 5.0,
        }),
        strategy: Some(StrategyConfig {
            strategy_name: "quick_test".to_string(),
            parameters: HashMap::new(),
            model_configs: vec![],
        }),
    });

    let start_response = service.start_backtest(start_request).await?;
    let backtest_id = start_response.into_inner().backtest_id;

    // Wait a bit for backtest to complete (in real scenario)
    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;

    // Get results
    let results_request = Request::new(GetBacktestResultsRequest {
        backtest_id: backtest_id.clone(),
    });

    let results_response = service.get_backtest_results(results_request).await;

    match results_response {
        Ok(response) => {
            let results = response.into_inner();
            println!("✓ Results retrieved for: {}", backtest_id);
            if let Some(metrics) = results.performance_metrics {
                println!("  Total Return: {:.2}%", metrics.total_return * 100.0);
                println!("  Sharpe Ratio: {:.2}", metrics.sharpe_ratio);
            }
        }
        Err(status) => {
            // Might not be completed yet
            println!("  Backtest not yet completed: {}", status.message());
        }
    }

    Ok(())
}

#[tokio::test]
async fn test_list_backtests() -> Result<()> {
    println!("\n=== Test: List Backtests ===");

    let service = setup_backtesting_service().await?;

    // Start a few backtests
    for i in 1..=3 {
        let request = Request::new(StartBacktestRequest {
            config: Some(BacktestConfig {
                start_date: "2024-01-01".to_string(),
                end_date: "2024-03-31".to_string(),
                initial_capital: 100000.0,
                symbols: vec!["AAPL".to_string()],
                commission_rate: 0.001,
                slippage_model: Some("fixed".to_string()),
                slippage_bps: 5.0,
            }),
            strategy: Some(StrategyConfig {
                strategy_name: format!("list_test_{}", i),
                parameters: HashMap::new(),
                model_configs: vec![],
            }),
        });

        let _ = service.start_backtest(request).await?;
    }

    // List all backtests
    let list_request = Request::new(ListBacktestsRequest {
        limit: 10,
        offset: 0,
        status_filter: None,
    });

    let list_response = service.list_backtests(list_request).await?;
    let backtests = list_response.into_inner();

    println!("✓ Listed {} backtests", backtests.backtests.len());
    assert!(backtests.backtests.len() >= 3);

    Ok(())
}

#[tokio::test]
async fn test_concurrent_backtests() -> Result<()> {
    println!("\n=== Test: Concurrent Backtests ===");

    let service = Arc::new(setup_backtesting_service().await?);
    let mut handles = vec![];

    // Start 5 backtests concurrently
    for i in 1..=5 {
        let svc = service.clone();
        let handle = tokio::spawn(async move {
            let request = Request::new(StartBacktestRequest {
                config: Some(BacktestConfig {
                    start_date: "2024-01-01".to_string(),
                    end_date: "2024-03-31".to_string(),
                    initial_capital: 100000.0,
                    symbols: vec!["SPY".to_string()],
                    commission_rate: 0.001,
                    slippage_model: Some("fixed".to_string()),
                    slippage_bps: 5.0,
                }),
                strategy: Some(StrategyConfig {
                    strategy_name: format!("concurrent_{}", i),
                    parameters: HashMap::new(),
                    model_configs: vec![],
                }),
            });

            svc.start_backtest(request).await
        });
        handles.push(handle);
    }

    // Wait for all to complete
    let mut success_count = 0;
    for handle in handles {
        if let Ok(Ok(_)) = handle.await {
            success_count += 1;
        }
    }

    println!("✓ {}/5 concurrent backtests started successfully", success_count);
    assert_eq!(success_count, 5, "All concurrent backtests should start");

    Ok(())
}

#[tokio::test]
async fn test_backtest_with_multiple_symbols() -> Result<()> {
    println!("\n=== Test: Backtest with Multiple Symbols ===");

    let service = setup_backtesting_service().await?;

    let request = Request::new(StartBacktestRequest {
        config: Some(BacktestConfig {
            start_date: "2024-01-01".to_string(),
            end_date: "2024-03-31".to_string(),
            initial_capital: 100000.0,
            symbols: vec![
                "AAPL".to_string(),
                "GOOGL".to_string(),
                "MSFT".to_string(),
                "AMZN".to_string(),
            ],
            commission_rate: 0.001,
            slippage_model: Some("fixed".to_string()),
            slippage_bps: 5.0,
        }),
        strategy: Some(StrategyConfig {
            strategy_name: "multi_symbol".to_string(),
            parameters: {
                let mut params = HashMap::new();
                params.insert("rebalance_frequency".to_string(), "weekly".to_string());
                params
            },
            model_configs: vec![],
        }),
    });

    let response = service.start_backtest(request).await?;
    let backtest = response.into_inner();

    println!("✓ Multi-symbol backtest started: {}", backtest.backtest_id);
    assert!(!backtest.backtest_id.is_empty());

    Ok(())
}

#[tokio::test]
async fn test_backtest_with_high_commission() -> Result<()> {
    println!("\n=== Test: Backtest with High Commission Rate ===");

    let service = setup_backtesting_service().await?;

    let request = Request::new(StartBacktestRequest {
        config: Some(BacktestConfig {
            start_date: "2024-01-01".to_string(),
            end_date: "2024-03-31".to_string(),
            initial_capital: 100000.0,
            symbols: vec!["AAPL".to_string()],
            commission_rate: 0.01, // 1% commission (very high)
            slippage_model: Some("fixed".to_string()),
            slippage_bps: 50.0, // High slippage too
        }),
        strategy: Some(StrategyConfig {
            strategy_name: "high_cost".to_string(),
            parameters: HashMap::new(),
            model_configs: vec![],
        }),
    });

    let response = service.start_backtest(request).await?;
    let backtest = response.into_inner();

    println!("✓ High commission backtest started: {}", backtest.backtest_id);
    // Should still start, but will show impact of costs in results

    Ok(())
}

#[tokio::test]
async fn test_backtest_strategy_parameters() -> Result<()> {
    println!("\n=== Test: Backtest with Strategy Parameters ===");

    let service = setup_backtesting_service().await?;

    let mut parameters = HashMap::new();
    parameters.insert("sma_fast".to_string(), "10".to_string());
    parameters.insert("sma_slow".to_string(), "50".to_string());
    parameters.insert("position_size".to_string(), "0.1".to_string());

    let request = Request::new(StartBacktestRequest {
        config: Some(BacktestConfig {
            start_date: "2024-01-01".to_string(),
            end_date: "2024-03-31".to_string(),
            initial_capital: 100000.0,
            symbols: vec!["SPY".to_string()],
            commission_rate: 0.001,
            slippage_model: Some("fixed".to_string()),
            slippage_bps: 5.0,
        }),
        strategy: Some(StrategyConfig {
            strategy_name: "sma_crossover".to_string(),
            parameters,
            model_configs: vec![],
        }),
    });

    let response = service.start_backtest(request).await?;
    let backtest = response.into_inner();

    println!("✓ Parameterized strategy backtest started: {}", backtest.backtest_id);
    assert!(!backtest.backtest_id.is_empty());

    Ok(())
}