foxhunt/tests/e2e/tests/performance_validation_tests.rs

//! Performance Validation E2E Tests
//!
//! Comprehensive performance validation tests for the Foxhunt HFT system.
//! Tests critical path latency, throughput, resource utilization, and scalability.

use std::sync::Arc;
use std::time::Duration;

// Import E2E framework
use foxhunt_e2e::{e2e_test, E2ETestFramework, WorkflowTestResult};

// Import common types
use common::types::{Price, Quantity, Symbol};

// Helper function to create a new test workflow result
fn new_workflow_result(name: &str) -> WorkflowTestResult {
    WorkflowTestResult {
        workflow_name: name.to_string(),
        success: false,
        duration: Duration::from_secs(0),
        steps_completed: 0,
        total_steps: 0,
        error_message: None,
        metrics: std::collections::HashMap::new(),
        order_ids: Vec::new(),
        trades_executed: 0,
    }
}

// Helper function to mark result as success
fn mark_success(
    mut result: WorkflowTestResult,
    duration: Duration,
    steps: usize,
) -> WorkflowTestResult {
    result.success = true;
    result.duration = duration;
    result.steps_completed = steps;
    result.total_steps = steps;
    result
}

// Helper function to add metric
fn add_metric(result: &mut WorkflowTestResult, name: &str, value: f64) {
    result.metrics.insert(name.to_string(), value);
}

// Helper function to calculate percentile from sorted values
fn percentile(values: &[u64], p: f64) -> u64 {
    if values.is_empty() {
        return 0;
    }
    let mut sorted = values.to_vec();
    sorted.sort_unstable();
    let index = ((p / 100.0) * (sorted.len() - 1) as f64) as usize;
    sorted[index.min(sorted.len() - 1)]
}

