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

net_reporter_api/api/http_clients/
http_clients_request.rs
