net_reporter_api/api/http_responses/
http_responses_request.rs

1use ion_rs;
2
3use ion_rs::IonReader;
4use ion_rs::IonType;
5use ion_rs::IonWriter;
6use ion_rs::ReaderBuilder;
7
8use net_core_api::core::api::API;
9use net_core_api::core::encoder_api::Encoder;
10use net_core_api::core::decoder_api::Decoder;
11use net_core_api::core::typed_api::Typed;
12
13use super::http_responses_filters::HttpResponsesFiltersDTO;
14
15const DATA_TYPE: &str = "http-responses-request";
16
17#[derive(Debug, PartialEq, Eq)]
18pub struct HttpResponsesRequestDTO {
19    start_date_time: i64,
20    end_date_time: i64,
21    network_id: Option<String>,
22    filters: HttpResponsesFiltersDTO,
23}
24impl API for HttpResponsesRequestDTO { }
25
26impl HttpResponsesRequestDTO {
27    pub fn new(start_date_time: i64, end_date_time: i64, network_id: Option<&str>, filters: HttpResponsesFiltersDTO) -> Self {
28        HttpResponsesRequestDTO {
29            start_date_time,
30            end_date_time,
31            network_id: network_id.map(str::to_string),
32            filters,
33        }
34    }
35
36    pub fn get_start_date_time(&self) -> i64 {
37        self.start_date_time
38    }
39
40    pub fn get_end_date_time(&self) -> i64 {
41        self.end_date_time
42    }
43
44    pub fn get_network_id(&self) -> Option<&str> {
45        self.network_id.as_deref()
46    }
47
48    pub fn get_filters(&self) -> &HttpResponsesFiltersDTO {
49        &self.filters
50    }
51}
52
53impl Encoder for HttpResponsesRequestDTO {
54    fn encode(&self) -> Vec<u8> {
55        let buffer: Vec<u8> = Vec::new();
56
57        let binary_writer_builder = ion_rs::BinaryWriterBuilder::new();
58        let mut writer = binary_writer_builder.build(buffer.clone()).unwrap();
59        
60        writer.step_in(IonType::Struct).expect("Error while creating an ion struct");
61        
62        writer.set_field_name("start_date_time");
63        writer.write_i64(self.start_date_time).unwrap();
64
65        writer.set_field_name("end_date_time");
66        writer.write_i64(self.end_date_time).unwrap();
67
68        writer.set_field_name("network_id");
69        match self.network_id.as_deref() {
70            Some(network_id) => writer.write_string(network_id).unwrap(),
71            None => writer.write_null(IonType::String).unwrap(),
72        }
73
74        writer.set_field_name("filters");
75        writer.write_blob(self.filters.encode().as_slice()).unwrap();
76
77        writer.step_out().unwrap();
78        writer.flush().unwrap();
79
80        writer.output().as_slice().into()
81    }
82}
83
84impl Decoder for HttpResponsesRequestDTO {
85    fn decode(data: &[u8]) -> Self {
86        let mut binary_user_reader = ReaderBuilder::new().build(data).unwrap();
87        binary_user_reader.next().unwrap();
88        binary_user_reader.step_in().unwrap();
89
90        binary_user_reader.next().unwrap();
91        let start_date_time = binary_user_reader.read_i64().unwrap();
92        
93        binary_user_reader.next().unwrap();
94        let end_date_time = binary_user_reader.read_i64().unwrap();
95
96        binary_user_reader.next().unwrap();
97        let network_id = match binary_user_reader.current() {
98            ion_rs::StreamItem::Value(_) => Some(binary_user_reader.read_string().unwrap().text().to_owned()),
99            _ => None,
100        };
101
102        binary_user_reader.next().unwrap();
103        let data = binary_user_reader.read_blob().unwrap();
104        let filters = HttpResponsesFiltersDTO::decode(data.as_slice());
105        
106        HttpResponsesRequestDTO::new(
107            start_date_time,
108            end_date_time,
109            network_id.as_deref(),
110            filters,
111        )
112    }
113}
114
115impl Typed for HttpResponsesRequestDTO {
116    fn get_data_type() -> &'static str {
117        DATA_TYPE
118    }
119
120    fn get_type(&self) -> &str {
121        Self::get_data_type()
122    }
123}
124
125#[cfg(test)]
126mod tests {
127    use ion_rs::IonType;
128    use ion_rs::IonReader;
129    use ion_rs::ReaderBuilder;
130    use ion_rs::StreamItem;
131    
132    use net_core_api::core::encoder_api::Encoder;
133    use net_core_api::core::decoder_api::Decoder;
134
135    use crate::api::http_responses::http_responses_request::HttpResponsesRequestDTO;
136    use crate::api::http_responses::http_responses_filters::HttpResponsesFiltersDTO;
137
138    fn get_test_filters() -> HttpResponsesFiltersDTO {
139        let http_responses = vec![200, 400];
140        const INCLUDE_RESPONSE_MODE: bool = false;
141        let endpoints = vec!["0.0.0.0".to_string(), "1.1.1.1".to_string()];
142        const INCLUDE_ENDPOINTS_MODE: bool = true;
143        
144        HttpResponsesFiltersDTO::new(
145            &http_responses,
146            Some(INCLUDE_RESPONSE_MODE),
147            &endpoints,
148            Some(INCLUDE_ENDPOINTS_MODE),
149            None,
150            None,
151        )
152    }
153
154    #[test]
155    fn reader_correctly_read_encoded_http_responses_request_some_filters() {
156        const START_DATE_TIME: i64 = i64::MIN;
157        const END_DATE_TIME: i64 = i64::MAX;
158        const NETWORK_ID: &str = "1";
159
160        let network_bandwidth_request = HttpResponsesRequestDTO::new(
161            START_DATE_TIME,
162            END_DATE_TIME,
163            Some(NETWORK_ID),
164            get_test_filters(),
165        );
166        
167        let mut binary_user_reader = ReaderBuilder::new().build(network_bandwidth_request.encode()).unwrap();
168
169        assert_eq!(StreamItem::Value(IonType::Struct), binary_user_reader.next().unwrap());
170        binary_user_reader.step_in().unwrap();
171
172        assert_eq!(StreamItem::Value(IonType::Int), binary_user_reader.next().unwrap());
173        assert_eq!("start_date_time", binary_user_reader.field_name().unwrap());
174        assert_eq!(START_DATE_TIME, binary_user_reader.read_i64().unwrap());
175        
176        assert_eq!(StreamItem::Value(IonType::Int), binary_user_reader.next().unwrap());
177        assert_eq!("end_date_time", binary_user_reader.field_name().unwrap());
178        assert_eq!(END_DATE_TIME,  binary_user_reader.read_i64().unwrap());
179
180        assert_eq!(StreamItem::Value(IonType::String), binary_user_reader.next().unwrap());
181        assert_eq!("network_id", binary_user_reader.field_name().unwrap());
182        assert_eq!(NETWORK_ID,  binary_user_reader.read_string().unwrap().text());
183
184        assert_eq!(StreamItem::Value(IonType::Blob), binary_user_reader.next().unwrap());
185        assert_eq!("filters", binary_user_reader.field_name().unwrap());
186        assert_eq!(get_test_filters(), HttpResponsesFiltersDTO::decode(binary_user_reader.read_blob().unwrap().as_slice()));
187        
188        binary_user_reader.step_out().unwrap();
189    }
190
191    #[test]
192    fn endec_http_responses_request() {
193        const START_DATE_TIME: i64 = i64::MIN;
194        const END_DATE_TIME: i64 = i64::MAX;
195        const NETWORK_ID: &str = "1";
196
197        let network_bandwidth_request = HttpResponsesRequestDTO::new(
198            START_DATE_TIME,
199            END_DATE_TIME,
200            Some(NETWORK_ID),
201            get_test_filters(),
202        );
203        assert_eq!(network_bandwidth_request, HttpResponsesRequestDTO::decode(&network_bandwidth_request.encode()));
204    }
205
206    #[test]
207    fn endec_http_responses_request_with_optional_network_id() {
208        const START_DATE_TIME: i64 = i64::MIN;
209        const END_DATE_TIME: i64 = i64::MAX;
210
211
212        let network_bandwidth_request = HttpResponsesRequestDTO::new(
213            START_DATE_TIME,
214            END_DATE_TIME,
215            None,
216            get_test_filters(),
217        );
218        assert_eq!(network_bandwidth_request, HttpResponsesRequestDTO::decode(&network_bandwidth_request.encode()));
219    }
220}
net_reporter_api/api/http_responses/http_responses_request.rs

net_reporter_api/api/http_responses/
http_responses_request.rs
