Luigit
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());
}