ngtask_queue_basic 0.1.0

A trait-based abstraction layer for task queues with ID and category support
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

use ngtask_queue_basic::TaskQueue;
use ngtq::NGTQ;

#[test]
fn no_queue_for_the_category_exist_test_pull_category_task() {
    let task_queue_arc = TaskQueue::initialise();
    
    match task_queue_arc.lock() {
        Ok(mut queue) => {
            match queue.pull_category_task_from_queue("test") {
               Ok(_) => {
                println!("Test Failed - expected to fail for no queue for this category exist");
                assert!(false)
               },
               Err(_) => assert!(true)
            }
        },
        Err(error) => {
            println!("Test Failed - failed to open queue: {:?}", error);
            assert!(false)
        }
    };
}

#[test]
fn queue_for_the_category_exist_test_pull_category_task() {
    let task_queue_arc = TaskQueue::initialise();
    let task_payload = String::from("Do This");

    match task_queue_arc.lock() {
        Ok(mut task_queue) => {
            match task_queue.push_category_task_to_queue(String::from("test"), task_payload.to_string()) {
                Ok(_) => assert!(true),
                Err(error) => {
                    println!("Test Failed - expected to return ok: {}", error);
                    assert!(false)
                }
            }
            match task_queue.push_category_task_to_queue(String::from("test"), task_payload.to_string()) {
                Ok(_) => assert!(true),
                Err(error) => {
                    println!("Test Failed - expected to return ok: {}", error);
                    assert!(false)    
                }
            }
            match task_queue.get_category_queue_len("test") {
                Ok(queue_size) => assert_eq!(queue_size, 2),
                Err(error) => {
                    println!("Test Failed - failed to get queue length: {}", error);
                    assert!(false)
                }
            }

            match task_queue.pull_category_task_from_queue("test") {
                Ok(payload) => {
                    assert_eq!(payload, task_payload);
                },
                Err(error)=> {
                    println!("{}", error);
                    assert!(false)
                }
            }

            assert_eq!(task_queue.get_category_queue_len("test").unwrap(), 1)
        },
        Err(error) => {
            println!("Test Failed - failed to open queue: {:?}", error);
            assert!(false)
        }
    };
}

#[test]
fn queue_for_the_category_exist_with_last_task_test_pull_category_task() {
    let task_queue_arc = TaskQueue::initialise();
    let task_payload = String::from("Do This");

    match task_queue_arc.lock() {
        Ok(mut queue) => {
            match queue.push_category_task_to_queue(String::from("test"), task_payload.to_string()){
                Ok(_) => assert!(true),
                Err(error) => {
                    println!("Test Failed - expected to return ok: {}", error);
                    assert!(false)    
                }
            }
            match queue.pull_category_task_from_queue("test") {
                Ok(payload) => {
                    assert_eq!(payload, task_payload);
                    match queue.get_category_queue_len("test") {
                        Ok(_) => {
                            println!("Test Failed - queue exists while should be empty");
                            assert!(false)
                        },
                        Err(_) => assert!(true)
                    }
                },
                Err(error) => {
                    println!("Test Failed - {}", error);
                    assert!(false)
                }
            }
        },
        Err(error) => {
            println!("Test Failed - failed to open queue: {:?}", error);
            assert!(false)
        }
    };
}