foxhunt/tests/load_tests/tests/load_test_database.rs

//! Database and Resource Load Tests
//!
//! Tests database performance under load and system resource monitoring.
//! Validates write throughput and health/metrics endpoints.
//!
//! Run with: cargo test --package tests --test load_test_database --release -- --nocapture

use std::time::Instant;
use tonic::Request;

use integration_load_tests::*;

/// Test: Database performance under load
#[tokio::test]
async fn test_database_performance() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n╔═══════════════════════════════════════════════════════════╗");
    println!("║  DATABASE PERFORMANCE TEST                                ║");
    println!("╚═══════════════════════════════════════════════════════════╝");

    // This test measures order submission which triggers database writes
    let num_orders = 5000;
    let mut client = connect_trading_service().await?;

    println!(
        "📊 Submitting {} orders to measure database performance...",
        num_orders
    );

    let start_time = Instant::now();
    let mut success_count = 0;
    let mut failure_count = 0;

    for i in 0..num_orders {
        let request = create_order_request(i);

        match client.submit_order(Request::new(request)).await {
            Ok(_) => success_count += 1,
            Err(e) => {
                failure_count += 1;
                if failure_count <= 5 {
                    eprintln!("❌ Order {} failed: {}", i, e);
                }
            },
        }
    }

    let duration = start_time.elapsed();
    let throughput = success_count as f64 / duration.as_secs_f64();

    println!("\n📈 DATABASE PERFORMANCE:");
    println!("  Duration:         {:.2}s", duration.as_secs_f64());
    println!("  Successful:       {}", success_count);
    println!("  Failed:           {}", failure_count);
    println!("  DB Writes/sec:    {:.0}", throughput);

    if throughput >= 2000.0 {
        println!("✅ Database performance GOOD: {:.0} writes/sec", throughput);
    } else {
        println!(
            "⚠️  Database performance: {:.0} writes/sec (expected >2000)",
            throughput
        );
    }

    // Assert minimum database throughput
    assert!(
        throughput >= 1000.0,
        "Database throughput too low: {:.0} writes/sec",
        throughput
    );

    Ok(())
}

/// Test: Resource monitoring (health and metrics endpoints)
#[tokio::test]
async fn test_resource_monitoring() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n╔═══════════════════════════════════════════════════════════╗");
    println!("║  RESOURCE MONITORING TEST                                 ║");
    println!("╚═══════════════════════════════════════════════════════════╝");

    // Check service health
    let health_url = "http://localhost:8081/health";
    println!("🏥 Checking service health at {}...", health_url);

    match reqwest::get(health_url).await {
        Ok(response) => {
            println!("✅ Health check response: {}", response.status());
            if let Ok(body) = response.text().await {
                println!("   Body: {}", body);
            }
        },
        Err(e) => {
            println!("⚠️  Health check failed: {}", e);
        },
    }

    // Check Prometheus metrics
    let metrics_url = "http://localhost:9092/metrics";
    println!("\n📊 Checking Prometheus metrics at {}...", metrics_url);

    match reqwest::get(metrics_url).await {
        Ok(response) => {
            if let Ok(body) = response.text().await {
                // Parse relevant metrics
                let lines: Vec<&str> = body
                    .lines()
                    .filter(|line| !line.starts_with('#') && !line.is_empty())
                    .collect();

                println!("✅ Found {} metric entries", lines.len());

                // Show some key metrics
                for line in lines.iter().take(10) {
                    if line.contains("orders") || line.contains("latency") || line.contains("cpu") {
                        println!("   {}", line);
                    }
                }
            }
        },
        Err(e) => {
            println!("⚠️  Metrics check failed: {}", e);
        },
    }

    Ok(())
}