foxhunt/tests/load_tests/tests/load_test_concurrent.rs

//! Concurrent Connections Load Tests
//!
//! Tests multi-client concurrent performance with 100+ connections.
//! Validates system behavior under parallel load.
//!
//! Run with: cargo test --package tests --test load_test_concurrent --release -- --nocapture

use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::time::timeout;
use tonic::Request;

use integration_load_tests::*;

/// Test: Concurrent connections (100 clients)
#[tokio::test]
async fn test_concurrent_connections() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n╔═══════════════════════════════════════════════════════════╗");
    println!("║  CONCURRENT CONNECTIONS TEST (100 Clients)               ║");
    println!("╚═══════════════════════════════════════════════════════════╝");

    let num_clients = 100;
    let orders_per_client = 100;

    let metrics = Arc::new(PerformanceMetrics::new());
    let latencies = Arc::new(tokio::sync::Mutex::new(Vec::new()));

    println!(
        "🚀 Spawning {} concurrent clients ({} orders each)...",
        num_clients, orders_per_client
    );

    let start_time = Instant::now();
    let mut tasks = Vec::new();

    for client_id in 0..num_clients {
        let metrics_clone = Arc::clone(&metrics);
        let latencies_clone = Arc::clone(&latencies);

        let task = tokio::spawn(async move {
            let mut client = match connect_trading_service().await {
                Ok(c) => c,
                Err(e) => {
                    eprintln!("❌ Client {} connection failed: {}", client_id, e);
                    return;
                },
            };

            for order_idx in 0..orders_per_client {
                let request =
                    create_order_request((client_id * orders_per_client + order_idx) as u64);
                let req_start = Instant::now();

                match timeout(
                    Duration::from_secs(5),
                    client.submit_order(Request::new(request)),
                )
                .await
                {
                    Ok(Ok(_response)) => {
                        let latency_ns = req_start.elapsed().as_nanos() as u64;
                        metrics_clone.record_success(latency_ns);
                        latencies_clone.lock().await.push(latency_ns);
                    },
                    Ok(Err(status)) => {
                        metrics_clone.record_failure();
                        if order_idx < 2 {
                            eprintln!(
                                "❌ Client {} order {} failed: {}",
                                client_id, order_idx, status
                            );
                        }
                    },
                    Err(_) => {
                        metrics_clone.record_failure();
                        if order_idx < 2 {
                            eprintln!("⏱️  Client {} order {} timed out", client_id, order_idx);
                        }
                    },
                }
            }
        });

        tasks.push(task);
    }

    // Wait for all clients to complete
    for task in tasks {
        let _ = task.await;
    }

    let test_duration = start_time.elapsed();
    let latencies_vec = latencies.lock().await.clone();

    let metrics_final = PerformanceMetrics {
        latencies_ns: latencies_vec.clone(),
        successful_orders: AtomicU64::new(metrics.successful_orders.load(Ordering::Relaxed)),
        failed_orders: AtomicU64::new(metrics.failed_orders.load(Ordering::Relaxed)),
        total_orders: AtomicU64::new(metrics.total_orders.load(Ordering::Relaxed)),
        test_duration,
    };

    metrics_final.print_summary(&latencies_vec);

    // Assertions for concurrent performance
    let success_rate = (metrics_final.successful_orders.load(Ordering::Relaxed) as f64
        / metrics_final.total_orders.load(Ordering::Relaxed) as f64)
        * 100.0;

    assert!(
        success_rate >= 95.0,
        "Success rate too low: {:.2}%",
        success_rate
    );

    Ok(())
}