nexus-acto-rs 0.4.2

A Rust crate for Actors
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

#[cfg(test)]
mod test {
  use std::env;
  use std::time::{Duration, Instant};

  use rstest::*;
  use tracing_subscriber::EnvFilter;

  use crate::actor::actor::restart_statistics::RestartStatistics;
  use crate::actor::supervisor::exponential_backoff_strategy::ExponentialBackoffStrategy;

  #[rstest(ft, fc, expected)]
  #[case(11, 10, 1)]
  #[case(9, 10, 11)]
  #[tokio::test]
  async fn test_exponential_backoff_strategy_set_failure_count(ft: u64, fc: usize, expected: usize) {
    let _ = env::set_var("RUST_LOG", "debug");
    let _ = tracing_subscriber::fmt()
      .with_env_filter(EnvFilter::from_default_env())
      .try_init();

    let s = ExponentialBackoffStrategy::new(Duration::from_secs(10));
    let mut rs = RestartStatistics::new();
    for _ in 0..fc {
      rs.push(Instant::now() - Duration::from_secs(ft)).await;
    }

    s.set_failure_count(&mut rs).await;
    assert_eq!(expected, rs.failure_count().await);
  }

  #[tokio::test]
  async fn test_exponential_backoff_strategy_increments_failure_count() {
    let _ = env::set_var("RUST_LOG", "debug");
    let _ = tracing_subscriber::fmt()
      .with_env_filter(EnvFilter::from_default_env())
      .try_init();

    let mut rs = RestartStatistics::new();
    let s = ExponentialBackoffStrategy::new(Duration::from_secs(10));

    s.set_failure_count(&mut rs).await;
    s.set_failure_count(&mut rs).await;
    s.set_failure_count(&mut rs).await;

    assert_eq!(3, rs.failure_count().await);
  }

  #[tokio::test]
  async fn test_exponential_backoff_strategy_resets_failure_count() {
    let _ = env::set_var("RUST_LOG", "debug");
    let _ = tracing_subscriber::fmt()
      .with_env_filter(EnvFilter::from_default_env())
      .try_init();

    let mut rs = RestartStatistics::new();
    for _ in 0..10 {
      rs.push(Instant::now() - Duration::from_secs(11)).await;
    }
    let s = ExponentialBackoffStrategy::new(Duration::from_secs(10)).with_initial_backoff(Duration::from_secs(1));

    s.set_failure_count(&mut rs).await;

    assert_eq!(1, rs.failure_count().await);
  }
}