puniyu_types 0.7.7

puniyu 通用类型库
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

use async_trait::async_trait;
use puniyu_types::task::{Task, TaskBuilder, TaskId};
use std::sync::{Arc, Mutex};

#[test]
fn test_task_id_from_u64() {
	let task_id: TaskId = 42u64.into();
	match task_id {
		TaskId::Index(idx) => assert_eq!(idx, 42),
		_ => panic!("Expected TaskId::Index"),
	}
}

#[test]
fn test_task_id_from_string() {
	let task_id: TaskId = "test_task".to_string().into();
	match task_id {
		TaskId::Name(name) => assert_eq!(name, "test_task"),
		_ => panic!("Expected TaskId::Name"),
	}
}

#[test]
fn test_task_id_from_str() {
	let task_id: TaskId = "test_task".into();
	match task_id {
		TaskId::Name(name) => assert_eq!(name, "test_task"),
		_ => panic!("Expected TaskId::Name"),
	}
}

#[test]
fn test_task_creation() {
	let task = Task { name: "my_task", cron: "0 0 * * * *" };

	assert_eq!(task.name, "my_task");
	assert_eq!(task.cron, "0 0 * * * *");
}

struct TestTask {
	name: &'static str,
	cron: &'static str,
	run_count: Arc<Mutex<u32>>,
}

impl TestTask {
	fn new(name: &'static str, cron: &'static str) -> Self {
		Self { name, cron, run_count: Arc::new(Mutex::new(0)) }
	}

	fn get_run_count(&self) -> u32 {
		*self.run_count.lock().unwrap()
	}
}

#[async_trait]
impl TaskBuilder for TestTask {
	fn name(&self) -> &'static str {
		self.name
	}

	fn cron(&self) -> &'static str {
		self.cron
	}

	async fn run(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
		let mut count = self.run_count.lock().unwrap();
		*count += 1;
		Ok(())
	}
}

#[tokio::test]
async fn test_task_name() {
	let task = TestTask::new("test_task", "0 0 * * * *");
	assert_eq!(task.name(), "test_task");
}

#[tokio::test]
async fn test_task_cron() {
	let task = TestTask::new("test_task", "0 */5 * * * *");
	assert_eq!(task.cron(), "0 */5 * * * *");
}

#[tokio::test]
async fn test_task_run() {
	let task = TestTask::new("test_task", "0 0 * * * *");

	assert_eq!(task.get_run_count(), 0);

	task.run().await.unwrap();
	assert_eq!(task.get_run_count(), 1);

	task.run().await.unwrap();
	assert_eq!(task.get_run_count(), 2);
}

#[tokio::test]
async fn test_task_multiple_tasks() {
	let task1 = TestTask::new("task1", "0 0 * * * *");
	let task2 = TestTask::new("task2", "0 */10 * * * *");

	assert_eq!(task1.name(), "task1");
	assert_eq!(task2.name(), "task2");

	task1.run().await.unwrap();
	task2.run().await.unwrap();
	task2.run().await.unwrap();

	assert_eq!(task1.get_run_count(), 1);
	assert_eq!(task2.get_run_count(), 2);
}

#[test]
fn test_cron_expressions() {
	let task1 = Task { name: "hourly", cron: "0 0 * * * *" };
	assert_eq!(task1.cron, "0 0 * * * *");

	let task2 = Task { name: "daily", cron: "0 0 0 * * *" };
	assert_eq!(task2.cron, "0 0 0 * * *");

	let task3 = Task { name: "every_5_min", cron: "0 */5 * * * *" };
	assert_eq!(task3.cron, "0 */5 * * * *");
}