retry_fn 0.1.0

A simple retry function with versions for blocking or non-blocking, tokio or async-std
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

//! retry impls for async-std

retry_impl!(async_std::task::sleep);

#[cfg(test)]
mod test {
    use crate::RetryResult;

    use super::*;
    use crate::strategy::*;

    use async_std::task;
    use std::{
        io,
        sync::{Arc, Mutex},
    };

    #[test]
    fn fail_on_three() {
        task::block_on(async {
            let count: Arc<Mutex<i32>> = Arc::new(Mutex::new(0));
            let res = retry(Constant::from_millis(100), |op| {
                let count = count.clone();
                async move {
                    if op.retries >= 3 {
                        RetryResult::<&str, _>::Err(io::Error::new(
                            io::ErrorKind::TimedOut,
                            "timed out",
                        ))
                    } else {
                        *count.lock().unwrap() += 1;
                        RetryResult::Retry()
                    }
                }
            })
            .await;
            assert_eq!(*count.lock().unwrap(), 3);
            assert!(res.is_err());
        });
    }

    #[test]
    fn pass_eventually() {
        task::block_on(async {
            let count = Arc::new(Mutex::new(0));
            let res = retry(Constant::from_millis(100), |op| {
                let count = count.clone();
                async move {
                    if op.retries >= 3 {
                        RetryResult::<&str, &str>::Err("failed on 3")
                    } else {
                        *count.lock().unwrap() += 1;
                        RetryResult::Retry()
                    }
                }
            })
            .await;
            assert_eq!(*count.lock().unwrap(), 3);
            assert!(res.is_err());
        });
    }
}