ic-timers 0.14.12

Observable and recovery-aware timers for Internet Computer canisters
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

use super::*;
use crate::schedule::ScheduleError;
use crate::snapshot::TimerDirectiveSnapshot;

#[test]
fn policy_results_preserve_completion_and_force_invariant_failures_to_stop() {
    let completions = [
        TimerCompletion::success(4),
        TimerCompletion::no_work(),
        TimerCompletion::retryable_failure(2),
        TimerCompletion::invariant_failure(3),
    ];
    for completion in completions {
        for decision in [
            OnceDecision::Stop,
            OnceDecision::ContinueImmediately,
            OnceDecision::RetryAfter(Duration::from_nanos(7)),
            OnceDecision::ScheduleAt(50),
        ] {
            let result = OnceRunResult::new(completion, decision);
            assert_eq!(result.completion(), completion);
            let expected = if completion.outcome() == TimerCompletionOutcome::InvariantFailure {
                OnceDecision::Stop
            } else {
                decision
            };
            assert_eq!(result.decision(), expected);
        }
        for decision in [
            AfterCompletionDecision::Stop,
            AfterCompletionDecision::ContinueImmediately,
            AfterCompletionDecision::RetryAfter(Duration::from_nanos(7)),
            AfterCompletionDecision::ScheduleAt(50),
            AfterCompletionDecision::RecurAfterCompletion,
        ] {
            let result = AfterCompletionRunResult::new(completion, decision);
            assert_eq!(result.completion(), completion);
            let expected = if completion.outcome() == TimerCompletionOutcome::InvariantFailure {
                AfterCompletionDecision::Stop
            } else {
                decision
            };
            assert_eq!(result.decision(), expected);
        }
    }
}

#[test]
fn public_decisions_project_inert_snapshots_with_checked_delays() {
    for (once, recurring, expected) in [
        (
            OnceDecision::Stop,
            AfterCompletionDecision::Stop,
            TimerDirectiveSnapshot::Stop,
        ),
        (
            OnceDecision::ContinueImmediately,
            AfterCompletionDecision::ContinueImmediately,
            TimerDirectiveSnapshot::ContinueImmediately,
        ),
        (
            OnceDecision::RetryAfter(Duration::from_nanos(7)),
            AfterCompletionDecision::RetryAfter(Duration::from_nanos(7)),
            TimerDirectiveSnapshot::RetryAfter { delay_ns: 7 },
        ),
        (
            OnceDecision::ScheduleAt(50),
            AfterCompletionDecision::ScheduleAt(50),
            TimerDirectiveSnapshot::ScheduleAt { deadline_ns: 50 },
        ),
    ] {
        assert_eq!(TimerDirectiveSnapshot::try_from(once), Ok(expected));
        assert_eq!(TimerDirectiveSnapshot::try_from(recurring), Ok(expected));
    }
    assert_eq!(
        TimerDirectiveSnapshot::try_from(AfterCompletionDecision::RecurAfterCompletion),
        Ok(TimerDirectiveSnapshot::RecurAfterCompletion),
    );
    assert_eq!(
        TimerDirectiveSnapshot::try_from(OnceDecision::RetryAfter(Duration::MAX)),
        Err(ScheduleError::DelayOutOfRange),
    );
    assert_eq!(
        TimerDirectiveSnapshot::try_from(AfterCompletionDecision::RetryAfter(Duration::MAX)),
        Err(ScheduleError::DelayOutOfRange),
    );
}