net_core_api/api/envelope/
envelope.rs

1use ion_rs;
2
3use ion_rs::IonReader;
4use ion_rs::IonWriter;
5
6use crate::core::api::API;
7use crate::core::decoder_api::Decoder;
8use crate::core::encoder_api::Encoder;
9use crate::core::typed_api::Typed;
10
11const DATA_TYPE: &str = "envelope";
12
13#[derive(Debug, PartialEq, Eq, Clone)]
14pub struct Envelope {
15    tenant_id: String,
16    envelope_type: String,
17    data: Vec<u8>,
18}
19
20impl API for Envelope {}
21
22impl Envelope {
23    pub fn new(tenant_id: &str, envelope_type: &str, data: &[u8]) -> Self {
24        Envelope {
25            tenant_id: tenant_id.into(),
26            envelope_type: envelope_type.into(),
27            data: data.into()
28        }
29    }
30
31    pub fn get_tenant_id(&self) -> &str {
32        &self.tenant_id
33    }
34
35    pub fn get_envelope_type(&self) -> &str {
36        &self.envelope_type
37    }
38
39    pub fn get_data(&self) -> &[u8] {
40        &self.data
41    }
42}
43
44impl Typed for Envelope {
45    fn get_type(&self) -> &str {
46        DATA_TYPE
47    }
48
49    fn get_data_type() -> &'static str where Self : Sized {
50        DATA_TYPE
51    }
52}
53
54impl Encoder for Envelope {
55    fn encode(&self) -> Vec<u8> {
56        let buffer: Vec<u8> = Vec::new();
57
58        let binary_writer_builder = ion_rs::BinaryWriterBuilder::new();
59        
60        let mut writer = binary_writer_builder.build(buffer.clone()).unwrap();
61        
62        writer.step_in(ion_rs::IonType::Struct).expect("Error while creating an ion struct");
63
64        writer.set_field_name("tenant_id");
65        writer.write_string(&self.tenant_id).unwrap();
66
67        writer.set_field_name("type");
68        writer.write_string(&self.envelope_type).unwrap();
69
70        writer.set_field_name("data");
71        writer.write_blob(&self.data).unwrap();
72
73        writer.step_out().unwrap();
74        writer.flush().unwrap();
75
76        writer.output().as_slice().to_owned()
77    }
78}
79
80impl Decoder for Envelope {
81    fn decode(data: &[u8]) -> Self {
82
83        let mut binary_user_reader = ion_rs::ReaderBuilder::new().build(data).unwrap();
84        binary_user_reader.next().unwrap();
85        binary_user_reader.step_in().unwrap();
86
87        binary_user_reader.next().unwrap();
88        let binding = binary_user_reader.read_string().unwrap();
89        let tenant_id = binding.text();
90
91        binary_user_reader.next().unwrap();
92        let binding = binary_user_reader.read_string().unwrap();
93        let envelope_type = binding.text();
94
95        binary_user_reader.next().unwrap();
96        let binding = binary_user_reader.read_blob().unwrap();
97        let data = binding.as_slice();
98
99        Envelope::new(
100            tenant_id,
101            envelope_type,
102            data,
103        )
104    }
105}
106
107
108#[cfg(test)]
109mod tests {
110    use ion_rs::IonType;
111    use ion_rs::IonReader;
112    use ion_rs::ReaderBuilder;
113    use ion_rs::StreamItem;
114
115    use crate::core::decoder_api::Decoder;
116    use crate::core::encoder_api::Encoder;
117    use crate::core::typed_api::Typed;
118
119
120    use super::Envelope;
121
122
123    #[test]
124    fn reader_correctly_read_encoded_envelope() {
125        const TENANT_ID: &str = "TENANT_ID";
126        const ENVELOPE_TYPE: &str = "ENVELOPE_TYPE";
127        const ENVELOPE_DATA: &[u8] = "ENVELOPE_DATA".as_bytes();
128        let envelope = Envelope::new(TENANT_ID, ENVELOPE_TYPE, ENVELOPE_DATA);
129
130        let mut binary_user_reader = ReaderBuilder::new().build(envelope.encode()).unwrap();
131
132        assert_eq!(StreamItem::Value(IonType::Struct), binary_user_reader.next().unwrap());
133        binary_user_reader.step_in().unwrap();
134
135        assert_eq!(StreamItem::Value(IonType::String), binary_user_reader.next().unwrap());
136        assert_eq!("tenant_id", binary_user_reader.field_name().unwrap());
137        assert_eq!(TENANT_ID,  binary_user_reader.read_string().unwrap().text());
138
139
140        assert_eq!(StreamItem::Value(IonType::String), binary_user_reader.next().unwrap());
141        assert_eq!("type", binary_user_reader.field_name().unwrap());
142        assert_eq!(ENVELOPE_TYPE, binary_user_reader.read_string().unwrap().text());
143
144        assert_eq!(StreamItem::Value(IonType::Blob), binary_user_reader.next().unwrap());
145        assert_eq!("data", binary_user_reader.field_name().unwrap());
146        assert_eq!(ENVELOPE_DATA, binary_user_reader.read_blob().unwrap().as_slice());
147    }
148    
149    #[test]
150    fn endec_envelope() {
151        const TENANT_ID: &str = "TENANT_ID";
152        const ENVELOPE_TYPE: &str = "ENVELOPE_TYPE";
153        const ENVELOPE_DATA: &[u8] = "ENVELOPE_DATA".as_bytes();
154        let envelope = Envelope::new(TENANT_ID, ENVELOPE_TYPE, ENVELOPE_DATA);
155        assert_eq!(envelope, Envelope::decode(&envelope.encode()));
156    }
157
158    #[test]
159    fn test_getting_data_types() {
160        const TENANT_ID: &str = "TENANT_ID";
161        const ENVELOPE_TYPE: &str = "ENVELOPE_TYPE";
162        const ENVELOPE_DATA: &[u8] = "ENVELOPE_DATA".as_bytes();
163        let envelope = Envelope::new(TENANT_ID, ENVELOPE_TYPE, ENVELOPE_DATA);
164        
165        assert_eq!(envelope.get_type(), Envelope::get_data_type());
166        assert_eq!(envelope.get_type(), super::DATA_TYPE);
167    }
168}
net_core_api/api/envelope/envelope.rs

net_core_api/api/envelope/
envelope.rs
