use core::time::Duration;
use std::sync::{Arc, Mutex};
use super::{
Registries, Registry, RetireOrigin, RetiredLedger, Retirement, RootAdvance, RootState, Stamp,
};
use crate::{RegistryOptions, RegistryOverride};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct MediaId(u64);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct TrackId(u64);
#[derive(Debug, Default)]
struct Kept(Mutex<Vec<(MediaId, Retirement)>>);
impl Kept {
fn acts(&self) -> Vec<(MediaId, Retirement)> {
self
.0
.lock()
.unwrap_or_else(|held| held.into_inner())
.clone()
}
}
impl RetiredLedger<MediaId> for Kept {
fn owed(&self, key: &MediaId, act: Retirement) {
self
.0
.lock()
.unwrap_or_else(|held| held.into_inner())
.push((*key, act));
}
}
struct Reentrant(Mutex<Vec<RootState>>, Mutex<Option<Arc<Registry<MediaId>>>>);
impl RetiredLedger<MediaId> for Reentrant {
fn owed(&self, key: &MediaId, _act: Retirement) {
let table = self.1.lock().unwrap_or_else(|held| held.into_inner());
let Some(registry) = table.as_ref() else {
return;
};
let state = registry.state(key);
self
.0
.lock()
.unwrap_or_else(|held| held.into_inner())
.push(state);
}
}
#[test]
fn an_untouched_family_is_empty_and_idle() {
let registry = Registry::<MediaId>::new(RegistryOptions::new());
assert!(registry.is_empty());
assert_eq!(registry.held(), 0);
assert_eq!(registry.state(&MediaId(1)), RootState::Idle);
assert!(!registry.is_recorded());
}
#[test]
fn the_table_holds_only_what_is_true_of_a_key() {
let at = Stamp::now();
let registry = Registry::<MediaId>::new(RegistryOptions::new());
let key = MediaId(7);
assert_eq!(registry.dispatched(&key, at), RootAdvance::Moved);
assert_eq!(registry.held(), 1);
assert!(matches!(
registry.state(&key),
RootState::Analyzing { inflight: 1, .. }
));
assert_eq!(registry.observed(&key, at), RootAdvance::Moved);
assert_eq!(registry.state(&key), RootState::Idle);
assert_eq!(
registry.held(),
0,
"a key back at idle leaves the table rather than sitting in it saying nothing"
);
}
#[test]
fn a_retirement_lands_and_is_restored() {
let at = Stamp::now();
let registry = Registry::<MediaId>::new(RegistryOptions::new());
let key = MediaId(3);
assert_eq!(
registry.retire(&key, RetireOrigin::Vanished, at),
RootAdvance::Moved
);
assert!(matches!(
registry.state(&key),
RootState::Retired {
origin: RetireOrigin::Vanished,
..
}
));
assert_eq!(registry.held(), 1);
assert_eq!(registry.reappear(&key, at), RootAdvance::Moved);
assert_eq!(registry.state(&key), RootState::Restoring);
assert_eq!(registry.restored(&key, at), RootAdvance::Moved);
assert_eq!(registry.state(&key), RootState::Idle);
assert_eq!(registry.held(), 0);
}
#[test]
fn keys_in_one_family_are_independent() {
let at = Stamp::now();
let registry = Registry::<MediaId>::new(RegistryOptions::new());
assert_eq!(
registry.retire(&MediaId(1), RetireOrigin::User, at),
RootAdvance::Moved
);
assert_eq!(registry.dispatched(&MediaId(2), at), RootAdvance::Moved);
assert!(matches!(
registry.state(&MediaId(1)),
RootState::Retired { .. }
));
assert!(matches!(
registry.state(&MediaId(2)),
RootState::Analyzing { .. }
));
assert_eq!(registry.state(&MediaId(3)), RootState::Idle);
assert_eq!(registry.held(), 2);
}
#[test]
fn the_seated_ledger_takes_the_acts() {
let at = Stamp::now();
let registry = Registry::<MediaId>::new(RegistryOptions::new());
let kept = Arc::new(Kept::default());
assert!(registry.installing(Arc::clone(&kept) as Arc<dyn RetiredLedger<MediaId>>));
assert!(registry.is_recorded());
let key = MediaId(5);
assert_eq!(
registry.retire(&key, RetireOrigin::Vanished, at),
RootAdvance::Moved
);
assert_eq!(registry.reappear(&key, at), RootAdvance::Moved);
assert_eq!(
kept.acts(),
vec![
(
key,
Retirement::Recorded {
at: at.wall(),
origin: RetireOrigin::Vanished,
late_tails: false,
}
),
(key, Retirement::Erased),
]
);
}
#[test]
fn an_unseated_family_still_transitions() {
let at = Stamp::now();
let registry = Registry::<MediaId>::new(RegistryOptions::new());
assert_eq!(
registry.retire(&MediaId(9), RetireOrigin::User, at),
RootAdvance::Moved
);
assert!(matches!(
registry.state(&MediaId(9)),
RootState::Retired { .. }
));
}
#[test]
fn the_ledger_seat_takes_one_occupant() {
let registry = Registry::<MediaId>::new(RegistryOptions::new());
let first = Arc::new(Kept::default());
let second = Arc::new(Kept::default());
assert!(registry.installing(Arc::clone(&first) as Arc<dyn RetiredLedger<MediaId>>));
assert!(
!registry.installing(Arc::clone(&second) as Arc<dyn RetiredLedger<MediaId>>),
"a second writer for one family's rows is refused rather than replacing the first"
);
assert_eq!(
registry.retire(&MediaId(1), RetireOrigin::User, Stamp::now()),
RootAdvance::Moved
);
assert_eq!(first.acts().len(), 1);
assert_eq!(second.acts().len(), 0);
}
#[test]
fn the_ledger_is_spent_outside_the_lock() {
let registry = Arc::new(Registry::<MediaId>::new(RegistryOptions::new()));
let ledger = Arc::new(Reentrant(Mutex::new(Vec::new()), Mutex::new(None)));
*ledger.1.lock().expect("fresh") = Some(Arc::clone(®istry));
assert!(registry.installing(Arc::clone(&ledger) as Arc<dyn RetiredLedger<MediaId>>));
assert_eq!(
registry.retire(&MediaId(2), RetireOrigin::User, Stamp::now()),
RootAdvance::Moved
);
let seen = ledger.0.lock().expect("fresh").clone();
assert!(
matches!(seen.as_slice(), [RootState::Retired { .. }]),
"the ledger read the state the act had already produced: {seen:?}"
);
}
#[test]
fn a_fresh_registries_has_no_families() {
let registries = Registries::default();
assert!(registries.is_empty());
assert_eq!(registries.families(), 0);
assert!(registries.of::<MediaId>().is_none());
assert_eq!(
registries.families(),
0,
"the read door does not mint a family"
);
}
#[test]
fn a_family_is_opened_once() {
let registries = Registries::default();
let first = registries.open::<MediaId>("media");
let second = registries.open::<MediaId>("media");
assert!(Arc::ptr_eq(&first, &second));
assert_eq!(registries.families(), 1);
let read = registries.of::<MediaId>().expect("it is open");
assert!(Arc::ptr_eq(&first, &read));
assert_eq!(
first.retire(&MediaId(4), RetireOrigin::User, Stamp::now()),
RootAdvance::Moved
);
assert!(matches!(
second.state(&MediaId(4)),
RootState::Retired { .. }
));
}
#[test]
fn families_are_kept_apart_by_their_types() {
let registries = Registries::default();
let media = registries.open::<MediaId>("media");
let track = registries.open::<TrackId>("track");
assert_eq!(registries.families(), 2);
assert_eq!(
media.retire(&MediaId(1), RetireOrigin::User, Stamp::now()),
RootAdvance::Moved
);
assert_eq!(media.held(), 1);
assert_eq!(
track.held(),
0,
"a key in one family is nothing at all in another"
);
assert_eq!(track.state(&TrackId(1)), RootState::Idle);
}
#[test]
fn a_family_resolves_its_own_override() {
let one_second = Duration::from_secs(1);
let options = RegistryOptions::new()
.with_debounce(Duration::from_millis(50))
.with_family("media", RegistryOverride::new().with_debounce(one_second));
let registries = Registries::new(options);
assert_eq!(
registries.open::<MediaId>("media").options().debounce(),
one_second
);
assert_eq!(
registries.open::<TrackId>("track").options().debounce(),
Duration::from_millis(50),
"a family nobody wrote an override for reads the defaults"
);
}
#[test]
fn an_unnamed_family_reads_the_defaults() {
let registries = Registries::new(RegistryOptions::new().with_debounce(Duration::from_millis(70)));
assert_eq!(
registries.open::<MediaId>("").options().debounce(),
Duration::from_millis(70)
);
}
#[test]
fn a_second_open_does_not_retune_a_family() {
let options = RegistryOptions::new()
.with_debounce(Duration::from_millis(10))
.with_family(
"media",
RegistryOverride::new().with_debounce(Duration::from_secs(2)),
);
let registries = Registries::new(options);
assert_eq!(
registries.open::<MediaId>("media").options().debounce(),
Duration::from_secs(2)
);
assert_eq!(
registries.open::<MediaId>("nowhere").options().debounce(),
Duration::from_secs(2)
);
}
#[test]
fn the_document_is_kept_whole() {
let options = RegistryOptions::new().with_family("media", RegistryOverride::new());
let registries = Registries::new(options.clone());
assert_eq!(registries.options(), &options);
}
#[test]
fn a_shared_table_is_a_usable_table() {
let registries = Arc::new(Registries::default());
let mine = Arc::clone(®istries);
let table = mine.open::<MediaId>("media");
assert_eq!(
table.dispatched(&MediaId(11), Stamp::now()),
RootAdvance::Moved
);
assert!(matches!(
registries
.of::<MediaId>()
.expect("open")
.state(&MediaId(11)),
RootState::Analyzing { .. }
));
}
#[test]
fn a_lapse_takes_only_the_drains_that_ran_out_of_window() {
let registry =
Registry::<MediaId>::new(RegistryOptions::new().with_retire_drain(Duration::from_secs(30)));
let opened = Stamp::now();
let stale = MediaId(1);
let fresh = MediaId(2);
for key in [stale, fresh] {
assert_eq!(registry.dispatched(&key, opened), RootAdvance::Moved);
assert_eq!(
registry.retire(&key, RetireOrigin::Vanished, opened),
RootAdvance::Moved
);
}
let restarted = Stamp::new(
opened.monotonic() + Duration::from_secs(40),
crate::Timestamp::UNIX_EPOCH,
opened.run(),
);
assert_eq!(
registry.lapse(Stamp::new(
opened.monotonic() + Duration::from_secs(20),
crate::Timestamp::UNIX_EPOCH,
opened.run()
)),
Vec::new(),
"twenty seconds is inside a thirty-second window"
);
let spent = restarted;
let lapsed = registry.lapse(spent);
assert_eq!(
lapsed.len(),
2,
"both are past the window by now: {lapsed:?}"
);
for key in [stale, fresh] {
assert!(
registry.state(&key).has_late_tails(),
"{key:?} went out with work still owed"
);
assert_eq!(registry.inflight(&key), 0, "a retired key has nothing out");
}
}
#[test]
fn a_lapse_pays_the_ledger_after_the_walk() {
let registry = Registry::<MediaId>::new(RegistryOptions::new().with_retire_drain(Duration::ZERO));
let kept = Arc::new(Kept::default());
assert!(registry.installing(Arc::clone(&kept) as Arc<dyn RetiredLedger<MediaId>>));
let at = Stamp::now();
let key = MediaId(9);
assert_eq!(registry.dispatched(&key, at), RootAdvance::Moved);
assert_eq!(
registry.retire(&key, RetireOrigin::User, at),
RootAdvance::Moved
);
assert_eq!(registry.lapse(at), vec![key]);
assert_eq!(
kept.acts(),
vec![(
key,
Retirement::Recorded {
at: at.wall(),
origin: RetireOrigin::User,
late_tails: true,
}
)]
);
}
#[test]
fn a_lapse_over_a_quiet_family_does_nothing() {
let registry = Registry::<MediaId>::new(RegistryOptions::new());
let at = Stamp::now();
assert_eq!(registry.dispatched(&MediaId(3), at), RootAdvance::Moved);
assert_eq!(registry.lapse(at), Vec::new());
assert!(matches!(
registry.state(&MediaId(3)),
RootState::Analyzing { .. }
));
assert_eq!(registry.held(), 1);
}
#[test]
fn inflight_is_the_difference_between_the_two_counting_doors() {
let registry = Registry::<MediaId>::new(RegistryOptions::new());
let at = Stamp::now();
let key = MediaId(4);
assert_eq!(registry.inflight(&key), 0, "an idle key has nothing out");
for _ in 0..3 {
assert_eq!(registry.dispatched(&key, at), RootAdvance::Moved);
}
assert_eq!(registry.inflight(&key), 3);
assert_eq!(registry.observed(&key, at), RootAdvance::Moved);
assert_eq!(registry.inflight(&key), 2);
for _ in 0..2 {
assert_eq!(registry.observed(&key, at), RootAdvance::Moved);
}
assert_eq!(registry.inflight(&key), 0);
assert_eq!(
registry.state(&key),
RootState::Idle,
"zero is what ends the analysis"
);
assert!(registry.is_empty(), "and an idle key leaves the table");
}
#[test]
fn counting_opens_a_real_family_and_refuses_the_unit() {
let registries = Registries::default();
assert!(
registries.counting::<MediaId>("media").is_some(),
"a real root is a real family"
);
assert!(
registries.counting::<()>("").is_none(),
"the unit root is the absence of a projection, not a family of one"
);
assert_eq!(registries.families(), 1, "and the refusal opened nothing");
}
#[test]
fn counting_mints_the_family_that_of_would_have_missed() {
let registries = Registries::default();
assert!(registries.of::<MediaId>().is_none());
let family = registries
.counting::<MediaId>("media")
.expect("a real root");
assert_eq!(
family.dispatched(&MediaId(1), Stamp::now()),
RootAdvance::Moved
);
assert_eq!(
registries
.of::<MediaId>()
.expect("now open")
.inflight(&MediaId(1)),
1,
"the same table, reachable by the read that mints nothing"
);
}