chrono_machines 0.5.2 → 0.9.1

data/ext/chrono_machines_native/core/src/lib.rs

@@ -43,12 +43,36 @@ pub mod policy;
 pub mod retry;
 pub mod sleep;
 
+/// The `rand` crate this one was built against.
+///
+/// [`BackoffStrategy::delay`] is generic over [`rand::Rng`], which puts that
+/// trait in the public API: a downstream strategy cannot be written without
+/// naming it. Re-exporting it here means implementors do not have to add their
+/// own `rand` dependency and keep its version in lockstep with this crate's by
+/// hand — a mismatch there produces two incompatible `Rng` traits and an error
+/// that says nothing about the real cause.
+///
+/// ```rust
+/// use chrono_machines::{rand::Rng, BackoffStrategy};
+///
+/// struct Immediate;
+///
+/// impl BackoffStrategy for Immediate {
+///     fn delay<R: Rng>(&self, attempt: u8, _rng: &mut R) -> Option<u64> {
+///         self.should_retry(attempt).then_some(0)
+///     }
+///     fn should_retry(&self, attempt: u8) -> bool { attempt < self.max_attempts() }
+///     fn max_attempts(&self) -> u8 { 3 }
+/// }
+/// ```
+pub use ::rand;
+
 pub use backoff::{
-    fibonacci, BackoffPolicy, BackoffStrategy, ConstantBackoff, ExponentialBackoff,
-    FibonacciBackoff,
+    BackoffPolicy, BackoffStrategy, ConstantBackoff, ExponentialBackoff, FibonacciBackoff,
+    fibonacci,
 };
 #[cfg(feature = "std")]
-pub use dsl::{builder_for_policy, retry_with_policy, DslError};
+pub use dsl::{DslError, builder_for_policy, retry_with_policy};
 #[cfg(any(feature = "std", feature = "alloc"))]
 pub use policy::PolicyRegistry;
 #[cfg(feature = "std")]
@@ -56,15 +80,21 @@ pub use policy::{
     clear_global_policies, get_global_policy, list_global_policies, register_global_policy,
     remove_global_policy,
 };
+#[cfg(feature = "async")]
+pub use retry::AsyncRetryable;
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub use retry::{RetryBuilder, RetryContext, RetryError, RetryOutcome, Retryable, RetryableExt};
+pub use retry::{
+    DelayHint, RetryBuilder, RetryContext, RetryError, RetryOutcome, Retryable, RetryableExt,
+};
+#[cfg(feature = "async")]
+pub use sleep::AsyncSleeper;
 #[cfg(feature = "std")]
 pub use sleep::StdSleeper;
 pub use sleep::{FnSleeper, Sleeper};
 
+use rand::RngExt;
 #[cfg(feature = "std")]
 use rand::rngs::StdRng;
-use rand::RngExt;
 
 use rand::Rng;
 
