rovkit 0.0.6

rust kit for my self
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

#[cfg(test)]
mod tests {
    use rovkit::jobkit::{JobKit, JobType, MAX_HISTORY_RECORDS};
    use std::sync::atomic::{AtomicUsize, Ordering};
    use std::sync::Arc;
    use std::time::Duration;

    fn init_logger() {
        let _ = env_logger::builder().is_test(true).try_init();
    }

    #[tokio::test]
    async fn test_interval_job_execution() {
        init_logger();
        let kit = JobKit::new(4);

        let counter = Arc::new(AtomicUsize::new(0));
        let counter_clone = counter.clone();

        let _id = kit
            .add_job(
                "test_interval",
                JobType::Interval(Duration::from_millis(300)),
                move || {
                    counter_clone.fetch_add(1, Ordering::SeqCst);
                    Ok(())
                },
            )
            .unwrap();

        tokio::time::sleep(Duration::from_secs(1)).await;

        let count = counter.load(Ordering::SeqCst);
        assert!(count >= 2, "任务应至少执行两次，但执行了 {}", count);

        let history = kit.get_history("test_interval").unwrap();
        assert!(!history.is_empty());
        assert!(history.iter().all(|r| r.result.is_ok()));

        kit.stop("test_interval");
    }

    #[tokio::test]
    async fn test_cron_job_execution() {
        init_logger();
        let kit = JobKit::new(4);

        let counter = Arc::new(AtomicUsize::new(0));
        let counter_clone = counter.clone();

        kit.add_job(
            "test_cron",
            JobType::Cron("*/1 * * * * *".into()),
            move || {
                counter_clone.fetch_add(1, Ordering::SeqCst);
                Ok(())
            },
        )
        .unwrap();

        tokio::time::sleep(Duration::from_secs(2)).await;

        let count = counter.load(Ordering::SeqCst);
        assert!(count >= 1, "Cron 任务应至少执行一次，但执行了 {} 次", count);

        let history = kit.get_history("test_cron").unwrap();
        assert!(!history.is_empty());

        kit.stop_all();
    }

    #[tokio::test]
    async fn test_panic_handling() {
        init_logger();
        let kit = JobKit::new(2);

        kit.add_job(
            "panic_job",
            JobType::Interval(Duration::from_millis(200)),
            || {
                panic!("panic in task");
            },
        )
        .unwrap();

        tokio::time::sleep(Duration::from_secs(1)).await;

        let history = kit.get_history("panic_job").unwrap();
        assert!(!history.is_empty());

        let panics = history
            .iter()
            .filter(|r| r.result.as_ref().is_err())
            .count();
        assert!(panics >= 2, "应至少捕获 2 次 panic，实际 {}", panics);

        kit.stop("panic_job");
    }

    #[tokio::test]
    async fn test_stop_by_name_and_id() {
        init_logger();
        let kit = JobKit::new(2);

        let _job_id = kit
            .add_job(
                "named_job",
                JobType::Interval(Duration::from_millis(100)),
                || Ok(()),
            )
            .unwrap();

        assert!(kit.stop("named_job"));
        assert!(!kit.stop("named_job")); // 已停止，不能再停

        let new_id = kit
            .add_job(
                "named_job2",
                JobType::Interval(Duration::from_millis(100)),
                || Ok(()),
            )
            .unwrap();

        assert!(kit.stop(&new_id));
    }

    #[tokio::test]
    async fn test_history_limit() {
        init_logger();
        let kit = JobKit::new(2);

        kit.add_job(
            "fast_job",
            JobType::Interval(Duration::from_millis(10)),
            || Ok(()),
        )
        .unwrap();

        tokio::time::sleep(Duration::from_millis(500)).await;

        let history = kit.get_history("fast_job").unwrap();
        assert!(history.len() <= MAX_HISTORY_RECORDS);
        kit.stop("fast_job");
    }
}