foxhunt/tests/load_tests

Load Tests - Minimal Dependency Crate

Purpose: Fast-compiling load tests for Foxhunt Trading Service

Compilation Time: 20-30 seconds (vs 120-180s in original tests/ crate)

Dependency Reduction: 86% (5 deps vs 36 deps)

---

Quick Start

Run All Load Tests

cd tests/load_tests
cargo test --release -- --nocapture

Run Specific Test

# Baseline latency (1000 sequential orders)
cargo test --release test_1_baseline_latency -- --nocapture

# Concurrent connections (100 clients, 100 orders each)
cargo test --release test_2_concurrent_connections -- --nocapture

# Database performance (5000 orders)
cargo test --release test_4_database_performance -- --nocapture

# Resource monitoring (health + metrics)
cargo test --release test_5_resource_monitoring -- --nocapture

# Production readiness assessment
cargo test --release test_6_production_readiness -- --nocapture

Run Sustained Load Test (Ignored by Default)

# 5-minute sustained load (50 clients, 200 orders/sec each = 10K total)
cargo test --release test_3_sustained_load -- --ignored --nocapture

---

Prerequisites

1. Infrastructure Running

# Start PostgreSQL and Trading Service
cd ../..
docker-compose up -d postgres trading_service

# Verify services healthy
docker-compose ps

2. Trading Service Available

The load tests connect to:

• Trading Service gRPC: localhost:50052
• Health Endpoint: http://localhost:8081/health (test_5 only)
• Metrics Endpoint: http://localhost:9092/metrics (test_5 only)

---

Test Suite

Test 1: Baseline Latency

• Orders: 1,000 sequential
• Purpose: Single-client latency baseline
• Metrics: P50, P95, P99 latency + throughput

Test 2: Concurrent Connections

• Clients: 100 concurrent
• Orders per client: 100
• Total orders: 10,000
• Purpose: Concurrency stress test
• Metrics: Latency distribution + success rate

Test 3: Sustained Load (Ignored)

• Duration: 5 minutes
• Clients: 50 concurrent
• Target rate: 10,000 orders/sec total
• Purpose: Sustained load validation
• Metrics: Long-term stability

Test 4: Database Performance

• Orders: 5,000
• Purpose: Database write throughput
• Target: >2,000 writes/sec

Test 5: Resource Monitoring

• Purpose: Health + metrics validation
• Checks: HTTP health endpoint, Prometheus metrics
• Requires: health-checks feature

Test 6: Production Readiness

• Clients: 50 concurrent
• Orders per client: 200
• Total orders: 10,000
• Criteria:
  • Success rate >= 99%
  • Throughput >= 5,000 orders/sec
  • P99 latency < 100ms

---

Features

Default (No Features)

• Core gRPC load testing (tests 1-4, 6)
• Dependencies: tokio, tonic, uuid

health-checks (Optional)

cargo test --release --features health-checks

• Enables test_5 (resource monitoring)
• Adds reqwest dependency
• HTTP health + metrics checks

---

Performance Targets

Metric	Target	Typical
Success Rate	>= 99%	99.5-100%
Throughput	>= 5K orders/sec	7-10K
P50 Latency	< 20ms	10-15ms
P99 Latency	< 100ms	30-50ms
DB Writes/sec	>= 2K	2.5-3K

---

Troubleshooting

"Connection refused" Error

Trading Service not running on port 50052

Fix:

docker-compose up -d trading_service
docker-compose ps  # Verify "Up" status

"Too many open files" Error

ulimit: open files: increase limit

Fix:

ulimit -n 4096  # Increase file descriptor limit

High Latency

P99 latency > 100ms

Check:

1. PostgreSQL synchronous_commit setting
2. Network latency (localhost vs Docker)
3. System load (CPU, memory)

---

Compilation Time Comparison

Crate	Dependencies	Compile Time	Speedup
tests/ (original)	36	120-180s	Baseline
tests/load_tests	5	20-30s	6x faster

---

Architecture

Minimal Dependencies

[dependencies]
tokio = { workspace = true }           # Async runtime
tonic = { workspace = true }           # gRPC client
tonic-prost = { workspace = true }     # Protobuf runtime
prost = { workspace = true }           # Protobuf types
uuid = { workspace = true }            # Order IDs
reqwest = { optional = true }          # HTTP (feature-gated)

Build Process

1. build.rs compiles trading.proto from Trading Service
2. Generated code included via tonic::include_proto!("trading")
3. No heavy dependencies (ML, database clients, test frameworks)

---

Maintenance

Adding New Load Tests

1. Create new test function in tests/load_test_trading_service.rs:

#[tokio::test]
async fn test_7_my_new_load_test() -> Result<(), Box<dyn std::error::Error>> {
    // Test implementation
    Ok(())
}

2. Run:

cargo test --release test_7_my_new_load_test -- --nocapture

Updating Proto Files

If Trading Service proto changes:

# Rebuild will automatically pick up changes
cargo clean
cargo build --release

---

CI/CD Integration

GitHub Actions

- name: Run Load Tests
  run: |
    docker-compose up -d postgres trading_service
    cd tests/load_tests
    cargo test --release --features health-checks

GitLab CI

load_tests:
  script:
    - docker-compose up -d postgres trading_service
    - cd tests/load_tests
    - cargo test --release --features health-checks

---

Related Documentation

• LOAD_TEST_DEPENDENCY_OPTIMIZATION.md - Detailed analysis
• LOAD_TEST_OPTIMIZATION_SUMMARY.md - Implementation summary
• TESTING_PLAN.md - Overall testing strategy

---

Status: ✅ Production Ready Compilation Time: < 30 seconds ✅ Target Met: Yes (< 2 minutes) ✅