// Test 1: Critical path sub-50μs latency validation
// Validates that the critical trading path meets HFT latency requirements
e2e_test!(test_critical_path_latency, |framework: Arc<
    E2ETestFramework,
>| async move {
    let start_time = Instant::now();
    let mut result = new_workflow_result("Critical Path Latency Validation");
    let mut steps = 0;

    // Step 1: Basic type creation latency measurement
    let type_creation_samples: Vec<u64> = (0..10000)
        .map(|i| {
            let start = Instant::now();
            let _symbol = Symbol::new(format!("TEST{}", i % 100));
            let _price = Price::from_f64(150.0 + (i as f64 * 0.01)).unwrap_or(Price::ZERO);
            let _qty = Quantity::from_u64(100 + i).unwrap_or(Quantity::ZERO);
            start.elapsed().as_nanos() as u64
        })
        .collect();

    let type_p50 = percentile(&type_creation_samples, 50.0);
    let type_p95 = percentile(&type_creation_samples, 95.0);

    add_metric(&mut result, "type_creation_p50_ns", type_p50 as f64);
    add_metric(&mut result, "type_creation_p95_ns", type_p95 as f64);

    // Type creation should be very fast (< 1μs P95)
    assert!(
        type_p95 < 1_000,
        "Type creation P95 should be <1μs, got {}ns",
        type_p95
    );
    steps += 1;

    // Step 2: Memory allocation latency
    let alloc_samples: Vec<u64> = (0..1000)
        .map(|_| {
            let start = Instant::now();
            let _vec: Vec<u64> = Vec::with_capacity(100);
            start.elapsed().as_nanos() as u64
        })
        .collect();

    let alloc_p95 = percentile(&alloc_samples, 95.0);
    add_metric(&mut result, "allocation_p95_ns", alloc_p95 as f64);
    steps += 1;

    // Step 3: Performance tracker recording latency
    let tracker = &framework.performance_tracker;
    let recording_samples: Vec<u64> = (0..1000)
        .map(|i| {
            let start = Instant::now();
            let _ = tracker.record_metric("test_metric", i as f64);
            start.elapsed().as_nanos() as u64
        })
        .collect();

    let recording_p95 = percentile(&recording_samples, 95.0);
    add_metric(&mut result, "metric_recording_p95_ns", recording_p95 as f64);
    steps += 1;

    // Step 4: Validate overall measurement overhead
    assert!(
        recording_p95 < 50_000,
        "Metric recording should be <50μs P95"
    );
    steps += 1;

    // Step 5: Price calculation latency
    let price_calc_samples: Vec<u64> = (0..10000)
        .map(|i| {
            let start = Instant::now();
            let price1 = Price::from_f64(100.0 + (i as f64 * 0.01)).unwrap();
            let price2 = Price::from_f64(150.0 - (i as f64 * 0.01)).unwrap();
            let _result = price1.to_f64() * price2.to_f64();
            start.elapsed().as_nanos() as u64
        })
        .collect();

    let price_p95 = percentile(&price_calc_samples, 95.0);
    add_metric(&mut result, "price_calculation_p95_ns", price_p95 as f64);

    assert!(price_p95 < 500, "Price calculations should be <500ns P95");
    steps += 1;

    // Step 6: Symbol lookup simulation
    let symbols: Vec<Symbol> = (0..100)
        .map(|i| Symbol::new(format!("SYM{:03}", i)))
        .collect();

    let lookup_samples: Vec<u64> = (0..10000)
        .map(|i| {
            let start = Instant::now();
            let _symbol = &symbols[i % symbols.len()];
            start.elapsed().as_nanos() as u64
        })
        .collect();

    let lookup_p95 = percentile(&lookup_samples, 95.0);
    add_metric(&mut result, "symbol_lookup_p95_ns", lookup_p95 as f64);
    steps += 1;

    // Step 7: End-to-end critical path simulation
    let e2e_samples: Vec<u64> = (0..1000)
        .map(|i| {
            let start = Instant::now();

            // Simulate critical path operations
            let _symbol = Symbol::new(format!("TEST{}", i % 10));
            let _price = Price::from_f64(150.0).unwrap();
            let _qty = Quantity::from_u64(100).unwrap();

            // Simulate risk check (minimal operation)
            let _risk_ok = _qty.to_f64() < 1_000_000.0;

            // Simulate position update
            let _new_position = _qty.to_f64() * _price.to_f64();

            start.elapsed().as_nanos() as u64
        })
        .collect();

    let e2e_p50 = percentile(&e2e_samples, 50.0);
    let e2e_p95 = percentile(&e2e_samples, 95.0);
    let e2e_p99 = percentile(&e2e_samples, 99.0);

    add_metric(&mut result, "e2e_simulation_p50_ns", e2e_p50 as f64);
    add_metric(&mut result, "e2e_simulation_p95_ns", e2e_p95 as f64);
    add_metric(&mut result, "e2e_simulation_p99_ns", e2e_p99 as f64);

    // Critical requirement: Sub-50μs for simplified path
    assert!(
        e2e_p95 < 50_000,
        "End-to-end simulation P95 should be <50μs, got {}ns",
        e2e_p95
    );
    steps += 1;

    // Step 8: Jitter analysis
    let jitter_samples: Vec<u64> = e2e_samples
        .windows(2)
        .map(|pair| (pair[1] as i64 - pair[0] as i64).abs() as u64)
        .collect();

    let jitter_p95 = percentile(&jitter_samples, 95.0);
    let jitter_max = jitter_samples.iter().max().unwrap_or(&0);

    add_metric(&mut result, "jitter_p95_ns", jitter_p95 as f64);
    add_metric(&mut result, "jitter_max_ns", *jitter_max as f64);

    assert!(
        jitter_p95 < 10_000,
        "Jitter P95 should be <10μs, got {}ns",
        jitter_p95
    );
    steps += 1;

    // Record all metrics to performance tracker
    for (name, value) in &result.metrics {
        tracker.record_metric(name, *value)?;
    }

    let duration = start_time.elapsed();
    let _result = mark_success(result, duration, steps);

    Ok(())
});

