foxhunt/tests/load_tests/tests/load_test_baseline.rs

//! Baseline Latency Load Tests
//!
//! Tests single-client baseline performance without concurrency.
//! Establishes performance baseline for comparison.
//!
//! Run with: cargo test --package tests --test load_test_baseline --release -- --nocapture

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

use integration_load_tests::*;

/// Test: Baseline latency with single client
#[tokio::test]
async fn test_baseline_latency() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n╔═══════════════════════════════════════════════════════════╗");
    println!("║  BASELINE LATENCY TEST (Single Client)                   ║");
    println!("╚═══════════════════════════════════════════════════════════╝");

    let mut client = connect_trading_service().await?;
    let num_requests = 1000;
    let mut latencies = Vec::with_capacity(num_requests);

    println!("📊 Sending {} orders sequentially...", num_requests);

    let start_time = Instant::now();

    for i in 0..num_requests {
        let request = create_order_request(i as u64);
        let req_start = Instant::now();

        let result = client.submit_order(Request::new(request)).await;
        let latency_ns = req_start.elapsed().as_nanos() as u64;

        latencies.push(latency_ns);

        if result.is_err() && i < 5 {
            eprintln!("❌ Order {} failed: {:?}", i, result.err());
        }
    }

    let test_duration = start_time.elapsed();

    let (min, p50, p95, p99, max) = PerformanceMetrics::calculate_percentiles(latencies.clone());

    println!("\n📈 BASELINE RESULTS:");
    println!("  Duration:     {:.2}s", test_duration.as_secs_f64());
    println!(
        "  Throughput:   {:.0} orders/sec",
        num_requests as f64 / test_duration.as_secs_f64()
    );
    println!("  Min Latency:  {:.2}ms", min as f64 / 1_000_000.0);
    println!("  P50 Latency:  {:.2}ms", p50 as f64 / 1_000_000.0);
    println!("  P95 Latency:  {:.2}ms", p95 as f64 / 1_000_000.0);
    println!("  P99 Latency:  {:.2}ms", p99 as f64 / 1_000_000.0);
    println!("  Max Latency:  {:.2}ms", max as f64 / 1_000_000.0);

    // Assertions for baseline performance
    assert!(
        p99 < 100_000_000,
        "P99 latency too high: {:.2}ms",
        p99 as f64 / 1_000_000.0
    );

    Ok(())
}