foxhunt/tests/run_comprehensive_tests.rs

#!/usr/bin/env cargo +nightly run --bin run_comprehensive_tests

//! Comprehensive Integration Test Runner for Foxhunt HFT System
//!
//! This is the main entry point for running the complete integration test suite
//! across all services and components of the Foxhunt HFT trading system.
//!
//! Usage:
//!   cargo test --test run_comprehensive_tests            # Run full test suite
//!   cargo test --test run_comprehensive_tests smoke      # Run smoke tests only
//!   cargo test --test run_comprehensive_tests services   # Run service tests only
//!   cargo test --test run_comprehensive_tests e2e        # Run end-to-end tests only
//!
//! Environment Variables:
//!   TEST_DATABASE_URL    - PostgreSQL test database connection string
//!   RUST_LOG            - Logging level (default: info)
//!   TEST_TIMEOUT        - Test timeout in seconds (default: 1800)

use std::env;
use std::time::Duration;
use tokio;

use tests::framework::TestOrchestrator;
use tests::integration::{MasterIntegrationTestRunner, MasterTestResults};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::init();

    println!("🚀 Foxhunt HFT System - Comprehensive Integration Test Suite");
    println!("=".repeat(80));

    // Parse command line arguments
    let args: Vec<String> = env::args().collect();
    let test_mode = if args.len() > 1 {
        args[1].as_str()
    } else {
        "full"
    };

    // Validate environment
    validate_test_environment().await?;

    // Initialize master test runner
    let runner = MasterIntegrationTestRunner::new().await?;

    // Execute tests based on mode
    let results = match test_mode {
        "smoke" => {
            println!("💨 Running Smoke Tests Only");
            runner.run_smoke_tests().await?
        },
        "services" => {
            println!("🔧 Running Service Integration Tests Only");
            run_service_tests_only(&runner).await?
        },
        "e2e" => {
            println!("🔄 Running End-to-End Tests Only");
            run_e2e_tests_only(&runner).await?
        },
        "full" | _ => {
            println!("🎯 Running Complete Integration Test Suite");
            runner.run_all_integration_tests().await?
        },
    };

    // Print final results and exit with appropriate code
    print_final_summary(&results);

    if results.system_validated {
        println!("✅ All tests passed! System ready for deployment.");
        std::process::exit(0);
    } else {
        println!("❌ Test failures detected! System requires fixes before deployment.");
        std::process::exit(1);
    }
}

/// Validate test environment and prerequisites
async fn validate_test_environment() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔍 Validating Test Environment...");

    // Check required environment variables
    let required_vars = vec![
        ("DATABASE_URL", "PostgreSQL database connection required"),
        ("RUST_LOG", "Logging configuration (defaulting to 'info')"),
    ];

    for (var, description) in &required_vars {
        match env::var(var) {
            Ok(value) => {
                if var == &"DATABASE_URL" {
                    println!("   ✅ {}: configured", var);
                } else {
                    println!("   ✅ {}: {}", var, value);
                }
            },
            Err(_) => {
                if var == &"DATABASE_URL" {
                    return Err(format!("❌ Missing required environment variable: {} - {}", var, description).into());
                } else {
                    println!("   ⚠️ {}: not set, {}", var, description);
                    if var == &"RUST_LOG" {
                        env::set_var("RUST_LOG", "info");
                    }
                }
            }
        }
    }

    // Check test database connectivity
    println!("   🔌 Testing database connectivity...");
    match test_database_connection().await {
        Ok(_) => println!("   ✅ Database connection successful"),
        Err(e) => {
            return Err(format!("❌ Database connection failed: {}", e).into());
        }
    }

    // Check for required ports availability
    let required_ports = vec![50051, 50052, 50053]; // Trading, Backtesting, ML Training
    for port in &required_ports {
        match test_port_availability(*port).await {
            true => println!("   ✅ Port {} available for testing", port),
            false => println!("   ⚠️ Port {} may be in use - tests may fail", port),
        }
    }

    println!("✅ Environment validation completed\n");
    Ok(())
}

