foxhunt/ml/tests/test_regime_orchestrator.rs

//! Integration Tests for Regime Orchestrator
//!
//! Tests the complete end-to-end flow:
//! 1. CUSUM break detection
//! 2. Regime classification (Trending, Ranging, Volatile)
//! 3. Database persistence (regime_states, regime_transitions)
//! 4. Transition tracking

use chrono::Utc;
use ml::regime::orchestrator::{Bar, RegimeOrchestrator};
use sqlx::PgPool;

/// Helper to create test bars with trending pattern
fn create_trending_bars(count: usize, base_price: f64) -> Vec<Bar> {
    let base_time = Utc::now();
    (0..count)
        .map(|i| {
            let price = base_price + (i as f64 * 2.0); // Strong uptrend
            Bar {
                timestamp: base_time + chrono::Duration::seconds(i as i64 * 60),
                open: price,
                high: price + 1.0,
                low: price - 0.5,
                close: price + 0.8,
                volume: 1000.0,
            }
        })
        .collect()
}

/// Helper to create ranging bars (oscillating)
fn create_ranging_bars(count: usize, base_price: f64) -> Vec<Bar> {
    let base_time = Utc::now();
    (0..count)
        .map(|i| {
            let cycle = (i as f64 * std::f64::consts::PI / 10.0).sin();
            let price = base_price + cycle * 5.0; // Oscillate ±5
            Bar {
                timestamp: base_time + chrono::Duration::seconds(i as i64 * 60),
                open: price,
                high: price + 0.5,
                low: price - 0.5,
                close: price,
                volume: 1000.0,
            }
        })
        .collect()
}

/// Helper to create volatile bars (large ranges)
fn create_volatile_bars(count: usize, base_price: f64) -> Vec<Bar> {
    let base_time = Utc::now();
    (0..count)
        .map(|i| {
            let price = base_price + (i as f64 % 2.0) * 10.0 - 5.0; // Large swings
            Bar {
                timestamp: base_time + chrono::Duration::seconds(i as i64 * 60),
                open: price,
                high: price * 1.1, // 10% range
                low: price * 0.9,
                close: price + (i as f64 % 3.0),
                volume: 1000.0,
            }
        })
        .collect()
}

#[sqlx::test(fixtures("regime_detection"))]
async fn test_orchestrator_initialization(pool: PgPool) -> sqlx::Result<()> {
    let orchestrator = RegimeOrchestrator::new(pool.clone())
        .await
        .expect("Failed to create orchestrator");

    // Verify CUSUM sums are initialized to zero
    let (s_plus, s_minus) = orchestrator.get_cusum_sums();
    assert_eq!(s_plus, 0.0, "CUSUM S+ should be initialized to 0");
    assert_eq!(s_minus, 0.0, "CUSUM S- should be initialized to 0");

    // Verify ADX is initialized to zero
    let adx = orchestrator.get_adx();
    assert_eq!(adx, 0.0, "ADX should be initialized to 0");

    Ok(())
}

#[sqlx::test(fixtures("regime_detection"))]
async fn test_orchestrator_insufficient_data(pool: PgPool) -> sqlx::Result<()> {
    let mut orchestrator = RegimeOrchestrator::new(pool.clone())
        .await
        .expect("Failed to create orchestrator");

    // Create insufficient bars (< 20)
    let bars = create_trending_bars(10, 100.0);

    // Should return InsufficientData error
    let result = orchestrator.detect_and_persist("ES.FUT", &bars).await;

    assert!(result.is_err(), "Should fail with insufficient data");

    if let Err(e) = result {
        let error_msg = e.to_string();
        assert!(
            error_msg.contains("Insufficient data"),
            "Error should mention insufficient data"
        );
    }

    Ok(())
}

#[sqlx::test(fixtures("regime_detection"))]
async fn test_orchestrator_trending_detection(pool: PgPool) -> sqlx::Result<()> {
    let mut orchestrator = RegimeOrchestrator::new(pool.clone())
        .await
        .expect("Failed to create orchestrator");

    // Create trending bars
    let bars = create_trending_bars(60, 100.0);

    // Detect and persist regime
    let regime_state = orchestrator
        .detect_and_persist("ES.FUT", &bars)
        .await
        .expect("Failed to detect regime");

    // Should detect trending or normal (early bars might not trigger break)
    assert!(
        regime_state.regime == "Trending" || regime_state.regime == "Normal",
        "Expected Trending or Normal regime, got: {}",
        regime_state.regime
    );

    // Confidence should be valid (0-1)
    assert!(
        regime_state.confidence >= 0.0 && regime_state.confidence <= 1.0,
        "Confidence should be in [0, 1], got: {}",
        regime_state.confidence
    );

    // Verify database persistence
    let db_regime = sqlx::query!(
        r#"
        SELECT regime, confidence, adx, cusum_s_plus, cusum_s_minus
        FROM regime_states
        WHERE symbol = $1
        ORDER BY event_timestamp DESC
        LIMIT 1
        "#,
        "ES.FUT"
    )
    .fetch_one(&pool)
    .await?;

    assert_eq!(
        db_regime.regime, regime_state.regime,
        "Database regime should match returned regime"
    );
    assert!(
        (db_regime.confidence - regime_state.confidence).abs() < 1e-6,
        "Database confidence should match"
    );

    Ok(())
}

