use super::{Snapshot, WatchView};
use crate::{
interest::Interest,
subscription::Subscription,
subsume::{Subsumer, WatchOutcome},
};
type S = Subsumer<u8, u32, u32>;
fn install(s: &mut S, handle: u32, key: &[u8], value: u32) -> Subscription {
let outcome = s.plan_watch(key, value, Interest::all());
let sub = match &outcome {
WatchOutcome::Covered { sub, .. }
| WatchOutcome::Widen { sub, .. }
| WatchOutcome::Disjoint { sub, .. } => *sub,
};
s.commit_watch(&outcome, handle, key);
sub
}
#[test]
fn view_is_clone_send_sync() {
fn assert_bounds<T: Clone + Send + Sync>() {}
assert_bounds::<WatchView<u8, u32, u32>>();
}
#[test]
fn view_reflects_committed_watch_set() {
let mut s = S::new();
let view = s.view();
assert!(view.is_empty());
assert_eq!(view.len(), 0);
assert!(!view.is_watched(b"a"));
assert_eq!(view.covering(b"a"), None);
install(&mut s, 1, b"a", 100);
assert!(!view.is_empty());
assert_eq!(view.len(), 1);
assert!(view.contains(b"a"), "the exact root is present");
assert!(view.is_watched(b"a"), "an exact watch is watched");
assert!(
view.is_watched(b"ab"),
"a descendant is covered by the ancestor watch"
);
assert!(!view.contains(b"ab"), "…but it is not an exact root");
assert!(!view.is_watched(b"b"), "a disjoint key is not watched");
assert_eq!(view.covering(b"ab").map(Snapshot::into_inner), Some(100));
assert_eq!(view.resolve(b"a").map(|snap| *snap.get()), Some(100));
assert_eq!(
view.covering(b"b"),
None,
"an unwatched key resolves to nothing"
);
}
#[test]
fn a_clone_shares_the_published_slot() {
let mut s = S::new();
let view = s.view();
let clone = view.clone();
install(&mut s, 1, b"x", 7);
assert!(
view.is_watched(b"xy"),
"the original handle observes the commit"
);
assert!(
clone.is_watched(b"xy"),
"the clone observes the same commit (shared slot)"
);
assert_eq!(clone.covering(b"x").map(Snapshot::into_inner), Some(7));
let pre = s.view();
install(&mut s, 2, b"z", 9);
assert!(
pre.is_watched(b"z"),
"a pre-commit view sees a later commit"
);
assert_eq!(pre.len(), 2);
}
#[test]
fn view_reflects_unwatch() {
let mut s = S::new();
let view = s.view();
let sub = install(&mut s, 1, b"a", 1);
assert!(view.contains(b"a"));
s.plan_unwatch(sub);
assert!(
!view.contains(b"a"),
"the released root is gone from the view"
);
assert!(
!view.is_watched(b"ab"),
"…and no longer covers its former descendants"
);
assert!(view.is_empty());
}
#[test]
fn covered_sub_resolves_to_its_own_value_not_the_departed_root() {
let mut s = S::new();
let view = s.view();
let a = install(&mut s, 1, b"a", 100);
let _b = install(&mut s, 1, b"ab", 200);
assert_eq!(
view.resolve(b"abx").map(Snapshot::into_inner),
Some(200),
"a covered key resolves to the covered subscription's OWN value (longest live sub)"
);
assert_eq!(
view.resolve(b"ax").map(Snapshot::into_inner),
Some(100),
"a key only the broader root covers resolves to the root subscription's value"
);
s.plan_unwatch(a);
assert_eq!(
view.resolve(b"abx").map(Snapshot::into_inner),
Some(200),
"/a/b/x still resolves to the surviving covered sub's value (200), NOT the departed root's \
stale 100"
);
assert_eq!(
view.resolve(b"ax"),
None,
"/a/x is no longer covered by any live subscription (only /a/b is live) → nothing"
);
}