graphile_worker_task_details 0.1.5

Task details for graphile_worker, mapping task IDs to identifiers
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

use super::*;

#[test]
fn task_details_new_creates_empty() {
    let details = TaskDetails::new();
    assert!(details.task_ids().is_empty());
    assert!(details.task_names().is_empty());
}

#[test]
fn task_details_insert_and_get() {
    let mut details = TaskDetails::new();
    details.insert(1, "task_one".to_string());
    details.insert(2, "task_two".to_string());

    assert_eq!(details.get(&1), Some(&"task_one".to_string()));
    assert_eq!(details.get(&2), Some(&"task_two".to_string()));
    assert_eq!(details.get(&3), None);
}

#[test]
fn task_details_task_ids_and_names() {
    let mut details = TaskDetails::new();
    details.insert(10, "alpha".to_string());
    details.insert(20, "beta".to_string());

    let ids = details.task_ids();
    assert_eq!(ids.len(), 2);
    assert!(ids.contains(&10));
    assert!(ids.contains(&20));

    let names = details.task_names();
    assert_eq!(names.len(), 2);
    assert!(names.contains(&"alpha".to_string()));
    assert!(names.contains(&"beta".to_string()));
}

#[test]
fn task_details_get_or_empty_found() {
    let mut details = TaskDetails::new();
    details.insert(5, "my_task".to_string());

    let result = details.get_or_empty(&100, &5);
    assert_eq!(result, "my_task");
}

#[test]
fn task_details_get_id_found() {
    let mut details = TaskDetails::new();
    details.insert(5, "my_task".to_string());

    assert_eq!(details.get_id("my_task"), Some(5));
    assert_eq!(details.get_id("other_task"), None);
}

#[test]
fn task_details_get_or_empty_not_found() {
    let details = TaskDetails::new();
    let result = details.get_or_empty(&100, &999);
    assert_eq!(result, "");
}

#[test]
fn task_details_default() {
    let details = TaskDetails::default();
    assert!(details.task_ids().is_empty());
}

#[tokio::test]
async fn shared_task_details_new_and_default() {
    let shared = SharedTaskDetails::new(TaskDetails::new());
    assert!(shared.task_ids().await.is_empty());

    let shared_default = SharedTaskDetails::default();
    assert!(shared_default.task_ids().await.is_empty());
}

#[tokio::test]
async fn shared_task_details_from_task_details() {
    let mut details = TaskDetails::new();
    details.insert(1, "test".to_string());

    let shared: SharedTaskDetails = details.into();
    assert_eq!(shared.get(&1).await, Some("test".to_string()));
}

#[tokio::test]
async fn shared_task_details_insert_and_get() {
    let shared = SharedTaskDetails::default();
    shared.insert(42, "answer".to_string()).await;

    assert_eq!(shared.get(&42).await, Some("answer".to_string()));
    assert_eq!(shared.get(&0).await, None);
}

#[tokio::test]
async fn shared_task_details_task_ids_and_names() {
    let shared = SharedTaskDetails::default();
    shared.insert(1, "one".to_string()).await;
    shared.insert(2, "two".to_string()).await;

    let ids = shared.task_ids().await;
    assert_eq!(ids.len(), 2);

    let names = shared.task_names().await;
    assert_eq!(names.len(), 2);
}

#[tokio::test]
async fn shared_task_details_get_or_empty() {
    let shared = SharedTaskDetails::default();
    shared.insert(5, "found".to_string()).await;

    assert_eq!(shared.get_or_empty(&1, &5).await, "found");
    assert_eq!(shared.get_or_empty(&1, &999).await, "");
}

#[tokio::test]
async fn shared_task_details_read_write() {
    let shared = SharedTaskDetails::default();

    {
        let mut guard = shared.write().await;
        guard.insert(100, "via_write".to_string());
    }

    {
        let guard = shared.read().await;
        assert_eq!(guard.get(&100), Some(&"via_write".to_string()));
    }
}