pg_task 1.0.0

Resumable state machine based Postgres tasks
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

use crate::StepResult;
use std::time::Duration;

/// Represents next step of the task
pub enum NextStep<T> {
    /// The task is done
    None,
    /// Run the next step immediately
    Now(T),
    /// Delay the next step
    Delayed(T, Duration),
}

impl<T> NextStep<T> {
    /// The task is done
    pub fn none() -> StepResult<T> {
        Ok(Self::None)
    }

    /// Run the next step immediately
    pub fn now(step: impl Into<T>) -> StepResult<T> {
        Ok(Self::Now(step.into()))
    }

    /// Delay the next step
    pub fn delay(step: impl Into<T>, delay: Duration) -> StepResult<T> {
        Ok(Self::Delayed(step.into(), delay))
    }
}

#[cfg(test)]
mod tests {
    use super::NextStep;
    use std::time::Duration;

    #[test]
    fn none_returns_the_terminal_variant() {
        assert!(matches!(NextStep::<u8>::none().unwrap(), NextStep::None));
    }

    #[test]
    fn now_converts_input_into_the_target_step_type() {
        let next = NextStep::<u16>::now(7_u8).unwrap();

        assert!(matches!(next, NextStep::Now(7)));
    }

    #[test]
    fn delay_preserves_the_delay_and_converts_the_step() {
        let delay = Duration::from_millis(25);
        let next = NextStep::<u16>::delay(9_u8, delay).unwrap();

        match next {
            NextStep::Delayed(step, actual_delay) => {
                assert_eq!(step, 9);
                assert_eq!(actual_delay, delay);
            }
            _ => panic!("expected the delayed variant"),
        }
    }
}