use std::sync::RwLock;
use crate::auth::Session;
use crate::error::StorageError;
use super::CredentialStore;
#[derive(Debug, Default)]
pub struct MemoryStore(RwLock<Option<Session>>);
impl MemoryStore {
#[must_use]
pub fn new() -> Self {
Self::default()
}
fn poisoned() -> StorageError {
StorageError::Backend {
backend: "memory".to_owned(),
message: "lock poisoned by a prior panic".to_owned(),
}
}
}
impl CredentialStore for MemoryStore {
fn load(&self) -> Result<Session, StorageError> {
let guard = self.0.read().map_err(|_| Self::poisoned())?;
Ok(guard.clone().unwrap_or_else(Session::empty))
}
fn save(&self, session: &Session) -> Result<(), StorageError> {
let mut guard = self.0.write().map_err(|_| Self::poisoned())?;
*guard = Some(session.clone());
Ok(())
}
fn clear(&self) -> Result<(), StorageError> {
let mut guard = self.0.write().map_err(|_| Self::poisoned())?;
*guard = None;
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::{CredentialStore, MemoryStore};
use crate::auth::Session;
#[test]
fn load_before_save_returns_empty_session() {
let store = MemoryStore::new();
let session = store.load().expect("load never fails");
assert!(!session.is_valid());
assert_eq!(session.expose_token(), "");
}
#[test]
fn save_then_load_round_trips_the_session() {
let store = MemoryStore::new();
let session = Session::from_token("tok-123");
store.save(&session).expect("save succeeds");
let loaded = store.load().expect("load succeeds");
assert_eq!(loaded.expose_token(), "tok-123");
assert!(loaded.is_valid());
}
#[test]
fn save_replaces_the_previously_stored_session() {
let store = MemoryStore::new();
store
.save(&Session::from_token("first"))
.expect("save succeeds");
store
.save(&Session::from_token("second"))
.expect("save succeeds");
let loaded = store.load().expect("load succeeds");
assert_eq!(loaded.expose_token(), "second");
}
#[test]
fn clear_resets_to_an_empty_session() {
let store = MemoryStore::new();
store
.save(&Session::from_token("tok-123"))
.expect("save succeeds");
store.clear().expect("clear succeeds");
let loaded = store.load().expect("load succeeds");
assert!(!loaded.is_valid());
assert_eq!(loaded.expose_token(), "");
}
#[test]
fn clear_before_any_save_is_a_no_op() {
let store = MemoryStore::new();
store.clear().expect("clear never fails, even when empty");
assert!(!store.load().expect("load succeeds").is_valid());
}
#[test]
fn each_load_returns_an_independent_clone() {
let store = MemoryStore::new();
store
.save(&Session::from_token("original"))
.expect("save succeeds");
let first_load = store.load().expect("load succeeds");
drop(first_load);
assert_eq!(
store.load().expect("load succeeds").expose_token(),
"original"
);
}
}