/// Test database connection
async fn test_database_connection() -> Result<(), Box<dyn std::error::Error>> {
    let database_url = env::var("DATABASE_URL")
        .or_else(|_| env::var("TEST_DATABASE_URL"))
        .unwrap_or_else(|_| "postgresql://foxhunt:foxhunt@localhost:5432/foxhunt_test".to_string());

    let pool = sqlx::PgPool::connect(&database_url).await?;

    // Simple health check query
    sqlx::query("SELECT 1 as health_check")
        .fetch_one(&pool)
        .await?;

    pool.close().await;
    Ok(())
}

/// Test if a port is available
async fn test_port_availability(port: u16) -> bool {
    use std::net::{IpAddr, Ipv4Addr, SocketAddr};
    use tokio::net::TcpListener;

    let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), port);

    match TcpListener::bind(addr).await {
        Ok(_) => true,
        Err(_) => false,
    }
}

/// Run only service integration tests
async fn run_service_tests_only(runner: &MasterIntegrationTestRunner) -> Result<MasterTestResults, Box<dyn std::error::Error>> {
    use tests::integration::{TradingServiceTests, BacktestingServiceTests, MLTrainingServiceTests, TestSummary, MasterTestResults};
    use std::time::Instant;

    let start_time = Instant::now();
    let mut all_results = Vec::new();
    let mut test_summary = TestSummary::new();

    println!("🔧 Running Service Integration Tests");

    // Create test suites
    let trading_tests = TradingServiceTests::new().await?;
    let backtesting_tests = BacktestingServiceTests::new().await?;
    let ml_training_tests = MLTrainingServiceTests::new().await?;

    // Run service tests in parallel
    let (trading_results, backtesting_results, ml_training_results) = tokio::join!(
        trading_tests.run_all_tests(),
        backtesting_tests.run_all_tests(),
        ml_training_tests.run_all_tests()
    );

    // Collect results
    if let Ok(results) = trading_results {
        test_summary.add_results(&results);
        all_results.extend(results);
        println!("✅ Trading Service tests completed");
    } else {
        test_summary.services_failed = true;
        println!("❌ Trading Service tests failed");
    }

    if let Ok(results) = backtesting_results {
        test_summary.add_results(&results);
        all_results.extend(results);
        println!("✅ Backtesting Service tests completed");
    } else {
        test_summary.services_failed = true;
        println!("❌ Backtesting Service tests failed");
    }

    if let Ok(results) = ml_training_results {
        test_summary.add_results(&results);
        all_results.extend(results);
        println!("✅ ML Training Service tests completed");
    } else {
        test_summary.services_failed = true;
        println!("❌ ML Training Service tests failed");
    }

    let duration = start_time.elapsed();

    Ok(MasterTestResults {
        total_duration: duration,
        all_results,
        summary: test_summary,
        system_validated: !test_summary.services_failed,
    })
}

/// Run only end-to-end tests
async fn run_e2e_tests_only(runner: &MasterIntegrationTestRunner) -> Result<MasterTestResults, Box<dyn std::error::Error>> {
    use tests::integration::{ComprehensiveServiceTests, TestSummary, MasterTestResults};
    use std::time::Instant;

    let start_time = Instant::now();
    let mut all_results = Vec::new();
    let mut test_summary = TestSummary::new();

    println!("🔄 Running End-to-End Tests");

    let comprehensive_tests = ComprehensiveServiceTests::new().await?;
    match comprehensive_tests.run_all_tests().await {
        Ok(results) => {
            test_summary.add_results(&results);
            all_results.extend(results);
            println!("✅ End-to-End tests completed");
        }
        Err(_) => {
            test_summary.e2e_failed = true;
            println!("❌ End-to-End tests failed");
        }
    }

    let duration = start_time.elapsed();

    Ok(MasterTestResults {
        total_duration: duration,
        all_results,
        summary: test_summary,
        system_validated: !test_summary.e2e_failed,
    })
}

