use dashmap::DashMap;
use limiteron::circuit::{ManualCircuitBreaker, ManualCircuitBreakerConfig};
use limiteron::error::CircuitState;
#[cfg(feature = "metrics")]
use metrics::{counter, gauge};
use parking_lot::RwLock;
use std::collections::HashMap;
use std::collections::VecDeque;
use std::sync::atomic::{AtomicU64, AtomicU8, Ordering};
use std::sync::Arc;
use std::time::{Duration, Instant};
#[derive(Clone, Debug)]
pub struct CircuitConfig {
pub failure_threshold: u32,
pub recovery_timeout: Duration,
pub failure_window: Duration,
}
impl Default for CircuitConfig {
fn default() -> Self {
Self {
failure_threshold: 5,
recovery_timeout: Duration::from_secs(30),
failure_window: Duration::from_secs(60),
}
}
}
const LIBRARY_FAILURE_RATIO: f64 = 0.5;
const MIRROR_CLOSED: u8 = 0;
const MIRROR_OPEN: u8 = 1;
const MIRROR_HALF_OPEN: u8 = 2;
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum Status {
Closed,
Open,
HalfOpen,
}
#[derive(Clone, Debug, Default)]
pub struct CircuitStats {
pub is_open: bool,
pub failure_count: u32,
pub total_requests: u64,
pub total_failures: u64,
pub total_successes: u64,
}
#[derive(Debug, Default)]
struct EngineLedger {
total_requests: u64,
total_failures: u64,
total_successes: u64,
failure_timestamps: VecDeque<Instant>,
}
#[derive(Debug, Default)]
struct EngineMirror {
state: AtomicU8,
opened_at_ms: AtomicU64,
}
fn to_library_config(config: &CircuitConfig) -> ManualCircuitBreakerConfig {
ManualCircuitBreakerConfig {
failure_threshold: LIBRARY_FAILURE_RATIO,
min_requests: (config.failure_threshold as u64).max(1),
half_open_interval: config.recovery_timeout,
half_open_max_successes: 1,
}
}
fn now_unix_ms() -> u64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_millis() as u64)
.unwrap_or(0)
}
fn mirror_code_to_status(code: u8) -> Status {
match code {
MIRROR_OPEN => Status::Open,
MIRROR_HALF_OPEN => Status::HalfOpen,
_ => Status::Closed,
}
}
#[derive(Clone)]
pub struct CircuitBreaker {
breakers: Arc<DashMap<String, Arc<ManualCircuitBreaker>>>,
mirrors: Arc<DashMap<String, Arc<EngineMirror>>>,
ledgers: Arc<DashMap<String, RwLock<EngineLedger>>>,
configs: Arc<RwLock<HashMap<String, CircuitConfig>>>,
default_config: CircuitConfig,
}
impl Default for CircuitBreaker {
fn default() -> Self {
Self::new()
}
}
impl CircuitBreaker {
pub fn new() -> Self {
Self {
breakers: Arc::new(DashMap::with_capacity(8)),
mirrors: Arc::new(DashMap::with_capacity(8)),
ledgers: Arc::new(DashMap::with_capacity(8)),
configs: Arc::new(RwLock::new(HashMap::with_capacity(8))),
default_config: CircuitConfig::default(),
}
}
pub fn with_default_config(config: CircuitConfig) -> Self {
Self {
breakers: Arc::new(DashMap::with_capacity(8)),
mirrors: Arc::new(DashMap::with_capacity(8)),
ledgers: Arc::new(DashMap::with_capacity(8)),
configs: Arc::new(RwLock::new(HashMap::with_capacity(8))),
default_config: config,
}
}
pub fn set_config(&self, engine_name: &str, config: CircuitConfig) {
let mut configs = self.configs.write();
configs.insert(engine_name.to_string(), config);
}
fn get_config(&self, engine_name: &str) -> CircuitConfig {
let configs = self.configs.read();
configs
.get(engine_name)
.cloned()
.unwrap_or(self.default_config.clone())
}
fn get_or_create_breaker(&self, engine_name: &str) -> Arc<ManualCircuitBreaker> {
let entry = self
.breakers
.entry(engine_name.to_string())
.or_insert_with(|| {
let config = self.get_config(engine_name);
Arc::new(ManualCircuitBreaker::new(to_library_config(&config)))
});
Arc::clone(entry.value())
}
fn get_or_create_mirror(&self, engine_name: &str) -> Arc<EngineMirror> {
let entry = self.mirrors.entry(engine_name.to_string()).or_default();
Arc::clone(entry.value())
}
pub fn is_open(&self, engine_name: &str) -> bool {
let Some(mirror) = self
.mirrors
.get(engine_name)
.map(|entry| Arc::clone(entry.value()))
else {
return false;
};
match mirror.state.load(Ordering::Acquire) {
MIRROR_CLOSED => false,
MIRROR_HALF_OPEN => false,
MIRROR_OPEN => {
let opened_at_ms = mirror.opened_at_ms.load(Ordering::Acquire);
let recovery_ms = self.get_config(engine_name).recovery_timeout.as_millis() as u64;
if opened_at_ms > 0 && now_unix_ms().saturating_sub(opened_at_ms) >= recovery_ms {
mirror.state.store(MIRROR_HALF_OPEN, Ordering::Release);
mirror.opened_at_ms.store(0, Ordering::Release);
self.update_status_metric(engine_name, Status::HalfOpen);
false
} else {
#[cfg(feature = "metrics")]
counter!("circuit_breaker_rejected_total", "engine" => engine_name.to_string())
.increment(1);
true
}
}
_ => false,
}
}
pub async fn record_success(&self, engine_name: &str) {
let breaker = self.get_or_create_breaker(engine_name);
breaker.state().await;
breaker.record_success().await;
self.record_ledger(engine_name, true);
self.refresh_mirror(engine_name, &breaker).await;
}
pub async fn record_failure(&self, engine_name: &str) {
let breaker = self.get_or_create_breaker(engine_name);
breaker.state().await;
breaker.record_failure().await;
self.record_ledger(engine_name, false);
self.refresh_mirror(engine_name, &breaker).await;
}
fn record_ledger(&self, engine_name: &str, success: bool) {
let entry = self
.ledgers
.entry(engine_name.to_string())
.or_insert_with(|| RwLock::new(EngineLedger::default()));
let mut ledger = entry.write();
ledger.total_requests += 1;
if success {
ledger.total_successes += 1;
#[cfg(feature = "metrics")]
counter!("circuit_breaker_successes_total", "engine" => engine_name.to_string())
.increment(1);
} else {
ledger.total_failures += 1;
ledger.failure_timestamps.push_back(Instant::now());
let window = self.get_config(engine_name).failure_window;
let now = Instant::now();
while let Some(front) = ledger.failure_timestamps.front() {
if now.duration_since(*front) > window {
ledger.failure_timestamps.pop_front();
} else {
break;
}
}
#[cfg(feature = "metrics")]
counter!("circuit_breaker_failures_total", "engine" => engine_name.to_string())
.increment(1);
}
#[cfg(feature = "metrics")]
counter!("circuit_breaker_requests_total", "engine" => engine_name.to_string())
.increment(1);
}
async fn refresh_mirror(&self, engine_name: &str, breaker: &ManualCircuitBreaker) {
let state = breaker.state().await;
let mirror = self.get_or_create_mirror(engine_name);
let (code, opened_at_ms) = match state {
CircuitState::Closed => (MIRROR_CLOSED, 0u64),
CircuitState::Open => (MIRROR_OPEN, now_unix_ms()),
CircuitState::HalfOpen => (MIRROR_HALF_OPEN, 0u64),
};
let previous = mirror.state.swap(code, Ordering::AcqRel);
mirror.opened_at_ms.store(opened_at_ms, Ordering::Release);
self.update_status_metric(engine_name, mirror_code_to_status(code));
if previous != code {
if code == MIRROR_CLOSED {
if let Some(ledger) = self.ledgers.get(engine_name) {
ledger.write().failure_timestamps.clear();
}
}
}
}
pub async fn get_stats(&self, engine_name: &str) -> CircuitStats {
let is_open = self
.mirrors
.get(engine_name)
.map(|m| m.value().state.load(Ordering::Acquire) == MIRROR_OPEN)
.unwrap_or(false);
if let Some(ledger) = self.ledgers.get(engine_name) {
let ledger = ledger.read();
CircuitStats {
is_open,
failure_count: ledger.failure_timestamps.len() as u32,
total_requests: ledger.total_requests,
total_failures: ledger.total_failures,
total_successes: ledger.total_successes,
}
} else {
CircuitStats {
is_open,
..Default::default()
}
}
}
#[cfg_attr(not(feature = "metrics"), allow(unused_variables))]
fn update_status_metric(&self, engine_name: &str, status: Status) {
let val = match status {
Status::Closed => 0.0,
Status::Open => 1.0,
Status::HalfOpen => 0.5,
};
#[cfg(feature = "metrics")]
gauge!("circuit_breaker_status", "engine" => engine_name.to_string()).set(val);
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Arc;
use std::time::Duration;
#[test]
fn test_circuit_config_default() {
let config = CircuitConfig::default();
assert_eq!(config.failure_threshold, 5);
assert_eq!(config.recovery_timeout, Duration::from_secs(30));
assert_eq!(config.failure_window, Duration::from_secs(60));
}
#[test]
fn test_circuit_config_clone() {
let config = CircuitConfig {
failure_threshold: 10,
recovery_timeout: Duration::from_secs(60),
failure_window: Duration::from_secs(120),
};
let cloned = config.clone();
assert_eq!(config.failure_threshold, cloned.failure_threshold);
assert_eq!(config.recovery_timeout, cloned.recovery_timeout);
assert_eq!(config.failure_window, cloned.failure_window);
}
#[test]
fn test_circuit_breaker_new() {
let cb = CircuitBreaker::new();
assert!(!cb.is_open("unknown_engine"));
}
#[test]
fn test_circuit_breaker_default() {
let cb = CircuitBreaker::default();
assert!(!cb.is_open("any_engine"));
}
#[test]
fn test_circuit_breaker_with_default_config() {
let config = CircuitConfig {
failure_threshold: 3,
recovery_timeout: Duration::from_secs(10),
failure_window: Duration::from_secs(30),
};
let cb = CircuitBreaker::with_default_config(config);
assert!(!cb.is_open("engine_a"));
}
#[tokio::test]
async fn test_set_config_uses_custom_threshold() {
let cb = CircuitBreaker::new();
let config = CircuitConfig {
failure_threshold: 2,
recovery_timeout: Duration::from_secs(30),
failure_window: Duration::from_secs(60),
};
cb.set_config("fast_trip", config);
cb.record_failure("fast_trip").await;
assert!(!cb.is_open("fast_trip")); cb.record_failure("fast_trip").await;
assert!(cb.is_open("fast_trip")); }
#[tokio::test]
async fn test_set_config_does_not_affect_other_engines() {
let cb = CircuitBreaker::new();
let config = CircuitConfig {
failure_threshold: 1,
recovery_timeout: Duration::from_secs(30),
failure_window: Duration::from_secs(60),
};
cb.set_config("strict", config);
cb.record_failure("other").await;
assert!(!cb.is_open("other")); }
#[test]
fn test_closed_state_not_open() {
let cb = CircuitBreaker::new();
assert!(!cb.is_open("engine"));
}
#[tokio::test]
async fn test_closed_state_records_success() {
let cb = CircuitBreaker::new();
cb.record_success("engine").await;
let stats = cb.get_stats("engine").await;
assert_eq!(stats.total_requests, 1);
assert_eq!(stats.total_successes, 1);
assert_eq!(stats.total_failures, 0);
assert!(!stats.is_open);
}
#[tokio::test]
async fn test_closed_state_records_failure() {
let cb = CircuitBreaker::new();
cb.record_failure("engine").await;
let stats = cb.get_stats("engine").await;
assert_eq!(stats.total_requests, 1);
assert_eq!(stats.total_failures, 1);
assert_eq!(stats.total_successes, 0);
assert!(!stats.is_open);
}
#[tokio::test]
async fn test_open_state_after_threshold() {
let cb = CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 3,
recovery_timeout: Duration::from_secs(60),
failure_window: Duration::from_secs(60),
});
cb.record_failure("engine").await;
cb.record_failure("engine").await;
assert!(!cb.is_open("engine"));
cb.record_failure("engine").await;
assert!(cb.is_open("engine")); }
#[tokio::test]
async fn test_open_state_default_threshold() {
let cb = CircuitBreaker::new();
for _ in 0..4 {
cb.record_failure("engine").await;
assert!(!cb.is_open("engine"));
}
cb.record_failure("engine").await;
assert!(cb.is_open("engine")); }
#[tokio::test]
async fn test_open_state_blocks_requests() {
let cb = CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 1,
recovery_timeout: Duration::from_secs(60),
failure_window: Duration::from_secs(60),
});
cb.record_failure("engine").await;
assert!(cb.is_open("engine"));
assert!(cb.is_open("engine"));
assert!(cb.is_open("engine"));
}
#[tokio::test]
async fn test_half_open_after_recovery_timeout() {
let cb = CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 1,
recovery_timeout: Duration::from_millis(500),
failure_window: Duration::from_secs(60),
});
cb.record_failure("engine").await;
assert!(cb.is_open("engine"));
tokio::time::sleep(Duration::from_millis(1000)).await;
assert!(!cb.is_open("engine"));
}
#[tokio::test]
async fn test_half_open_success_closes_circuit() {
let cb = CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 1,
recovery_timeout: Duration::from_millis(500),
failure_window: Duration::from_secs(60),
});
cb.record_failure("engine").await;
assert!(cb.is_open("engine"));
tokio::time::sleep(Duration::from_millis(1000)).await;
assert!(!cb.is_open("engine"));
cb.record_success("engine").await;
assert!(!cb.is_open("engine"));
let stats = cb.get_stats("engine").await;
assert!(!stats.is_open);
assert_eq!(stats.failure_count, 0); }
#[tokio::test]
async fn test_half_open_failure_reopens_circuit() {
let cb = CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 1,
recovery_timeout: Duration::from_millis(500),
failure_window: Duration::from_secs(60),
});
cb.record_failure("engine").await;
assert!(cb.is_open("engine"));
tokio::time::sleep(Duration::from_millis(1000)).await;
assert!(!cb.is_open("engine"));
cb.record_failure("engine").await;
assert!(cb.is_open("engine"));
}
#[tokio::test]
async fn test_half_open_not_triggered_before_timeout() {
let cb = CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 1,
recovery_timeout: Duration::from_secs(60),
failure_window: Duration::from_secs(60),
});
cb.record_failure("engine").await;
assert!(cb.is_open("engine"));
assert!(cb.is_open("engine"));
}
#[tokio::test]
async fn test_cumulative_ratio_trips_after_stats_window_eviction() {
let cb = CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 3,
recovery_timeout: Duration::from_secs(60),
failure_window: Duration::from_millis(50),
});
cb.record_failure("engine").await;
cb.record_failure("engine").await;
assert!(!cb.is_open("engine"));
tokio::time::sleep(Duration::from_millis(1000)).await;
cb.record_failure("engine").await;
assert!(
cb.is_open("engine"),
"cumulative ratio trigger: 3/3 failures >= 0.5 with total >= min_requests"
);
let stats = cb.get_stats("engine").await;
assert_eq!(stats.failure_count, 1);
}
#[tokio::test]
async fn test_failure_window_keeps_recent_failures() {
let cb = CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 3,
recovery_timeout: Duration::from_secs(60),
failure_window: Duration::from_secs(60),
});
cb.record_failure("engine").await;
cb.record_failure("engine").await;
cb.record_failure("engine").await;
assert!(cb.is_open("engine"));
let stats = cb.get_stats("engine").await;
assert_eq!(stats.failure_count, 3);
}
#[tokio::test]
async fn test_get_stats_unknown_engine() {
let cb = CircuitBreaker::new();
let stats = cb.get_stats("nonexistent").await;
assert!(!stats.is_open);
assert_eq!(stats.failure_count, 0);
assert_eq!(stats.total_requests, 0);
assert_eq!(stats.total_failures, 0);
assert_eq!(stats.total_successes, 0);
}
#[tokio::test]
async fn test_get_stats_tracks_totals() {
let cb = CircuitBreaker::new();
cb.record_success("engine").await;
cb.record_success("engine").await;
cb.record_failure("engine").await;
let stats = cb.get_stats("engine").await;
assert_eq!(stats.total_requests, 3);
assert_eq!(stats.total_successes, 2);
assert_eq!(stats.total_failures, 1);
}
#[tokio::test]
async fn test_get_stats_is_open_reflects_status() {
let cb = CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 1,
recovery_timeout: Duration::from_secs(60),
failure_window: Duration::from_secs(60),
});
let stats_before = cb.get_stats("engine").await;
assert!(!stats_before.is_open);
cb.record_failure("engine").await;
let stats_after = cb.get_stats("engine").await;
assert!(stats_after.is_open);
}
#[tokio::test]
async fn test_multiple_engines_are_isolated() {
let cb = CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 1,
recovery_timeout: Duration::from_secs(60),
failure_window: Duration::from_secs(60),
});
cb.record_failure("engine_a").await;
assert!(cb.is_open("engine_a"));
assert!(!cb.is_open("engine_b")); }
#[tokio::test]
async fn test_multiple_engines_stats_isolated() {
let cb = CircuitBreaker::new();
cb.record_success("engine_a").await;
cb.record_failure("engine_b").await;
let stats_a = cb.get_stats("engine_a").await;
let stats_b = cb.get_stats("engine_b").await;
assert_eq!(stats_a.total_successes, 1);
assert_eq!(stats_a.total_failures, 0);
assert_eq!(stats_b.total_successes, 0);
assert_eq!(stats_b.total_failures, 1);
}
#[tokio::test]
async fn test_concurrent_record_failures() {
let cb = Arc::new(CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 100,
recovery_timeout: Duration::from_secs(60),
failure_window: Duration::from_secs(60),
}));
let mut handles = Vec::new();
for _ in 0..10 {
let cb_clone = Arc::clone(&cb);
handles.push(tokio::spawn(async move {
for _ in 0..10 {
cb_clone.record_failure("concurrent_engine").await;
}
}));
}
for handle in handles {
handle.await.unwrap();
}
let stats = cb.get_stats("concurrent_engine").await;
assert_eq!(stats.total_failures, 100);
assert!(stats.is_open); }
#[tokio::test]
async fn test_concurrent_record_successes() {
let cb = Arc::new(CircuitBreaker::new());
let mut handles = Vec::new();
for _ in 0..10 {
let cb_clone = Arc::clone(&cb);
handles.push(tokio::spawn(async move {
for _ in 0..10 {
cb_clone.record_success("concurrent_engine").await;
}
}));
}
for handle in handles {
handle.await.unwrap();
}
let stats = cb.get_stats("concurrent_engine").await;
assert_eq!(stats.total_successes, 100);
assert_eq!(stats.total_requests, 100);
}
#[tokio::test]
async fn test_concurrent_mixed_operations() {
let cb = Arc::new(CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 1000,
recovery_timeout: Duration::from_secs(60),
failure_window: Duration::from_secs(60),
}));
let mut handles = Vec::new();
for _ in 0..5 {
let cb_clone = Arc::clone(&cb);
handles.push(tokio::spawn(async move {
for _ in 0..20 {
cb_clone.record_failure("mixed_engine").await;
}
}));
}
for _ in 0..5 {
let cb_clone = Arc::clone(&cb);
handles.push(tokio::spawn(async move {
for _ in 0..20 {
cb_clone.record_success("mixed_engine").await;
}
}));
}
for _ in 0..5 {
let cb_clone = Arc::clone(&cb);
handles.push(tokio::spawn(async move {
for _ in 0..20 {
let _ = cb_clone.is_open("mixed_engine");
}
}));
}
for handle in handles {
handle.await.unwrap();
}
let stats = cb.get_stats("mixed_engine").await;
assert_eq!(stats.total_requests, 200);
assert_eq!(stats.total_failures, 100);
assert_eq!(stats.total_successes, 100);
}
#[tokio::test]
async fn test_full_lifecycle_closed_open_half_open_closed() {
let cb = CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 2,
recovery_timeout: Duration::from_millis(500),
failure_window: Duration::from_secs(60),
});
assert!(!cb.is_open("lifecycle"));
cb.record_failure("lifecycle").await;
cb.record_failure("lifecycle").await;
assert!(cb.is_open("lifecycle"));
tokio::time::sleep(Duration::from_millis(1000)).await;
assert!(!cb.is_open("lifecycle"));
cb.record_success("lifecycle").await;
assert!(!cb.is_open("lifecycle"));
let stats = cb.get_stats("lifecycle").await;
assert!(!stats.is_open);
assert_eq!(stats.total_requests, 3); assert_eq!(stats.total_failures, 2);
assert_eq!(stats.total_successes, 1);
assert_eq!(stats.failure_count, 0); }
#[tokio::test]
async fn test_full_lifecycle_closed_open_half_open_open() {
let cb = CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 2,
recovery_timeout: Duration::from_millis(500),
failure_window: Duration::from_secs(60),
});
cb.record_failure("lifecycle").await;
cb.record_failure("lifecycle").await;
assert!(cb.is_open("lifecycle"));
tokio::time::sleep(Duration::from_millis(1000)).await;
assert!(!cb.is_open("lifecycle"));
cb.record_failure("lifecycle").await;
assert!(cb.is_open("lifecycle"));
let stats = cb.get_stats("lifecycle").await;
assert!(stats.is_open);
assert_eq!(stats.total_failures, 3);
}
#[tokio::test]
async fn test_mirror_consistent_with_library_state_after_records() {
let cb = CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 2,
recovery_timeout: Duration::from_secs(60),
failure_window: Duration::from_secs(60),
});
cb.record_success("engine").await;
let breaker = cb.get_or_create_breaker("engine");
assert_eq!(breaker.state().await, CircuitState::Closed);
assert!(!cb.is_open("engine"));
cb.record_failure("engine").await;
cb.record_failure("engine").await;
assert_eq!(breaker.state().await, CircuitState::Open);
assert!(
cb.is_open("engine"),
"镜像读必须立即生效(selector 同步剔除)"
);
let cb2 = CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 1,
recovery_timeout: Duration::from_millis(50),
failure_window: Duration::from_secs(60),
});
cb2.record_failure("engine").await;
assert!(cb2.is_open("engine"));
tokio::time::sleep(Duration::from_millis(100)).await;
assert!(!cb2.is_open("engine"), "冷却后镜像转 HalfOpen 放行");
let breaker2 = cb2.get_or_create_breaker("engine");
assert_eq!(breaker2.state().await, CircuitState::HalfOpen);
cb2.record_success("engine").await;
assert_eq!(breaker2.state().await, CircuitState::Closed);
assert!(!cb2.is_open("engine"));
}
#[test]
fn test_status_equality() {
assert_eq!(Status::Closed, Status::Closed);
assert_eq!(Status::Open, Status::Open);
assert_eq!(Status::HalfOpen, Status::HalfOpen);
assert_ne!(Status::Closed, Status::Open);
assert_ne!(Status::Open, Status::HalfOpen);
assert_ne!(Status::Closed, Status::HalfOpen);
}
#[test]
fn test_status_copy() {
let s1 = Status::Open;
let s2 = s1; assert_eq!(s1, s2);
}
#[test]
fn test_circuit_stats_default() {
let stats = CircuitStats::default();
assert!(!stats.is_open);
assert_eq!(stats.failure_count, 0);
assert_eq!(stats.total_requests, 0);
assert_eq!(stats.total_failures, 0);
assert_eq!(stats.total_successes, 0);
}
#[tokio::test]
async fn test_record_failure_on_open_breaker_is_noop_status() {
let cb = CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 1,
recovery_timeout: Duration::from_secs(60),
failure_window: Duration::from_secs(60),
});
cb.record_failure("engine").await;
assert!(cb.is_open("engine"));
cb.record_failure("engine").await;
assert!(cb.is_open("engine"));
let stats = cb.get_stats("engine").await;
assert!(stats.is_open);
assert_eq!(stats.total_failures, 2);
assert_eq!(stats.total_requests, 2);
}
#[tokio::test]
async fn test_record_success_on_closed_breaker_does_not_change_state() {
let cb = CircuitBreaker::new();
cb.record_success("engine").await;
cb.record_success("engine").await;
let stats = cb.get_stats("engine").await;
assert!(!stats.is_open);
assert_eq!(stats.total_successes, 2);
assert_eq!(stats.total_requests, 2);
}
#[tokio::test]
async fn test_circuit_breaker_clone_shares_state() {
let cb = CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 1,
recovery_timeout: Duration::from_secs(60),
failure_window: Duration::from_secs(60),
});
let cb_clone = cb.clone();
cb.record_failure("engine").await;
assert!(cb_clone.is_open("engine")); }
#[tokio::test]
async fn test_is_open_returns_false_when_already_half_open() {
let cb = CircuitBreaker::with_default_config(CircuitConfig {
failure_threshold: 1,
recovery_timeout: Duration::from_millis(500),
failure_window: Duration::from_secs(60),
});
cb.record_failure("engine").await;
assert!(cb.is_open("engine"));
tokio::time::sleep(Duration::from_millis(1000)).await;
assert!(!cb.is_open("engine"));
assert!(!cb.is_open("engine"));
}
}