just-lists-core 0.2.5

Core library for just-lists terminal-based task manager.
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

pub mod list;
pub mod list_item;

use crate::list::List;
use crate::list_item::ListItem;

pub fn get_sample_list() -> List {
    let mut list = List::new();

    let top_item_1 = ListItem::new("First item".to_string());
    let top_item_2 = ListItem::new("Second item".to_string());

    let parent_1_id = top_item_1.id.clone();
    let parent_2_id = top_item_2.id.clone();

    list.add_list_item(top_item_1, None);
    list.add_list_item(top_item_2, None);

    let _ = list.add_child_list_item(
        ListItem::new("First child item".to_string()),
        &parent_1_id,
        None,
    );
    let _ = list.add_child_list_item(
        ListItem::new("Second child item".to_string()),
        &parent_2_id,
        None,
    );

    list
}

#[cfg(test)]
mod tests {
    use core::panic;

    use crate::list::List;
    use crate::list_item::ListItem;

    #[test]
    fn can_get_new_list() {
        let _ = List::new();
    }

    #[test]
    fn can_add_item_to_list() {
        let mut list = List::new();
        list.add_list_item(ListItem::new("First list item".to_string()), None);

        let mut list_length = list.get_top_level_list_items().len();
        assert!(
            list_length == 1,
            "List item length was not 1. Actual: {list_length}"
        );

        list.add_list_item(ListItem::new("Second item".to_string()), None);

        list_length = list.get_top_level_list_items().len();
        assert!(
            list_length == 2,
            "List item length was not 2. Actual: {list_length}"
        );
    }

    #[test]
    fn can_serialize_and_deserialize() {
        let list = super::get_sample_list();

        let serialized = list.into_string();
        let deserialized: List = List::from_string(serialized);

        println!("{:?}", deserialized);
    }

    #[test]
    fn can_remove_list_items() {
        let mut list = super::get_sample_list();

        let top_level_items = list.get_top_level_list_items();

        let item_1_id = top_level_items.first().unwrap().id.clone();
        let item_2_id = top_level_items.last().unwrap().id.clone();

        match list.remove_list_item(&item_1_id) {
            Ok(_value) => (),
            Err(error) => panic!(
                "Expected to successfully remove top level item. Actual:{:?}",
                error
            ),
        };

        let first_child_of_2_id = list
            .get_list_item(
                list.get_list_item(&item_2_id)
                    .unwrap()
                    .children
                    .first()
                    .unwrap(),
            )
            .unwrap()
            .id
            .clone();

        match list.remove_list_item(&first_child_of_2_id) {
            Ok(_value) => (),
            Err(error) => panic!(
                "Expected to successfully remove child level item. Actual:{:?}",
                error
            ),
        }
    }
}