#![cfg(test)]
use super::session::{
EmptyInputBatchError, InputBatch, InputMailbox, InputTarget, LeaseError, Session,
hold_mailbox_lock, install_admit_before_control, install_admit_with_control,
install_commit_overlap, install_release_probe, install_transaction_arrival,
};
use crate::redact_tests::{SECRET, assert_redacted, assert_states};
use crate::state::session_state::{Key, SnapshotValue, WriteError};
use crate::transcript::item::{Item, ModelVisibility, System};
use crate::transcript::store::{self, Snapshot, Version};
use std::error::Error;
use std::sync::mpsc::{self, TryRecvError};
use std::sync::{Arc, Barrier};
use std::thread;
fn item(text: &str) -> Item {
Item::System(System::new(
"test".into(),
text.into(),
ModelVisibility::Visible,
))
}
fn text(item: &Item) -> &str {
match item {
Item::System(system) => system.text(),
_ => panic!("test fixture must remain a system item"),
}
}
fn batch(target: InputTarget, value: &str) -> InputBatch {
InputBatch::new(target, vec![item(value)]).unwrap()
}
#[derive(Clone, Debug, Eq, PartialEq)]
struct StateSnapshotValue(Vec<u8>);
impl SnapshotValue for StateSnapshotValue {}
#[test]
fn batch_and_error_surfaces_are_closed_and_owned() {
assert!(matches!(
InputBatch::new(InputTarget::NextStep, Vec::new()),
Err(EmptyInputBatchError)
));
assert_eq!(
EmptyInputBatchError.to_string(),
"input batch must not be empty"
);
let frozen = batch(InputTarget::NextTurn, "owned");
assert_eq!(frozen.target(), InputTarget::NextTurn);
assert_eq!(text(&frozen.items()[0]), "owned");
let rendered = format!("{frozen:?}");
assert!(rendered.starts_with("InputBatch { target: NextTurn, items: ["));
assert!(
!rendered.contains("enqueue_sequence"),
"the private mailbox position must not enter the public Debug contract"
);
let (target, items) = frozen.into_parts();
assert_eq!(target, InputTarget::NextTurn);
assert_eq!(text(&items[0]), "owned");
let errors = [
LeaseError::Released,
LeaseError::AlreadyAdmitted,
LeaseError::Transcript(store::Error::Poisoned),
];
assert_eq!(errors[0].to_string(), "session lease released");
assert_eq!(errors[1].to_string(), "session lease already admitted");
assert_eq!(errors[2].to_string(), "transcript store lock poisoned");
assert_eq!(
errors[2]
.source()
.and_then(|cause| cause.downcast_ref::<store::Error>())
.copied(),
Some(store::Error::Poisoned)
);
for leaf in &errors[..2] {
assert!(leaf.source().is_none(), "{leaf} is its own whole content");
}
}
#[test]
fn mailbox_claims_target_fifo_and_moves_owned_batches() {
let mailbox = InputMailbox::new();
assert!(mailbox.is_empty());
assert!(mailbox.claim(InputTarget::NextStep).is_none());
mailbox.push(batch(InputTarget::NextTurn, "turn-1"));
mailbox.push(batch(InputTarget::NextStep, "step-1"));
mailbox.push(batch(InputTarget::NextTurn, "turn-2"));
mailbox.push(batch(InputTarget::NextStep, "step-2"));
assert_eq!(mailbox.len(), 4);
assert!(!mailbox.is_empty());
let claimed = mailbox.claim(InputTarget::NextStep).unwrap();
assert_eq!(text(&claimed.items()[0]), "step-1");
let remaining = mailbox.drain();
let values: Vec<_> = remaining
.iter()
.map(|entry| (entry.target(), text(&entry.items()[0])))
.collect();
assert_eq!(
values,
[
(InputTarget::NextTurn, "turn-1"),
(InputTarget::NextTurn, "turn-2"),
(InputTarget::NextStep, "step-2"),
]
);
assert!(mailbox.drain().is_empty());
}
fn queued(mailbox: &InputMailbox) -> Vec<(InputTarget, String)> {
mailbox
.drain()
.iter()
.map(|entry| (entry.target(), text(&entry.items()[0]).to_owned()))
.collect()
}
#[test]
fn an_unsettled_claim_restores_its_batch_at_its_enqueue_position() {
let mailbox = InputMailbox::new();
mailbox.push(batch(InputTarget::NextTurn, "turn-1"));
mailbox.push(batch(InputTarget::NextStep, "step-1"));
mailbox.push(batch(InputTarget::NextTurn, "turn-2"));
let claim = mailbox.claim_conserved(InputTarget::NextStep).unwrap();
assert_eq!(text(&claim.batch().items()[0]), "step-1");
assert_eq!(mailbox.len(), 2, "an in-flight claim is in no queue slot");
mailbox.push(batch(InputTarget::NextStep, "step-2"));
drop(claim);
assert_eq!(
queued(&mailbox),
[
(InputTarget::NextTurn, "turn-1".to_owned()),
(InputTarget::NextStep, "step-1".to_owned()),
(InputTarget::NextTurn, "turn-2".to_owned()),
(InputTarget::NextStep, "step-2".to_owned()),
]
);
}
#[test]
fn restores_interleave_by_enqueue_order_whatever_order_they_drop_in() {
let mailbox = InputMailbox::new();
mailbox.push(batch(InputTarget::NextStep, "first"));
mailbox.push(batch(InputTarget::NextStep, "second"));
mailbox.push(batch(InputTarget::NextStep, "third"));
let first = mailbox.claim_conserved(InputTarget::NextStep).unwrap();
let second = mailbox.claim_conserved(InputTarget::NextStep).unwrap();
assert!(mailbox.drain().len() == 1, "only the third remains queued");
drop(second);
drop(first);
assert_eq!(
queued(&mailbox),
[
(InputTarget::NextStep, "first".to_owned()),
(InputTarget::NextStep, "second".to_owned()),
]
);
}
#[test]
fn a_settled_claim_restores_nothing() {
let mailbox = InputMailbox::new();
mailbox.push(batch(InputTarget::NextTurn, "settled"));
let mut claim = mailbox.claim_conserved(InputTarget::NextTurn).unwrap();
let settled = claim.settle();
assert_eq!(text(&settled.items()[0]), "settled");
drop(claim);
assert!(mailbox.is_empty());
assert!(mailbox.claim_conserved(InputTarget::NextTurn).is_none());
}
#[test]
fn an_unwinding_claim_restores_its_batch() {
let mailbox = InputMailbox::new();
mailbox.push(batch(InputTarget::NextTurn, "unwound"));
let caught = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let _claim = mailbox.claim_conserved(InputTarget::NextTurn).unwrap();
panic!("admission unwound");
}));
assert!(caught.is_err());
assert_eq!(
queued(&mailbox),
[(InputTarget::NextTurn, "unwound".to_owned())]
);
}
#[test]
fn session_seed_identity_shared_handles_and_state_are_owned() {
let seed = Snapshot::new(Version::from_u64(7), vec![item("seed")]);
let session = Session::new("session-id".into(), Some(seed.clone()));
assert_eq!(session.id(), "session-id");
assert_eq!(
session.transcript().version().unwrap(),
Version::from_u64(7)
);
assert_eq!(
text(&session.transcript().snapshot().unwrap().items()[0]),
"seed"
);
assert_eq!(text(&seed.items()[0]), "seed");
let first = session.input_mailbox();
let second = session.input_mailbox();
first.push(batch(InputTarget::NextStep, "shared"));
assert_eq!(
text(&second.claim(InputTarget::NextStep).unwrap().items()[0]),
"shared"
);
let key = Key::<StateSnapshotValue>::new();
let lease = session.try_acquire().unwrap();
assert!(!lease.is_admitted());
lease
.state()
.set(&key, &StateSnapshotValue(vec![1]))
.unwrap();
lease.admit().unwrap();
assert!(lease.is_admitted());
lease.release();
assert!(!lease.is_admitted());
assert_eq!(
session.state().load(&key),
Some(StateSnapshotValue(vec![1]))
);
assert_eq!(
lease.state().set(&key, &StateSnapshotValue(vec![2])),
Err(WriteError::LeaseReleased)
);
}
#[test]
fn admission_is_once_per_lease_and_resets_for_each_successor() {
let session = Session::new("admission".into(), None);
let first = session.try_acquire().unwrap();
assert!(session.try_acquire().is_none());
assert!(!first.is_admitted());
first.admit().unwrap();
assert!(first.is_admitted());
assert!(matches!(first.admit(), Err(LeaseError::AlreadyAdmitted)));
first.release();
first.release();
assert!(!first.is_admitted());
assert!(matches!(first.admit(), Err(LeaseError::Released)));
let successor = session.try_acquire().unwrap();
assert!(!first.is_admitted());
assert!(!successor.is_admitted());
successor.admit().unwrap();
assert!(successor.is_admitted());
}
#[test]
fn transcript_authority_is_cas_only_and_release_bound() {
let session = Session::new("transcript".into(), None);
let lease = session.try_acquire().unwrap();
lease.admit().unwrap();
assert_eq!(
lease
.append_batch_if_version(vec![item("first")], Version::ZERO)
.unwrap(),
Version::from_u64(1)
);
let conflict = lease
.append_batch_if_version(vec![item("stale")], Version::ZERO)
.unwrap_err();
assert!(matches!(
conflict,
LeaseError::Transcript(store::Error::VersionConflict { .. })
));
assert_eq!(
lease
.replace_if_version(vec![item("replacement")], Version::from_u64(1))
.unwrap(),
Version::from_u64(2)
);
lease.release();
let saved = lease.transcript_snapshot().unwrap();
assert_eq!(saved.version(), Version::from_u64(2));
assert_eq!(text(&saved.items()[0]), "replacement");
assert!(matches!(
lease.replace_if_version(Vec::new(), Version::from_u64(2)),
Err(LeaseError::Released)
));
}
#[test]
fn admitted_transcript_commit_linearizes_before_release_and_successor() {
let session = Session::new("linear".into(), None);
let lease = Arc::new(session.try_acquire().unwrap());
lease.admit().unwrap();
let overlap = install_commit_overlap(&session);
let arrival = install_transaction_arrival(&session);
let writer = Arc::clone(&lease);
let commit =
thread::spawn(move || writer.append_batch_if_version(vec![item("winner")], Version::ZERO));
overlap.wait_until_reached();
overlap.assert_control_is_locked();
let releaser = Arc::clone(&lease);
let (released_tx, released_rx) = mpsc::channel();
arrival.arm();
let release = thread::spawn(move || {
releaser.release();
released_tx.send(()).unwrap();
});
arrival.wait_until_blocked();
assert_eq!(released_rx.try_recv(), Err(TryRecvError::Empty));
overlap.proceed();
assert_eq!(commit.join().unwrap().unwrap(), Version::from_u64(1));
release.join().unwrap();
released_rx.recv().unwrap();
let successor = session.try_acquire().unwrap();
successor.admit().unwrap();
assert_eq!(
successor
.replace_if_version(vec![item("successor")], Version::from_u64(1))
.unwrap(),
Version::from_u64(2)
);
}
#[test]
fn no_argument_admission_holds_control_and_linearizes_before_release() {
let session = Session::new("admit-first".into(), None);
let lease = Arc::new(session.try_acquire().unwrap());
let admit_pause = install_admit_with_control(&session);
let release_probe = install_release_probe(&session);
let admitting = Arc::clone(&lease);
let admit = thread::spawn(move || admitting.admit());
admit_pause.wait_until_reached();
admit_pause.assert_control_is_locked();
let releasing = Arc::clone(&lease);
let release = thread::spawn(move || releasing.release());
release_probe.wait_until_reached();
admit_pause.proceed();
assert!(admit.join().unwrap().is_ok());
release_probe.proceed();
release.join().unwrap();
let successor = session.try_acquire().unwrap();
assert!(!successor.is_admitted());
successor.admit().unwrap();
assert!(successor.is_admitted());
}
#[test]
fn release_before_admission_makes_old_admit_released_and_successor_admits() {
let session = Session::new("release-first".into(), None);
let old = Arc::new(session.try_acquire().unwrap());
let admit_pause = install_admit_before_control(&session);
let admitting = Arc::clone(&old);
let admit = thread::spawn(move || admitting.admit());
admit_pause.wait_until_reached();
old.release();
let successor = session.try_acquire().unwrap();
successor.admit().unwrap();
admit_pause.proceed();
assert!(matches!(admit.join().unwrap(), Err(LeaseError::Released)));
assert!(successor.is_admitted());
successor.release();
let continued = session.try_acquire().unwrap();
continued.admit().unwrap();
}
#[test]
fn admission_commit_and_release_race_is_linearized() {
for _ in 0..128 {
let session = Session::new("admission-race".into(), None);
let lease = Arc::new(session.try_acquire().unwrap());
let start = Arc::new(Barrier::new(3));
let admitting = Arc::clone(&lease);
let admit_start = Arc::clone(&start);
let admit = thread::spawn(move || {
admit_start.wait();
admitting.admit()
});
let releasing = Arc::clone(&lease);
let release_start = Arc::clone(&start);
let release = thread::spawn(move || {
release_start.wait();
releasing.release();
});
start.wait();
let result = admit.join().unwrap();
release.join().unwrap();
let successor = session.try_acquire().unwrap();
match result {
Ok(()) | Err(LeaseError::Released) => successor.admit().unwrap(),
Err(error) => panic!("unexpected admission race result: {error}"),
}
}
}
#[test]
fn concurrent_acquire_has_one_winner_and_mailbox_delivers_exactly_once() {
let session = Session::new("concurrent".into(), None);
let start = Arc::new(Barrier::new(17));
let (leases_tx, leases_rx) = mpsc::channel();
let mut workers = Vec::new();
for _ in 0..16 {
let session = session.clone();
let start = Arc::clone(&start);
let leases_tx = leases_tx.clone();
workers.push(thread::spawn(move || {
start.wait();
if let Some(lease) = session.try_acquire() {
leases_tx.send(lease).unwrap();
}
}));
}
start.wait();
for worker in workers {
worker.join().unwrap();
}
drop(leases_tx);
let winners: Vec<_> = leases_rx.into_iter().collect();
assert_eq!(winners.len(), 1);
drop(winners);
assert!(session.try_acquire().is_some());
let mailbox = InputMailbox::new();
let mut producers = Vec::new();
for number in 0..64 {
let mailbox = mailbox.clone();
producers.push(thread::spawn(move || {
mailbox.push(batch(InputTarget::NextStep, &number.to_string()));
}));
}
for producer in producers {
producer.join().unwrap();
}
let mut values: Vec<_> = mailbox
.drain()
.iter()
.map(|entry| text(&entry.items()[0]).parse::<usize>().unwrap())
.collect();
values.sort_unstable();
assert_eq!(values, (0..64).collect::<Vec<_>>());
}
#[test]
fn session_owned_mailbox_preserves_unclaimed_input_for_a_successor_lease() {
let session = Session::new("miri".into(), None);
let mailbox = session.input_mailbox();
mailbox.push(batch(InputTarget::NextStep, "step"));
mailbox.push(batch(InputTarget::NextTurn, "turn"));
let first_run = session.try_acquire().unwrap();
first_run.admit().unwrap();
drop(first_run);
let successor_run = session
.try_acquire()
.expect("the successor owns the Session");
assert_eq!(
text(&mailbox.claim(InputTarget::NextTurn).unwrap().items()[0]),
"turn"
);
assert_eq!(
text(&mailbox.claim(InputTarget::NextStep).unwrap().items()[0]),
"step"
);
assert!(mailbox.is_empty());
successor_run.release();
}
#[test]
fn successor_acquisition_cannot_cross_an_in_flight_transaction() {
let session = Session::new("acquire-gate".into(), None);
let lease = session.try_acquire().unwrap();
lease.admit().unwrap();
let overlap = install_commit_overlap(&session);
let arrival = install_transaction_arrival(&session);
thread::scope(|scope| {
let committing =
scope.spawn(|| lease.append_batch_if_version(vec![item("first")], Version::ZERO));
overlap.wait_until_reached();
arrival.arm();
let (seen_tx, seen_rx) = mpsc::channel();
let acquiring = scope.spawn(move || {
let outcome = session.try_acquire();
seen_tx.send(outcome.is_none()).unwrap();
});
arrival.wait_until_blocked();
assert_eq!(seen_rx.try_recv(), Err(TryRecvError::Empty));
overlap.proceed();
assert_eq!(committing.join().unwrap().unwrap(), Version::from_u64(1));
acquiring.join().unwrap();
assert!(
seen_rx.recv().unwrap(),
"the predecessor still holds the lease, so acquisition fails after waiting"
);
});
}
#[test]
fn a_resumed_session_lets_its_creator_name_the_boundary_between_replay_and_live() {
let replayed = vec![item("turn-1 ask"), item("turn-1 answer")];
let first_live_index = replayed.len();
let first_live_version = Version::from_u64(7);
let session = Session::new(
"resumed".into(),
Some(Snapshot::new(first_live_version, replayed)),
);
let lease = session.try_acquire().unwrap();
lease.admit().unwrap();
lease
.append_batch_if_version(vec![item("turn-2 ask")], first_live_version)
.unwrap();
lease
.append_batch_if_version(
vec![item("turn-2 answer")],
Version::from_u64(first_live_version.as_u64() + 1),
)
.unwrap();
let snapshot = session.transcript().snapshot().unwrap();
assert_eq!(snapshot.version(), Version::from_u64(9));
let (seed, live) = snapshot.items().split_at(first_live_index);
assert_eq!(
seed.iter().map(text).collect::<Vec<_>>(),
["turn-1 ask", "turn-1 answer"],
"the replayed prefix is exactly what its creator handed in"
);
assert_eq!(
live.iter().map(text).collect::<Vec<_>>(),
["turn-2 ask", "turn-2 answer"],
"everything after it is this Run's own work"
);
assert_eq!(
snapshot.version().as_u64() - first_live_version.as_u64(),
live.len() as u64
);
}
#[test]
fn session_and_lease_debug_name_the_session_they_are_bound_to() {
let session = Session::new("session-1".into(), None);
assert_eq!(format!("{session:?}"), r#"Session { id: "session-1" }"#);
let lease = session
.try_acquire()
.expect("a fresh session grants a lease");
assert_eq!(format!("{lease:?}"), r#"Lease { session: "session-1" }"#);
}
#[test]
fn input_batch_debug_keeps_the_target_and_redacts_the_items() {
let batch = InputBatch::new(InputTarget::NextTurn, vec![item(SECRET)])
.expect("a non-empty batch freezes");
assert_redacted(&batch);
assert_states(
&batch,
&["target: NextTurn", "text: <21 bytes>", r#"subtype: "test""#],
);
}
#[test]
fn mailbox_debug_reports_queue_depth_and_never_waits_for_the_lock() {
let mailbox = InputMailbox::new();
assert_eq!(format!("{mailbox:?}"), "InputMailbox { batches: 0 }");
mailbox.push(InputBatch::new(InputTarget::NextTurn, vec![item(SECRET)]).expect("non-empty"));
assert_redacted(&mailbox);
assert_eq!(format!("{mailbox:?}"), "InputMailbox { batches: 1 }");
let held = Barrier::new(2);
let release = Barrier::new(2);
thread::scope(|scope| {
scope.spawn(|| hold_mailbox_lock(&mailbox, &held, &release));
held.wait();
assert_eq!(format!("{mailbox:?}"), "InputMailbox { batches: <locked> }");
release.wait();
});
assert_eq!(format!("{mailbox:?}"), "InputMailbox { batches: 1 }");
}