holochain 0.7.0-dev.20

Holochain, a framework for distributed applications
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

#![allow(missing_docs)]
use std::time::Duration;

#[macro_export]
macro_rules! wait_for {
    ($wait:expr, $test:expr, $check:expr, $assert:expr) => {{
        let mut w = $wait;
        let assert = $assert;
        loop {
            let o = $test;
            let check = $check;
            if !w.wait_any().await || check(&o) {
                assert(o);
                break;
            }
        }
    }};
}

#[macro_export]
macro_rules! wait_for_10s {
    ($test:expr, $check:expr, $assert:expr) => {{
        let wait_for = $crate::test_utils::WaitFor::ten_s();
        $crate::wait_for!(wait_for, $test, $check, $assert)
    }};
}

#[macro_export]
macro_rules! wait_for_1m {
    ($test:expr, $check:expr, $assert:expr) => {
        let wait_for = $crate::test_utils::WaitFor::one_m();
        $crate::wait_for!(wait_for, $test, $check, $assert)
    };
}

#[macro_export]
macro_rules! assert_retry {
    ($wait:expr, $test:expr $(, $reason:literal)?) => {
        $crate::wait_for!($wait, $test, |x: &bool| *x, |x: bool| assert!(x $(, $reason)?))
    };
}

#[macro_export]
macro_rules! assert_eq_retry {
    ($wait:expr, $test:expr, $check:expr $(, $reason:literal)?) => {
        $crate::wait_for!($wait, $test, |x| x == &$check, |x| assert_eq!(x, $check $(, $reason)?))
    };
}

#[macro_export]
macro_rules! assert_retry_10s {
    ($test:expr $(, $reason:literal)? $(,)?) => {
        let wait_for = $crate::test_utils::WaitFor::ten_s();
        $crate::assert_retry!(wait_for, $test  $(, $reason:literal)?)
    };
}

#[macro_export]
macro_rules! assert_eq_retry_10s {
    ($test:expr, $check:expr $(, $reason:literal)? $(,)?) => {
        let wait_for = $crate::test_utils::WaitFor::ten_s();
        $crate::assert_eq_retry!(wait_for, $test, $check  $(, $reason:literal)?)
    };
}

#[macro_export]
macro_rules! assert_retry_1m {
    ($test:expr $(, $reason:literal)? $(,)?) => {
        let wait_for = $crate::test_utils::WaitFor::one_m();
        $crate::assert_retry!(wait_for, $test $(, $reason:literal)?)
    };
}

#[macro_export]
macro_rules! assert_eq_retry_1m {
    ($test:expr, $check:expr $(, $reason:literal)? $(,)?) => {
        let wait_for = $crate::test_utils::WaitFor::one_m();
        $crate::assert_eq_retry!(wait_for, $test, $check  $(, $reason:literal)?)
    };
}

#[macro_export]
macro_rules! assert_eq_retry_5m {
    ($test:expr, $check:expr $(, $reason:literal)? $(,)?) => {
        let wait_for = $crate::test_utils::WaitFor::five_m();
        $crate::assert_eq_retry!(wait_for, $test, $check  $(, $reason:literal)?)
    };
}

/// Generic waiting for some test property to
/// be true. This allows early exit from waiting when
/// the condition becomes true but will wait up to a
/// maximum if the condition is not true.
#[derive(Debug, Clone)]
pub struct WaitFor {
    num_attempts: u32,
    attempt: u32,
    delay: Duration,
}

impl WaitFor {
    /// Create a new wait for from a number of attempts and delay in between attempts
    pub fn new(total: Duration, num_attempts: u32) -> Self {
        Self {
            num_attempts,
            attempt: 0,
            delay: total / num_attempts,
        }
    }

    /// Wait for 1s checking every 100ms.
    pub fn one_s() -> Self {
        Self::new(std::time::Duration::from_secs(1), 10)
    }

    /// Wait for 10s checking every 100ms.
    pub fn ten_s() -> Self {
        Self::new(std::time::Duration::from_secs(10), 100)
    }

    /// Wait for 1 minute checking every 500ms.
    pub fn one_m() -> Self {
        Self::new(std::time::Duration::from_secs(60), 120)
    }

    /// Wait for 5 minutes checking every 1000ms.
    pub fn five_m() -> Self {
        Self::new(std::time::Duration::from_secs(5 * 60), 5 * 60)
    }

    /// Wait for some time before trying again.
    /// Will return false when you should stop waiting.
    #[cfg_attr(feature = "instrument", tracing::instrument(skip(self)))]
    pub async fn wait_any(&mut self) -> bool {
        if self.attempt >= self.num_attempts {
            return false;
        }
        self.attempt += 1;
        tracing::debug!(attempt = ?self.attempt, out_of = ?self.num_attempts, delaying_for = ?self.delay);
        tokio::time::sleep(self.delay).await;
        true
    }
}

#[tokio::test]
async fn wait_for_tests() {
    wait_for!(WaitFor::one_s(), true, |&x| x, |x: bool| assert!(x));
    wait_for!(WaitFor::one_s(), false, |&x| x, |x: bool| assert!(!x));
}