opendev-runtime 0.1.4

Runtime services: approval rules, cost tracking, interrupt token, plan management, error handling
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

use super::*;
use std::sync::atomic::AtomicBool;
use tokio::time;

#[tokio::test]
async fn test_schedule_once_executes() {
    let scheduler = TaskScheduler::new();
    let flag = Arc::new(AtomicBool::new(false));
    let flag_clone = Arc::clone(&flag);

    scheduler.schedule_once(Duration::from_millis(10), "test", move || {
        let f = Arc::clone(&flag_clone);
        async move {
            f.store(true, Ordering::SeqCst);
        }
    });

    time::sleep(Duration::from_millis(50)).await;
    assert!(flag.load(Ordering::SeqCst));
}

#[tokio::test]
async fn test_schedule_once_respects_delay() {
    let scheduler = TaskScheduler::new();
    let flag = Arc::new(AtomicBool::new(false));
    let flag_clone = Arc::clone(&flag);

    scheduler.schedule_once(Duration::from_millis(200), "delayed", move || {
        let f = Arc::clone(&flag_clone);
        async move {
            f.store(true, Ordering::SeqCst);
        }
    });

    // Should not have fired yet after 10ms.
    time::sleep(Duration::from_millis(10)).await;
    assert!(!flag.load(Ordering::SeqCst));
}

#[tokio::test]
async fn test_schedule_periodic_fires_multiple_times() {
    let scheduler = TaskScheduler::new();
    let counter = Arc::new(AtomicU64::new(0));
    let counter_clone = Arc::clone(&counter);

    scheduler.schedule_periodic(Duration::from_millis(15), "ticker", move |_tick| {
        let c = Arc::clone(&counter_clone);
        async move {
            c.fetch_add(1, Ordering::SeqCst);
        }
    });

    time::sleep(Duration::from_millis(100)).await;
    let count = counter.load(Ordering::SeqCst);
    // Should have fired multiple times (at least 3 in 100ms with 15ms interval).
    assert!(count >= 3, "expected >= 3 ticks, got {count}");
}

#[tokio::test]
async fn test_cancel_task() {
    let scheduler = TaskScheduler::new();
    let flag = Arc::new(AtomicBool::new(false));
    let flag_clone = Arc::clone(&flag);

    let id = scheduler.schedule_once(Duration::from_millis(100), "cancel_me", move || {
        let f = Arc::clone(&flag_clone);
        async move {
            f.store(true, Ordering::SeqCst);
        }
    });

    // Give the spawn a moment to register.
    time::sleep(Duration::from_millis(5)).await;

    let cancelled = scheduler.cancel(id).await;
    assert!(cancelled);

    time::sleep(Duration::from_millis(150)).await;
    assert!(!flag.load(Ordering::SeqCst), "task should not have fired");
}

#[tokio::test]
async fn test_shutdown_cancels_all() {
    let scheduler = TaskScheduler::new();
    let counter = Arc::new(AtomicU64::new(0));

    for i in 0..5 {
        let c = Arc::clone(&counter);
        scheduler.schedule_once(Duration::from_millis(200), format!("task-{i}"), move || {
            let c = Arc::clone(&c);
            async move {
                c.fetch_add(1, Ordering::SeqCst);
            }
        });
    }

    time::sleep(Duration::from_millis(10)).await;
    scheduler.shutdown().await;

    time::sleep(Duration::from_millis(300)).await;
    assert_eq!(counter.load(Ordering::SeqCst), 0);
}

#[tokio::test]
async fn test_cancel_nonexistent_returns_false() {
    let scheduler = TaskScheduler::new();
    assert!(!scheduler.cancel(999).await);
}

#[test]
fn test_default_scheduler() {
    let _scheduler = TaskScheduler::default();
}

#[test]
fn test_debug_format() {
    let scheduler = TaskScheduler::new();
    let debug_str = format!("{:?}", scheduler);
    assert!(debug_str.contains("TaskScheduler"));
}