use std::sync::Arc;
use garrison::dao::GarrisonDao;
use garrison::dao::GarrisonDaoOxcache;
use parking_lot::RwLock;
static GARRISON_DAO: RwLock<Option<Arc<dyn GarrisonDao>>> = RwLock::new(None);
#[cfg(test)]
pub(crate) static TEST_MUTEX: std::sync::OnceLock<tokio::sync::Mutex<()>> =
std::sync::OnceLock::new();
#[cfg(test)]
pub(crate) fn test_mutex() -> &'static tokio::sync::Mutex<()> {
TEST_MUTEX.get_or_init(|| tokio::sync::Mutex::new(()))
}
pub async fn init_garrison_dao() -> garrison::prelude::GarrisonResult<Arc<dyn GarrisonDao>> {
let dao = GarrisonDaoOxcache::new().await?;
Ok(Arc::new(dao))
}
pub fn set_garrison_dao(dao: Arc<dyn GarrisonDao>) -> Result<(), Arc<dyn GarrisonDao>> {
let mut guard = GARRISON_DAO.write();
if guard.is_some() {
return Err(dao);
}
*guard = Some(dao);
Ok(())
}
pub fn get_garrison_dao() -> Option<Arc<dyn GarrisonDao>> {
GARRISON_DAO.read().clone()
}
#[cfg(any(test, feature = "test-mocks"))]
pub(crate) fn reset_garrison_dao_for_test() {
*GARRISON_DAO.write() = None;
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn test_init_garrison_dao_returns_usable_dao() {
let dao = init_garrison_dao().await;
assert!(dao.is_ok(), "init_garrison_dao must succeed in memory mode");
let dao = dao.unwrap();
let key = "crawlrs:test:garrison_dao:usable";
let value = "test_value";
dao.set(key, value, 60).await.expect("set must succeed");
let got = dao
.get(key)
.await
.expect("get must succeed")
.expect("value must exist");
assert_eq!(got, value);
dao.delete(key).await.expect("delete must succeed");
let after_delete = dao.get(key).await.expect("get after delete must succeed");
assert!(after_delete.is_none(), "value must be deleted");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn test_init_garrison_dao_returns_independent_instances() {
let dao1 = init_garrison_dao().await.unwrap();
let dao2 = init_garrison_dao().await.unwrap();
let key = "crawlrs:test:garrison_dao:independence";
dao1.set(key, "from_dao1", 60).await.unwrap();
let from_dao2 = dao2.get(key).await.unwrap();
assert!(
from_dao2.is_none(),
"dao2 must not see dao1's writes (independent instances)"
);
dao1.delete(key).await.unwrap();
}
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn test_set_garrison_dao_first_call_ok_second_err() {
let _guard = test_mutex().lock().await;
reset_garrison_dao_for_test();
let dao1 = init_garrison_dao().await.unwrap();
let dao2 = init_garrison_dao().await.unwrap();
let result = set_garrison_dao(dao1.clone());
assert!(result.is_ok(), "first set_garrison_dao must succeed");
let result2 = set_garrison_dao(dao2.clone());
assert!(result2.is_err(), "second set_garrison_dao must return Err");
let returned = result2.unwrap_err();
assert!(
Arc::ptr_eq(&returned, &dao2),
"returned dao must be the same Arc as dao2"
);
reset_garrison_dao_for_test();
}
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn test_get_garrison_dao_before_and_after_set() {
let _guard = test_mutex().lock().await;
reset_garrison_dao_for_test();
assert!(
get_garrison_dao().is_none(),
"get_garrison_dao must return None before set"
);
let dao = init_garrison_dao().await.unwrap();
match set_garrison_dao(dao.clone()) {
Ok(()) => {}
Err(_) => panic!("set_garrison_dao must succeed on first call"),
}
let got = get_garrison_dao().expect("must be Some after set");
assert!(
Arc::ptr_eq(&got, &dao),
"get_garrison_dao must return Arc pointing to the same instance"
);
reset_garrison_dao_for_test();
}
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn test_reset_garrison_dao_for_test_clears_global() {
let _guard = test_mutex().lock().await;
reset_garrison_dao_for_test();
let dao = init_garrison_dao().await.unwrap();
match set_garrison_dao(dao) {
Ok(()) => {}
Err(_) => panic!("set_garrison_dao must succeed on first call"),
}
assert!(get_garrison_dao().is_some(), "must be Some after set");
reset_garrison_dao_for_test();
assert!(
get_garrison_dao().is_none(),
"must be None after reset_garrison_dao_for_test"
);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn test_get_garrison_dao_returned_arc_survives_reset() {
let _guard = test_mutex().lock().await;
reset_garrison_dao_for_test();
let dao = init_garrison_dao().await.unwrap();
match set_garrison_dao(dao.clone()) {
Ok(()) => {}
Err(_) => panic!("set_garrison_dao must succeed on first call"),
}
let cloned = get_garrison_dao().expect("must be Some");
reset_garrison_dao_for_test();
assert!(get_garrison_dao().is_none(), "must be None after reset");
assert!(
Arc::strong_count(&cloned) >= 1,
"cloned Arc must remain valid after reset"
);
cloned
.set("crawlrs:test:after_reset", "v", 60)
.await
.expect("cloned Arc must still be usable");
}
}