/// Print final test summary
fn print_final_summary(results: &MasterTestResults) {
    println!("\n" + "=".repeat(80).as_str());
    println!("🎯 FINAL TEST EXECUTION SUMMARY");
    println!("=".repeat(80));

    println!("⏱️ Execution Time: {:.1} minutes", results.total_duration.as_secs_f64() / 60.0);
    println!("📊 Test Results:");
    println!("   • Total Suites: {}", results.all_results.len());
    println!("   • Passed: {} ✅", results.summary.total_passed);
    println!("   • Failed: {} ❌", results.summary.total_failed);

    let success_rate = if results.all_results.is_empty() {
        0.0
    } else {
        (results.summary.total_passed as f64 / results.all_results.len() as f64) * 100.0
    };
    println!("   • Success Rate: {:.1}%", success_rate);

    if results.system_validated {
        println!("\n🎉 SYSTEM STATUS: ✅ VALIDATED");
        println!("   System is ready for production deployment!");
    } else {
        println!("\n⚠️ SYSTEM STATUS: ❌ VALIDATION FAILED");
        println!("   Critical issues detected - system requires fixes before deployment!");

        if results.summary.total_failed > 0 {
            println!("\n❌ Failed Tests:");
            for (i, result) in results.all_results.iter().enumerate().filter(|(_, r)| !r.passed) {
                println!("   {}. {} - {} failures", i + 1, result.test_name, result.failures.len());
            }
        }
    }

    // Performance indicators
    if let Some(perf) = &results.summary.performance_summary {
        println!("\n⚡ Performance Indicators:");
        println!("   • Average Latency: {:.1}μs", perf.avg_latency_us);
        println!("   • P99 Latency: {:.1}μs", perf.p99_latency_us);
        println!("   • Throughput: {:.0} ops/sec", perf.avg_throughput_ops_sec);

        if perf.meets_hft_requirements {
            println!("   • HFT Requirements: ✅ MET");
        } else {
            println!("   • HFT Requirements: ❌ NOT MET");
        }
    }

    println!("\n" + "=".repeat(80).as_str());
}

#[cfg(test)]
mod integration_tests {
    use super::*;
    use tokio;

    #[tokio::test]
    async fn test_environment_validation() {
        // Set minimal environment for testing
        env::set_var("DATABASE_URL", "postgresql://test:test@localhost:5432/test");
        env::set_var("RUST_LOG", "info");

        // This should not panic
        let result = validate_test_environment().await;

        // We expect this might fail in CI/test environments, so we just check it doesn't panic
        match result {
            Ok(_) => println!("Environment validation passed"),
            Err(e) => println!("Environment validation failed (expected in test environment): {}", e),
        }
    }

    #[tokio::test]
    async fn test_comprehensive_runner_initialization() {
        let runner = MasterIntegrationTestRunner::new().await;
        assert!(runner.is_ok(), "Master test runner should initialize successfully");
    }

    #[tokio::test]
    async fn test_smoke_tests_execution() {
        let runner = MasterIntegrationTestRunner::new().await
            .expect("Failed to create test runner");

        let smoke_results = runner.run_smoke_tests().await
            .expect("Failed to run smoke tests");

        // Smoke tests should complete within reasonable time
        assert!(smoke_results.total_duration.as_secs() <= 60,
            "Smoke tests took too long: {}s", smoke_results.total_duration.as_secs());

        // Should have executed some tests
        assert!(!smoke_results.all_results.is_empty(),
            "No smoke tests were executed");
    }
}

// Module-level integration test that can be run with `cargo test`
#[tokio::test]
#[ignore] // Ignored by default due to long execution time
async fn comprehensive_integration_test_suite() {
    println!("🚀 Starting Comprehensive Integration Test Suite");

    let runner = MasterIntegrationTestRunner::new().await
        .expect("Failed to initialize master test runner");

    let results = runner.run_all_integration_tests().await
        .expect("Failed to execute comprehensive test suite");

    // Print summary
    print_final_summary(&results);

    // Validate results
    assert!(results.total_duration.as_secs() <= 2400, // 40 minutes max
        "Test suite took too long: {} minutes", results.total_duration.as_secs() / 60);

    assert!(!results.all_results.is_empty(),
        "No integration tests were executed");

    // For a healthy system, we expect high success rate
    let success_rate = results.summary.total_passed as f64 /
                      (results.summary.total_passed + results.summary.total_failed) as f64;

    assert!(success_rate >= 0.75, // At least 75% success rate
        "Success rate too low: {:.1}% - System may have critical issues",
        success_rate * 100.0);

    println!("✅ Comprehensive integration test suite completed successfully!");
}