@@ -209,147 +239,4 @@ impl Default for Policy {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use rand::rngs::StdRng;
-    use rand::SeedableRng;
-
-    #[test]
-    fn test_policy_default() {
-        let policy = Policy::default();
-        assert_eq!(policy.max_attempts, 3);
-        assert_eq!(policy.base_delay_ms, 100);
-        assert_eq!(policy.multiplier, 2.0);
-        assert_eq!(policy.max_delay_ms, 10_000);
-    }
-
-    #[test]
-    fn test_calculate_delay_bounds() {
-        let policy = Policy {
-            max_attempts: 5,
-            base_delay_ms: 100,
-            multiplier: 2.0,
-            max_delay_ms: 1000,
-        };
-
-        let mut rng = StdRng::seed_from_u64(42);
-
-        // First attempt with full jitter: delay should be between 0 and 100ms
-        let delay1 = policy.calculate_delay_with_rng(1, 1.0, &mut rng);
-        assert!(delay1 <= 100);
-
-        // Second attempt with full jitter: delay should be between 0 and 200ms
-        let delay2 = policy.calculate_delay_with_rng(2, 1.0, &mut rng);
-        assert!(delay2 <= 200);
-
-        // Fifth attempt with full jitter: delay should be capped at max_delay_ms (1000ms)
-        let delay5 = policy.calculate_delay_with_rng(5, 1.0, &mut rng);
-        assert!(delay5 <= 1000);
-    }
-
-    #[test]
-    fn test_should_retry() {
-        let policy = Policy {
-            max_attempts: 3,
-            ..Policy::default()
-        };
-
-        assert!(policy.should_retry(1));
-        assert!(policy.should_retry(2));
-        assert!(!policy.should_retry(3));
-        assert!(!policy.should_retry(4));
-    }
-
-    #[test]
-    fn test_max_delay_cap() {
-        let policy = Policy {
-            max_attempts: 10,
-            base_delay_ms: 100,
-            multiplier: 2.0,
-            max_delay_ms: 500,
-        };
-
-        let mut rng = StdRng::seed_from_u64(42);
-
-        // High attempt number should still be capped
-        let delay = policy.calculate_delay_with_rng(10, 1.0, &mut rng);
-        assert!(delay <= 500);
-    }
-
-    #[test]
-    fn test_zero_multiplier() {
-        let policy = Policy {
-            max_attempts: 5,
-            base_delay_ms: 100,
-            multiplier: 1.0, // No exponential growth
-            max_delay_ms: 10_000,
-        };
-
-        let mut rng = StdRng::seed_from_u64(42);
-
-        // All delays with full jitter should be between 0 and base_delay_ms
-        for attempt in 1..=5 {
-            let delay = policy.calculate_delay_with_rng(attempt, 1.0, &mut rng);
-            assert!(delay <= 100);
-        }
-    }
-
-    #[test]
-    fn test_jitter_factor() {
-        let policy = Policy {
-            max_attempts: 5,
-            base_delay_ms: 1000,
-            multiplier: 1.0,
-            max_delay_ms: 10_000,
-        };
-
-        let mut rng = StdRng::seed_from_u64(42);
-
-        // 10% jitter: delay should be between 900ms (90%) and 1000ms (100%)
-        let delay = policy.calculate_delay_with_rng(1, 0.1, &mut rng);
-        assert!(
-            delay >= 900 && delay <= 1000,
-            "delay {} not in range 900-1000",
-            delay
-        );
-
-        // No jitter: delay should be exactly base_delay_ms
-        let delay = policy.calculate_delay_with_rng(1, 0.0, &mut rng);
-        assert_eq!(delay, 1000);
-
-        // Full jitter: delay should be between 0 and 1000ms
-        let delay = policy.calculate_delay_with_rng(1, 1.0, &mut rng);
-        assert!(delay <= 1000);
-    }
-
-    #[test]
-    fn test_jitter_factor_clamping() {
-        let policy = Policy {
-            max_attempts: 5,
-            base_delay_ms: 1000,
-            multiplier: 1.0,
-            max_delay_ms: 10_000,
-        };
-
-        let mut rng = StdRng::seed_from_u64(42);
-
-        // Negative jitter_factor should be clamped to 0.0
-        let delay = policy.calculate_delay_with_rng(1, -0.5, &mut rng);
-        assert_eq!(delay, 1000, "negative jitter_factor should clamp to 0.0");
-
-        // jitter_factor > 1.0 should be clamped to 1.0
-        let delay = policy.calculate_delay_with_rng(1, 2.0, &mut rng);
-        assert!(
-            delay <= 1000,
-            "jitter_factor > 1.0 should clamp to 1.0, got delay {}",
-            delay
-        );
-
-        // Extreme values should still be clamped
-        let delay = policy.calculate_delay_with_rng(1, 999.0, &mut rng);
-        assert!(delay <= 1000, "extreme jitter_factor should be clamped");
-
-        let delay = policy.calculate_delay_with_rng(1, -999.0, &mut rng);
-        assert_eq!(delay, 1000, "extreme negative should clamp to 0.0");
-    }
-}
+mod tests;