v_storage/
memory_storage.rs

1// memory_storage.rs
2
3use v_individual_model::onto::individual::Individual;
4use v_individual_model::onto::parser::parse_raw;
5use crate::common::{Storage, StorageId, StorageResult};
6use std::collections::HashMap;
7use std::sync::RwLock;
8
9pub struct MemoryStorage {
10    individuals: RwLock<HashMap<String, Vec<u8>>>,
11    tickets: RwLock<HashMap<String, Vec<u8>>>,
12    az: RwLock<HashMap<String, Vec<u8>>>,
13}
14
15impl Default for MemoryStorage {
16    fn default() -> Self {
17        Self::new()
18    }
19}
20
21impl MemoryStorage {
22    pub fn new() -> Self {
23        MemoryStorage {
24            individuals: RwLock::new(HashMap::new()),
25            tickets: RwLock::new(HashMap::new()),
26            az: RwLock::new(HashMap::new()),
27        }
28    }
29
30    fn get_storage(&self, storage: StorageId) -> &RwLock<HashMap<String, Vec<u8>>> {
31        match storage {
32            StorageId::Individuals => &self.individuals,
33            StorageId::Tickets => &self.tickets,
34            StorageId::Az => &self.az,
35        }
36    }
37
38    #[cfg(test)]
39    pub fn insert_test_data(&self, storage: StorageId, key: &str, val: Vec<u8>) {
40        if let Ok(mut map) = self.get_storage(storage).write() {
41            map.insert(key.to_string(), val);
42        }
43    }
44
45    #[cfg(test)]
46    pub fn get_test_data(&self, storage: StorageId, key: &str) -> Option<Vec<u8>> {
47        if let Ok(map) = self.get_storage(storage).read() {
48            map.get(key).cloned()
49        } else {
50            None
51        }
52    }
53}
54
55impl Storage for MemoryStorage {
56    fn get_individual(&mut self, storage: StorageId, uri: &str, iraw: &mut Individual) -> StorageResult<()> {
57        let storage_map = self.get_storage(storage);
58        if let Some(data) = storage_map.read().unwrap().get(uri) {
59            iraw.set_raw(data);
60            if parse_raw(iraw).is_ok() {
61                return StorageResult::Ok(());
62            } else {
63                return StorageResult::UnprocessableEntity;
64            }
65        }
66        StorageResult::NotFound
67    }
68
69    fn get_value(&mut self, storage: StorageId, key: &str) -> StorageResult<String> {
70        if let Ok(map) = self.get_storage(storage).read() {
71            match map.get(key) {
72                Some(val) => match String::from_utf8(val.clone()) {
73                    Ok(string_val) => StorageResult::Ok(string_val),
74                    Err(_) => StorageResult::Error("Invalid UTF-8 data".to_string()),
75                },
76                None => StorageResult::NotFound,
77            }
78        } else {
79            StorageResult::NotReady
80        }
81    }
82
83    fn get_raw_value(&mut self, storage: StorageId, key: &str) -> StorageResult<Vec<u8>> {
84        if let Ok(map) = self.get_storage(storage).read() {
85            match map.get(key) {
86                Some(val) => StorageResult::Ok(val.clone()),
87                None => StorageResult::NotFound,
88            }
89        } else {
90            StorageResult::NotReady
91        }
92    }
93
94    fn put_value(&mut self, storage: StorageId, key: &str, val: &str) -> StorageResult<()> {
95        if let Ok(mut map) = self.get_storage(storage).write() {
96            map.insert(key.to_string(), val.as_bytes().to_vec());
97            StorageResult::Ok(())
98        } else {
99            StorageResult::NotReady
100        }
101    }
102
103    fn put_raw_value(&mut self, storage: StorageId, key: &str, val: Vec<u8>) -> StorageResult<()> {
104        if let Ok(mut map) = self.get_storage(storage).write() {
105            map.insert(key.to_string(), val);
106            StorageResult::Ok(())
107        } else {
108            StorageResult::NotReady
109        }
110    }
111
112    fn remove_value(&mut self, storage: StorageId, key: &str) -> StorageResult<()> {
113        if let Ok(mut map) = self.get_storage(storage).write() {
114            match map.remove(key) {
115                Some(_) => StorageResult::Ok(()),
116                None => StorageResult::NotFound,
117            }
118        } else {
119            StorageResult::NotReady
120        }
121    }
122
123    fn count(&mut self, storage: StorageId) -> StorageResult<usize> {
124        if let Ok(map) = self.get_storage(storage).read() {
125            StorageResult::Ok(map.len())
126        } else {
127            StorageResult::NotReady
128        }
129    }
130}
131
132#[cfg(test)]
133mod tests {
134    use super::*;
135
136    #[test]
137    fn test_basic_operations() {
138        let mut storage = MemoryStorage::new();
139
140        // Test put and get
141        assert!(storage.put_value(StorageId::Individuals, "key1", "value1").is_ok());
142        let get_result = storage.get_value(StorageId::Individuals, "key1");
143        assert!(get_result.is_ok(), "Expected Ok, got: {:?}", get_result);
144        assert_eq!(get_result.unwrap_or_default(), "value1");
145
146        // Test raw operations
147        let raw_data = vec![1, 2, 3, 4];
148        assert!(storage.put_raw_value(StorageId::Individuals, "key2", raw_data.clone()).is_ok());
149        let raw_result = storage.get_raw_value(StorageId::Individuals, "key2");
150        assert!(raw_result.is_ok(), "Expected Ok, got: {:?}", raw_result);
151        assert_eq!(raw_result.unwrap_or_default(), raw_data);
152
153        // Test remove
154        assert!(storage.remove_value(StorageId::Individuals, "key1").is_ok());
155        let removed_result = storage.get_value(StorageId::Individuals, "key1");
156        assert_eq!(removed_result, StorageResult::NotFound, "Expected NotFound, got: {:?}", removed_result);
157
158        // Test count
159        let count_result = storage.count(StorageId::Individuals);
160        assert!(count_result.is_ok(), "Expected Ok count, got: {:?}", count_result);
161        assert_eq!(count_result.unwrap_or_default(), 1);
162    }
163
164    #[test]
165    fn test_individual() {
166        let mut storage = MemoryStorage::new();
167        let mut individual = Individual::default();
168
169        // Test non-existent individual
170        assert_eq!(storage.get_individual(StorageId::Individuals, "non-existent", &mut individual), StorageResult::NotFound);
171
172        // Test with properly formatted Individual data
173        let valid_individual_data = r#"{"@": "test:individual", "rdf:type": [{"type": "Uri", "data": "test:Class"}]}"#;
174        let put_result = storage.put_value(StorageId::Individuals, "test:individual", valid_individual_data);
175        assert!(put_result.is_ok(), "Failed to put individual data: {:?}", put_result);
176        
177                let get_result = storage.get_individual(StorageId::Individuals, "test:individual", &mut individual);
178        assert!(get_result == StorageResult::Ok(()) || get_result == StorageResult::UnprocessableEntity, 
179                "Expected Ok or UnprocessableEntity, got: {:?}", get_result);
180
181        // Test with invalid data
182        let invalid_data = "invalid json";
183        assert!(storage.put_value(StorageId::Individuals, "test:invalid", invalid_data).is_ok());
184        let invalid_result = storage.get_individual(StorageId::Individuals, "test:invalid", &mut individual);
185        assert_eq!(invalid_result, StorageResult::UnprocessableEntity, "Expected UnprocessableEntity for invalid data");
186    }
187
188    #[test]
189    fn test_backward_compatibility() {
190        let mut storage = MemoryStorage::new();
191
192        // Test deprecated methods still work
193        #[allow(deprecated)]
194        {
195            assert!(storage.put_kv(StorageId::Individuals, "key", "value"));
196            assert_eq!(storage.get_v(StorageId::Individuals, "key"), Some("value".to_string()));
197            assert!(storage.remove(StorageId::Individuals, "key"));
198        }
199    }
200
201    #[test]
202    fn test_edge_cases() {
203        let mut storage = MemoryStorage::new();
204
205        // Test with very long keys and values
206        let long_key = "a".repeat(1000);
207        let long_value = "b".repeat(10000);
208        assert!(storage.put_value(StorageId::Individuals, &long_key, &long_value).is_ok());
209        
210        let long_result = storage.get_value(StorageId::Individuals, &long_key);
211        assert!(long_result.is_ok());
212        if let StorageResult::Ok(value) = long_result {
213            assert_eq!(value.len(), 10000);
214            assert_eq!(value, long_value);
215        }
216
217        // Test with special characters
218        let special_key = "тест-ключ!@#$%^&*()_+{}|:\"<>?";
219        let special_value = "тест-значение\n\t\r\\\"'";
220        assert!(storage.put_value(StorageId::Individuals, special_key, special_value).is_ok());
221        
222        let special_result = storage.get_value(StorageId::Individuals, special_key);
223        assert!(special_result.is_ok());
224        if let StorageResult::Ok(value) = special_result {
225            assert_eq!(value, special_value);
226        }
227
228        // Test binary data in raw operations
229        let binary_data = vec![0u8, 255u8, 128u8, 42u8];
230        assert!(storage.put_raw_value(StorageId::Individuals, "binary", binary_data.clone()).is_ok());
231        
232        let binary_result = storage.get_raw_value(StorageId::Individuals, "binary");
233        assert!(binary_result.is_ok());
234        if let StorageResult::Ok(data) = binary_result {
235            assert_eq!(data, binary_data);
236        }
237
238        // Test overwriting existing keys
239        assert!(storage.put_value(StorageId::Individuals, "overwrite", "first").is_ok());
240        assert!(storage.put_value(StorageId::Individuals, "overwrite", "second").is_ok());
241        
242        let overwrite_result = storage.get_value(StorageId::Individuals, "overwrite");
243        assert!(overwrite_result.is_ok());
244        if let StorageResult::Ok(value) = overwrite_result {
245            assert_eq!(value, "second");
246        }
247    }
248
249    #[test]
250    fn test_different_storage_types() {
251        let mut storage = MemoryStorage::new();
252
253        // Test that different StorageId types are isolated
254        assert!(storage.put_value(StorageId::Individuals, "same_key", "individuals_value").is_ok());
255        assert!(storage.put_value(StorageId::Tickets, "same_key", "tickets_value").is_ok());
256        assert!(storage.put_value(StorageId::Az, "same_key", "az_value").is_ok());
257
258        let individuals_result = storage.get_value(StorageId::Individuals, "same_key");
259        let tickets_result = storage.get_value(StorageId::Tickets, "same_key");
260        let az_result = storage.get_value(StorageId::Az, "same_key");
261
262        assert!(individuals_result.is_ok() && tickets_result.is_ok() && az_result.is_ok());
263
264        if let (StorageResult::Ok(ind_val), StorageResult::Ok(tick_val), StorageResult::Ok(az_val)) = 
265            (individuals_result, tickets_result, az_result) {
266            assert_eq!(ind_val, "individuals_value");
267            assert_eq!(tick_val, "tickets_value");
268            assert_eq!(az_val, "az_value");
269        }
270
271        // Test counts are separate
272        let ind_count = storage.count(StorageId::Individuals);
273        let tick_count = storage.count(StorageId::Tickets);
274        let az_count = storage.count(StorageId::Az);
275
276        assert!(ind_count.is_ok() && tick_count.is_ok() && az_count.is_ok());
277        if let (StorageResult::Ok(ic), StorageResult::Ok(tc), StorageResult::Ok(ac)) = (ind_count, tick_count, az_count) {
278            assert_eq!(ic, 1);
279            assert_eq!(tc, 1); 
280            assert_eq!(ac, 1);
281        }
282    }
283}
v_storage/memory_storage.rs

v_storage/
memory_storage.rs
