pub mod chained;
pub mod file;
#[cfg(feature = "keyring")]
pub mod keyring;
pub mod memory;
#[cfg(test)]
pub(crate) mod test_support;
pub use crate::error::StorageError;
pub use chained::ChainedStore;
pub use file::FileStore;
#[cfg(feature = "keyring")]
pub use keyring::KeyringStore;
pub use memory::MemoryStore;
use std::panic::AssertUnwindSafe;
use std::path::PathBuf;
use std::sync::Arc;
use tokio::task::{JoinError, JoinHandle};
use crate::auth::Session;
pub(crate) fn migrate_and_verify(
session: &Session,
backend: &str,
save: impl FnOnce(&Session) -> Result<(), StorageError>,
) {
tracing::debug!("Migrated legacy credential record in {backend} storage");
if save(session).is_ok() {
tracing::debug!("Migration read-back verified for {backend} storage");
} else {
tracing::warn!(
"Migration read-back did not match for {backend} storage; in-memory credentials \
are still returned to the caller"
);
}
}
pub trait CredentialStore: Send + Sync + std::fmt::Debug {
fn load(&self) -> Result<Session, StorageError>;
fn save(&self, session: &Session) -> Result<(), StorageError>;
fn clear(&self) -> Result<(), StorageError>;
fn reports_failures(&self) -> bool {
false
}
}
const TASK_BACKEND: &str = "credential-store-task";
pub(crate) fn is_task_failure(err: &StorageError) -> bool {
matches!(err, StorageError::Backend { backend, .. } if backend == TASK_BACKEND)
}
fn join_error_to_storage_error(join_err: &JoinError) -> StorageError {
StorageError::Backend {
backend: TASK_BACKEND.to_owned(),
message: format!(
"blocking credential-store task {} failed: panicked={}, cancelled={}",
join_err.id(),
join_err.is_panic(),
join_err.is_cancelled()
),
}
}
fn spawn_guarded<R>(spawn: impl FnOnce() -> JoinHandle<R>) -> Result<JoinHandle<R>, StorageError> {
std::panic::catch_unwind(AssertUnwindSafe(spawn)).map_err(|_payload| StorageError::Backend {
backend: TASK_BACKEND.to_owned(),
message: "blocking credential-store task could not start".to_owned(),
})
}
fn spawn_store_task<R: Send + 'static>(
work: impl FnOnce() -> R + Send + 'static,
) -> Result<JoinHandle<R>, StorageError> {
let dispatch = tracing::dispatcher::get_default(Clone::clone);
let span = tracing::Span::current();
spawn_guarded(|| {
tokio::task::spawn_blocking(move || {
tracing::dispatcher::with_default(&dispatch, || span.in_scope(work))
})
})
}
fn flatten_join<T>(joined: Result<Result<T, StorageError>, JoinError>) -> Result<T, StorageError> {
match joined {
Ok(result) => result,
Err(join_err) => Err(join_error_to_storage_error(&join_err)),
}
}
pub async fn load_async(store: Arc<dyn CredentialStore>) -> Result<Session, StorageError> {
flatten_join(spawn_store_task(move || store.load())?.await)
}
pub async fn save_async(
store: Arc<dyn CredentialStore>,
session: Session,
) -> Result<(), StorageError> {
flatten_join(spawn_store_task(move || store.save(&session))?.await)
}
pub async fn clear_async(store: Arc<dyn CredentialStore>) -> Result<(), StorageError> {
flatten_join(spawn_store_task(move || store.clear())?.await)
}
#[derive(Debug, Clone, Default)]
pub struct StorageConfig {
pub use_keyring: bool,
pub cookie_file: Option<PathBuf>,
}
impl StorageConfig {
#[must_use]
pub fn new() -> Self {
Self::default()
}
}
#[cfg(feature = "keyring")]
#[must_use]
pub fn create_storage(config: &StorageConfig) -> Arc<dyn CredentialStore> {
match (config.use_keyring, &config.cookie_file) {
(true, Some(path)) => Arc::new(ChainedStore::new(
Arc::new(KeyringStore::new().warn_on_unpersisted(false)),
Arc::new(FileStore::new(path.clone())),
)),
(true, None) => Arc::new(KeyringStore::new()),
(false, Some(path)) => Arc::new(FileStore::new(path.clone())),
(false, None) => Arc::new(MemoryStore::new()),
}
}
#[cfg(not(feature = "keyring"))]
#[must_use]
pub fn create_storage(config: &StorageConfig) -> Arc<dyn CredentialStore> {
match &config.cookie_file {
Some(path) => Arc::new(FileStore::new(path.clone())),
None => Arc::new(MemoryStore::new()),
}
}
#[cfg(test)]
mod tests {
use std::path::Path;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex, PoisonError, mpsc};
use std::thread::ThreadId;
use std::time::{Duration, Instant};
use tracing::Level;
use super::test_support::capture_logs;
use super::{
CredentialStore, FileStore, StorageConfig, StorageError, clear_async, create_storage,
load_async, migrate_and_verify, save_async, spawn_guarded,
};
use crate::auth::Session;
#[test]
fn storage_config_default_and_new_are_both_off() {
let default = StorageConfig::default();
assert!(!default.use_keyring);
assert!(default.cookie_file.is_none());
let via_new = StorageConfig::new();
assert!(!via_new.use_keyring);
assert!(via_new.cookie_file.is_none());
}
#[cfg(feature = "keyring")]
mod keyring_feature_matrix {
use std::path::PathBuf;
use super::{Session, StorageConfig, create_storage};
#[test]
fn neither_yields_a_working_memory_store() {
let store = create_storage(&StorageConfig::default());
assert!(format!("{store:?}").contains("MemoryStore"));
store
.save(&Session::from_token("tok"))
.expect("MemoryStore never fails");
assert_eq!(
store.load().expect("load never fails").expose_token(),
"tok"
);
}
#[test]
fn file_only_yields_a_working_file_store() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
let store = create_storage(&StorageConfig {
use_keyring: false,
cookie_file: Some(path.clone()),
});
let debug = format!("{store:?}");
assert!(debug.contains("FileStore"));
assert!(!debug.contains("ChainedStore"));
store
.save(&Session::from_token("tok"))
.expect("file save succeeds");
assert!(path.exists());
assert_eq!(
store.load().expect("file load succeeds").expose_token(),
"tok"
);
}
#[test]
fn keyring_only_yields_a_bare_keyring_store_with_no_file_fallback() {
let store = create_storage(&StorageConfig {
use_keyring: true,
cookie_file: None,
});
let debug = format!("{store:?}");
assert!(debug.contains("KeyringStore"));
assert!(!debug.contains("ChainedStore"));
assert!(!debug.contains("FileStore"));
assert!(
debug.contains("warn_on_unpersisted: true"),
"a bare keyring warns when a save is not retained: {debug}"
);
}
#[test]
fn both_yields_a_chained_store_of_keyring_primary_and_file_fallback() {
let store = create_storage(&StorageConfig {
use_keyring: true,
cookie_file: Some(PathBuf::from("/tmp/rusteero-test-does-not-touch-disk.json")),
});
let debug = format!("{store:?}");
assert!(debug.contains("ChainedStore"));
assert!(debug.contains("KeyringStore"));
assert!(debug.contains("FileStore"));
assert!(
debug.contains("warn_on_unpersisted: false"),
"a keyring in front of a file fallback is silenced: {debug}"
);
}
}
#[cfg(not(feature = "keyring"))]
mod no_keyring_feature_matrix {
use super::{Session, StorageConfig, create_storage};
#[test]
fn neither_yields_a_working_memory_store() {
let store = create_storage(&StorageConfig::default());
assert!(format!("{store:?}").contains("MemoryStore"));
store
.save(&Session::from_token("tok"))
.expect("MemoryStore never fails");
assert_eq!(
store.load().expect("load never fails").expose_token(),
"tok"
);
}
#[test]
fn file_only_yields_a_working_file_store() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
let store = create_storage(&StorageConfig {
use_keyring: false,
cookie_file: Some(path.clone()),
});
store
.save(&Session::from_token("tok"))
.expect("file save succeeds");
assert!(path.exists());
}
#[test]
fn keyring_requested_with_no_file_degrades_to_a_working_memory_store() {
let store = create_storage(&StorageConfig {
use_keyring: true,
cookie_file: None,
});
assert!(format!("{store:?}").contains("MemoryStore"));
store
.save(&Session::from_token("tok"))
.expect("MemoryStore never fails");
assert_eq!(
store.load().expect("load never fails").expose_token(),
"tok"
);
}
#[test]
fn keyring_requested_with_a_file_degrades_to_a_working_file_store() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
let store = create_storage(&StorageConfig {
use_keyring: true,
cookie_file: Some(path.clone()),
});
assert!(format!("{store:?}").contains("FileStore"));
store
.save(&Session::from_token("tok"))
.expect("file save succeeds");
assert!(path.exists());
}
}
#[tokio::test]
async fn save_load_clear_async_round_trip_through_a_shared_store() {
let store: Arc<dyn CredentialStore> = Arc::new(super::MemoryStore::new());
save_async(Arc::clone(&store), Session::from_token("tok-async"))
.await
.expect("save succeeds");
let loaded = load_async(Arc::clone(&store)).await.expect("load succeeds");
assert_eq!(loaded.expose_token(), "tok-async");
clear_async(Arc::clone(&store))
.await
.expect("clear succeeds");
assert!(!load_async(store).await.expect("load succeeds").is_valid());
}
#[derive(Debug, Default)]
struct AlwaysFailsStore;
impl CredentialStore for AlwaysFailsStore {
fn load(&self) -> Result<Session, StorageError> {
Err(StorageError::Backend {
backend: "always-fails".to_owned(),
message: "deliberate test failure".to_owned(),
})
}
fn save(&self, _session: &Session) -> Result<(), StorageError> {
Err(StorageError::Backend {
backend: "always-fails".to_owned(),
message: "deliberate test failure".to_owned(),
})
}
fn clear(&self) -> Result<(), StorageError> {
Err(StorageError::Backend {
backend: "always-fails".to_owned(),
message: "deliberate test failure".to_owned(),
})
}
}
#[tokio::test]
async fn save_async_propagates_the_stores_own_error_unchanged() {
let store: Arc<dyn CredentialStore> = Arc::new(AlwaysFailsStore);
let err = save_async(store, Session::from_token("tok"))
.await
.expect_err("the store always fails");
assert!(matches!(err, StorageError::Backend { backend, .. } if backend == "always-fails"));
}
#[derive(Debug, Default)]
struct PanickingStore;
impl CredentialStore for PanickingStore {
fn load(&self) -> Result<Session, StorageError> {
panic!("PanickingStore::load always panics");
}
fn save(&self, _session: &Session) -> Result<(), StorageError> {
panic!("PanickingStore::save always panics");
}
fn clear(&self) -> Result<(), StorageError> {
panic!("PanickingStore::clear always panics");
}
}
#[tokio::test]
async fn load_async_converts_a_panicking_store_into_a_storage_error() {
let store: Arc<dyn CredentialStore> = Arc::new(PanickingStore);
let err = load_async(store)
.await
.expect_err("a panicking store must not take down the caller's task");
assert!(
matches!(&err, StorageError::Backend { backend, .. } if backend == "credential-store-task")
);
assert!(
err.to_string().contains("panicked=true"),
"expected the panic flag recorded in the message, got {err}"
);
}
#[tokio::test]
async fn save_async_converts_a_panicking_store_into_a_storage_error() {
let store: Arc<dyn CredentialStore> = Arc::new(PanickingStore);
let err = save_async(store, Session::from_token("tok"))
.await
.expect_err("a panicking store must not take down the caller's task");
assert!(
matches!(&err, StorageError::Backend { backend, .. } if backend == "credential-store-task")
);
assert!(
err.to_string().contains("panicked=true"),
"expected the panic flag recorded in the message, got {err}"
);
}
#[tokio::test]
async fn clear_async_converts_a_panicking_store_into_a_storage_error() {
let store: Arc<dyn CredentialStore> = Arc::new(PanickingStore);
let err = clear_async(store)
.await
.expect_err("a panicking store must not take down the caller's task");
assert!(
matches!(&err, StorageError::Backend { backend, .. } if backend == "credential-store-task")
);
assert!(
err.to_string().contains("panicked=true"),
"expected the panic flag recorded in the message, got {err}"
);
}
#[derive(Debug, Default)]
struct PanickingWithCredentialLikePayloadStore;
impl CredentialStore for PanickingWithCredentialLikePayloadStore {
fn load(&self) -> Result<Session, StorageError> {
panic!("session_token=leaked-secret-should-never-appear-in-storage-error");
}
fn save(&self, _session: &Session) -> Result<(), StorageError> {
panic!("session_token=leaked-secret-should-never-appear-in-storage-error");
}
fn clear(&self) -> Result<(), StorageError> {
panic!("session_token=leaked-secret-should-never-appear-in-storage-error");
}
}
#[tokio::test]
async fn load_async_never_lets_the_panic_payload_reach_the_storage_error() {
let store: Arc<dyn CredentialStore> = Arc::new(PanickingWithCredentialLikePayloadStore);
let err = load_async(store)
.await
.expect_err("a panicking store must not take down the caller's task");
let display = err.to_string();
let debug = format!("{err:?}");
assert!(
!display.contains("leaked-secret") && !debug.contains("leaked-secret"),
"the JoinError's own Display must never be interpolated into a StorageError (S4): \
display={display:?} debug={debug:?}"
);
}
#[derive(Debug)]
struct ThreadRecordingStore {
blob: Mutex<String>,
threads: Mutex<Vec<ThreadId>>,
}
impl ThreadRecordingStore {
fn record(&self) {
self.threads
.lock()
.unwrap_or_else(PoisonError::into_inner)
.push(std::thread::current().id());
}
}
impl CredentialStore for ThreadRecordingStore {
fn load(&self) -> Result<Session, StorageError> {
self.record();
let blob = self
.blob
.lock()
.unwrap_or_else(PoisonError::into_inner)
.clone();
let (session, migrated) = Session::from_json_migrating(&blob)?;
if migrated {
migrate_and_verify(&session, "recording", |migrated| self.save(migrated));
}
Ok(session)
}
fn save(&self, session: &Session) -> Result<(), StorageError> {
self.record();
*self.blob.lock().unwrap_or_else(PoisonError::into_inner) = session.to_json()?;
Ok(())
}
fn clear(&self) -> Result<(), StorageError> {
self.record();
Ok(())
}
}
#[tokio::test]
async fn load_async_runs_a_migrating_load_on_one_blocking_thread() {
let store = Arc::new(ThreadRecordingStore {
blob: Mutex::new(r#"{"user_token":"tok"}"#.to_owned()),
threads: Mutex::new(Vec::new()),
});
let session = load_async(Arc::clone(&store) as _)
.await
.expect("load succeeds");
assert_eq!(session.expose_token(), "tok");
let stored = store.blob.lock().expect("blob lock").clone();
assert!(
stored.contains(r#""schema_version":2"#),
"the legacy record was migrated in place: {stored}"
);
let mut threads = store.threads.lock().expect("threads lock").clone();
assert!(
threads.len() >= 2,
"the load and the migration write both ran"
);
threads.sort_by_key(|id| format!("{id:?}"));
threads.dedup();
assert_eq!(threads.len(), 1, "one thread hop for the whole load");
assert_ne!(threads[0], std::thread::current().id());
}
#[tokio::test]
async fn load_async_migrates_a_legacy_file_record_in_one_call() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
std::fs::write(&path, r#"{"user_token":"tok"}"#).expect("seed the legacy record");
let store: Arc<dyn CredentialStore> = Arc::new(FileStore::new(&path));
let session = load_async(Arc::clone(&store)).await.expect("load succeeds");
assert_eq!(session.expose_token(), "tok");
let on_disk = std::fs::read_to_string(&path).expect("the file still exists");
assert!(on_disk.contains(r#""schema_version":2"#), "{on_disk}");
}
#[derive(Debug, Default)]
struct StubbornStore {
loads: AtomicUsize,
saves: AtomicUsize,
}
impl CredentialStore for StubbornStore {
fn load(&self) -> Result<Session, StorageError> {
self.loads.fetch_add(1, Ordering::SeqCst);
let (session, migrated) = Session::from_json_migrating(r#"{"user_token":"tok"}"#)?;
if migrated {
migrate_and_verify(&session, "stubborn", |migrated| self.save(migrated));
}
Ok(session)
}
fn save(&self, _session: &Session) -> Result<(), StorageError> {
self.saves.fetch_add(1, Ordering::SeqCst);
Ok(())
}
fn clear(&self) -> Result<(), StorageError> {
Ok(())
}
}
#[test]
fn a_store_that_keeps_serving_the_legacy_record_does_not_recurse() {
let store = StubbornStore::default();
let session = store.load().expect("load succeeds");
assert_eq!(session.expose_token(), "tok");
assert_eq!(store.loads.load(Ordering::SeqCst), 1, "no re-entrant load");
assert_eq!(store.saves.load(Ordering::SeqCst), 1, "one migration write");
}
#[test]
fn migrate_and_verify_logs_the_outcome_of_the_save_and_never_the_token() {
let (_guard, logs) = capture_logs();
let session = Session::from_token("legacy_token");
migrate_and_verify(&session, "keyring", |_| Ok(()));
assert_eq!(
logs.count(
Level::DEBUG,
"Migrated legacy credential record in keyring storage"
),
1
);
assert_eq!(
logs.count(
Level::DEBUG,
"Migration read-back verified for keyring storage"
),
1
);
assert!(logs.messages(Level::WARN).is_empty());
migrate_and_verify(&session, "file", |_| {
Err(StorageError::NotRetained {
backend: "file".to_owned(),
})
});
assert_eq!(
logs.messages(Level::WARN),
vec![
"Migration read-back did not match for file storage; in-memory credentials are \
still returned to the caller"
.to_owned()
]
);
assert!(!logs.mentions("legacy_token"));
}
#[derive(Debug)]
struct GatedStore {
inner: FileStore,
entered: Mutex<mpsc::Sender<ThreadId>>,
release: Mutex<mpsc::Receiver<()>>,
finished: Mutex<mpsc::Sender<()>>,
}
struct Gate {
entered: Arc<Mutex<mpsc::Receiver<ThreadId>>>,
release: mpsc::Sender<()>,
finished: Arc<Mutex<mpsc::Receiver<()>>>,
}
fn gated(inner: FileStore) -> (Arc<GatedStore>, Gate) {
let (entered_tx, entered_rx) = mpsc::channel();
let (release_tx, release_rx) = mpsc::channel();
let (finished_tx, finished_rx) = mpsc::channel();
let store = Arc::new(GatedStore {
inner,
entered: Mutex::new(entered_tx),
release: Mutex::new(release_rx),
finished: Mutex::new(finished_tx),
});
let gate = Gate {
entered: Arc::new(Mutex::new(entered_rx)),
release: release_tx,
finished: Arc::new(Mutex::new(finished_rx)),
};
(store, gate)
}
impl GatedStore {
fn park(&self) {
let _ = self
.entered
.lock()
.unwrap_or_else(PoisonError::into_inner)
.send(std::thread::current().id());
let _ = self
.release
.lock()
.unwrap_or_else(PoisonError::into_inner)
.recv_timeout(Duration::from_secs(5));
}
fn finish(&self) {
let _ = self
.finished
.lock()
.unwrap_or_else(PoisonError::into_inner)
.send(());
}
}
impl CredentialStore for GatedStore {
fn load(&self) -> Result<Session, StorageError> {
self.inner.load()
}
fn save(&self, session: &Session) -> Result<(), StorageError> {
self.park();
let result = self.inner.save(session);
self.finish();
result
}
fn clear(&self) -> Result<(), StorageError> {
self.park();
let result = self.inner.clear();
self.finish();
result
}
}
async fn next<T: Send + 'static>(receiver: &Arc<Mutex<mpsc::Receiver<T>>>) -> T {
let receiver = Arc::clone(receiver);
tokio::task::spawn_blocking(move || {
receiver
.lock()
.unwrap_or_else(PoisonError::into_inner)
.recv_timeout(Duration::from_secs(5))
.expect("the gated store signals in time")
})
.await
.expect("the waiting task finishes")
}
fn token_on_disk(path: &Path) -> Option<String> {
let contents = std::fs::read_to_string(path).ok()?;
Some(
Session::from_json(&contents)
.ok()?
.expose_token()
.to_owned(),
)
}
#[tokio::test]
async fn dropping_save_async_does_not_interrupt_the_blocking_write() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
FileStore::new(&path)
.save(&Session::from_token("old"))
.expect("seed save succeeds");
let (store, gate) = gated(FileStore::new(&path));
let task = tokio::spawn(save_async(store, Session::from_token("new")));
next(&gate.entered).await;
task.abort();
assert!(
task.await
.expect_err("the awaiting task was aborted")
.is_cancelled()
);
assert_eq!(
token_on_disk(&path).as_deref(),
Some("old"),
"the parked write has not happened yet, and nothing partial is on disk"
);
gate.release.send(()).expect("the worker is parked");
next(&gate.finished).await;
let reloaded = load_async(Arc::new(FileStore::new(&path)))
.await
.expect("load succeeds");
assert_eq!(reloaded.expose_token(), "new");
let listing: Vec<_> = std::fs::read_dir(dir.path())
.expect("read dir")
.filter_map(Result::ok)
.map(|entry| entry.file_name())
.collect();
assert_eq!(
listing,
vec![std::ffi::OsString::from("cookies.json")],
"no temporary file is left behind"
);
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let mode = std::fs::metadata(&path)
.expect("file exists")
.permissions()
.mode()
& 0o777;
assert_eq!(mode, 0o600);
}
}
async fn heartbeat(ticks: u32) -> Duration {
let started = Instant::now();
tokio::time::timeout(Duration::from_secs(5), async {
for _ in 0..ticks {
tokio::time::sleep(Duration::from_millis(5)).await;
}
})
.await
.expect("the runtime keeps ticking while the store call is parked");
started.elapsed()
}
#[tokio::test]
async fn save_async_keeps_the_runtime_responsive_while_the_write_blocks() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
let (store, gate) = gated(FileStore::new(&path));
let save = tokio::spawn(save_async(store, Session::from_token("tok")));
let worker = next(&gate.entered).await;
assert_ne!(
worker,
std::thread::current().id(),
"the write runs off-runtime"
);
assert!(heartbeat(10).await < Duration::from_secs(2));
assert!(!save.is_finished(), "the write is still parked");
gate.release.send(()).expect("the worker is parked");
save.await
.expect("the save task finishes")
.expect("save succeeds");
assert_eq!(token_on_disk(&path).as_deref(), Some("tok"));
}
#[tokio::test]
async fn clear_async_keeps_the_runtime_responsive_while_the_clear_blocks() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
FileStore::new(&path)
.save(&Session::from_token("tok"))
.expect("seed save succeeds");
let (store, gate) = gated(FileStore::new(&path));
let clear = tokio::spawn(clear_async(store));
let worker = next(&gate.entered).await;
assert_ne!(
worker,
std::thread::current().id(),
"the clear runs off-runtime"
);
assert!(heartbeat(10).await < Duration::from_secs(2));
assert!(!clear.is_finished(), "the clear is still parked");
gate.release.send(()).expect("the worker is parked");
clear
.await
.expect("the clear task finishes")
.expect("clear succeeds");
assert!(!path.exists());
}
#[test]
fn a_file_store_works_across_two_successive_runtimes() {
let dir = tempfile::tempdir().expect("tempdir");
let store: Arc<dyn CredentialStore> =
Arc::new(FileStore::new(dir.path().join("cookies.json")));
for token in ["a", "b"] {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("a current-thread runtime builds");
runtime.block_on(async {
save_async(Arc::clone(&store), Session::from_token(token))
.await
.expect("save succeeds");
let loaded = load_async(Arc::clone(&store)).await.expect("load succeeds");
assert_eq!(loaded.expose_token(), token);
});
}
}
#[tokio::test]
async fn only_the_adapters_own_failures_are_task_failures() {
let unstartable = spawn_guarded::<()>(|| panic!("OS can't spawn worker thread: test"))
.expect_err("the spawner panicked");
assert!(super::is_task_failure(&unstartable));
let store: Arc<dyn CredentialStore> = Arc::new(PanickingStore);
let panicked = save_async(store, Session::from_token("tok"))
.await
.expect_err("the store panicked");
assert!(super::is_task_failure(&panicked), "{panicked:?}");
for returned in [
StorageError::Backend {
backend: "file".to_owned(),
message: "disk is on fire".to_owned(),
},
StorageError::NotRetained {
backend: "credential-store-task".to_owned(),
},
] {
assert!(!super::is_task_failure(&returned), "{returned:?}");
}
}
#[tokio::test]
async fn a_worker_thread_that_cannot_be_spawned_is_a_handled_storage_error() {
let err = spawn_guarded::<()>(|| panic!("OS can't spawn worker thread: test"))
.expect_err("the spawner panicked");
match &err {
StorageError::Backend { backend, message } => {
assert_eq!(backend, "credential-store-task");
assert_eq!(message, "blocking credential-store task could not start");
}
other => panic!("expected a backend error, got {other:?}"),
}
assert!(
!format!("{err} {err:?}").contains("OS can't spawn"),
"the panic payload never reaches the error"
);
let store: Arc<dyn CredentialStore> = Arc::new(super::MemoryStore::new());
save_async(Arc::clone(&store), Session::from_token("tok"))
.await
.expect("a following save succeeds");
assert_eq!(
load_async(store)
.await
.expect("load succeeds")
.expose_token(),
"tok"
);
}
#[derive(Debug)]
struct NullStore;
impl CredentialStore for NullStore {
fn load(&self) -> Result<Session, StorageError> {
Ok(Session::empty())
}
fn save(&self, _session: &Session) -> Result<(), StorageError> {
Err(StorageError::NotRetained {
backend: "null".to_owned(),
})
}
fn clear(&self) -> Result<(), StorageError> {
Ok(())
}
}
#[tokio::test]
async fn save_async_returns_a_not_retained_error_unchanged() {
let err = save_async(Arc::new(NullStore), Session::from_token("tok"))
.await
.expect_err("the store did not retain the session");
assert!(matches!(&err, StorageError::NotRetained { backend } if backend == "null"));
}
#[derive(Debug, Default)]
struct WarningStore {
spans: Mutex<Vec<Option<tracing::Id>>>,
}
impl WarningStore {
fn note(&self) {
tracing::warn!("store warning from the blocking thread");
self.spans
.lock()
.unwrap_or_else(PoisonError::into_inner)
.push(tracing::Span::current().id());
}
}
impl CredentialStore for WarningStore {
fn load(&self) -> Result<Session, StorageError> {
self.note();
Ok(Session::empty())
}
fn save(&self, _session: &Session) -> Result<(), StorageError> {
self.note();
Ok(())
}
fn clear(&self) -> Result<(), StorageError> {
self.note();
Ok(())
}
}
#[tokio::test]
async fn a_store_warning_inside_save_async_reaches_the_callers_scoped_subscriber() {
let (_guard, logs) = capture_logs();
let store = Arc::new(WarningStore::default());
save_async(Arc::clone(&store) as _, Session::from_token("tok"))
.await
.expect("save succeeds");
assert_eq!(
logs.count(Level::WARN, "store warning from the blocking thread"),
1,
"the blocking thread logs under the dispatcher that was current when it was spawned"
);
}
#[tokio::test]
async fn load_and_clear_async_forward_the_callers_subscriber_too() {
let (_guard, logs) = capture_logs();
let store = Arc::new(WarningStore::default());
load_async(Arc::clone(&store) as _)
.await
.expect("load succeeds");
clear_async(Arc::clone(&store) as _)
.await
.expect("clear succeeds");
assert_eq!(
logs.count(Level::WARN, "store warning from the blocking thread"),
2
);
}
#[tokio::test]
async fn the_callers_current_span_is_current_inside_the_store_call() {
use tracing::Instrument;
let (_guard, _logs) = capture_logs();
let store = Arc::new(WarningStore::default());
let span = tracing::info_span!("caller");
let expected = span.id();
assert!(
expected.is_some(),
"the capturing subscriber assigns span ids"
);
save_async(Arc::clone(&store) as _, Session::from_token("tok"))
.instrument(span)
.await
.expect("save succeeds");
let seen = store.spans.lock().expect("spans lock").clone();
assert_eq!(seen, vec![expected]);
}
}