repositories / smith
smith
There are many coding harnesses - but this one is fast
owned by admin
smith-harness/src/durable/tests.rs
Raw//! SMH-SPEC-SPEC0001: durable control remains live independently of execution.
use super::*;
use smith::stream::StopReason;
use smith::tool::CancelHandle;
use smith_core::agent::Agent;
use smith_core::frame::Frame;
use smith_core::store::WorkStatus;
use smith_core::tools::ToolSession;
use std::sync::mpsc;
use std::time::Duration;
const DEADLINE: Duration = Duration::from_secs(10);
fn config() -> RuntimeConfig {
let directory = std::env::temp_dir().join(format!(
"smith-durable-control-{}",
smith::id::SessionId::new()
));
std::fs::create_dir(&directory).unwrap();
RuntimeConfig::mock(&directory, vec![crate::mock_text_reply("answer")])
}
#[test]
fn backend_retry_inspection_and_busy_never_execute_twice() {
let config = config();
let path = config.session_path.clone();
let (control, mut executor) = writer_backend(config).unwrap();
let admission = control.admit("first", Some("key")).unwrap();
let id = admission.work.receipt.submission_id;
assert!(admission.is_new);
assert_eq!(
control.admit("first", Some("key")).unwrap().work,
admission.work
);
assert!(control.admit("busy", None).is_err());
assert!(
control.abort(Some(id)).is_err(),
"queued withdrawal is unsupported"
);
assert_eq!(executor.execute(id, &mut |_| {}).unwrap().text, "answer");
let retry = control.admit("first", Some("key")).unwrap();
assert!(!retry.is_new);
assert_eq!(
retry.work.status,
WorkStatus::Terminal(Some(StopReason::EndTurn))
);
assert!(executor.execute(id, &mut |_| {}).is_err());
assert_eq!(control.inspect(id).unwrap(), Some(retry.work));
drop((executor, control));
let reader = SessionReader::open(&path).unwrap();
let mut admissions = 0;
reader
.scan(Config::default_valid().frame_bytes_max, |frame| {
if matches!(frame, Frame::Admission { .. }) {
admissions += 1;
}
Ok(())
})
.unwrap();
assert_eq!(
admissions, 1,
"BUSY and retry must not create another admission"
);
}
#[test]
fn read_only_missing_and_existing_sessions_never_mutate_or_prepare_provider() {
let config = config();
let missing = config.session_path.with_file_name("missing.smh");
assert!(ReadOnlyControl::open(&missing).is_err());
assert!(!missing.exists());
let (control, executor) = writer_backend(config.clone()).unwrap();
let id = control
.admit("pending", None)
.unwrap()
.work
.receipt
.submission_id;
drop((control, executor));
let before = std::fs::read(&config.session_path).unwrap();
let reader = ReadOnlyControl::open(&config.session_path).unwrap();
assert_eq!(reader.access_mode(), AccessMode::ReadOnly);
assert_eq!(
reader.inspect(id).unwrap().unwrap().status,
WorkStatus::Queued
);
assert!(reader.admit("forbidden", None).is_err());
assert!(reader.abort(Some(id)).is_err());
assert_eq!(std::fs::read(&config.session_path).unwrap(), before);
let (control, _executor) = writer_backend(config).unwrap();
assert!(control.admit("blocked after reopen", None).is_err());
assert_eq!(
control.inspect(id).unwrap().unwrap().status,
WorkStatus::Queued
);
}
#[test]
fn pre_registration_abort_is_durable_before_signal_and_observed_on_binding() {
let (control, _executor) = writer_backend(config()).unwrap();
let id = control
.admit("input", None)
.unwrap()
.work
.receipt
.submission_id;
control.storage.claim(id).unwrap();
let storage = Arc::clone(&control.storage);
let (ready_tx, ready) = mpsc::sync_channel(1);
let (release, release_rx) = mpsc::sync_channel(1);
let (done_tx, done) = mpsc::sync_channel(1);
let thread = std::thread::spawn(move || {
let cancel = CancelHandle::new();
ready_tx.send(()).unwrap();
release_rx.recv_timeout(DEADLINE).unwrap();
storage.register_cancel(id, cancel.clone()).unwrap();
assert!(cancel.is_cancelled());
storage.unregister_cancel(id).unwrap();
done_tx.send(()).unwrap();
});
ready.recv_timeout(DEADLINE).unwrap();
assert!(
control.abort(None).is_err(),
"no implicit recovery-root resolution"
);
assert_eq!(control.abort(Some(id)).unwrap(), id);
assert!(control.inspect(id).unwrap().unwrap().cancel_requested);
assert!(control.abort(Some(id)).is_err());
release.send(()).unwrap();
done.recv_timeout(DEADLINE).unwrap();
thread.join().unwrap();
assert_eq!(
control.inspect(id).unwrap().unwrap().status,
WorkStatus::Running
);
}
#[test]
fn acknowledged_cancel_wins_late_success_without_publishing_assistant() {
let config = config();
let path = config.session_path.clone();
let (control, _executor) = writer_backend(config.clone()).unwrap();
let id = control
.admit("input", None)
.unwrap()
.work
.receipt
.submission_id;
let session = control.storage.claim(id).unwrap();
let storage = Arc::clone(&control.storage);
let (at_settlement_tx, at_settlement) = mpsc::sync_channel(1);
let (release, release_rx) = mpsc::sync_channel(1);
let (done_tx, done) = mpsc::sync_channel(1);
let thread = std::thread::spawn(move || {
let tools = ToolSession::with_persist(config.workdir, session, |_, _| Ok(()));
let mut agent = Agent::new(
crate::mock_stream(vec![crate::mock_text_reply("unstored answer")]),
tools,
"mock",
);
storage.register_cancel(id, agent.cancel_handle()).unwrap();
let result = agent.run_admitted_controlled(
id,
|command| {
if matches!(
command,
Frame::Settlement {
reason: Some(StopReason::EndTurn),
..
}
) {
at_settlement_tx.send(()).unwrap();
release_rx.recv_timeout(DEADLINE).unwrap();
}
storage.settle_execution(command)
},
&mut |_| {},
);
storage.unregister_cancel(id).unwrap();
let outcome = result.unwrap();
assert_eq!(outcome.reason, StopReason::Abort);
assert_eq!(outcome.text, "unstored answer");
assert_eq!(agent.session().active_branch().entries().len(), 1);
done_tx.send(()).unwrap();
});
at_settlement.recv_timeout(DEADLINE).unwrap();
assert_eq!(control.abort(None).unwrap(), id);
release.send(()).unwrap();
done.recv_timeout(DEADLINE).unwrap();
thread.join().unwrap();
assert_eq!(
control.inspect(id).unwrap().unwrap().status,
WorkStatus::Terminal(Some(StopReason::Abort))
);
assert!(control.abort(Some(id)).is_err());
assert!(control.abort(None).is_err());
let reader = SessionReader::open(&path).unwrap();
reader
.scan(Config::default_valid().frame_bytes_max, |frame| {
if let Frame::Settlement { reason, output, .. } = frame {
assert_eq!(reason, Some(StopReason::Abort));
assert!(
output.is_none(),
"rejected success must not acknowledge assistant output"
);
}
Ok(())
})
.unwrap();
// Stale unregister and abort cannot target a newer root.
let next = control
.admit("next", None)
.unwrap()
.work
.receipt
.submission_id;
control.storage.claim(next).unwrap();
let next_cancel = CancelHandle::new();
control
.storage
.register_cancel(next, next_cancel.clone())
.unwrap();
control.storage.unregister_cancel(id).unwrap();
assert!(control.abort(Some(id)).is_err());
assert!(!next_cancel.is_cancelled());
assert_eq!(control.abort(None).unwrap(), next);
assert!(next_cancel.is_cancelled());
}