use core::fmt;
use super::{DynRegistry, KeyDoesNotParse};
use crate::{Registry, RegistryOptions, RegistryOverride, RetireOrigin, RootState};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct MediaId(u64);
impl fmt::Display for MediaId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.0)
}
}
impl core::str::FromStr for MediaId {
type Err = core::num::ParseIntError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
s.parse().map(MediaId)
}
}
fn table() -> Registry<MediaId> {
Registry::new(RegistryOptions::new())
}
#[test]
fn an_unheard_of_key_is_idle_through_the_wire_door() {
let table = table();
assert_eq!(DynRegistry::state(&table, "7"), RootState::Idle);
}
#[test]
fn an_unparseable_key_is_idle_rather_than_a_refusal() {
let table = table();
assert_eq!(DynRegistry::state(&table, "not-a-number"), RootState::Idle);
assert_eq!(DynRegistry::state(&table, ""), RootState::Idle);
}
#[test]
fn a_typed_dispatch_is_visible_through_the_wire_door() {
let table = table();
let key = MediaId(7);
let stamp = crate::Stamp::now();
let _advance = table.dispatched(&key, stamp);
assert!(matches!(
DynRegistry::state(&table, "7"),
RootState::Analyzing { inflight: 1, .. }
));
}
#[test]
fn retire_through_the_wire_door_lands_and_answers() {
let table = table();
let landed =
DynRegistry::retire(&table, "7", RetireOrigin::Vanished).expect("7 parses as a MediaId");
assert!(matches!(
landed,
RootState::Retired {
origin: RetireOrigin::Vanished,
..
}
));
assert_eq!(table.state(&MediaId(7)), landed, "the typed door agrees");
}
#[test]
fn retire_on_an_unparseable_key_refuses_by_name() {
let table = table();
assert_eq!(
DynRegistry::retire(&table, "nope", RetireOrigin::User),
Err(KeyDoesNotParse)
);
}
#[test]
fn restore_through_the_wire_door_lands_and_answers() {
let table = table();
let key = MediaId(7);
let _ = table.retire(&key, RetireOrigin::User, crate::Stamp::now());
assert!(matches!(table.state(&key), RootState::Retired { .. }));
let landed = DynRegistry::restore(&table, "7").expect("7 parses");
assert_eq!(landed, RootState::Restoring);
assert_eq!(table.state(&key), RootState::Restoring);
}
#[test]
fn reanalyze_through_the_wire_door_is_an_intake() {
let table = table();
let landed = DynRegistry::reanalyze(&table, "7").expect("7 parses");
assert!(matches!(landed, RootState::Analyzing { inflight: 0, .. }));
assert_eq!(table.state(&MediaId(7)), landed);
}
#[test]
fn counts_cross_through_the_wire_door() {
let table = table();
let stamp = crate::Stamp::now();
let _ = table.intake(&MediaId(1), stamp);
let _ = table.intake(&MediaId(2), stamp);
let _ = table.retire(&MediaId(3), RetireOrigin::Vanished, stamp);
let counts = DynRegistry::counts(&table);
assert_eq!(counts.analyzing, 2);
assert_eq!(counts.retired, 1);
assert_eq!(counts.retiring, 0);
}
#[test]
fn recent_renders_held_keys_as_text() {
let table = table();
let stamp = crate::Stamp::now();
let _ = table.intake(&MediaId(1), stamp);
let _ = table.intake(&MediaId(2), stamp);
let mut recent = DynRegistry::recent(&table, 10);
recent.sort_by(|a, b| a.0.cmp(&b.0));
assert_eq!(recent.len(), 2);
assert_eq!(recent[0].0.as_str(), "1");
assert_eq!(recent[1].0.as_str(), "2");
assert_eq!(
DynRegistry::recent(&table, 1).len(),
1,
"the limit is honoured"
);
}
#[test]
fn apply_knobs_through_the_wire_door_is_apply_knobs() {
let table = table();
let quiet = core::time::Duration::from_millis(9);
DynRegistry::apply_knobs(&table, &RegistryOverride::new().with_debounce(quiet));
assert_eq!(DynRegistry::options(&table).debounce(), quiet);
assert_eq!(table.options().debounce(), quiet, "the typed door agrees");
}