net_reporter_api/api/http_responses_distribution/
http_responses_distribution_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_disribution_filters::HttpResponsesDistributionFiltersDTO;
14
15const DATA_TYPE: &str = "http-responses-distribution-request";
16
17#[derive(Debug, PartialEq, Eq)]
18pub struct HttpResponsesDistributionRequestDTO {
19    start_date_time: i64,
20    end_date_time: i64,
21    network_id: Option<String>,
22    filters: HttpResponsesDistributionFiltersDTO,
23}
24impl API for HttpResponsesDistributionRequestDTO { }
25
26impl HttpResponsesDistributionRequestDTO {
27    pub fn new(start_date_time: i64, end_date_time: i64, network_id: Option<&str>, filters: HttpResponsesDistributionFiltersDTO) -> Self {
28        HttpResponsesDistributionRequestDTO {
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) -> &HttpResponsesDistributionFiltersDTO {
49        &self.filters
50    }
51}
52
53impl Encoder for HttpResponsesDistributionRequestDTO {
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 HttpResponsesDistributionRequestDTO {
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 filters = HttpResponsesDistributionFiltersDTO::decode(binary_user_reader.read_blob().unwrap().as_slice());
104
105        HttpResponsesDistributionRequestDTO::new(
106            start_date_time,
107            end_date_time,
108            network_id.as_deref(),
109            filters,
110        )
111    }
112}
113
114impl Typed for HttpResponsesDistributionRequestDTO {
115    fn get_data_type() -> &'static str {
116        DATA_TYPE
117    }
118
119    fn get_type(&self) -> &str {
120        Self::get_data_type()
121    }
122}
123
124#[cfg(test)]
125mod tests {
126    use ion_rs::IonType;
127    use ion_rs::IonReader;
128    use ion_rs::ReaderBuilder;
129    use ion_rs::StreamItem;
130
131    use net_core_api::core::encoder_api::Encoder;
132    use net_core_api::core::decoder_api::Decoder;
133    use net_core_api::core::typed_api::Typed;
134
135    use crate::api::http_responses_distribution::http_responses_distribution_request::HttpResponsesDistributionRequestDTO;
136    use crate::api::http_responses_distribution::http_responses_disribution_filters::HttpResponsesDistributionFiltersDTO;
137
138    fn get_test_filters() -> HttpResponsesDistributionFiltersDTO {
139        let endpoints = vec!["0.0.0.0".to_string(), "1.1.1.1".to_string()];
140        const INCLUDE_ENDPOINTS_MODE: bool = true;
141        let bytes_lower_bound = Some(100);
142        
143        HttpResponsesDistributionFiltersDTO::new(
144            &endpoints,
145            Some(INCLUDE_ENDPOINTS_MODE),
146            bytes_lower_bound,
147            None,
148        )
149    }
150
151    #[test]
152    fn reader_correctly_read_encoded_hrmd_request() {
153        const START_DATE_TIME: i64 = i64::MIN;
154        const END_DATE_TIME: i64 = i64::MAX;
155        const NETWORK_ID: &str = "1";
156
157        let http_responses_dist_request = HttpResponsesDistributionRequestDTO::new(
158            START_DATE_TIME,
159            END_DATE_TIME,
160            Some(NETWORK_ID),
161            get_test_filters(),
162        );
163        
164        let mut binary_user_reader = ReaderBuilder::new().build(http_responses_dist_request.encode()).unwrap();
165
166        assert_eq!(StreamItem::Value(IonType::Struct), binary_user_reader.next().unwrap());
167        binary_user_reader.step_in().unwrap();
168
169        assert_eq!(StreamItem::Value(IonType::Int), binary_user_reader.next().unwrap());
170        assert_eq!("start_date_time", binary_user_reader.field_name().unwrap());
171        assert_eq!(START_DATE_TIME, binary_user_reader.read_i64().unwrap());
172        
173        assert_eq!(StreamItem::Value(IonType::Int), binary_user_reader.next().unwrap());
174        assert_eq!("end_date_time", binary_user_reader.field_name().unwrap());
175        assert_eq!(END_DATE_TIME,  binary_user_reader.read_i64().unwrap());
176
177        assert_eq!(StreamItem::Value(IonType::String), binary_user_reader.next().unwrap());
178        assert_eq!("network_id", binary_user_reader.field_name().unwrap());
179        assert_eq!(NETWORK_ID,  binary_user_reader.read_string().unwrap().text());
180
181        assert_eq!(StreamItem::Value(IonType::Blob), binary_user_reader.next().unwrap());
182        assert_eq!("filters", binary_user_reader.field_name().unwrap());
183        assert_eq!(get_test_filters(), HttpResponsesDistributionFiltersDTO::decode(binary_user_reader.read_blob().unwrap().as_slice()));
184    }
185
186    #[test]
187    fn endec_hrmd_request() {
188        const START_DATE_TIME: i64 = i64::MIN;
189        const END_DATE_TIME: i64 = i64::MAX;
190        const NETWORK_ID: &str = "1";
191
192        let network_graph_request = HttpResponsesDistributionRequestDTO::new(
193            START_DATE_TIME,
194            END_DATE_TIME,
195            Some(NETWORK_ID),
196            get_test_filters(),
197        );
198        assert_eq!(network_graph_request, HttpResponsesDistributionRequestDTO::decode(&network_graph_request.encode()));
199    }
200
201    #[test]
202    fn endec_hrmd_request_with_optional_network_id() {
203        const START_DATE_TIME: i64 = i64::MIN;
204        const END_DATE_TIME: i64 = i64::MAX;
205
206        let network_graph_request = HttpResponsesDistributionRequestDTO::new(
207            START_DATE_TIME,
208            END_DATE_TIME,
209            None,
210            get_test_filters(),
211        );
212        assert_eq!(network_graph_request, HttpResponsesDistributionRequestDTO::decode(&network_graph_request.encode()));
213    }
214
215    #[test]
216    fn test_getting_data_types() {
217        const START_DATE_TIME: i64 = i64::MIN;
218        const END_DATE_TIME: i64 = i64::MAX;
219        const NETWORK_ID: &str = "1";
220
221        let network_graph_request = HttpResponsesDistributionRequestDTO::new(
222            START_DATE_TIME,
223            END_DATE_TIME,
224            Some(NETWORK_ID),
225            get_test_filters(),
226            
227        );
228        assert_eq!(network_graph_request.get_type(), HttpResponsesDistributionRequestDTO::get_data_type());
229        assert_eq!(network_graph_request.get_type(), super::DATA_TYPE);
230    }
231}
net_reporter_api/api/http_responses_distribution/http_responses_distribution_request.rs

net_reporter_api/api/http_responses_distribution/
http_responses_distribution_request.rs
