foxhunt/ml/tests/circuit_breaker_integration_test.rs

//! Circuit Breaker Integration Tests for DQN Training
//!
//! Tests circuit breaker behavior during training to prevent runaway losses.

use ml::dqn::{CircuitBreaker, CircuitBreakerConfig, CircuitState};
use std::time::Duration;

#[test]
fn test_circuit_breaker_trips_after_consecutive_failures() {
    let config = CircuitBreakerConfig {
        failure_threshold: 3,
        success_threshold: 2,
        timeout_duration: Duration::from_millis(100),
        half_open_max_calls: 1,
    };

    let breaker = CircuitBreaker::new(config);

    // Initial state should be closed
    assert_eq!(breaker.current_state(), CircuitState::Closed);
    assert!(breaker.allow_request());

    // Record 2 failures - should stay closed
    breaker.record_failure();
    breaker.record_failure();
    assert_eq!(breaker.current_state(), CircuitState::Closed);
    assert!(breaker.allow_request());

    // Third failure - should open
    breaker.record_failure();
    assert_eq!(breaker.current_state(), CircuitState::Open);
    assert!(!breaker.allow_request());
}

#[test]
fn test_circuit_breaker_success_resets_failure_count() {
    let config = CircuitBreakerConfig {
        failure_threshold: 3,
        success_threshold: 2,
        timeout_duration: Duration::from_millis(100),
        half_open_max_calls: 1,
    };

    let breaker = CircuitBreaker::new(config);

    // Record 2 failures
    breaker.record_failure();
    breaker.record_failure();

    // Record success - should reset counter
    breaker.record_success();

    // Record 2 more failures - should stay closed (not 3 consecutive)
    breaker.record_failure();
    breaker.record_failure();
    assert_eq!(breaker.current_state(), CircuitState::Closed);
}

#[test]
fn test_circuit_breaker_half_open_transition() {
    let config = CircuitBreakerConfig {
        failure_threshold: 2,
        success_threshold: 2,
        timeout_duration: Duration::from_millis(50),
        half_open_max_calls: 2,
    };

    let breaker = CircuitBreaker::new(config);

    // Open the circuit
    breaker.record_failure();
    breaker.record_failure();
    assert_eq!(breaker.current_state(), CircuitState::Open);

    // Wait for timeout
    std::thread::sleep(Duration::from_millis(100));

    // Next request should transition to half-open
    assert!(breaker.allow_request());
    assert_eq!(breaker.current_state(), CircuitState::HalfOpen);

    // Should allow second test call
    assert!(breaker.allow_request());

    // Third call should be blocked
    assert!(!breaker.allow_request());
}

#[test]
fn test_circuit_breaker_closes_from_half_open() {
    let config = CircuitBreakerConfig {
        failure_threshold: 2,
        success_threshold: 2,
        timeout_duration: Duration::from_millis(50),
        half_open_max_calls: 2,
    };

    let breaker = CircuitBreaker::new(config);

    // Open the circuit
    breaker.record_failure();
    breaker.record_failure();

    // Wait and transition to half-open
    std::thread::sleep(Duration::from_millis(100));
    breaker.allow_request();
    assert_eq!(breaker.current_state(), CircuitState::HalfOpen);

    // Record 2 successes to close
    breaker.record_success();
    assert_eq!(breaker.current_state(), CircuitState::HalfOpen);

    breaker.record_success();
    assert_eq!(breaker.current_state(), CircuitState::Closed);
}

#[test]
fn test_circuit_breaker_reopens_from_half_open() {
    let config = CircuitBreakerConfig {
        failure_threshold: 2,
        success_threshold: 2,
        timeout_duration: Duration::from_millis(50),
        half_open_max_calls: 2,
    };

    let breaker = CircuitBreaker::new(config);

    // Open the circuit
    breaker.record_failure();
    breaker.record_failure();

    // Wait and transition to half-open
    std::thread::sleep(Duration::from_millis(100));
    breaker.allow_request();
    assert_eq!(breaker.current_state(), CircuitState::HalfOpen);

    // Any failure in half-open returns to open
    breaker.record_failure();
    assert_eq!(breaker.current_state(), CircuitState::Open);
}

#[test]
fn test_circuit_breaker_stats() {
    let config = CircuitBreakerConfig::default();
    let breaker = CircuitBreaker::new(config);

    // Record mixed outcomes
    breaker.record_success();
    breaker.record_success();
    breaker.record_failure();
    breaker.record_failure();
    breaker.record_success();

    let stats = breaker.stats();
    assert_eq!(stats.total_successes, 3);
    assert_eq!(stats.total_failures, 2);
    assert_eq!(stats.consecutive_successes, 1); // Last was success
    assert_eq!(stats.consecutive_failures, 0); // Reset by success
}

#[test]
fn test_circuit_breaker_reset() {
    let config = CircuitBreakerConfig {
        failure_threshold: 2,
        success_threshold: 2,
        timeout_duration: Duration::from_millis(100),
        half_open_max_calls: 1,
    };

    let breaker = CircuitBreaker::new(config);

    // Open the circuit
    breaker.record_failure();
    breaker.record_failure();
    assert_eq!(breaker.current_state(), CircuitState::Open);

    // Manual reset
    breaker.reset();
    assert_eq!(breaker.current_state(), CircuitState::Closed);
    assert!(breaker.allow_request());

    let stats = breaker.stats();
    assert_eq!(stats.consecutive_failures, 0);
    assert_eq!(stats.consecutive_successes, 0);
}

#[test]
fn test_circuit_breaker_default_config() {
    let config = CircuitBreakerConfig::default();

    // Verify default values
    assert_eq!(config.failure_threshold, 5);
    assert_eq!(config.success_threshold, 3);
    assert_eq!(config.timeout_duration, Duration::from_secs(60));
    assert_eq!(config.half_open_max_calls, 2);
}

#[test]
fn test_circuit_breaker_realistic_scenario() {
    // Simulate realistic trading scenario with losses triggering circuit breaker
    let config = CircuitBreakerConfig {
        failure_threshold: 5,
        success_threshold: 3,
        timeout_duration: Duration::from_millis(100),
        half_open_max_calls: 2,
    };

    let breaker = CircuitBreaker::new(config);

    // Simulate 10 trades: 4 wins, then 5 consecutive losses
    breaker.record_success(); // Win
    breaker.record_success(); // Win
    breaker.record_failure(); // Loss
    breaker.record_success(); // Win
    breaker.record_success(); // Win

    assert_eq!(breaker.current_state(), CircuitState::Closed);

    // Now 5 consecutive losses
    breaker.record_failure();
    breaker.record_failure();
    breaker.record_failure();
    breaker.record_failure();
    assert_eq!(breaker.current_state(), CircuitState::Closed); // Still closed after 4

    breaker.record_failure(); // 5th consecutive loss
    assert_eq!(breaker.current_state(), CircuitState::Open); // Now open

    // Wait for cooldown
    std::thread::sleep(Duration::from_millis(150));

    // Try recovery
    assert!(breaker.allow_request()); // Half-open
    breaker.record_success();
    breaker.record_success();
    breaker.record_success(); // 3 consecutive successes

    assert_eq!(breaker.current_state(), CircuitState::Closed); // Recovered
}