Luigit
repositories / smith

smith

There are many coding harnesses - but this one is fast

owned by admin

smith-core/src/store/cancel_tests.rs

Raw
//! SMH-SPEC-SPEC0001: durable work abort, recovery, writer acknowledgement.
use super::*;
use smith::message::{Message, Role};
use smith::stream::StopReason;

fn setup() -> (PathBuf, SessionWriter, EntryId) {
    let directory = std::env::temp_dir().join(format!("smith-cancel-{}", SessionId::new()));
    std::fs::create_dir(&directory).unwrap();
    let mut writer = open_session(&directory.join("session.smh"), Config::default_valid())
        .unwrap()
        .writer;
    let receipt = writer
        .admit(&Message::with_text(Role::User, "input"), None, None)
        .unwrap();
    (directory, writer, receipt.submission_id)
}

#[test]
fn cancellation_requires_running_identity_and_survives_reopen_without_settlement() {
    let (directory, mut writer, id) = setup();
    assert!(writer.request_cancel(id).is_err());
    writer.claim(id).unwrap();
    assert!(writer.request_cancel(EntryId::new()).is_err());
    writer.request_cancel(id).unwrap();
    assert!(writer.request_cancel(id).is_err());
    assert!(matches!(
        writer.settle(id, Some(StopReason::EndTurn), None),
        Err(SmithError::Cancelled)
    ));
    drop(writer);
    let mut writer = open_session(&directory.join("session.smh"), Config::default_valid())
        .unwrap()
        .writer;
    let receipt = writer.inspect_work(id).unwrap().unwrap();
    assert_eq!(receipt.status, WorkStatus::Running);
    assert!(receipt.cancel_requested);
    assert!(writer.claim(id).is_err());
    writer.settle(id, Some(StopReason::Abort), None).unwrap();
    assert!(writer.request_cancel(id).is_err());
    assert_eq!(
        writer.inspect_work(id).unwrap().unwrap().status,
        WorkStatus::Terminal(Some(StopReason::Abort))
    );
}

#[test]
fn foreground_retry_reuses_receipt_but_new_input_cannot_queue() {
    let (_directory, mut writer, _) = setup();
    assert!(writer.admit_foreground("second", None).is_err());
    // Baseline admission above is deliberately unkeyed, not a retry.
    let (directory, mut writer, id) = setup();
    writer.claim(id).unwrap();
    writer.settle(id, Some(StopReason::EndTurn), None).unwrap();
    let accepted = writer.admit_foreground("keyed", Some("key")).unwrap();
    assert!(accepted.is_new);
    let retry = writer.admit_foreground("keyed", Some("key")).unwrap();
    assert!(!retry.is_new);
    assert_eq!(accepted.work, retry.work);
    assert!(writer.admit_foreground("changed", Some("key")).is_err());
    assert!(writer.admit_foreground("new", None).is_err());
    drop(writer);
    let mut writer = open_session(&directory.join("session.smh"), Config::default_valid())
        .unwrap()
        .writer;
    assert!(writer.admit_foreground("after reopen", None).is_err());
    assert_eq!(
        writer
            .inspect_work(accepted.work.receipt.submission_id)
            .unwrap()
            .unwrap()
            .status,
        WorkStatus::Queued
    );
}

#[test]
fn poisoned_writer_cannot_acknowledge_cancel_or_inspect_uncertain_bytes() {
    let (_directory, mut writer, id) = setup();
    writer.claim(id).unwrap();
    let bytes = Frame::CancelIntent { submission_id: id }
        .encode(Config::default_valid().frame_bytes_max)
        .unwrap();
    assert!(
        writer
            .write_step(|file| {
                file.write_all(&bytes).unwrap();
                Err(admission_fault("injected cancellation sync failure"))
            })
            .is_err()
    );
    assert!(writer.request_cancel(id).is_err());
    assert!(writer.inspect_work(id).is_err());
    assert!(writer.admit_foreground("input", None).is_err());
    assert!(writer.claim(id).is_err());
    assert!(writer.settle(id, Some(StopReason::Abort), None).is_err());
}