foxhunt/tests/e2e/src/lib.rs

//! Foxhunt E2E Testing Framework
//!
//! Comprehensive End-to-End testing framework for the Foxhunt High-Frequency Trading system.
//! Tests complete integration between TLI client, Trading Service, Backtesting Service,
//! ML Training Service, database interactions, and complete trading workflows.

pub mod clients;
pub mod database;
pub mod framework;
pub mod ml_pipeline;
pub mod performance;
pub mod services;
pub mod utils;
pub mod workflows;

use anyhow::Result;
use std::future::Future;
use std::pin::Pin;

pub use framework::E2ETestFramework;

/// E2E Test Result type
pub type E2ETestResult<T = ()> = Result<T>;

/// Async test function trait
pub type E2ETestFn = fn(E2ETestFramework) -> Pin<Box<dyn Future<Output = E2ETestResult> + Send>>;

/// E2E test macro for creating standardized tests
///
/// This macro provides:
/// - Automatic service orchestration
/// - Test framework initialization
/// - Proper cleanup on test completion or failure
/// - Performance monitoring
/// - Comprehensive logging
///
/// # Example
///
/// ```rust
/// use foxhunt_e2e::{e2e_test, E2ETestFramework, E2ETestResult};
///
/// e2e_test!(test_basic_trading_flow, |framework: E2ETestFramework| async {
///     let trading_client = framework.get_trading_client().await?;
///     
///     let response = trading_client.get_account_info().await?;
///     assert!(response.total_value > 0.0);
///     
///     Ok(())
/// });
/// ```
#[macro_export]
macro_rules! e2e_test {
    ($test_name:ident, |$framework:ident: $framework_type:ty| $test_body:expr) => {
        #[tokio::test]
        async fn $test_name() -> $crate::E2ETestResult {
            use tracing::{info, error, warn};
            use std::time::Instant;

            info!("🚀 Starting E2E test: {}", stringify!($test_name));
            let start_time = Instant::now();

            // Initialize the test framework
            let mut $framework = match $crate::framework::E2ETestFramework::new().await {
                Ok(framework) => {
                    info!("✅ E2E test framework initialized successfully");
                    framework
                }
                Err(e) => {
                    error!("❌ Failed to initialize E2E test framework: {}", e);
                    return Err(e);
                }
            };

            // Start services if needed
            if let Err(e) = $framework.start_services().await {
                error!("❌ Failed to start services: {}", e);
                return Err(e);
            }

            // Execute the test body
            let test_result: $crate::E2ETestResult = async move $test_body.await;

            // Cleanup and report results
            match &test_result {
                Ok(_) => {
                    let duration = start_time.elapsed();
                    info!("✅ E2E test {} completed successfully in {:?}",
                          stringify!($test_name), duration);
                }
                Err(e) => {
                    let duration = start_time.elapsed();
                    error!("❌ E2E test {} failed after {:?}: {}",
                           stringify!($test_name), duration, e);
                }
            }

            // Stop services and cleanup
            if let Err(e) = $framework.stop_services().await {
                warn!("⚠️ Failed to stop services cleanly: {}", e);
            }

            test_result
        }
    };
}

/// Utilities for test data generation and validation
pub mod test_utils {
    use anyhow::Result;
    use rand::Rng;
    use std::time::{SystemTime, UNIX_EPOCH};

    /// Generate realistic market data for testing
    pub fn generate_market_data(symbol: &str, count: usize) -> Vec<MarketTick> {
        let mut rng = rand::thread_rng();
        let mut price = 150.0; // Base price
        let mut ticks = Vec::with_capacity(count);

        for i in 0..count {
            price += rng.gen_range(-0.5..0.5);
            price = price.max(100.0).min(200.0); // Keep price in reasonable range

            ticks.push(MarketTick {
                symbol: symbol.to_string(),
                timestamp: SystemTime::now()
                    .duration_since(UNIX_EPOCH)
                    .unwrap()
                    .as_nanos() as i64,
                price,
                size: rng.gen_range(100..1000),
                exchange: "NASDAQ".to_string(),
            });
        }

        ticks
    }

    /// Generate realistic order for testing
    pub fn generate_test_order(symbol: &str) -> TestOrder {
        let mut rng = rand::thread_rng();

        TestOrder {
            symbol: symbol.to_string(),
            side: if rng.gen_bool(0.5) { "buy" } else { "sell" }.to_string(),
            order_type: "market".to_string(),
            quantity: rng.gen_range(100.0..1000.0),
            price: None, // Market order
            time_in_force: "day".to_string(),
        }
    }

    /// Wait for condition with timeout
    pub async fn wait_for_condition<F, Fut>(
        condition: F,
        timeout_secs: u64,
        check_interval_ms: u64,
    ) -> Result<()>
    where
        F: Fn() -> Fut,
        Fut: std::future::Future<Output = bool>,
    {
        use tokio::time::{sleep, Duration, Instant};

        let start = Instant::now();
        let timeout = Duration::from_secs(timeout_secs);
        let interval = Duration::from_millis(check_interval_ms);

        while start.elapsed() < timeout {
            if condition().await {
                return Ok(());
            }
            sleep(interval).await;
        }

        Err(anyhow::anyhow!(
            "Condition not met within {} seconds",
            timeout_secs
        ))
    }
}

/// Test data structures
#[derive(Debug, Clone)]
pub struct MarketTick {
    pub symbol: String,
    pub timestamp: i64,
    pub price: f64,
    pub size: i32,
    pub exchange: String,
}

#[derive(Debug, Clone)]
pub struct TestOrder {
    pub symbol: String,
    pub side: String,
    pub order_type: String,
    pub quantity: f64,
    pub price: Option<f64>,
    pub time_in_force: String,
}

#[derive(Debug, Clone)]
pub struct TestPosition {
    pub symbol: String,
    pub quantity: f64,
    pub average_price: f64,
    pub market_value: f64,
    pub unrealized_pnl: f64,
}

/// Re-export commonly used types
pub use clients::*;
pub use database::DatabaseTestHarness;
pub use ml_pipeline::MLPipelineTestHarness;
pub use performance::PerformanceTracker;
pub use services::ServiceManager;
pub use utils::*;

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

    #[tokio::test]
    async fn test_framework_initialization() {
        let framework = E2ETestFramework::new().await;
        assert!(
            framework.is_ok(),
            "Framework should initialize successfully"
        );
    }

    #[test]
    fn test_data_generation() {
        let ticks = test_utils::generate_market_data("AAPL", 10);
        assert_eq!(ticks.len(), 10);
        assert!(ticks.iter().all(|t| t.symbol == "AAPL"));
        assert!(ticks.iter().all(|t| t.price > 100.0 && t.price < 200.0));
    }

    #[test]
    fn test_order_generation() {
        let order = test_utils::generate_test_order("MSFT");
        assert_eq!(order.symbol, "MSFT");
        assert!(order.side == "buy" || order.side == "sell");
        assert!(order.quantity >= 100.0 && order.quantity <= 1000.0);
    }
}