// Test 2: Throughput and scalability benchmarks
// Validates system throughput under various load conditions
e2e_test!(test_throughput_scalability, |framework: Arc<
    E2ETestFramework,
>| async move {
    let start_time = Instant::now();
    let mut result = new_workflow_result("Throughput Scalability Benchmarks");
    let mut steps = 0;

    // Step 1: Single-threaded baseline throughput
    let single_thread_start = Instant::now();
    let mut operations_completed = 0u64;
    let test_duration = Duration::from_secs(3);
    let end_time = single_thread_start + test_duration;

    while Instant::now() < end_time {
        // Simulate lightweight trading operation
        let _symbol = Symbol::new("EURUSD".to_string());
        let _price = Price::from_f64(1.1050).unwrap();
        let _qty = Quantity::from_u64(100_000).unwrap();
        operations_completed += 1;
    }

    let actual_duration = single_thread_start.elapsed().as_secs_f64();
    let single_thread_ops_per_sec = operations_completed as f64 / actual_duration;

    add_metric(
        &mut result,
        "single_thread_ops_per_sec",
        single_thread_ops_per_sec,
    );
    add_metric(
        &mut result,
        "single_thread_total_ops",
        operations_completed as f64,
    );

    // Should achieve at least 100k ops/sec for simple operations
    assert!(
        single_thread_ops_per_sec > 100_000.0,
        "Single-thread throughput should exceed 100k ops/sec, got {:.0}",
        single_thread_ops_per_sec
    );
    steps += 1;

    // Step 2: Memory bandwidth test with Vec operations
    let memory_test_data: Vec<f64> = (0..100_000).map(|i| i as f64 * 1.1).collect();
    let memory_start = Instant::now();

    let memory_operations = 1000;
    for _ in 0..memory_operations {
        let _sum: f64 = memory_test_data.iter().sum();
        std::hint::black_box(_sum); // Prevent optimization
    }

    let memory_duration = memory_start.elapsed().as_millis() as f64;
    let memory_bandwidth_mbps = (memory_test_data.len() * 8 * memory_operations) as f64
        / 1_000_000.0
        / (memory_duration / 1000.0);

    add_metric(&mut result, "memory_bandwidth_mbps", memory_bandwidth_mbps);
    steps += 1;

    // Step 3: Batch processing optimization test
    let batch_sizes = vec![1, 10, 50, 100, 500];
    let mut best_throughput = 0.0f64;
    let mut optimal_batch_size = 0;

    for batch_size in batch_sizes {
        let batch_start = Instant::now();
        let total_batches = 1000;

        for _ in 0..total_batches {
            let mut batch = Vec::with_capacity(batch_size);
            for i in 0..batch_size {
                batch.push((
                    Symbol::new(format!("SYM{}", i % 10)),
                    Price::from_f64(100.0 + i as f64).unwrap(),
                    Quantity::from_u64(1000).unwrap(),
                ));
            }
            // Simulate batch processing
            let _processed = batch.len();
            std::hint::black_box(_processed);
        }

        let batch_duration = batch_start.elapsed().as_secs_f64();
        let batch_ops_per_sec = (total_batches * batch_size) as f64 / batch_duration;

        add_metric(
            &mut result,
            &format!("batch_{}_ops_per_sec", batch_size),
            batch_ops_per_sec,
        );

        if batch_ops_per_sec > best_throughput {
            best_throughput = batch_ops_per_sec;
            optimal_batch_size = batch_size;
        }
    }

    add_metric(&mut result, "optimal_batch_size", optimal_batch_size as f64);
    add_metric(&mut result, "optimal_batch_ops_per_sec", best_throughput);
    steps += 1;

    // Step 4: Sustained performance test (10 seconds)
    let sustained_start = Instant::now();
    let mut sustained_samples = Vec::with_capacity(10000);
    let sustained_duration = Duration::from_secs(10);
    let sustained_end = sustained_start + sustained_duration;

    while Instant::now() < sustained_end {
        let sample_start = Instant::now();

        // Simulate trading operation
        let _symbol = Symbol::new("AAPL".to_string());
        let _price = Price::from_f64(150.0).unwrap();
        let _qty = Quantity::from_u64(100).unwrap();
        let _value = _price.to_f64() * _qty.to_f64();

        let elapsed = sample_start.elapsed().as_nanos() as u64;
        sustained_samples.push(elapsed);
    }

    let sustained_p50 = percentile(&sustained_samples, 50.0);
    let sustained_p95 = percentile(&sustained_samples, 95.0);
    let sustained_p99 = percentile(&sustained_samples, 99.0);

    add_metric(
        &mut result,
        "sustained_samples_count",
        sustained_samples.len() as f64,
    );
    add_metric(&mut result, "sustained_p50_ns", sustained_p50 as f64);
    add_metric(&mut result, "sustained_p95_ns", sustained_p95 as f64);
    add_metric(&mut result, "sustained_p99_ns", sustained_p99 as f64);

    // Sustained performance should not degrade significantly
    assert!(
        sustained_p95 < 100_000,
        "Sustained performance P95 should be <100μs"
    );
    steps += 1;

    // Step 5: Record all metrics to performance tracker
    let tracker = &framework.performance_tracker;
    for (name, value) in &result.metrics {
        tracker.record_metric(name, *value)?;
    }

    // Step 6: Calculate performance score
    let throughput_score = (single_thread_ops_per_sec / 100_000.0).min(10.0) * 10.0;
    let latency_score = if sustained_p95 < 50_000 {
        100.0
    } else if sustained_p95 < 100_000 {
        80.0
    } else {
        60.0
    };
    let overall_score = (throughput_score + latency_score) / 2.0;

    add_metric(&mut result, "throughput_score", throughput_score);
    add_metric(&mut result, "latency_score", latency_score);
    add_metric(&mut result, "overall_performance_score", overall_score);

    assert!(
        overall_score > 70.0,
        "Overall performance score should exceed 70/100, got {:.1}",
        overall_score
    );
    steps += 1;

    let duration = start_time.elapsed();
    let _result = mark_success(result, duration, steps);

    Ok(())
});

