tearup 0.3.0

Setup - teardown your tests
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use std::{thread::sleep, time::Duration};

#[cfg(feature = "async")]
pub use asyncc::*;

pub type PredicateFn = Box<dyn Fn() -> bool + Send + Sync>;

/// Periadically try the predicate waiting for the given duration.
///
/// Useful when you can't trigger a ready from your dependencies.
pub fn ready_when(predicate: PredicateFn, retry_interval: Duration) {
    while !predicate() {
        sleep(retry_interval)
    }
}

#[cfg(test)]
mod test {
    use super::ready_when;
    use std::time::Duration;
    use stopwatch::Stopwatch;

    #[test]
    fn it_wait_until_predicate_becames_true() {
        let stopwatch = Stopwatch::start_new();
        ready_when(
            Box::new(move || stopwatch.elapsed_ms() > 100),
            Duration::from_millis(10),
        );

        assert_around_100ms_(&stopwatch);
    }

    fn assert_around_100ms_(stopwatch: &Stopwatch) {
        let ms = stopwatch.elapsed_ms();
        assert!(115 > ms, "stopwatch has {} elapsed ms > 115", ms);
        assert!(ms > 85, "stopwatch has {} elapsed ms < 85", ms);
    }
}

#[cfg(feature = "async")]
mod asyncc {
    use futures::future::BoxFuture;
    use std::time::Duration;
    use tokio::time::sleep;

    /// Periadically try the predicate waiting for the given duration.
    ///
    /// Useful when you can't trigger a ready from your dependencies.
    pub async fn async_ready_when<'a, PredicateFn>(
        mut predicate: PredicateFn,
        waiting_duration: Duration,
    ) where
        PredicateFn: FnMut() -> BoxFuture<'a, bool> + Send,
    {
        while !predicate().await {
            sleep(waiting_duration).await;
        }
    }

    #[cfg(test)]
    mod test {
        use super::async_ready_when;
        use futures::FutureExt;
        use std::time::Duration;
        use stopwatch::Stopwatch;

        #[tokio::test]
        async fn it_wait_until_predicate_becames_true() {
            let stopwatch = Stopwatch::start_new();
            async_ready_when(
                || async move { stopwatch.elapsed_ms() > 100 }.boxed(),
                Duration::from_millis(10),
            )
            .await;

            assert_around_100ms_(&stopwatch);
        }

        fn assert_around_100ms_(stopwatch: &Stopwatch) {
            let ms = stopwatch.elapsed_ms();
            assert!(115 > ms, "stopwatch has {} elapsed ms > 115", ms);
            assert!(ms > 85, "stopwatch has {} elapsed ms < 85", ms);
        }
    }
}