Skip to main content

bitwarden_test/
repository.rs

1use bitwarden_state::repository::{Repository, RepositoryError, RepositoryItem};
2
3/// A simple in-memory repository implementation. The data is only stored in memory and will not
4/// persist beyond the lifetime of the repository instance.
5///
6/// Primary use case is for unit and integration tests.
7pub struct MemoryRepository<V: RepositoryItem> {
8    store: std::sync::Mutex<std::collections::HashMap<String, V>>,
9}
10
11impl<V: RepositoryItem + Clone> Default for MemoryRepository<V> {
12    fn default() -> Self {
13        Self {
14            store: std::sync::Mutex::new(std::collections::HashMap::new()),
15        }
16    }
17}
18
19#[async_trait::async_trait]
20impl<V: RepositoryItem + Clone> Repository<V> for MemoryRepository<V> {
21    async fn get(&self, key: V::Key) -> Result<Option<V>, RepositoryError> {
22        let store = self
23            .store
24            .lock()
25            .map_err(|e| RepositoryError::Internal(e.to_string()))?;
26        let key = key.to_string();
27        Ok(store.get(&key).cloned())
28    }
29
30    async fn list(&self) -> Result<Vec<V>, RepositoryError> {
31        let store = self
32            .store
33            .lock()
34            .map_err(|e| RepositoryError::Internal(e.to_string()))?;
35        Ok(store.values().cloned().collect())
36    }
37
38    async fn set(&self, key: V::Key, value: V) -> Result<(), RepositoryError> {
39        let mut store = self
40            .store
41            .lock()
42            .map_err(|e| RepositoryError::Internal(e.to_string()))?;
43        let key = key.to_string();
44        store.insert(key, value);
45        Ok(())
46    }
47
48    async fn remove(&self, key: V::Key) -> Result<(), RepositoryError> {
49        let mut store = self
50            .store
51            .lock()
52            .map_err(|e| RepositoryError::Internal(e.to_string()))?;
53        let key = key.to_string();
54        store.remove(&key);
55        Ok(())
56    }
57}