// Test 3: Resource utilization validation
// Validates memory usage and allocation patterns
e2e_test!(test_resource_utilization, |framework: Arc<
    E2ETestFramework,
>| async move {
    let start_time = Instant::now();
    let mut result = new_workflow_result("Resource Utilization Validation");
    let mut steps = 0;

    // Step 1: Baseline memory measurement
    let baseline_allocations = 1000;
    let baseline_start = Instant::now();

    for _ in 0..baseline_allocations {
        let _vec: Vec<u64> = Vec::with_capacity(100);
        std::hint::black_box(&_vec);
    }

    let baseline_duration = baseline_start.elapsed();
    add_metric(
        &mut result,
        "baseline_allocation_time_ms",
        baseline_duration.as_millis() as f64,
    );
    steps += 1;

    // Step 2: Stress test memory allocation
    let stress_allocations = 10000;
    let stress_start = Instant::now();

    for i in 0..stress_allocations {
        let _vec: Vec<u64> = (0..100).map(|x| x + i).collect();
        std::hint::black_box(&_vec);
    }

    let stress_duration = stress_start.elapsed();
    let alloc_per_sec = stress_allocations as f64 / stress_duration.as_secs_f64();

    add_metric(
        &mut result,
        "stress_allocation_time_ms",
        stress_duration.as_millis() as f64,
    );
    add_metric(&mut result, "allocations_per_sec", alloc_per_sec);
    steps += 1;

    // Step 3: Collection growth patterns
    let mut growth_vec = Vec::new();
    let growth_samples: Vec<u64> = (0..1000)
        .map(|i| {
            let start = Instant::now();
            growth_vec.push(i);
            start.elapsed().as_nanos() as u64
        })
        .collect();

    let growth_p95 = percentile(&growth_samples, 95.0);
    add_metric(&mut result, "vec_growth_p95_ns", growth_p95 as f64);
    steps += 1;

    // Step 4: Validate no memory leaks in short-lived allocations
    let leak_test_iterations = 10000;
    let leak_test_start = Instant::now();

    for i in 0..leak_test_iterations {
        let _temp: Vec<f64> = (0..1000).map(|x| (x + i) as f64).collect();
        // Dropped immediately - should not accumulate
    }

    let leak_test_duration = leak_test_start.elapsed();
    add_metric(
        &mut result,
        "leak_test_duration_ms",
        leak_test_duration.as_millis() as f64,
    );

    // If this takes too long, there might be allocation issues
    assert!(
        leak_test_duration < Duration::from_secs(5),
        "Leak test should complete within 5 seconds"
    );
    steps += 1;

    // Step 5: Record metrics
    let tracker = &framework.performance_tracker;
    for (name, value) in &result.metrics {
        tracker.record_metric(name, *value)?;
    }
    steps += 1;

    let duration = start_time.elapsed();
    let _result = mark_success(result, duration, steps);

    Ok(())
});