#[sqlx::test(fixtures("regime_detection"))]
async fn test_orchestrator_ranging_detection(pool: PgPool) -> sqlx::Result<()> {
    let mut orchestrator = RegimeOrchestrator::new(pool.clone())
        .await
        .expect("Failed to create orchestrator");

    // Create ranging bars
    let bars = create_ranging_bars(60, 100.0);

    // Detect regime
    let regime_state = orchestrator
        .detect_and_persist("NQ.FUT", &bars)
        .await
        .expect("Failed to detect regime");

    // Should detect ranging or normal
    assert!(
        regime_state.regime == "Ranging" || regime_state.regime == "Normal",
        "Expected Ranging or Normal regime, got: {}",
        regime_state.regime
    );

    // Verify ADX is calculated
    assert!(regime_state.adx.is_some(), "ADX should be calculated");

    // Verify CUSUM sums are present
    assert!(
        regime_state.cusum_s_plus.is_some(),
        "CUSUM S+ should be present"
    );
    assert!(
        regime_state.cusum_s_minus.is_some(),
        "CUSUM S- should be present"
    );

    Ok(())
}

#[sqlx::test(fixtures("regime_detection"))]
async fn test_orchestrator_volatile_detection(pool: PgPool) -> sqlx::Result<()> {
    let mut orchestrator = RegimeOrchestrator::new(pool.clone())
        .await
        .expect("Failed to create orchestrator");

    // Create volatile bars
    let bars = create_volatile_bars(60, 100.0);

    // Detect regime
    let regime_state = orchestrator
        .detect_and_persist("6E.FUT", &bars)
        .await
        .expect("Failed to detect regime");

    // Should detect some regime (volatile detection may not always trigger with test data)
    assert!(!regime_state.regime.is_empty(), "Regime should be detected");

    // Verify database insertion
    let count =
        sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM regime_states WHERE symbol = $1")
            .bind("6E.FUT")
            .fetch_one(&pool)
            .await?;

    assert!(count > 0, "Regime state should be persisted to database");

    Ok(())
}

#[sqlx::test(fixtures("regime_detection"))]
async fn test_orchestrator_regime_transition(pool: PgPool) -> sqlx::Result<()> {
    let mut orchestrator = RegimeOrchestrator::new(pool.clone())
        .await
        .expect("Failed to create orchestrator");

    // First: Detect ranging regime
    let ranging_bars = create_ranging_bars(60, 100.0);
    let regime1 = orchestrator
        .detect_and_persist("ZN.FUT", &ranging_bars)
        .await
        .expect("Failed to detect first regime");

    // Second: Detect trending regime (different pattern)
    let trending_bars = create_trending_bars(60, 120.0);
    let regime2 = orchestrator
        .detect_and_persist("ZN.FUT", &trending_bars)
        .await
        .expect("Failed to detect second regime");

    // If regimes differ, check transition was recorded
    if regime1.regime != regime2.regime {
        let transition_count = sqlx::query_scalar::<_, i64>(
            "SELECT COUNT(*) FROM regime_transitions WHERE symbol = $1",
        )
        .bind("ZN.FUT")
        .fetch_one(&pool)
        .await?;

        assert!(
            transition_count > 0,
            "Regime transition should be recorded when regime changes"
        );
    }

    Ok(())
}

#[sqlx::test(fixtures("regime_detection"))]
async fn test_orchestrator_cached_regime(pool: PgPool) -> sqlx::Result<()> {
    let mut orchestrator = RegimeOrchestrator::new(pool.clone())
        .await
        .expect("Failed to create orchestrator");

    let bars = create_trending_bars(60, 100.0);

    // Detect regime
    let regime_state = orchestrator
        .detect_and_persist("CL.FUT", &bars)
        .await
        .expect("Failed to detect regime");

    // Get cached regime
    let cached = orchestrator
        .get_cached_regime("CL.FUT")
        .expect("Cached regime should exist");

    assert_eq!(
        cached.regime, regime_state.regime,
        "Cached regime should match detected regime"
    );
    assert_eq!(
        cached.confidence, regime_state.confidence,
        "Cached confidence should match"
    );

    Ok(())
}

