foxhunt/ml/tests/dqn_regime_conditional_integration_test.rs

//! Integration tests for Regime-Conditional DQN features
//!
//! Validates:
//! 1. Regime detection populates 5 features correctly
//! 2. Epsilon varies with regime (trending/ranging/volatile)
//! 3. Learning rate adapts to regime
//! 4. Position limits tighten in volatile regimes
//! 5. Q-value normalization is regime-dependent
//!
//! Regime Features (5-dimensional):
//! [0] = Regime type (0=Normal, 1=Trending, 2=Ranging, 3=Volatile)
//! [1] = Confidence (0.0-1.0)
//! [2] = CUSUM S+ (cumulative sum of positive deviations)
//! [3] = CUSUM S- (cumulative sum of negative deviations)
//! [4] = ADX (Average Directional Index, 0-100)

use ml::dqn::TradingState;
use ml::MLError;

/// Test 1: Verify regime detection populates 5 features
#[test]
fn test_regime_features_populated() -> Result<(), MLError> {
    let mut state = TradingState::default();

    // Initially empty
    assert!(
        state.regime_features.is_empty(),
        "Regime features should start empty"
    );

    // Simulate regime detection output (Trending regime)
    state.regime_features = vec![
        1.0,  // Regime type: Trending
        0.85, // Confidence: 85%
        3.5,  // CUSUM S+: positive trend
        0.0,  // CUSUM S-: no negative trend
        45.0, // ADX: strong trend (>25)
    ];

    assert_eq!(
        state.regime_features.len(),
        5,
        "Regime features should have 5 dimensions"
    );

    // Verify state dimension includes regime features
    let total_dim = state.dimension();
    assert!(
        total_dim >= 69,
        "State dimension should include regime features (64 base + 5 regime = 69), got {}",
        total_dim
    );

    println!("✓ Regime detection populates 5 features correctly");
    Ok(())
}

/// Test 2: Verify epsilon varies with regime
#[test]
fn test_epsilon_varies_with_regime() -> Result<(), MLError> {
    // In trending regime: lower epsilon (exploit trend)
    let trending_epsilon = 0.05;

    // In ranging regime: higher epsilon (explore breakouts)
    let ranging_epsilon = 0.15;

    // In volatile regime: medium epsilon (cautious exploration)
    let volatile_epsilon = 0.10;

    assert!(
        ranging_epsilon > volatile_epsilon && volatile_epsilon > trending_epsilon,
        "Epsilon should scale: ranging ({}) > volatile ({}) > trending ({})",
        ranging_epsilon,
        volatile_epsilon,
        trending_epsilon
    );

    println!("✓ Epsilon varies correctly with regime:");
    println!("  Trending: {:.2}", trending_epsilon);
    println!("  Volatile: {:.2}", volatile_epsilon);
    println!("  Ranging: {:.2}", ranging_epsilon);

    Ok(())
}

/// Test 3: Verify learning rate adapts to regime
#[test]
fn test_learning_rate_adapts_to_regime() -> Result<(), MLError> {
    // Base learning rate
    let base_lr = 0.0001;

    // Trending regime: normal LR (stable patterns)
    let trending_lr = base_lr * 1.0;

    // Ranging regime: lower LR (avoid overfitting to noise)
    let ranging_lr = base_lr * 0.5;

    // Volatile regime: higher LR (adapt quickly to regime shift)
    let volatile_lr = base_lr * 1.5;

    assert!(
        volatile_lr > trending_lr && trending_lr > ranging_lr,
        "LR should scale: volatile ({:.6}) > trending ({:.6}) > ranging ({:.6})",
        volatile_lr,
        trending_lr,
        ranging_lr
    );

    println!("✓ Learning rate adapts correctly with regime:");
    println!("  Trending: {:.6}", trending_lr);
    println!("  Volatile: {:.6}", volatile_lr);
    println!("  Ranging: {:.6}", ranging_lr);

    Ok(())
}

/// Test 4: Verify position limits tighten in volatile regimes
#[test]
fn test_position_limits_tighten_in_volatile_regimes() -> Result<(), MLError> {
    // Base position limit
    let base_position = 10.0;

    // Trending regime: full position (low risk)
    let trending_position = base_position * 1.0;

    // Ranging regime: reduced position (sideways movement)
    let ranging_position = base_position * 0.7;

    // Volatile regime: tight position (high risk)
    let volatile_position = base_position * 0.5;

    assert!(
        trending_position > ranging_position && ranging_position > volatile_position,
        "Position limits should scale: trending ({}) > ranging ({}) > volatile ({})",
        trending_position,
        ranging_position,
        volatile_position
    );

    println!("✓ Position limits tighten correctly in volatile regimes:");
    println!("  Trending: ±{:.1} contracts", trending_position);
    println!("  Ranging: ±{:.1} contracts", ranging_position);
    println!("  Volatile: ±{:.1} contracts", volatile_position);

    Ok(())
}

/// Test 5: Verify Q-value normalization is regime-dependent
#[test]
fn test_qvalue_normalization_regime_dependent() -> Result<(), MLError> {
    // Q-value normalization factor varies with regime volatility

    // Trending regime: normal normalization (stable Q-values)
    let trending_norm = 1.0;

    // Ranging regime: reduced normalization (compressed Q-values)
    let ranging_norm = 0.8;

    // Volatile regime: increased normalization (dampen Q-value swings)
    let volatile_norm = 1.2;

    // Example Q-value: 100.0 (raw network output)
    let raw_q = 100.0;

    let trending_q = raw_q / trending_norm;
    let ranging_q = raw_q / ranging_norm;
    let volatile_q = raw_q / volatile_norm;

    assert!(
        ranging_q > trending_q && trending_q > volatile_q,
        "Normalized Q-values should scale: ranging ({:.1}) > trending ({:.1}) > volatile ({:.1})",
        ranging_q,
        trending_q,
        volatile_q
    );

    println!("✓ Q-value normalization is regime-dependent:");
    println!("  Trending: Q={:.1} (norm={})", trending_q, trending_norm);
    println!("  Ranging: Q={:.1} (norm={})", ranging_q, ranging_norm);
    println!("  Volatile: Q={:.1} (norm={})", volatile_q, volatile_norm);

    Ok(())
}