#![cfg(test)]
use std::error::Error;
use std::fmt;
use std::sync::atomic::AtomicU64;
use std::sync::{Arc, Mutex};
use crate::cancel::Token;
use super::agent::{Agent, Config, StartError};
use super::agent_tests::Model;
use super::hook::{
self, ContinuationDecision, ContinuationScope, Emitter, HookError, HookResult,
LifecycleObservation, ObserverHooks, ObserverScope, PrepareDecision, PrepareError,
PrepareScope, ReadScope, RunHooks, StopDecision, StopDecisionScope, TranscriptHooks,
TranscriptMutation, TranscriptReservation,
};
use super::session::{LeaseError, Session};
use super::tool::{self};
use crate::audit;
use crate::runtime::model;
use crate::state::run_state::{self};
use crate::state::session_state::{self, SnapshotValue};
use crate::transcript::controller::ControllerError;
use crate::transcript::item::{Item, ModelVisibility, System};
use crate::transcript::store::{self, Version};
use crate::value::content::Part;
use crate::value::lifecycle::CoordError;
#[derive(Clone, Debug, Eq, PartialEq)]
struct PreparedState(&'static str);
impl SnapshotValue for PreparedState {}
#[derive(Debug)]
struct HookFailure(&'static str);
impl fmt::Display for HookFailure {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.0)
}
}
impl Error for HookFailure {}
enum PrepareReturn {
Rename,
Unchanged,
Blank,
}
struct PreparingHook {
name: &'static str,
key: session_state::Key<PreparedState>,
cancellation: Token,
cancel: bool,
fail: bool,
returns: PrepareReturn,
order: Arc<Mutex<Vec<&'static str>>>,
}
struct ReadOnlyPrepare;
impl RunHooks for ReadOnlyPrepare {
fn prepare(&self, scope: &PrepareScope<'_>) -> HookResult<PrepareDecision> {
scope.transcript().map_err(HookError::new)?;
Ok(PrepareDecision::Continue)
}
fn compose_continuation(
&self,
_scope: &ContinuationScope<'_>,
) -> HookResult<ContinuationDecision> {
Ok(ContinuationDecision::Keep)
}
fn decide_stop(&self, _scope: &StopDecisionScope<'_>) -> HookResult<StopDecision> {
Ok(StopDecision::Continue)
}
}
impl RunHooks for PreparingHook {
fn prepare(&self, scope: &PrepareScope<'_>) -> HookResult<PrepareDecision> {
self.order.lock().unwrap().push(self.name);
scope
.staged_session_state_writer()
.expect("test registration declares Session state")
.set(&self.key, &PreparedState(self.name))
.unwrap();
scope
.staged()
.append_batch(vec![Item::System(System::new(
self.name.to_owned(),
self.name.to_owned(),
ModelVisibility::Hidden,
))])
.unwrap();
if self.cancel {
self.cancellation.cancel();
}
if self.fail {
return Err(HookError::new(HookFailure("prepare failed")));
}
Ok(match self.returns {
PrepareReturn::Rename => {
PrepareDecision::Modify(vec![Part::text(self.name.to_owned())])
}
PrepareReturn::Unchanged => PrepareDecision::Continue,
PrepareReturn::Blank => PrepareDecision::Modify(Vec::new()),
})
}
fn compose_continuation(
&self,
_scope: &ContinuationScope<'_>,
) -> HookResult<ContinuationDecision> {
Ok(ContinuationDecision::Keep)
}
fn decide_stop(&self, _: &StopDecisionScope<'_>) -> HookResult<StopDecision> {
Ok(StopDecision::Continue)
}
}
struct AdmissionObserver {
name: &'static str,
key: session_state::Key<PreparedState>,
panic: bool,
order: Arc<Mutex<Vec<&'static str>>>,
}
impl ObserverHooks for AdmissionObserver {
fn run_admitted(&self, scope: &ReadScope<'_>) {
assert!(scope.session_state().load(&self.key).is_some());
self.order.lock().unwrap().push(self.name);
assert!(!self.panic, "observer panic");
}
fn lifecycle(&self, _: &LifecycleObservation, _: &ObserverScope<'_>) {}
fn model_event(&self, _: &ObserverScope<'_>, _: &model::Event) {}
fn audit_event(&self, _: &ReadScope<'_>, _: &audit::Event) {}
}
struct NoopReservation;
impl TranscriptReservation for NoopReservation {
fn publish(self: Box<Self>) {}
}
struct CancelOnPublish(Token);
impl TranscriptReservation for CancelOnPublish {
fn publish(self: Box<Self>) {
self.0.cancel();
}
}
enum ReservationBehavior {
Fail,
CancelDuringReserve(Token),
CancelOnPublish(Token),
}
struct ReservationHook(ReservationBehavior);
impl TranscriptHooks for ReservationHook {
fn reserve(
&self,
_: &ReadScope<'_>,
_: &TranscriptMutation,
) -> HookResult<Box<dyn TranscriptReservation>> {
match &self.0 {
ReservationBehavior::Fail => Err(HookError::new(HookFailure("reservation failed"))),
ReservationBehavior::CancelDuringReserve(token) => {
token.cancel();
Ok(Box::new(NoopReservation))
}
ReservationBehavior::CancelOnPublish(token) => {
Ok(Box::new(CancelOnPublish(token.clone())))
}
}
}
}
#[derive(Debug, Eq, PartialEq)]
struct SharedRunSnapshotValue(&'static str);
struct SharedRunStateHook {
key: run_state::Key<SharedRunSnapshotValue>,
observations: Arc<Mutex<Vec<&'static str>>>,
}
impl RunHooks for SharedRunStateHook {
fn prepare(&self, scope: &PrepareScope<'_>) -> HookResult<PrepareDecision> {
scope
.run_state()
.set(&self.key, Arc::new(SharedRunSnapshotValue("prepare")));
scope
.staged()
.append_batch(vec![Item::System(System::new(
"shared-run-state".into(),
"prepare".into(),
ModelVisibility::Hidden,
))])
.unwrap();
Ok(PrepareDecision::Continue)
}
fn compose_continuation(
&self,
_scope: &ContinuationScope<'_>,
) -> HookResult<ContinuationDecision> {
Ok(ContinuationDecision::Keep)
}
fn decide_stop(&self, _: &StopDecisionScope<'_>) -> HookResult<StopDecision> {
Ok(StopDecision::Continue)
}
}
impl TranscriptHooks for SharedRunStateHook {
fn reserve(
&self,
scope: &ReadScope<'_>,
_: &TranscriptMutation,
) -> HookResult<Box<dyn TranscriptReservation>> {
let value = scope.run_state().load(&self.key).unwrap();
self.observations.lock().unwrap().push(value.0);
Ok(Box::new(NoopReservation))
}
}
impl ObserverHooks for SharedRunStateHook {
fn run_admitted(&self, scope: &ReadScope<'_>) {
let value = scope.run_state().load(&self.key).unwrap();
self.observations.lock().unwrap().push(value.0);
}
fn lifecycle(&self, _: &LifecycleObservation, _: &ObserverScope<'_>) {}
fn model_event(&self, _: &ObserverScope<'_>, _: &model::Event) {}
fn audit_event(&self, _: &ReadScope<'_>, _: &audit::Event) {}
}
fn empty_tools() -> tool::Registry {
tool::RegistryBuilder::new().build().unwrap()
}
fn agent(registrations: Vec<hook::Registration>) -> Agent<Model> {
let mut hooks = hook::RegistryBuilder::new();
for registration in registrations {
hooks.register(registration);
}
Agent::new(Config::new(Arc::new(Model), empty_tools(), hooks)).unwrap()
}
fn prepare_registration(
name: &'static str,
key: &session_state::Key<PreparedState>,
cancellation: &Token,
cancel: bool,
fail: bool,
order: &Arc<Mutex<Vec<&'static str>>>,
) -> hook::Registration {
returning_prepare_registration(
name,
key,
cancellation,
cancel,
fail,
PrepareReturn::Rename,
order,
)
}
fn returning_prepare_registration(
name: &'static str,
key: &session_state::Key<PreparedState>,
cancellation: &Token,
cancel: bool,
fail: bool,
returns: PrepareReturn,
order: &Arc<Mutex<Vec<&'static str>>>,
) -> hook::Registration {
hook::Registration::new(name.to_owned())
.requires_session_state(true)
.run(Arc::new(PreparingHook {
name,
key: key.clone(),
cancellation: cancellation.clone(),
cancel,
fail,
returns,
order: Arc::clone(order),
}))
}
async fn drop_and_verify_reusable(owner: super::agent::AdmittedStart<Model>, agent: &Agent<Model>) {
let session = owner.session.clone();
assert!(session.try_acquire().is_none());
drop(owner);
let successor = session
.try_acquire()
.expect("admission owner releases lease");
successor.release();
agent.close().await.unwrap();
}
#[tokio::test]
async fn unchanged_prepare_does_not_force_history_copy_for_admitted_input() {
let snapshot = store::Snapshot::new(
Version::ZERO,
vec![Item::System(System::new(
"seed".to_owned(),
"history".to_owned(),
ModelVisibility::Visible,
))],
);
let session = Session::new("session".to_owned(), Some(snapshot));
let before = session.transcript().snapshot().unwrap();
let backing = before.items_backing_ptr();
drop(before);
let agent = agent(vec![
hook::Registration::new("read-only".to_owned()).run(Arc::new(ReadOnlyPrepare)),
]);
let owner = agent
.admit_start(
session.clone(),
vec![Part::text("input".to_owned())],
Token::new(),
)
.unwrap();
let after = session.transcript().snapshot().unwrap();
assert!(std::ptr::eq(after.items_backing_ptr(), backing));
assert_eq!(after.items().len(), 2);
drop_and_verify_reusable(owner, &agent).await;
}
#[tokio::test]
async fn close_first_precedes_session_and_busy_rolls_back_attachment() {
let closed = agent(Vec::new());
closed.close().await.unwrap();
let session = Session::new("close-first".to_owned(), None);
let held = session.try_acquire().unwrap();
assert!(matches!(
closed.admit_start(session.clone(), Vec::new(), Token::new()),
Err(StartError::AgentClosed)
));
assert!(session.try_acquire().is_none());
held.release();
let open = agent(Vec::new());
let held = session.try_acquire().unwrap();
assert!(matches!(
open.admit_start(session.clone(), Vec::new(), Token::new()),
Err(StartError::SessionBusy)
));
assert!(matches!(open.close().await, Ok(())));
held.release();
assert!(session.try_acquire().is_some());
}
#[tokio::test]
async fn invalid_or_exhausted_run_identity_rolls_back_lease_and_attachment() {
let agent = agent(Vec::new());
let empty = Session::new(String::new(), None);
let error = agent
.admit_start_with_run_ids(empty.clone(), Vec::new(), Token::new(), &AtomicU64::new(41))
.err()
.unwrap();
assert_eq!(error.to_string(), "session ID must not be empty");
assert!(error.source().is_some());
assert!(matches!(
error,
StartError::InvalidIdentity(CoordError::EmptySessionId)
));
let successor = empty
.try_acquire()
.expect("invalid identity releases lease");
successor.release();
for exhausted_id in [0, u64::MAX] {
let exhausted = Session::new(format!("exhausted-{exhausted_id}"), None);
let error = agent
.admit_start_with_run_ids(
exhausted.clone(),
Vec::new(),
Token::new(),
&AtomicU64::new(exhausted_id),
)
.err()
.unwrap();
assert_eq!(error.to_string(), "Run identity exhausted");
assert!(error.source().is_none());
assert!(matches!(error, StartError::RunIdExhausted));
let successor = exhausted
.try_acquire()
.expect("exhausted identity releases lease");
successor.release();
}
agent.close().await.unwrap();
}
#[tokio::test]
async fn successor_with_a_different_hook_roster_keeps_staged_session_state() {
let session = Session::new("state-continuity".to_owned(), None);
let key = session_state::Key::new();
let first_order = Arc::new(Mutex::new(Vec::new()));
let first = agent(vec![prepare_registration(
"first",
&key,
&Token::new(),
false,
false,
&first_order,
)]);
let owner = first
.admit_start(session.clone(), Vec::new(), Token::new())
.unwrap();
assert_eq!(session.state().load(&key), Some(PreparedState("first")));
drop_and_verify_reusable(owner, &first).await;
let second_order = Arc::new(Mutex::new(Vec::new()));
let second = agent(vec![prepare_registration(
"second",
&key,
&Token::new(),
false,
false,
&second_order,
)]);
let owner = second
.admit_start(session.clone(), Vec::new(), Token::new())
.unwrap();
assert_eq!(session.state().load(&key), Some(PreparedState("second")));
assert_eq!(*first_order.lock().unwrap(), ["first"]);
assert_eq!(*second_order.lock().unwrap(), ["second"]);
drop_and_verify_reusable(owner, &second).await;
}
#[tokio::test]
async fn prepare_error_discards_transcript_and_state_then_releases_all_owners() {
let token = Token::new();
let key = session_state::Key::new();
let order = Arc::new(Mutex::new(Vec::new()));
let agent = agent(vec![
prepare_registration("first", &key, &token, false, false, &order),
prepare_registration("failure", &key, &token, false, true, &order),
]);
let session = Session::new("prepare-error".to_owned(), None);
let error = agent
.admit_start(session.clone(), vec![Part::text("input".into())], token)
.err()
.unwrap();
assert!(matches!(error, StartError::Prepare(_)));
assert_eq!(*order.lock().unwrap(), ["first", "failure"]);
assert!(session.transcript().snapshot().unwrap().items().is_empty());
assert!(session.state().load(&key).is_none());
let successor = session.try_acquire().unwrap();
successor.release();
agent.close().await.unwrap();
}
#[tokio::test]
async fn cancellation_and_transcript_callback_failures_map_and_roll_back() {
for reservation in [false, true] {
let token = Token::new();
let key = session_state::Key::new();
let order = Arc::new(Mutex::new(Vec::new()));
let prepare = prepare_registration("prepare", &key, &token, !reservation, false, &order);
let mut registrations = vec![prepare];
if reservation {
registrations.push(
hook::Registration::new("cancel-reservation".into()).transcript(Arc::new(
ReservationHook(ReservationBehavior::CancelDuringReserve(token.clone())),
)),
);
}
let agent = agent(registrations);
let session = Session::new(format!("cancel-{reservation}"), None);
let error = agent
.admit_start(session.clone(), Vec::new(), token)
.err()
.unwrap();
assert!(matches!(error, StartError::Cancelled));
assert!(session.transcript().snapshot().unwrap().items().is_empty());
assert!(session.state().load(&key).is_none());
let successor = session.try_acquire().unwrap();
successor.release();
agent.close().await.unwrap();
}
let token = Token::new();
let key = session_state::Key::new();
let order = Arc::new(Mutex::new(Vec::new()));
let agent = agent(vec![
prepare_registration("prepare", &key, &token, false, false, &order),
hook::Registration::new("reject-reservation".into())
.transcript(Arc::new(ReservationHook(ReservationBehavior::Fail))),
]);
let session = Session::new("reservation-error".to_owned(), None);
let error = agent
.admit_start(session.clone(), Vec::new(), token)
.err()
.unwrap();
let StartError::Prepare(failure) = error else {
panic!("reservation callback must map to StartError::Prepare");
};
assert_eq!(failure.name(), "reject-reservation");
assert!(session.transcript().snapshot().unwrap().items().is_empty());
assert!(session.state().load(&key).is_none());
let successor = session.try_acquire().unwrap();
successor.release();
agent.close().await.unwrap();
}
#[tokio::test]
async fn prepare_reservation_and_admitted_share_registration_run_state() {
let observations = Arc::new(Mutex::new(Vec::new()));
let hook = Arc::new(SharedRunStateHook {
key: run_state::Key::new(),
observations: Arc::clone(&observations),
});
let registration = hook::Registration::new("shared-run-state".into())
.run(hook.clone())
.transcript(hook.clone())
.observer(hook);
let agent = agent(vec![registration]);
let session = Session::new("shared-run-state".into(), None);
let owner = agent
.admit_start(session, Vec::new(), Token::new())
.unwrap();
assert_eq!(*observations.lock().unwrap(), ["prepare", "prepare"]);
drop_and_verify_reusable(owner, &agent).await;
}
#[tokio::test]
async fn successful_admission_is_t0_visible_and_owner_is_fully_frozen() {
let token = Token::new();
let key = session_state::Key::new();
let prepare_order = Arc::new(Mutex::new(Vec::new()));
let observer_order = Arc::new(Mutex::new(Vec::new()));
let observer = AdmissionObserver {
name: "admitted",
key: key.clone(),
panic: false,
order: Arc::clone(&observer_order),
};
let agent = agent(vec![
prepare_registration("first", &key, &token, false, false, &prepare_order),
prepare_registration("second", &key, &token, false, false, &prepare_order),
hook::Registration::new("observer".into()).observer(Arc::new(observer)),
]);
let session = Session::new("success".to_owned(), None);
let revision = agent.revision().id();
let owner = agent
.admit_start(
session.clone(),
vec![Part::text("original".into())],
token.clone(),
)
.unwrap();
assert!(owner.lease.is_admitted());
assert_eq!(owner.revision.id(), revision);
assert_eq!(owner.identity.session_id(), "success");
assert!(!owner.identity.run_id().is_empty());
assert_eq!(owner.input[0].fields().text(), "second");
assert!(!owner.cancellation.is_cancelled());
assert_eq!(*prepare_order.lock().unwrap(), ["first", "second"]);
assert_eq!(*observer_order.lock().unwrap(), ["admitted"]);
assert_eq!(session.state().load(&key).unwrap(), PreparedState("second"));
let snapshot = session.transcript().snapshot().unwrap();
assert_eq!(snapshot.items().len(), 3);
assert!(matches!(&snapshot.items()[0], Item::System(item) if item.text() == "first"));
assert!(matches!(&snapshot.items()[1], Item::System(item) if item.text() == "second"));
assert!(
matches!(&snapshot.items()[2], Item::User(item) if item.parts()[0].fields().text() == "second")
);
drop_and_verify_reusable(owner, &agent).await;
}
#[tokio::test]
async fn admitted_observer_panic_is_audited_and_does_not_skip_peer() {
let token = Token::new();
let key = session_state::Key::new();
let prepare_order = Arc::new(Mutex::new(Vec::new()));
let observer_order = Arc::new(Mutex::new(Vec::new()));
let agent = agent(vec![
prepare_registration("prepare", &key, &token, false, false, &prepare_order),
hook::Registration::new("panic".into()).observer(Arc::new(AdmissionObserver {
name: "panic",
key: key.clone(),
panic: true,
order: Arc::clone(&observer_order),
})),
hook::Registration::new("peer".into()).observer(Arc::new(AdmissionObserver {
name: "peer",
key,
panic: false,
order: Arc::clone(&observer_order),
})),
]);
let session = Session::new("observer-panic".to_owned(), None);
let owner = agent.admit_start(session, Vec::new(), token).unwrap();
assert_eq!(*observer_order.lock().unwrap(), ["panic", "peer"]);
assert_eq!(owner.fact_buffer.audit_kinds(), ["hook.observer_panic"]);
assert!(owner.fact_buffer.error_messages().is_empty());
drop_and_verify_reusable(owner, &agent).await;
}
#[tokio::test]
async fn cancellation_after_live_prepare_commit_still_returns_admitted_owner() {
let token = Token::new();
let key = session_state::Key::new();
let prepare_order = Arc::new(Mutex::new(Vec::new()));
let observer_order = Arc::new(Mutex::new(Vec::new()));
let agent = agent(vec![
prepare_registration("prepare", &key, &token, false, false, &prepare_order),
hook::Registration::new("cancel-publisher".into()).transcript(Arc::new(ReservationHook(
ReservationBehavior::CancelOnPublish(token.clone()),
))),
hook::Registration::new("observer".into()).observer(Arc::new(AdmissionObserver {
name: "observer",
key: key.clone(),
panic: false,
order: Arc::clone(&observer_order),
})),
]);
let session = Session::new("post-commit-cancel".to_owned(), None);
let owner = agent
.admit_start(session.clone(), Vec::new(), token.clone())
.unwrap();
assert!(token.is_cancelled());
assert!(owner.cancellation.is_cancelled());
assert_eq!(*observer_order.lock().unwrap(), ["observer"]);
assert_eq!(session.transcript().snapshot().unwrap().items().len(), 2);
assert_eq!(session.state().load(&key), Some(PreparedState("prepare")));
drop_and_verify_reusable(owner, &agent).await;
}
#[tokio::test]
async fn unchanged_prepare_obeys_the_final_cancel_cut_and_can_admit() {
let admitted = agent(Vec::new());
let session = Session::new("unchanged-success".to_owned(), None);
let owner = admitted
.admit_start(session, Vec::new(), Token::new())
.unwrap();
drop_and_verify_reusable(owner, &admitted).await;
let canceled = agent(Vec::new());
let session = Session::new("unchanged-cancel".to_owned(), None);
let token = Token::new();
token.cancel();
assert!(matches!(
canceled.admit_start(session.clone(), Vec::new(), token),
Err(StartError::Cancelled)
));
let successor = session.try_acquire().unwrap();
successor.release();
canceled.close().await.unwrap();
}
#[tokio::test]
async fn a_registration_that_composes_nothing_cannot_erase_the_caller_input() {
let token = Token::new();
let key = session_state::Key::new();
let order = Arc::new(Mutex::new(Vec::new()));
let chained = agent(vec![
returning_prepare_registration(
"renames",
&key,
&token,
false,
false,
PrepareReturn::Rename,
&order,
),
returning_prepare_registration(
"abstains",
&key,
&token,
false,
false,
PrepareReturn::Unchanged,
&order,
),
]);
let session = Session::new("prepare-abstains".to_owned(), None);
let owner = chained
.admit_start(
session.clone(),
vec![Part::text("caller said this".into())],
token,
)
.expect("an abstaining registration admits");
assert_eq!(*order.lock().unwrap(), ["renames", "abstains"]);
assert_eq!(owner.input.len(), 1);
assert_eq!(owner.input[0].fields().text(), "renames");
let snapshot = session.transcript().snapshot().unwrap();
let user = snapshot
.items()
.iter()
.filter_map(|item| match item {
Item::User(item) => Some(item),
_ => None,
})
.collect::<Vec<_>>();
assert_eq!(user.len(), 1);
assert_eq!(user[0].parts()[0].fields().text(), "renames");
drop_and_verify_reusable(owner, &chained).await;
let token = Token::new();
let order = Arc::new(Mutex::new(Vec::new()));
let abstaining = agent(vec![returning_prepare_registration(
"abstains",
&key,
&token,
false,
false,
PrepareReturn::Unchanged,
&order,
)]);
let session = Session::new("prepare-abstains-only".to_owned(), None);
let owner = abstaining
.admit_start(
session.clone(),
vec![Part::text("caller said this".into())],
token,
)
.expect("an abstaining registration admits");
assert_eq!(owner.input[0].fields().text(), "caller said this");
let snapshot = session.transcript().snapshot().unwrap();
assert!(
matches!(&snapshot.items()[1], Item::User(item) if item.parts()[0].fields().text() == "caller said this")
);
drop_and_verify_reusable(owner, &abstaining).await;
}
#[tokio::test]
async fn a_prepare_rewrite_to_nothing_fails_admission_closed() {
let token = Token::new();
let key = session_state::Key::new();
let order = Arc::new(Mutex::new(Vec::new()));
let agent = agent(vec![returning_prepare_registration(
"blanker",
&key,
&token,
false,
false,
PrepareReturn::Blank,
&order,
)]);
let session = Session::new("prepare-blank".to_owned(), None);
let error = agent
.admit_start(
session.clone(),
vec![Part::text("caller said this".into())],
token,
)
.err()
.expect("an empty rewrite fails closed rather than deleting the input");
assert_eq!(error.to_string(), "hook blanker prepare failed");
let StartError::Prepare(failure) = error else {
panic!("an invalid prepare decision must map to StartError::Prepare");
};
assert_eq!(failure.name(), "blanker");
assert_eq!(
failure
.error()
.source_ref()
.downcast_ref::<PrepareError>()
.copied(),
Some(PrepareError::EmptyModify)
);
assert!(session.transcript().snapshot().unwrap().items().is_empty());
assert!(session.state().load(&key).is_none());
let successor = session.try_acquire().unwrap();
successor.release();
agent.close().await.unwrap();
}
#[tokio::test]
async fn a_recorded_input_keeps_the_final_cancel_cut_on_its_own_commit() {
let agent = agent(Vec::new());
let session = Session::new("recorded-input-cancel".to_owned(), None);
let token = Token::new();
token.cancel();
let error = agent
.admit_start(
session.clone(),
vec![Part::text("caller said this".into())],
token,
)
.err()
.expect("cancellation before the input commit is still a start error");
assert!(matches!(error, StartError::Cancelled));
assert!(session.transcript().snapshot().unwrap().items().is_empty());
let successor = session.try_acquire().unwrap();
successor.release();
agent.close().await.unwrap();
}
#[tokio::test]
async fn transcript_snapshot_failures_roll_back_before_and_after_prepare() {
for after_prepare in [false, true] {
let token = Token::new();
let key = session_state::Key::new();
let order = Arc::new(Mutex::new(Vec::new()));
let registrations = if after_prepare {
vec![prepare_registration(
"prepare", &key, &token, false, false, &order,
)]
} else {
Vec::new()
};
let agent = agent(registrations);
agent.install_start_snapshot_results(if after_prepare {
vec![None, Some(store::Error::Poisoned)]
} else {
vec![Some(store::Error::Poisoned)]
});
let session = Session::new(format!("snapshot-error-{after_prepare}"), None);
let error = agent
.admit_start(session.clone(), Vec::new(), token)
.err()
.unwrap();
assert!(matches!(
error,
StartError::Transcript(store::Error::Poisoned)
));
assert!(session.transcript().snapshot().unwrap().items().is_empty());
assert!(session.state().load(&key).is_none());
let successor = session.try_acquire().unwrap();
successor.release();
agent.close().await.unwrap();
}
}
#[test]
fn admission_fact_sink_and_internal_error_mappers_cover_closed_shapes() {
use super::hook::{BufferedFact, FactBuffer};
let emitter = FactBuffer::default();
emitter.emit_audit(audit::Event::new("first".into(), None));
emitter.emit_error(Arc::new(HookFailure("admission error")));
emitter.emit_audit(audit::Event::new("third".into(), None));
assert_eq!(emitter.audit_kinds(), ["first", "third"]);
assert_eq!(emitter.error_messages(), ["admission error"]);
let facts = emitter.take_facts();
assert_eq!(facts.len(), 3);
assert!(matches!(&facts[0], BufferedFact::Audit(event) if event.kind() == "first"));
assert!(
matches!(&facts[1], BufferedFact::Error(error) if error.to_string() == "admission error")
);
assert!(matches!(&facts[2], BufferedFact::Audit(event) if event.kind() == "third"));
assert!(emitter.take_facts().is_empty());
assert!(emitter.audit_kinds().is_empty());
assert!(emitter.error_messages().is_empty());
let poisoned = super::agent::start::map_snapshot::<()>(Err(store::Error::Poisoned))
.err()
.unwrap();
assert!(matches!(
poisoned,
StartError::Transcript(store::Error::Poisoned)
));
let transcript = super::agent::start::map_controller(ControllerError::Lease(
LeaseError::Transcript(store::Error::Poisoned),
));
assert!(matches!(
transcript,
StartError::Transcript(store::Error::Poisoned)
));
let released =
super::agent::start::map_controller(ControllerError::Lease(LeaseError::Released));
assert!(matches!(
released,
StartError::Admission(LeaseError::Released)
));
let overflow = super::agent::start::map_controller(ControllerError::InvalidTransition {
previous: Version::MAX,
delta: 1,
});
assert!(matches!(
overflow,
StartError::Transcript(store::Error::VersionOverflow {
current: Version::MAX,
delta: 1
})
));
}
#[tokio::test]
async fn a_refused_reservation_on_the_input_append_fails_admission_closed() {
let agent = agent(vec![
hook::Registration::new("reject-input-append".into())
.transcript(Arc::new(ReservationHook(ReservationBehavior::Fail))),
]);
let session = Session::new("input-append-error".to_owned(), None);
let error = agent
.admit_start(
session.clone(),
vec![Part::text("recorded".into())],
Token::new(),
)
.err()
.expect("the refused reservation fails admission");
let StartError::Prepare(failure) = error else {
panic!("a reservation callback must map to StartError::Prepare");
};
assert_eq!(failure.name(), "reject-input-append");
assert!(session.transcript().snapshot().unwrap().items().is_empty());
let successor = session.try_acquire().unwrap();
successor.release();
agent.close().await.unwrap();
}