#[sqlx::test(fixtures("regime_detection"))]
async fn test_orchestrator_cusum_reset(pool: PgPool) -> sqlx::Result<()> {
    let mut orchestrator = RegimeOrchestrator::new(pool.clone())
        .await
        .expect("Failed to create orchestrator");

    let bars = create_trending_bars(60, 100.0);

    // Detect regime (may accumulate CUSUM)
    orchestrator
        .detect_and_persist("GC.FUT", &bars)
        .await
        .expect("Failed to detect regime");

    // Reset CUSUM
    orchestrator.reset_cusum();

    // Verify reset
    let (s_plus, s_minus) = orchestrator.get_cusum_sums();
    assert_eq!(s_plus, 0.0, "CUSUM S+ should be reset to 0");
    assert_eq!(s_minus, 0.0, "CUSUM S- should be reset to 0");

    Ok(())
}

#[sqlx::test(fixtures("regime_detection"))]
async fn test_orchestrator_with_custom_config(pool: PgPool) -> sqlx::Result<()> {
    // Create orchestrator with custom thresholds
    let mut orchestrator = RegimeOrchestrator::with_config(
        pool.clone(),
        3.0,  // Lower CUSUM threshold (more sensitive)
        15.0, // Lower ADX threshold
        30,   // Shorter lookback
    )
    .await
    .expect("Failed to create orchestrator");

    let bars = create_trending_bars(40, 100.0);

    // Should work with custom config
    let regime_state = orchestrator
        .detect_and_persist("SI.FUT", &bars)
        .await
        .expect("Failed to detect regime with custom config");

    assert!(
        !regime_state.regime.is_empty(),
        "Should detect regime with custom config"
    );

    Ok(())
}

#[sqlx::test(fixtures("regime_detection"))]
async fn test_orchestrator_multiple_symbols(pool: PgPool) -> sqlx::Result<()> {
    let mut orchestrator = RegimeOrchestrator::new(pool.clone())
        .await
        .expect("Failed to create orchestrator");

    // Detect regimes for multiple symbols
    let symbols = vec!["ES.FUT", "NQ.FUT", "YM.FUT"];

    for symbol in &symbols {
        let bars = create_trending_bars(60, 100.0);
        orchestrator
            .detect_and_persist(symbol, &bars)
            .await
            .expect("Failed to detect regime");
    }

    // Verify all symbols have regime states
    for symbol in &symbols {
        let cached = orchestrator.get_cached_regime(symbol);
        assert!(
            cached.is_some(),
            "Symbol {} should have cached regime",
            symbol
        );
    }

    // Verify database has all symbols
    let db_count = sqlx::query_scalar::<_, i64>(
        "SELECT COUNT(DISTINCT symbol) FROM regime_states WHERE symbol = ANY($1)",
    )
    .bind(symbols)
    .fetch_one(&pool)
    .await?;

    assert_eq!(
        db_count, 3,
        "Database should have regime states for all 3 symbols"
    );

    Ok(())
}

#[sqlx::test(fixtures("regime_detection"))]
async fn test_regime_detection_populates_database(pool: PgPool) -> sqlx::Result<()> {
    let mut orchestrator = RegimeOrchestrator::new(pool.clone())
        .await
        .expect("Failed to create orchestrator");

    // Create test bars (100 bars as requested)
    let bars = create_trending_bars(100, 4500.0);

    // Run detection
    orchestrator
        .detect_and_persist("ES.FUT", &bars)
        .await
        .expect("Failed to detect and persist regime");

    // Verify database - check that regime_states table has rows
    let count: i64 =
        sqlx::query_scalar("SELECT COUNT(*) FROM regime_states WHERE symbol = 'ES.FUT'")
            .fetch_one(&pool)
            .await
            .expect("Failed to query regime_states count");

    assert!(
        count > 0,
        "regime_states table should have rows after detection, got count: {}",
        count
    );

    // Additional verification: Check the data quality
    let regime_data = sqlx::query!(
        r#"
        SELECT regime, confidence, adx, cusum_s_plus, cusum_s_minus
        FROM regime_states
        WHERE symbol = 'ES.FUT'
        ORDER BY event_timestamp DESC
        LIMIT 1
        "#
    )
    .fetch_one(&pool)
    .await
    .expect("Failed to fetch regime data");

    // Verify regime is valid
    assert!(!regime_data.regime.is_empty(), "Regime should not be empty");

    // Verify confidence is in valid range
    assert!(
        regime_data.confidence >= 0.0 && regime_data.confidence <= 1.0,
        "Confidence should be in [0, 1], got: {}",
        regime_data.confidence
    );

    // Verify ADX is present and non-negative
    assert!(regime_data.adx.is_some(), "ADX should be present");
    assert!(
        regime_data.adx.unwrap() >= 0.0,
        "ADX should be non-negative"
    );

    // Verify CUSUM sums are present
    assert!(
        regime_data.cusum_s_plus.is_some(),
        "CUSUM S+ should be present"
    );
    assert!(
        regime_data.cusum_s_minus.is_some(),
        "CUSUM S- should be present"
    );

    Ok(())
}