tube 0.0.2

This crate was renamed to 'tubez'. Please use that crate instead.
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

mod decoder;
mod encoder;
mod frame;
mod frame_handler;

// TODO: Are all these "(in crate)" specs really necessary? Feels excessive...
pub(in crate) use decoder::Decoder;
pub(in crate) use encoder::*;
pub(in crate) use frame::AbortReason;
pub(in crate) use frame::Frame;
pub(in crate) use frame_handler::FrameHandler;
pub(in crate) use frame_handler::FrameHandlerResult;

#[cfg(test)]
mod codec_tests {
    use std::collections::HashMap;

    use super::frame::Frame;
    use super::decoder::Decoder;
    use super::encoder::*;

    #[test]
    fn clienthasfinishedsending_frame_encodes_and_decodes() {
        let tube_id = 65000;
        let encoded_bytes = encode_client_has_finished_sending_frame(tube_id).unwrap();

        let mut decoder = Decoder::new();
        let frames = decoder.decode(encoded_bytes).unwrap();
        assert_eq!(frames.len(), 1);
        assert_eq!(frames[0], Frame::ClientHasFinishedSending { tube_id });
    }

    #[test]
    fn drain_frame_encodes_and_decodes() {
        let encoded_bytes = encode_drain_frame().unwrap();

        let mut decoder = Decoder::new();
        let frames = decoder.decode(encoded_bytes).unwrap();
        assert_eq!(frames.len(), 1);
        assert_eq!(frames[0], Frame::Drain);
    }

    #[test]
    fn newtube_frame_encodes_and_decodes() {
        let tube_id = 65000;
        let encoded_headers = HashMap::from([
          ("header1".to_string(), "value1".to_string()),
          ("header2".to_string(), "value2".to_string()),
        ]);
        let expected_headers = encoded_headers.clone();

        let encoded_bytes = 
          encode_newtube_frame(tube_id, encoded_headers).unwrap();

        let mut decoder = Decoder::new();
        let frames = decoder.decode(encoded_bytes).unwrap();
        assert_eq!(frames.len(), 1);
        assert_eq!(frames[0], Frame::NewTube {
          tube_id,
          headers: expected_headers,
        });
    }

    #[test]
    fn payload_frame_with_ack_encodes_and_decodes() {
        let tube_id = 65000;
        let ack_id = 32000;
        let data = vec![0, 1, 42, 255];
        let expected_data = data.clone();

        let encoded_bytes = encode_payload_frame(tube_id, Some(ack_id), data).unwrap();

        let mut decoder = Decoder::new();
        let frames = decoder.decode(encoded_bytes).unwrap();
        assert_eq!(frames.len(), 1);
        assert_eq!(frames[0], Frame::Payload {
          tube_id,
          ack_id: Some(ack_id),
          data: expected_data,
        });
    }

    #[test]
    fn payload_frame_without_ack_encodes_and_decodes() {
        let tube_id = 65000;
        let data = vec![0, 1, 42, 255];
        let expected_data = data.clone();

        let encoded_bytes = encode_payload_frame(tube_id, None, data).unwrap();

        let mut decoder = Decoder::new();
        let frames = decoder.decode(encoded_bytes).unwrap();
        assert_eq!(frames.len(), 1);
        assert_eq!(frames[0], Frame::Payload {
          tube_id,
          ack_id: None,
          data: expected_data,
        });
    }

    #[test]
    fn payload_ack_frame_encodes_and_decodes() {
        let tube_id = 65000;
        let ack_id: u16 = 32000;

        let encoded_bytes = encode_payload_ack_frame(tube_id, ack_id).unwrap();

        let mut decoder = Decoder::new();
        let frames = decoder.decode(encoded_bytes).unwrap();
        assert_eq!(frames.len(), 1);
        assert_eq!(frames[0], Frame::PayloadAck {
          tube_id,
          ack_id,
        });
    }

    #[test]
    fn serverhasfinishedsending_frame_encodes_and_decodes() {
        let tube_id = 65000;
        let encoded_bytes = encode_server_has_finished_sending_frame(tube_id).unwrap();

        let mut decoder = Decoder::new();
        let frames = decoder.decode(encoded_bytes).unwrap();
        assert_eq!(frames.len(), 1);
        assert_eq!(frames[0], Frame::ServerHasFinishedSending { tube_id });
    }
}