use std::time::Duration;
#[derive(Debug, Clone)]
pub struct RetryPolicy {
pub max_attempts: u32,
pub base_delay: Duration,
pub jitter: bool,
}
impl RetryPolicy {
#[must_use]
pub fn calculate_delay(&self, attempt: u32) -> Duration {
let factor = 1u32 << attempt; let base = self.base_delay * factor;
if self.jitter {
let jitter_factor = rand::random::<f64>(); let jitter = Duration::from_secs_f64(base.as_secs_f64() * jitter_factor);
base + jitter
} else {
base
}
}
#[must_use]
pub fn calculate_delay_with_jitter<F>(&self, attempt: u32, jitter_fn: F) -> Duration
where
F: Fn() -> f64,
{
let factor = 1u32 << attempt;
let base = self.base_delay * factor;
if self.jitter {
let jitter_factor = jitter_fn();
let jitter = Duration::from_secs_f64(base.as_secs_f64() * jitter_factor);
base + jitter
} else {
base
}
}
}
impl Default for RetryPolicy {
fn default() -> Self {
Self {
max_attempts: 3,
base_delay: Duration::from_millis(500),
jitter: true,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_values_are_sensible() {
let p = RetryPolicy::default();
assert_eq!(p.max_attempts, 3);
assert_eq!(p.base_delay, Duration::from_millis(500));
assert!(p.jitter, "jitter should be on by default");
}
#[test]
fn clone_is_independent() {
let a = RetryPolicy {
max_attempts: 5,
base_delay: Duration::from_millis(100),
jitter: false,
};
let b = a.clone();
assert_eq!(b.max_attempts, 5);
assert_eq!(b.base_delay, Duration::from_millis(100));
assert!(!b.jitter);
}
#[test]
fn custom_values_are_preserved() {
let p = RetryPolicy {
max_attempts: 10,
base_delay: Duration::from_secs(2),
..Default::default()
};
assert_eq!(p.max_attempts, 10);
assert_eq!(p.base_delay, Duration::from_secs(2));
assert!(p.jitter); }
#[test]
fn test_delay_calculation_no_jitter() {
let policy = RetryPolicy {
max_attempts: 3,
base_delay: Duration::from_millis(100),
jitter: false,
};
assert_eq!(policy.calculate_delay(0), Duration::from_millis(100));
assert_eq!(policy.calculate_delay(1), Duration::from_millis(200));
assert_eq!(policy.calculate_delay(2), Duration::from_millis(400));
assert_eq!(policy.calculate_delay(3), Duration::from_millis(800));
}
#[test]
fn test_delay_calculation_with_jitter() {
let policy = RetryPolicy {
max_attempts: 3,
base_delay: Duration::from_millis(100),
jitter: true,
};
let delay0 = policy.calculate_delay(0);
assert!(delay0 >= Duration::from_millis(100));
assert!(delay0 < Duration::from_millis(200));
let delay1 = policy.calculate_delay(1);
assert!(delay1 >= Duration::from_millis(200));
assert!(delay1 < Duration::from_millis(400));
}
#[test]
fn test_calculate_delay_with_custom_jitter() {
let policy = RetryPolicy {
max_attempts: 3,
base_delay: Duration::from_millis(100),
jitter: true,
};
let delay = policy.calculate_delay_with_jitter(0, || 0.5);
assert_eq!(delay, Duration::from_millis(150));
let delay = policy.calculate_delay_with_jitter(1, || 0.25);
assert_eq!(delay, Duration::from_millis(250)); }
}