foxhunt/tests/Cargo.toml

[package]
name = "tests"
version = "0.1.0"
edition = "2021"
description = "Comprehensive test suite for Foxhunt HFT trading system - organized by unit, integration, and performance tests"

[dependencies]
# Core async runtime
tokio.workspace = true
tokio-test.workspace = true
tokio-stream.workspace = true

# Core Foxhunt crates
trading_engine.workspace = true
risk.workspace = true
ml.workspace = true
data.workspace = true
tli.workspace = true
common.workspace = true

# Serialization and time
serde.workspace = true
serde_json.workspace = true
toml.workspace = true
chrono.workspace = true

# Mathematical operations
num.workspace = true

# Concurrency and atomics
crossbeam.workspace = true
arc-swap.workspace = true

# Async utilities
async-trait.workspace = true
futures.workspace = true

# Database and UUID
sqlx.workspace = true
uuid.workspace = true
rust_decimal.workspace = true

# Error handling
anyhow.workspace = true
thiserror.workspace = true

# CLI parsing for test utilities
clap.workspace = true

# Additional test dependencies
rand.workspace = true
parking_lot.workspace = true
hdrhistogram.workspace = true

# Testing utilities
criterion.workspace = true
proptest.workspace = true
quickcheck.workspace = true

# Database integration testing
# testcontainers = { workspace = true, optional = true }  # REMOVED - too heavy
redis = { workspace = true, optional = true }
influxdb2 = { workspace = true, optional = true }

# Performance monitoring
tracing.workspace = true
tracing-subscriber.workspace = true

# Memory profiling (optional)
dhat = { version = "0.3", optional = true }
jemalloc_pprof = { version = "0.4", optional = true }

[dev-dependencies]
# Additional test utilities
tempfile = "3.8"
serial_test = "3.0"
rstest = "0.18"

[features]
default = ["performance-tests"]

# Test feature flags
performance-tests = []
stress-tests = []
memory-profiling = ["dhat", "jemalloc_pprof"]
coverage-analysis = []
gpu-tests = []
integration-tests = ["redis", "influxdb2"]  # Removed testcontainers

# Performance optimization features
simd = []
lock-free = []
cache-optimized = []

[lib]
name = "critical_tests"
path = "lib.rs"

[[bin]]
name = "integration_test_runner"
path = "test_runner.rs"

[target.'cfg(target_os = "linux")'.dependencies]
# Linux-specific performance monitoring
perf-event = { version = "0.4", optional = true }

# Documentation configuration
[package.metadata.docs.rs]
all-features = true
rustdoc-args = ["--cfg", "docsrs"]

# Cargo configuration for testing
[package.metadata.cargo-udeps.ignore]
normal = ["criterion"]

# Test execution configuration
[package.metadata.test]
# Timeout for individual tests (in seconds)
timeout = 300

# Maximum memory usage per test (in MB)
max-memory = 1024

# Parallel test execution settings
parallel = true
max-threads = 8

# Coverage configuration
[package.metadata.coverage]
# Minimum coverage threshold (percentage)
threshold = 80.0

# Directories to include in coverage
include = [
    "src/",
    "../trading_engine/src/",
    "../risk/src/",
    "../ml/src/",
]

# Files to exclude from coverage
exclude = [
    "tests/",
    "benches/",
    "*/mock_*.rs",
    "*/test_*.rs",
]

# Performance benchmark configuration
[package.metadata.bench]
# Benchmark output format
format = "html"

# Baseline for performance regression detection
baseline = "main"

# Performance thresholds (fail if exceeded)
thresholds = [
    { name = "lock_free_queue_latency", max = "50ns" },
    { name = "simd_vwap_calculation", max = "1us" },
    { name = "var_calculation", max = "50us" },
    { name = "order_processing", max = "50us" },
    { name = "ml_inference", max = "50us" },
]

# HFT-specific test configuration
[package.metadata.hft]
# Latency requirements (in nanoseconds)
max_latencies = [
    { operation = "atomic_increment", max = 20 },
    { operation = "queue_push", max = 100 },
    { operation = "queue_pop", max = 100 },
    { operation = "simd_operation", max = 1000 },
    { operation = "risk_check", max = 50000 },
    { operation = "order_validation", max = 10000 },
    { operation = "ml_inference", max = 50000 },
]

# Throughput requirements (operations per second)
min_throughput = [
    { operation = "lock_free_operations", min = 1000000 },
    { operation = "simd_calculations", min = 500000 },
    { operation = "order_processing", min = 100000 },
    { operation = "risk_calculations", min = 50000 },
]

# Memory requirements
max_memory_allocation_time = "100ns"
max_memory_usage_mb = 100

# Cache efficiency requirements
min_cache_hit_ratio = 0.95
max_false_sharing_penalty = 2.0

# SIMD requirements
min_simd_speedup = 2.0
required_simd_features = ["avx2", "fma"]

# Example test execution commands:
#
# Run all critical path tests:
# cargo test --package critical-path-tests
#
# Run specific test suite:
# cargo run --bin test_runner lockfree
# cargo run --bin test_runner simd
# cargo run --bin test_runner risk
# cargo run --bin test_runner ml
# cargo run --bin test_runner order
# cargo run --bin test_runner memory
# cargo run --bin test_runner cache
# cargo run --bin test_runner all
#
# Run performance benchmarks:
# cargo run --bin performance_benchmark --release
#
# Generate coverage report:
# cargo run --bin coverage_report
#
# Run with memory profiling:
# cargo test --features memory-profiling
#
# Run stress tests:
# cargo test --features stress-tests
#
# Run with all optimizations:
# cargo test --release --features "simd,lock-free,cache-optimized"