// Test 4: Performance regression detection
// Compares performance metrics against baseline expectations
e2e_test!(test_performance_regression, |_framework: Arc<
    E2ETestFramework,
>| async move {
    let start_time = Instant::now();
    let mut result = new_workflow_result("Performance Regression Detection");
    let mut steps = 0;

    // Define baseline expectations (these would come from historical data)
    let baselines = vec![
        ("type_creation_p95_ns", 1_000.0),
        ("price_calculation_p95_ns", 500.0),
        ("allocation_p95_ns", 10_000.0),
    ];

    // Step 1: Run performance benchmarks
    let type_samples: Vec<u64> = (0..10000)
        .map(|i| {
            let start = Instant::now();
            let _symbol = Symbol::new(format!("TEST{}", i));
            start.elapsed().as_nanos() as u64
        })
        .collect();

    let type_p95 = percentile(&type_samples, 95.0);
    add_metric(&mut result, "type_creation_p95_ns", type_p95 as f64);
    steps += 1;

    let price_samples: Vec<u64> = (0..10000)
        .map(|i| {
            let start = Instant::now();
            let _price = Price::from_f64(100.0 + i as f64).unwrap();
            start.elapsed().as_nanos() as u64
        })
        .collect();

    let price_p95 = percentile(&price_samples, 95.0);
    add_metric(&mut result, "price_calculation_p95_ns", price_p95 as f64);
    steps += 1;

    let alloc_samples: Vec<u64> = (0..1000)
        .map(|_| {
            let start = Instant::now();
            let _vec: Vec<u64> = Vec::with_capacity(100);
            start.elapsed().as_nanos() as u64
        })
        .collect();

    let alloc_p95 = percentile(&alloc_samples, 95.0);
    add_metric(&mut result, "allocation_p95_ns", alloc_p95 as f64);
    steps += 1;

    // Step 2: Compare against baselines
    let mut regressions = Vec::new();

    for (metric_name, baseline) in baselines {
        if let Some(&actual) = result.metrics.get(metric_name) {
            let regression_pct = ((actual - baseline) / baseline) * 100.0;
            add_metric(
                &mut result,
                &format!("{}_regression_pct", metric_name),
                regression_pct,
            );

            // Allow 20% degradation tolerance
            if regression_pct > 20.0 {
                regressions.push(format!(
                    "{}: {:.1}% regression (baseline: {:.0}, actual: {:.0})",
                    metric_name, regression_pct, baseline, actual
                ));
            }
        }
    }
    steps += 1;

    // Step 3: Validate no significant regressions
    if !regressions.is_empty() {
        result.error_message = Some(format!(
            "Performance regressions detected: {}",
            regressions.join("; ")
        ));
        result.success = false;
        return Err(anyhow::anyhow!(
            "Performance regressions: {:?}",
            regressions
        ));
    }
    steps += 1;

    let duration = start_time.elapsed();
    let _result = mark_success(result, duration, steps);

    Ok(())
});

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

    #[test]
    fn test_percentile_calculation() {
        let values = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
        assert_eq!(percentile(&values, 0.0), 1);
        assert_eq!(percentile(&values, 50.0), 5);
        assert_eq!(percentile(&values, 95.0), 10);
        assert_eq!(percentile(&values, 100.0), 10);
    }

    #[test]
    fn test_percentile_empty() {
        let values: Vec<u64> = vec![];
        assert_eq!(percentile(&values, 50.0), 0);
    }

    #[test]
    fn test_workflow_result_creation() {
        let result = new_workflow_result("test");
        assert_eq!(result.workflow_name, "test");
        assert!(!result.success);
        assert_eq!(result.steps_completed, 0);
    }
}