#![cfg(test)]
use super::session_state::{
self, CallbackWritePermit, Key, SnapshotValue, StagedWriter, Store, WriteError, Writer,
install_write_overlap,
};
use std::collections::HashSet;
use std::sync::mpsc::{self, TryRecvError};
use std::sync::{Arc, Barrier};
use std::thread;
#[derive(Clone, Debug, Eq, PartialEq)]
struct Snapshot {
name: String,
nested: Vec<Vec<u8>>,
}
impl Snapshot {
fn new(name: &str, byte: u8) -> Self {
Self {
name: name.into(),
nested: vec![vec![byte]],
}
}
}
impl SnapshotValue for Snapshot {}
fn state() -> (Store, Writer) {
let store = Store::new();
let writer = store.acquire();
(store, writer)
}
#[test]
fn key_identity_and_store_isolation_are_per_slot_and_per_store() {
let first = Key::<Snapshot>::new();
let cloned = first.clone();
let second = Key::<Snapshot>::new();
assert!(first == cloned);
assert!(first != second);
let mut set = HashSet::new();
assert!(set.insert(first.clone()));
assert!(!set.insert(cloned));
assert!(set.insert(second.clone()));
let (left, writer) = state();
let (right, other_writer) = state();
writer.set(&first, &Snapshot::new("left", 1)).unwrap();
writer.set(&second, &Snapshot::new("second", 2)).unwrap();
assert_eq!(left.reader().load(&first).unwrap().name, "left");
assert_eq!(left.reader().load(&second).unwrap().name, "second");
assert!(right.reader().load(&first).is_none());
other_writer
.set(&first, &Snapshot::new("right", 3))
.unwrap();
assert_eq!(left.reader().load(&first).unwrap().name, "left");
assert_eq!(right.reader().load(&first).unwrap().name, "right");
}
#[test]
fn every_session_boundary_returns_an_owned_snapshot() {
let (store, writer) = state();
let key = Key::<Snapshot>::new();
assert!(writer.load(&key).is_none());
assert!(writer.delete(&key).unwrap().is_none());
let mut ingress = Snapshot::new("first", 1);
assert!(writer.set(&key, &ingress).unwrap().is_none());
ingress.name = "caller".into();
ingress.nested[0][0] = 9;
assert_eq!(
store.reader().load(&key).unwrap(),
Snapshot::new("first", 1)
);
let mut loaded = writer.reader().load(&key).unwrap();
loaded.name = "loaded".into();
loaded.nested[0][0] = 8;
let mut previous = writer
.set(&key, &Snapshot::new("replacement", 2))
.unwrap()
.unwrap();
assert_eq!(previous, Snapshot::new("first", 1));
previous.name = "previous".into();
let mut candidate = Snapshot::new("unused", 3);
let (mut actual, existed) = writer.load_or_store(&key, &candidate).unwrap();
assert!(existed);
assert_eq!(actual, Snapshot::new("replacement", 2));
actual.name = "actual".into();
candidate.name = "candidate".into();
assert_eq!(writer.load(&key).unwrap(), Snapshot::new("replacement", 2));
let fresh = Key::<Snapshot>::new();
let mut source = Snapshot::new("inserted", 4);
let (mut returned, existed) = writer.load_or_store(&fresh, &source).unwrap();
assert!(!existed);
source.name = "source".into();
returned.name = "returned".into();
assert_eq!(writer.load(&fresh).unwrap(), Snapshot::new("inserted", 4));
let mut deleted = writer.delete(&fresh).unwrap().unwrap();
deleted.name = "deleted".into();
assert!(writer.load(&fresh).is_none());
}
fn assert_send_sync<T: Send + Sync>() {}
#[test]
fn callback_permit_revokes_only_its_writer_and_preserves_auto_traits() {
assert_send_sync::<Writer>();
assert_send_sync::<StagedWriter>();
assert_send_sync::<CallbackWritePermit>();
let (store, ordinary) = state();
let set_key = Key::<Snapshot>::new();
let load_or_store_key = Key::<Snapshot>::new();
let delete_key = Key::<Snapshot>::new();
let staged_key = Key::<Snapshot>::new();
ordinary
.set(&delete_key, &Snapshot::new("keep", 1))
.unwrap();
let (callback, permit) = ordinary.clone_with_callback_permit();
let staged_before_revoke = callback.staged();
staged_before_revoke
.set(&staged_key, &Snapshot::new("pending", 2))
.unwrap();
permit.revoke();
assert_eq!(
callback.set(&set_key, &Snapshot::new("blocked", 3)),
Err(WriteError::LeaseReleased)
);
assert_eq!(
callback.load_or_store(&load_or_store_key, &Snapshot::new("blocked", 4)),
Err(WriteError::LeaseReleased)
);
assert_eq!(callback.delete(&delete_key), Err(WriteError::LeaseReleased));
let staged_after_revoke = callback.staged();
assert_eq!(
staged_after_revoke.set(&set_key, &Snapshot::new("blocked", 5)),
Err(WriteError::LeaseReleased)
);
assert_eq!(
staged_after_revoke.load_or_store(&load_or_store_key, &Snapshot::new("blocked", 6)),
Err(WriteError::LeaseReleased)
);
assert_eq!(
staged_after_revoke.delete(&delete_key),
Err(WriteError::LeaseReleased)
);
assert_eq!(
staged_before_revoke.commit(),
Err(WriteError::LeaseReleased)
);
assert!(store.reader().load(&set_key).is_none());
assert!(store.reader().load(&load_or_store_key).is_none());
assert_eq!(
store.reader().load(&delete_key),
Some(Snapshot::new("keep", 1))
);
assert!(store.reader().load(&staged_key).is_none());
ordinary
.set(&set_key, &Snapshot::new("ordinary", 7))
.unwrap();
let (actual, existed) = ordinary
.load_or_store(&load_or_store_key, &Snapshot::new("ordinary", 8))
.unwrap();
assert!(!existed);
assert_eq!(actual, Snapshot::new("ordinary", 8));
assert_eq!(
ordinary.delete(&delete_key).unwrap(),
Some(Snapshot::new("keep", 1))
);
}
#[test]
fn consecutive_loads_return_mutably_isolated_nested_snapshots() {
let (store, writer) = state();
let key = Key::<Snapshot>::new();
writer.set(&key, &Snapshot::new("stored", 1)).unwrap();
let mut first = writer.load(&key).unwrap();
let mut second = writer.load(&key).unwrap();
first.name = "first".into();
first.nested[0][0] = 2;
first.nested.push(vec![3]);
assert_eq!(second, Snapshot::new("stored", 1));
second.name = "second".into();
second.nested[0].push(4);
assert_eq!(first.name, "first");
assert_eq!(first.nested, vec![vec![2], vec![3]]);
assert_eq!(
store.reader().load(&key).unwrap(),
Snapshot::new("stored", 1)
);
}
#[test]
fn pre_release_nested_snapshot_cannot_affect_successor() {
let store = Store::new();
let key = Key::<Snapshot>::new();
let old = store.acquire();
old.set(&key, &Snapshot::new("old", 1)).unwrap();
let mut old_snapshot = old.load(&key).unwrap();
old.release();
let successor = store.acquire();
successor.set(&key, &Snapshot::new("successor", 2)).unwrap();
old_snapshot.name = "mutated-old".into();
old_snapshot.nested[0][0] = 9;
old_snapshot.nested.push(vec![8]);
drop(old_snapshot);
assert_eq!(successor.load(&key).unwrap(), Snapshot::new("successor", 2));
assert_eq!(old.load(&key).unwrap(), Snapshot::new("successor", 2));
}
#[test]
fn staged_commit_is_overlay_first_hidden_atomic_and_idempotent() {
let (store, writer) = state();
let kept = Key::<Snapshot>::new();
let dropped = Key::<Snapshot>::new();
writer.set(&dropped, &Snapshot::new("base", 1)).unwrap();
let staged = writer.staged();
assert!(
staged
.set(&kept, &Snapshot::new("one", 2))
.unwrap()
.is_none()
);
assert_eq!(
staged
.set(&kept, &Snapshot::new("two", 3))
.unwrap()
.unwrap()
.name,
"one"
);
assert_eq!(staged.delete(&dropped).unwrap().unwrap().name, "base");
assert_eq!(staged.load(&kept).unwrap().name, "two");
assert!(staged.load(&dropped).is_none());
assert!(store.reader().load(&kept).is_none());
assert_eq!(store.reader().load(&dropped).unwrap().name, "base");
let (actual, loaded) = staged
.load_or_store(&kept, &Snapshot::new("ignored", 4))
.unwrap();
assert!(loaded);
assert_eq!(actual.name, "two");
let fresh = Key::<Snapshot>::new();
let (actual, loaded) = staged
.load_or_store(&fresh, &Snapshot::new("fresh", 5))
.unwrap();
assert!(!loaded);
assert_eq!(actual.name, "fresh");
staged.commit().unwrap();
assert_eq!(store.reader().load(&kept).unwrap().name, "two");
assert!(store.reader().load(&dropped).is_none());
assert_eq!(store.reader().load(&fresh).unwrap().name, "fresh");
staged.commit().unwrap();
staged.discard();
}
#[test]
fn discard_and_retained_staged_views_forward_to_the_base() {
for commit in [false, true] {
let (store, writer) = state();
let key = Key::<Snapshot>::new();
writer.set(&key, &Snapshot::new("base", 1)).unwrap();
let staged = writer.staged();
staged.set(&key, &Snapshot::new("pending", 2)).unwrap();
if commit {
staged.commit().unwrap();
} else {
staged.discard();
staged.discard();
}
let expected = if commit { "pending" } else { "base" };
assert_eq!(staged.load(&key).unwrap().name, expected);
assert_eq!(
staged
.set(&key, &Snapshot::new("forwarded", 3))
.unwrap()
.unwrap()
.name,
expected
);
let (actual, loaded) = staged
.load_or_store(&key, &Snapshot::new("ignored", 4))
.unwrap();
assert!(loaded);
assert_eq!(actual.name, "forwarded");
assert_eq!(staged.delete(&key).unwrap().unwrap().name, "forwarded");
assert!(store.reader().load(&key).is_none());
writer.release();
assert_eq!(
staged.set(&key, &Snapshot::new("late", 5)),
Err(WriteError::LeaseReleased)
);
assert_eq!(
staged.load_or_store(&key, &Snapshot::new("late", 5)),
Err(WriteError::LeaseReleased)
);
assert_eq!(staged.delete(&key), Err(WriteError::LeaseReleased));
assert!(staged.load(&key).is_none());
}
}
#[test]
fn admitted_write_finishes_before_release_and_successor_wins() {
let store = Store::new();
let key = Arc::new(Key::<Snapshot>::new());
let old = Arc::new(store.acquire());
old.set(&key, &Snapshot::new("initial", 1)).unwrap();
let overlap = install_write_overlap(&old);
let old_write = {
let old = Arc::clone(&old);
let key = Arc::clone(&key);
thread::spawn(move || old.set(&key, &Snapshot::new("old-write", 2)))
};
overlap.wait_for_admission();
let (release_started_tx, release_started_rx) = mpsc::sync_channel(0);
let (release_done_tx, release_done_rx) = mpsc::channel();
let release = {
let old = Arc::clone(&old);
thread::spawn(move || {
release_started_tx.send(()).unwrap();
old.release();
release_done_tx.send(()).unwrap();
})
};
release_started_rx.recv().unwrap();
overlap.assert_release_is_blocked();
assert!(matches!(
release_done_rx.try_recv(),
Err(TryRecvError::Empty)
));
overlap.release_write();
assert_eq!(
old_write.join().unwrap().unwrap(),
Some(Snapshot::new("initial", 1))
);
release_done_rx.recv().unwrap();
release.join().unwrap();
let successor = store.acquire();
successor.set(&key, &Snapshot::new("successor", 3)).unwrap();
assert_eq!(old.load(&key).unwrap().name, "successor");
assert_eq!(store.reader().load(&key).unwrap().name, "successor");
}
#[test]
fn admitted_commit_finishes_before_release_and_successor_wins() {
let store = Store::new();
let first = Key::<Snapshot>::new();
let second = Key::<Snapshot>::new();
let old = Arc::new(store.acquire());
old.set(&first, &Snapshot::new("old-a", 1)).unwrap();
old.set(&second, &Snapshot::new("old-b", 1)).unwrap();
let staged = Arc::new(old.staged());
staged.set(&first, &Snapshot::new("commit-a", 2)).unwrap();
staged.set(&second, &Snapshot::new("commit-b", 2)).unwrap();
let overlap = install_write_overlap(&old);
let old_commit = {
let staged = Arc::clone(&staged);
thread::spawn(move || staged.commit())
};
overlap.wait_for_admission();
let (release_started_tx, release_started_rx) = mpsc::sync_channel(0);
let (release_done_tx, release_done_rx) = mpsc::channel();
let release = {
let old = Arc::clone(&old);
thread::spawn(move || {
release_started_tx.send(()).unwrap();
old.release();
release_done_tx.send(()).unwrap();
})
};
release_started_rx.recv().unwrap();
overlap.assert_release_is_blocked();
assert!(matches!(
release_done_rx.try_recv(),
Err(TryRecvError::Empty)
));
overlap.release_write();
old_commit.join().unwrap().unwrap();
release_done_rx.recv().unwrap();
release.join().unwrap();
let successor = store.acquire();
successor
.set(&first, &Snapshot::new("successor-a", 3))
.unwrap();
successor
.set(&second, &Snapshot::new("successor-b", 3))
.unwrap();
assert_eq!(store.reader().load(&first).unwrap().name, "successor-a");
assert_eq!(store.reader().load(&second).unwrap().name, "successor-b");
}
#[test]
fn concurrent_commit_and_discard_resolve_once_without_partial_state() {
let (store, writer) = state();
let first = Key::<Snapshot>::new();
let second = Key::<Snapshot>::new();
let staged = Arc::new(writer.staged());
staged.set(&first, &Snapshot::new("a", 1)).unwrap();
staged.set(&second, &Snapshot::new("b", 2)).unwrap();
let barrier = Arc::new(Barrier::new(3));
let commit = {
let staged = Arc::clone(&staged);
let barrier = Arc::clone(&barrier);
thread::spawn(move || {
barrier.wait();
staged.commit().unwrap();
})
};
let discard = {
let staged = Arc::clone(&staged);
let barrier = Arc::clone(&barrier);
thread::spawn(move || {
barrier.wait();
staged.discard();
})
};
barrier.wait();
commit.join().unwrap();
discard.join().unwrap();
let values = (store.reader().load(&first), store.reader().load(&second));
assert!(matches!(values, (Some(_), Some(_)) | (None, None)));
}
#[test]
fn failed_commit_resolves_once_and_a_retry_is_a_noop() {
let (store, writer) = state();
let first = Key::<Snapshot>::new();
let second = Key::<Snapshot>::new();
let staged = writer.staged();
staged.set(&first, &Snapshot::new("a", 1)).unwrap();
staged.set(&second, &Snapshot::new("b", 2)).unwrap();
writer.release();
assert_eq!(staged.commit(), Err(WriteError::LeaseReleased));
assert!(store.reader().load(&first).is_none());
assert!(store.reader().load(&second).is_none());
assert_eq!(staged.commit(), Ok(()));
}
#[test]
fn fresh_keys_are_unique_under_concurrency() {
const WORKERS: usize = 24;
let handles: Vec<_> = (0..WORKERS)
.map(|_| thread::spawn(Key::<Snapshot>::new))
.collect();
let mut keys = HashSet::new();
for handle in handles {
assert!(keys.insert(handle.join().unwrap()));
}
assert_eq!(keys.len(), WORKERS);
}
#[test]
fn error_text_and_private_type_corruption_are_explicit() {
assert_eq!(
WriteError::LeaseReleased.to_string(),
"session-state lease released"
);
let store = Store::new();
let key = Key::<Snapshot>::new();
store.corrupt(&key, WrongType);
let panic = std::panic::catch_unwind(|| store.reader().load(&key));
assert!(panic.is_err());
}
#[derive(Clone)]
struct WrongType;
impl SnapshotValue for WrongType {}
#[test]
fn key_debug_prints_a_slot_identity_with_no_value_bound() {
struct NotDebug;
let key = Key::<NotDebug>::new();
let cloned = key.clone();
let other = Key::<NotDebug>::new();
let rendering = format!("{key:?}");
assert!(rendering.starts_with("Key { slot: 0x"), "{rendering}");
assert_eq!(rendering, format!("{cloned:?}"));
assert_ne!(rendering, format!("{other:?}"));
}
#[test]
fn capability_debug_counts_slots_and_never_waits_for_them() {
let store = Store::new();
let writer = store.acquire();
let reader = store.reader();
assert_eq!(format!("{reader:?}"), "Reader { slots: 0 }");
assert_eq!(format!("{writer:?}"), "Writer { slots: 0 }");
let key = Key::<Snapshot>::new();
writer
.set(&key, &Snapshot::new("first", 1))
.expect("an admitted writer stores");
assert_eq!(format!("{reader:?}"), "Reader { slots: 1 }");
assert_eq!(format!("{writer:?}"), "Writer { slots: 1 }");
let held = Barrier::new(2);
let release = Barrier::new(2);
thread::scope(|scope| {
scope.spawn(|| session_state::hold_value_lock(&reader, &held, &release));
held.wait();
assert_eq!(format!("{reader:?}"), "Reader { slots: <locked> }");
assert_eq!(format!("{writer:?}"), "Writer { slots: <locked> }");
release.wait();
});
assert_eq!(format!("{reader:?}"), "Reader { slots: 1 }");
}
#[test]
fn staged_writer_debug_shows_the_overlay_until_it_resolves() {
let store = Store::new();
let writer = store.acquire();
let staged = writer.staged();
assert_eq!(
format!("{staged:?}"),
"StagedWriter { writer: Writer { slots: 0 }, stage: Active(0) }"
);
let key = Key::<Snapshot>::new();
staged
.set(&key, &Snapshot::new("staged", 2))
.expect("an active overlay stages");
assert_eq!(
format!("{staged:?}"),
"StagedWriter { writer: Writer { slots: 0 }, stage: Active(1) }"
);
let held = Barrier::new(2);
let release = Barrier::new(2);
thread::scope(|scope| {
scope.spawn(|| session_state::hold_stage_lock(&staged, &held, &release));
held.wait();
assert_eq!(
format!("{staged:?}"),
"StagedWriter { writer: Writer { slots: 0 }, stage: <locked> }"
);
release.wait();
});
staged.commit().expect("an admitted overlay publishes");
assert_eq!(
format!("{staged:?}"),
"StagedWriter { writer: Writer { slots: 1 }, stage: Resolved }"
);
}