net_reporter_api/api/http_responses_distribution/
http_responses_disribution_filters.rs

1use ion_rs;
2
3use ion_rs::element::reader::ElementReader;
4use ion_rs::IonReader;
5use ion_rs::IonType;
6use ion_rs::IonWriter;
7use ion_rs::ReaderBuilder;
8use ion_rs::StreamItem;
9
10use net_core_api::core::api::API;
11use net_core_api::core::encoder_api::Encoder;
12use net_core_api::core::decoder_api::Decoder;
13use net_core_api::core::typed_api::Typed;
14
15const DATA_TYPE: &str = "http_responses_distribution_filters";
16
17#[derive(Debug, PartialEq, Eq, Clone)]
18pub struct HttpResponsesDistributionFiltersDTO {
19    endpoints: Vec<String>,
20    include_endpoints_mode: Option<bool>,
21    bytes_lower_bound: Option<i64>,
22    bytes_upper_bound: Option<i64>,
23}
24impl API for HttpResponsesDistributionFiltersDTO { }
25
26impl HttpResponsesDistributionFiltersDTO {
27    pub fn new(
28        endpoints: &[String],
29        include_endpoints_mode: Option<bool>,
30        bytes_lower_bound: Option<i64>,
31        bytes_upper_bound: Option<i64>,
32    ) -> Self {
33        HttpResponsesDistributionFiltersDTO {
34            endpoints: endpoints.to_vec(),
35            include_endpoints_mode,
36            bytes_lower_bound,
37            bytes_upper_bound,
38        }
39    }
40
41    pub fn get_endpoints(&self) -> &[String] {
42        self.endpoints.as_slice()
43    }
44
45    pub fn is_include_endpoints_mode(&self) -> Option<bool> {
46        self.include_endpoints_mode
47    }
48
49    pub fn get_bytes_lower_bound(&self) -> Option<i64> {
50        self.bytes_lower_bound
51    }
52
53    pub fn get_bytes_upper_bound(&self) -> Option<i64> {
54        self.bytes_upper_bound
55    }
56}
57
58impl Encoder for HttpResponsesDistributionFiltersDTO {
59    fn encode(&self) -> Vec<u8> {
60        let buffer: Vec<u8> = Vec::new();
61
62        let binary_writer_builder = ion_rs::BinaryWriterBuilder::new();
63        let mut writer = binary_writer_builder.build(buffer.clone()).unwrap();
64        
65        writer.step_in(IonType::Struct).expect("Error while creating an ion struct");
66
67        writer.set_field_name("include_endpoints_mode");
68        match self.include_endpoints_mode {
69            Some(include_endpoints_mode) => {
70                writer.write_bool(include_endpoints_mode).unwrap();
71                writer.set_field_name("endpoints");
72                writer.step_in(IonType::List).expect("Error while entering an ion list");
73                self.endpoints.iter().for_each(|endpoint| {
74                    writer.write_string(endpoint).unwrap();
75                });
76                writer.step_out().unwrap();
77            },
78            None => writer.write_null(IonType::Bool).unwrap(),
79        }
80
81        writer.set_field_name("bytes_lower_bound");
82        match self.bytes_lower_bound {
83            Some(bytes_lower_bound) => writer.write_i64(bytes_lower_bound).unwrap(),
84            None => writer.write_null(IonType::Int).unwrap(),
85        }
86
87        writer.set_field_name("bytes_upper_bound");
88        match self.bytes_upper_bound {
89            Some(bytes_upper_bound) => writer.write_i64(bytes_upper_bound).unwrap(),
90            None => writer.write_null(IonType::Int).unwrap(),
91        }
92        
93        writer.step_out().unwrap();
94        writer.flush().unwrap();
95
96        writer.output().as_slice().into()
97    }
98}
99
100impl Decoder for HttpResponsesDistributionFiltersDTO {
101    fn decode(data: &[u8]) -> Self {
102
103        let mut binary_user_reader = ReaderBuilder::new().build(data).unwrap();
104        binary_user_reader.next().unwrap();
105        binary_user_reader.step_in().unwrap();
106
107        binary_user_reader.next().unwrap();
108        let (include_endpoints, endpoints) = match binary_user_reader.current() {
109            StreamItem::Value(_) => {
110                let include_endpoints = binary_user_reader.read_bool().unwrap();
111                binary_user_reader.next().unwrap();
112                binary_user_reader.step_in().unwrap();
113                let endpoints_elements = binary_user_reader.read_all_elements().unwrap();
114                let mut endpoints = Vec::with_capacity(endpoints_elements.len());
115                endpoints_elements.iter().for_each(|element| {
116                    let endpoint = element.as_string().unwrap();
117                    endpoints.push(endpoint.to_owned());
118                });
119                
120                binary_user_reader.step_out().unwrap();
121                (Some(include_endpoints), endpoints)
122            },
123            _ => (None, vec![]),
124        };
125
126        binary_user_reader.next().unwrap();
127        let bytes_lower_bound = match binary_user_reader.current() {
128            StreamItem::Value(_) => Some(binary_user_reader.read_i64().unwrap()),
129            _ => None,
130        };
131
132        binary_user_reader.next().unwrap();
133        let bytes_upper_bound = match binary_user_reader.current() {
134            StreamItem::Value(_) => Some(binary_user_reader.read_i64().unwrap()),
135            _ => None,
136        };
137
138        HttpResponsesDistributionFiltersDTO::new(
139            endpoints.as_slice(),
140            include_endpoints,
141            bytes_lower_bound,
142            bytes_upper_bound,
143        )
144    }
145}
146
147impl Typed for HttpResponsesDistributionFiltersDTO {
148    fn get_data_type() -> &'static str {
149        DATA_TYPE
150    }
151
152    fn get_type(&self) -> &str {
153        Self::get_data_type()
154    }
155}
156
157#[cfg(test)]
158mod tests {
159    use ion_rs::element::reader::ElementReader;
160    use ion_rs::IonType;
161    use ion_rs::IonReader;
162    use ion_rs::ReaderBuilder;
163    use ion_rs::StreamItem;
164    
165    use net_core_api::core::encoder_api::Encoder;
166    use net_core_api::core::decoder_api::Decoder;
167
168    use crate::api::http_responses_distribution::http_responses_disribution_filters::HttpResponsesDistributionFiltersDTO;
169
170    
171    #[test]
172    fn reader_correctly_read_encoded_http_responses_filters_0() {
173        let endpoints = vec!["0.0.0.0".to_string(), "1.1.1.1".to_string()];
174        const INCLUDE_ENDPOINTS_MODE: bool = true;
175        let bytes_lower_bound = Some(100);
176        
177        let filters = HttpResponsesDistributionFiltersDTO::new(
178            &endpoints,
179            Some(INCLUDE_ENDPOINTS_MODE),
180            bytes_lower_bound,
181            None,
182        );
183        
184        let mut binary_user_reader = ReaderBuilder::new().build(filters.encode()).unwrap();
185
186        assert_eq!(StreamItem::Value(IonType::Struct), binary_user_reader.next().unwrap());
187        binary_user_reader.step_in().unwrap();
188
189        assert_eq!(StreamItem::Value(IonType::Bool), binary_user_reader.next().unwrap());
190        assert_eq!("include_endpoints_mode", binary_user_reader.field_name().unwrap());
191        assert_eq!(INCLUDE_ENDPOINTS_MODE,  binary_user_reader.read_bool().unwrap());
192
193        assert_eq!(StreamItem::Value(IonType::List), binary_user_reader.next().unwrap());
194        assert_eq!("endpoints", binary_user_reader.field_name().unwrap());
195        binary_user_reader.step_in().unwrap();
196        let elements = binary_user_reader.read_all_elements().unwrap();
197        assert_eq!(elements.len(), endpoints.len());
198        for (element, core_endpoint) in elements.iter().zip(endpoints.as_slice()) {
199            let endpoint = element.as_string().unwrap();
200            assert_eq!(endpoint, *core_endpoint);
201        }
202        binary_user_reader.step_out().unwrap();
203
204        assert_eq!(StreamItem::Value(IonType::Int), binary_user_reader.next().unwrap());
205        assert_eq!("bytes_lower_bound", binary_user_reader.field_name().unwrap());
206        assert_eq!(*bytes_lower_bound.as_ref().unwrap(),  binary_user_reader.read_i64().unwrap());
207
208        assert_eq!(StreamItem::Null(IonType::Int), binary_user_reader.next().unwrap());
209        assert_eq!("bytes_upper_bound", binary_user_reader.field_name().unwrap());
210
211        binary_user_reader.step_out().unwrap();
212    }
213
214    
215    #[test]
216    fn reader_correctly_read_encoded_http_responses_filters_1() {
217        let endpoints = vec![];
218        let bytes_upper_bound = Some(100);
219        
220        let filters = HttpResponsesDistributionFiltersDTO::new(
221            &endpoints,
222            None,
223            None,
224            bytes_upper_bound,
225        );
226        
227        let mut binary_user_reader = ReaderBuilder::new().build(filters.encode()).unwrap();
228
229        assert_eq!(StreamItem::Value(IonType::Struct), binary_user_reader.next().unwrap());
230        binary_user_reader.step_in().unwrap();
231
232        assert_eq!(StreamItem::Null(IonType::Bool), binary_user_reader.next().unwrap());
233        assert_eq!("include_endpoints_mode", binary_user_reader.field_name().unwrap());
234
235        assert_eq!(StreamItem::Null(IonType::Int), binary_user_reader.next().unwrap());
236        assert_eq!("bytes_lower_bound", binary_user_reader.field_name().unwrap());
237
238        assert_eq!(StreamItem::Value(IonType::Int), binary_user_reader.next().unwrap());
239        assert_eq!("bytes_upper_bound", binary_user_reader.field_name().unwrap());
240        assert_eq!(*bytes_upper_bound.as_ref().unwrap(),  binary_user_reader.read_i64().unwrap());
241
242        binary_user_reader.step_out().unwrap();
243    }
244
245    #[test]
246    fn reader_correctly_read_encoded_http_responses_filters_2() {
247        let endpoints = vec!["0.0.0.0".to_string(), "1.1.1.1".to_string()];
248        const INCLUDE_ENDPOINTS_MODE: bool = true;
249        
250        let filters = HttpResponsesDistributionFiltersDTO::new(
251            &endpoints,
252            Some(INCLUDE_ENDPOINTS_MODE),
253            None,
254            None,
255        );
256        
257        let mut binary_user_reader = ReaderBuilder::new().build(filters.encode()).unwrap();
258
259        assert_eq!(StreamItem::Value(IonType::Struct), binary_user_reader.next().unwrap());
260        binary_user_reader.step_in().unwrap();
261
262        assert_eq!(StreamItem::Value(IonType::Bool), binary_user_reader.next().unwrap());
263        assert_eq!("include_endpoints_mode", binary_user_reader.field_name().unwrap());
264        assert_eq!(INCLUDE_ENDPOINTS_MODE,  binary_user_reader.read_bool().unwrap());
265
266        assert_eq!(StreamItem::Value(IonType::List), binary_user_reader.next().unwrap());
267        assert_eq!("endpoints", binary_user_reader.field_name().unwrap());
268        binary_user_reader.step_in().unwrap();
269        let elements = binary_user_reader.read_all_elements().unwrap();
270        assert_eq!(elements.len(), endpoints.len());
271        for (element, core_endpoint) in elements.iter().zip(endpoints.as_slice()) {
272            let endpoint = element.as_string().unwrap();
273            assert_eq!(endpoint, *core_endpoint);
274        }
275        binary_user_reader.step_out().unwrap();
276
277        assert_eq!(StreamItem::Null(IonType::Int), binary_user_reader.next().unwrap());
278        assert_eq!("bytes_lower_bound", binary_user_reader.field_name().unwrap());
279
280        assert_eq!(StreamItem::Null(IonType::Int), binary_user_reader.next().unwrap());
281        assert_eq!("bytes_upper_bound", binary_user_reader.field_name().unwrap());
282
283
284        binary_user_reader.step_out().unwrap();
285    }
286
287
288    #[test]
289    fn endec_http_respnses_filters() {
290        let endpoints = vec!["0.0.0.0".to_string(), "1.1.1.1".to_string()];
291        const INCLUDE_ENDPOINTS_MODE: bool = true;
292        
293        let filters: HttpResponsesDistributionFiltersDTO = HttpResponsesDistributionFiltersDTO::new(
294            &endpoints,
295            Some(INCLUDE_ENDPOINTS_MODE),
296            None,
297            None,
298        );
299        
300        assert_eq!(filters, HttpResponsesDistributionFiltersDTO::decode(&filters.encode()));
301    }
302}
net_reporter_api/api/http_responses_distribution/http_responses_disribution_filters.rs

net_reporter_api/api/http_responses_distribution/
http_responses_disribution_filters.rs
