net_reporter_api/api/network/
networks.rs

1use ion_rs::element::reader::ElementReader;
2use ion_rs::IonReader;
3use ion_rs::IonType;
4use ion_rs::IonWriter;
5use ion_rs::ReaderBuilder;
6use net_core_api::core::api::API;
7use net_core_api::core::encoder_api::Encoder;
8use net_core_api::core::decoder_api::Decoder;
9use net_core_api::core::typed_api::Typed;
10
11use super::network::NetworkDTO;
12
13const DATA_TYPE: &str = "networks";
14
15#[derive(Debug, Clone, Default, PartialEq, Eq)]
16pub struct NetworksDTO {
17    networks: Vec<NetworkDTO>,
18}
19impl API for NetworksDTO { }
20
21impl NetworksDTO {
22    pub fn new(networks: &[NetworkDTO]) -> Self {
23        Self { networks: networks.to_vec() }
24    }
25
26    pub fn get_networks(&self) -> &[NetworkDTO] {
27        &self.networks
28    }
29}
30
31impl Encoder for NetworksDTO {
32    fn encode(&self) -> Vec<u8> {
33        let buffer: Vec<u8> = Vec::new();
34
35        let binary_writer_builder = ion_rs::BinaryWriterBuilder::new();
36        let mut writer = binary_writer_builder.build(buffer.clone()).unwrap();
37        
38        writer.step_in(IonType::Struct).expect("Error while creating an ion struct");
39
40        writer.set_field_name("networks");
41        writer.step_in(IonType::List).unwrap();
42        self.networks.iter().for_each(|network| writer.write_blob(network.encode()).unwrap());
43        writer.step_out().unwrap();
44        
45        writer.step_out().unwrap();
46        writer.flush().unwrap();
47
48        writer.output().as_slice().into()
49    }
50}
51
52impl Decoder for NetworksDTO {
53    #[allow(unused_variables)]
54    fn decode(data: &[u8]) -> NetworksDTO {
55        let mut binary_user_reader = ReaderBuilder::new().build(data).unwrap();
56        binary_user_reader.next().unwrap();
57        binary_user_reader.step_in().unwrap();
58
59        binary_user_reader.next().unwrap();
60        binary_user_reader.step_in().unwrap();
61        let elements = binary_user_reader.read_all_elements().unwrap();
62        let mut networks = Vec::<NetworkDTO>::with_capacity(elements.len());
63        for element in elements {
64            networks.push(NetworkDTO::decode(element.as_blob().unwrap()));
65        }
66        binary_user_reader.step_out().unwrap();
67
68        NetworksDTO::new(&networks)
69    }
70}
71
72impl Typed for NetworksDTO {
73    fn get_data_type() -> &'static str {
74        DATA_TYPE
75    }
76
77    fn get_type(&self) -> &str {
78        Self::get_data_type()
79    }
80}
81#[cfg(test)]
82mod tests {
83    use ion_rs::IonType;
84    use ion_rs::IonReader;
85    use ion_rs::ReaderBuilder;
86    use ion_rs::StreamItem;
87
88    use net_core_api::core::encoder_api::Encoder;
89    use net_core_api::core::decoder_api::Decoder;
90    use net_core_api::core::typed_api::Typed;
91
92    use crate::api::network::network::NetworkDTO;
93
94    use super::NetworksDTO;
95
96    fn get_networks() -> Vec<NetworkDTO>{
97        const NETWORK_ID1: &str = "network_id1";
98        const NAME1: &str = "network name 1";
99        const COLOR1: &str = "network color 1";
100
101        const NETWORK_ID2: &str = "network_id2";
102        const NAME2: &str = "network name 2";
103        const COLOR2: &str = "network color 2";
104        vec![NetworkDTO::new(NETWORK_ID1, NAME1, COLOR1), NetworkDTO::new(NETWORK_ID2, NAME2, COLOR2)]
105    }
106
107    #[test]
108    fn reader_correctly_read_encoded_network_request() {
109        let networks = get_networks();
110        let get_networks_response = NetworksDTO::new(&networks);
111        let mut binary_user_reader = ReaderBuilder::new().build(get_networks_response.encode()).unwrap();
112
113        assert_eq!(StreamItem::Value(IonType::Struct), binary_user_reader.next().unwrap());
114        binary_user_reader.step_in().unwrap();
115
116        assert_eq!(StreamItem::Value(IonType::List), binary_user_reader.next().unwrap());
117        assert_eq!("networks", binary_user_reader.field_name().unwrap());
118        binary_user_reader.step_in().unwrap();
119        for network in networks {
120            assert_eq!(StreamItem::Value(IonType::Blob), binary_user_reader.next().unwrap());
121            assert_eq!(network, NetworkDTO::decode(binary_user_reader.read_blob().unwrap().as_slice()));
122        }
123        binary_user_reader.step_out().unwrap();
124    }
125
126    #[test]
127    fn endec_network_request() {
128        let networks = get_networks();
129        let get_networks_response = NetworksDTO::new(&networks);
130        assert_eq!(get_networks_response, NetworksDTO::decode(&get_networks_response.encode()));
131    }
132
133    #[test]
134    fn test_getting_data_types() {
135        let networks = get_networks();
136        let get_networks_response = NetworksDTO::new(&networks);
137        assert_eq!(get_networks_response.get_type(), NetworksDTO::get_data_type());
138        assert_eq!(get_networks_response.get_type(), super::DATA_TYPE);
139    }
140}
net_reporter_api/api/network/networks.rs

net_reporter_api/api/network/
networks.rs
