use super::*;
use crate::database::tenant::{Manager, Pool};
use std::{
    sync::Arc,
    time::{Duration, Instant},
};

#[test]
fn reaping_deadline_keeps_pending_and_active_pools_visible() {
    let directory = Directory::new();
    runtime()
        .run(async |scope| {
            let mut settings = settings(true, 2);
            settings.1.as_mut().unwrap().idle_timeout_ms = 86_400_000;
            let database = crate::database::Database::open(
                &directory.0,
                settings.0.remove("default").unwrap(),
                scope,
            )
            .await
            .unwrap();
            let manager = Manager::new(
                &directory.0,
                settings.1.unwrap(),
                std::slice::from_ref(&database),
                0,
                &[],
                &[],
                &["default"],
                &[],
            )
            .unwrap();
            let mut cache = manager.cache.lock().await;
            let first_state = manager.reserve(&mut cache, (0, 1)).unwrap();
            let active = Arc::new(Pool {
                database: database.clone(),
            });
            {
                let mut ready = first_state.try_lock().unwrap();
                ready.pool = Some(active.clone());
                ready.ready = true;
            }
            let first = Arc::downgrade(&first_state);
            drop(first_state);
            manager.evict(&mut cache);
            assert_eq!(first.strong_count(), 1);

            let pending_state = manager.reserve(&mut cache, (0, 2)).unwrap();
            let pending = Arc::downgrade(&pending_state);
            drop(pending_state);
            manager.evict(&mut cache);
            assert_eq!(pending.strong_count(), 0);
            assert_eq!(first.strong_count(), 1);

            cache.entries.get_mut(&(0, 1)).unwrap().touched =
                Instant::now() - Duration::from_secs(172800);
            cache.check_at = Instant::now();
            manager.evict(&mut cache);
            assert_eq!(first.strong_count(), 1);
            drop(active);
            manager.evict(&mut cache);
            assert_eq!(first.strong_count(), 1);
            assert!(cache.check_at > Instant::now());
            cache.check_at = Instant::now();
            manager.evict(&mut cache);
            assert_eq!(first.strong_count(), 0);
            drop(cache);
            manager.close().await;
        })
        .unwrap();
}