leptos_sync_core/storage/
memory.rs

1//! In-memory storage implementation
2
3use super::{LocalStorage, StorageError};
4use async_trait::async_trait;
5use serde::{de::DeserializeOwned, Serialize};
6use std::collections::HashMap;
7use std::sync::Arc;
8use tokio::sync::RwLock;
9
10/// In-memory storage using HashMap
11pub struct MemoryStorage {
12    data: Arc<RwLock<HashMap<String, Vec<u8>>>>,
13}
14
15impl MemoryStorage {
16    pub fn new() -> Self {
17        Self {
18            data: Arc::new(RwLock::new(HashMap::new())),
19        }
20    }
21}
22
23impl Default for MemoryStorage {
24    fn default() -> Self {
25        Self::new()
26    }
27}
28
29impl Clone for MemoryStorage {
30    fn clone(&self) -> Self {
31        Self {
32            data: self.data.clone(),
33        }
34    }
35}
36
37#[async_trait]
38impl LocalStorage for MemoryStorage {
39    async fn set<T: Serialize + Send + Sync>(&self, key: &str, value: &T) -> Result<(), StorageError> {
40        let serialized = serde_json::to_vec(value)
41            .map_err(|e| StorageError::Serialization(e))?;
42        
43        let mut data = self.data.write().await;
44        data.insert(key.to_string(), serialized);
45        Ok(())
46    }
47
48    async fn get<T: DeserializeOwned + Send + Sync>(&self, key: &str) -> Result<Option<T>, StorageError> {
49        let data = self.data.read().await;
50        
51        match data.get(key) {
52            Some(bytes) => {
53                let value = serde_json::from_slice(bytes)
54                    .map_err(|e| StorageError::Serialization(e))?;
55                Ok(Some(value))
56            }
57            None => Ok(None),
58        }
59    }
60
61    async fn remove(&self, key: &str) -> Result<(), StorageError> {
62        let mut data = self.data.write().await;
63        data.remove(key);
64        Ok(())
65    }
66
67    async fn keys(&self) -> Result<Vec<String>, StorageError> {
68        let data = self.data.read().await;
69        Ok(data.keys().cloned().collect())
70    }
71
72    async fn contains_key(&self, key: &str) -> Result<bool, StorageError> {
73        let data = self.data.read().await;
74        Ok(data.contains_key(key))
75    }
76
77    async fn len(&self) -> Result<usize, StorageError> {
78        let data = self.data.read().await;
79        Ok(data.len())
80    }
81
82    async fn is_empty(&self) -> Result<bool, StorageError> {
83        let data = self.data.read().await;
84        Ok(data.is_empty())
85    }
86
87    async fn clear(&self) -> Result<(), StorageError> {
88        let mut data = self.data.write().await;
89        data.clear();
90        Ok(())
91    }
92}
93
94#[cfg(test)]
95mod tests {
96    use super::*;
97
98    #[tokio::test]
99    async fn test_memory_storage_basic_operations() {
100        let storage = MemoryStorage::new();
101
102        // Test set and get
103        assert!(storage.set("key1", &"value1".to_string()).await.is_ok());
104        let value = storage.get::<String>("key1").await.unwrap();
105        assert_eq!(value, Some("value1".to_string()));
106
107        // Test get non-existent key
108        let value = storage.get::<String>("nonexistent").await.unwrap();
109        assert_eq!(value, None);
110
111        // Test remove
112        assert!(storage.remove("key1").await.is_ok());
113        let value = storage.get::<String>("key1").await.unwrap();
114        assert_eq!(value, None);
115    }
116
117    #[tokio::test]
118    async fn test_memory_storage_keys_and_length() {
119        let storage = MemoryStorage::new();
120
121        // Initially empty
122        assert_eq!(storage.len().await.unwrap(), 0);
123        assert!(storage.is_empty().await.unwrap());
124
125        // Add some data
126        assert!(storage.set("key1", &"value1".to_string()).await.is_ok());
127        assert!(storage.set("key2", &"value2".to_string()).await.is_ok());
128
129        // Check length and keys
130        assert_eq!(storage.len().await.unwrap(), 2);
131        assert!(!storage.is_empty().await.unwrap());
132
133        let keys = storage.keys().await.unwrap();
134        assert_eq!(keys.len(), 2);
135        assert!(keys.contains(&"key1".to_string()));
136        assert!(keys.contains(&"key2".to_string()));
137    }
138
139    #[tokio::test]
140    async fn test_memory_storage_clear() {
141        let storage = MemoryStorage::new();
142
143        // Add some data
144        assert!(storage.set("key1", &"value1".to_string()).await.is_ok());
145        assert!(storage.set("key2", &"value2".to_string()).await.is_ok());
146
147        // Clear all data
148        assert!(storage.clear().await.is_ok());
149
150        // Check that data is cleared
151        assert_eq!(storage.len().await.unwrap(), 0);
152        assert!(storage.is_empty().await.unwrap());
153    }
154
155    #[tokio::test]
156    async fn test_memory_storage_contains_key() {
157        let storage = MemoryStorage::new();
158
159        // Initially no keys
160        assert!(!storage.contains_key("key1").await.unwrap());
161
162        // Add a key
163        assert!(storage.set("key1", &"value1".to_string()).await.is_ok());
164        assert!(storage.contains_key("key1").await.unwrap());
165
166        // Remove the key
167        assert!(storage.remove("key1").await.is_ok());
168        assert!(!storage.contains_key("key1").await.unwrap());
169    }
170
171    #[tokio::test]
172    async fn test_memory_storage_clone() {
173        let storage = MemoryStorage::new();
174        let cloned_storage = storage.clone();
175
176        // Add data to original
177        assert!(storage.set("key1", &"value1".to_string()).await.is_ok());
178
179        // Check that cloned storage has the same data
180        let value = cloned_storage.get::<String>("key1").await.unwrap();
181        assert_eq!(value, Some("value1".to_string()));
182    }
183}
leptos_sync_core/storage/memory.rs

leptos_sync_core/storage/
memory.rs
