prodash 23.1.2

A dashboard for visualizing progress of asynchronous and possibly blocking tasks
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

mod message_buffer {
    use crate::messages::{Message, MessageLevel, MessageRingBuffer};

    fn push(buf: &mut MessageRingBuffer, msg: impl Into<String>) {
        buf.push_overwrite(MessageLevel::Info, "test".into(), msg);
    }
    fn push_and_copy_all(buf: &mut MessageRingBuffer, msg: impl Into<String>, out: &mut Vec<Message>) {
        push(buf, msg);
        buf.copy_all(out);
    }

    fn assert_messages(actual: &[Message], expected: &[&'static str]) {
        let actual: Vec<_> = actual.iter().map(|m| m.message.as_str()).collect();
        assert_eq!(expected, actual.as_slice(), "messages are ordered old to new");
    }

    #[test]
    fn copy_all() {
        let mut buf = MessageRingBuffer::with_capacity(2);
        let mut out = Vec::new();
        buf.copy_all(&mut out);
        assert_eq!(out, buf.buf);

        push_and_copy_all(&mut buf, "one", &mut out);
        assert_eq!(out, buf.buf);

        push_and_copy_all(&mut buf, "two", &mut out);
        assert_eq!(out, buf.buf);

        push_and_copy_all(&mut buf, "three", &mut out);
        assert_messages(&out, &["two", "three"]);

        push_and_copy_all(&mut buf, "four", &mut out);
        assert_messages(&out, &["three", "four"]);

        push_and_copy_all(&mut buf, "five", &mut out);
        buf.copy_all(&mut out);
        assert_messages(&out, &["four", "five"]);
    }

    mod copy_new {
        use crate::{
            messages::{Message, MessageCopyState, MessageRingBuffer},
            tree::tests::message_buffer::{assert_messages, push},
        };

        #[test]
        fn without_state() {
            fn push_and_copy_new(buf: &mut MessageRingBuffer, msg: impl Into<String>, out: &mut Vec<Message>) {
                push(buf, msg);
                buf.copy_new(out, None);
            }

            let mut buf = MessageRingBuffer::with_capacity(2);
            let mut out = Vec::new();
            buf.copy_new(&mut out, None);
            assert_eq!(out, buf.buf);

            push_and_copy_new(&mut buf, "one", &mut out);
            assert_eq!(out, buf.buf);

            push_and_copy_new(&mut buf, "two", &mut out);
            assert_eq!(out, buf.buf);

            push_and_copy_new(&mut buf, "three", &mut out);
            assert_messages(&out, &["two", "three"]);
        }

        #[test]
        fn with_continous_state() {
            fn push_and_copy_new(
                buf: &mut MessageRingBuffer,
                msg: impl Into<String>,
                out: &mut Vec<Message>,
                state: Option<MessageCopyState>,
            ) -> Option<MessageCopyState> {
                push(buf, msg);
                Some(buf.copy_new(out, state))
            }
            let mut buf = MessageRingBuffer::with_capacity(2);
            let mut out = Vec::new();
            let mut state = push_and_copy_new(&mut buf, "one", &mut out, None);
            assert_eq!(out, buf.buf);

            state = push_and_copy_new(&mut buf, "two", &mut out, state);
            assert_messages(&out, &["two"]);

            state = push_and_copy_new(&mut buf, "three", &mut out, state);
            assert_messages(&out, &["three"]);

            state = push_and_copy_new(&mut buf, "four", &mut out, state);
            assert_messages(&out, &["four"]);

            push_and_copy_new(&mut buf, "five", &mut out, state);
            assert_messages(&out, &["five"]);

            state = push_and_copy_new(&mut buf, "six", &mut out, None);
            assert_messages(&out, &["five", "six"]);

            state = Some(buf.copy_new(&mut out, state));
            assert_messages(&out, &[]);

            push(&mut buf, "seven");
            push(&mut buf, "eight");
            state = Some(buf.copy_new(&mut out, state));
            assert_messages(&out, &["seven", "eight"]);

            push(&mut buf, "1");
            push(&mut buf, "2");
            push(&mut buf, "3");
            buf.copy_new(&mut out, state);
            assert_messages(&out, &["2", "3"]);
        }
    }
}