Luigit
repositories / smith

smith

There are many coding harnesses - but this one is fast

owned by admin

smith-core/src/store/commit_tests.rs

Raw
//! SMH-SPEC-SPEC0001: atomic completion reader, writer, replay, recovery.
use super::*;
use crate::frame::ToolCompletionCheckpoint;
use crate::metadata::{ToolMutationMetadata, encode};
use crate::session::{EntryContent, TOOL_MUTATION_KIND};
use smith::error::MutationState;
use smith::id::ToolCallId;
use smith::message::{ContentBlock, Message, Role};
use smith::structured::ToolArguments;

pub(super) fn setup(state: MutationState) -> (PathBuf, OpenSession, Frame) {
    let path = std::env::temp_dir().join(format!("smith-completion-{}.smh", SessionId::new()));
    let mut opened = create_session(&path, &Session::new(), Config::default_valid()).unwrap();
    let receipt = opened
        .writer
        .admit(&Message::with_text(Role::User, "write"), None, None)
        .unwrap();
    opened.writer.claim(receipt.submission_id).unwrap();
    let call_id = ToolCallId::new();
    let intent = EntryFrame::new(
        Some(receipt.submission_id),
        &EntryContent::ToolCall {
            name: "write".into(),
            input: ToolArguments::empty_object(),
            call_id,
        },
    )
    .unwrap();
    let result = EntryFrame::new(
        Some(intent.id),
        &EntryContent::ToolResult {
            call_id,
            ok: state == MutationState::Applied,
            output: "evidence".into(),
        },
    )
    .unwrap();
    let evidence = EntryFrame::new(
        Some(result.id),
        &EntryContent::Meta {
            kind: TOOL_MUTATION_KIND.into(),
            detail: encode(&ToolMutationMetadata::new(call_id, state)).unwrap(),
        },
    )
    .unwrap();
    let mut message = Message::new(Role::Tool);
    message.add_block(ContentBlock::tool_result(
        call_id,
        state == MutationState::Applied,
        "evidence",
    ));
    let conversation = EntryFrame::new(Some(evidence.id), &EntryContent::Message(message)).unwrap();
    opened
        .writer
        .append_frame(&Frame::Known { entry: intent })
        .unwrap();
    (
        path,
        opened,
        Frame::Commit {
            checkpoint: ToolCompletionCheckpoint {
                submission_id: receipt.submission_id,
                call_id,
            },
            entries: Box::new([result, evidence, conversation]),
        },
    )
}

#[test]
fn completion_validation_failure_does_not_mutate_prior_state() {
    let (path, mut opened, mut commit) = setup(MutationState::Unknown);
    let before = std::fs::read(&path).unwrap();
    let Frame::Commit { checkpoint, .. } = &mut commit else {
        unreachable!()
    };
    checkpoint.submission_id = EntryId::new();
    assert!(opened.writer.append_frame(&commit).is_err());
    assert_eq!(std::fs::read(&path).unwrap(), before);
    drop(opened);
    clear(&path);
}

#[test]
fn in_memory_completion_cannot_adopt_another_pending_input() {
    let (path, opened, commit) = setup(MutationState::Unknown);
    let reader = SessionReader::open(&path).unwrap();
    let mut frames = Vec::new();
    reader
        .scan(Config::default_valid().frame_bytes_max, |frame| {
            frames.push(frame);
            Ok(())
        })
        .unwrap();
    let Frame::Commit { checkpoint, .. } = &commit else {
        unreachable!()
    };
    let queued = EntryFrame::new(
        Some(checkpoint.submission_id),
        &EntryContent::Message(Message::with_text(Role::User, "another input")),
    )
    .unwrap();
    for frame in &mut frames {
        if let Frame::Known { entry } = frame {
            entry.parent = Some(queued.id);
        }
    }
    frames.insert(
        2,
        Frame::Admission {
            entry: queued,
            key: None,
        },
    );
    frames.push(commit);
    assert!(Session::from_frames(&frames).is_err());
    drop(reader);
    drop(opened);
    clear(&path);
}

#[test]
fn admitted_completion_members_cannot_be_flattened_through_entry_writer() {
    let (path, mut opened, commit) = setup(MutationState::Applied);
    let before = std::fs::read(&path).unwrap();
    for entry in commit.entries() {
        assert!(
            opened
                .writer
                .append_frame(&Frame::Known {
                    entry: entry.clone()
                })
                .is_err()
        );
        let record = Entry {
            id: entry.id,
            parent: entry.parent,
            timestamp_ms: entry.timestamp_ms,
            kind: entry.kind,
            content: crate::session::Span { offset: 0, len: 0 },
        };
        assert!(opened.writer.append_entry(&record, &entry.content).is_err());
    }
    assert_eq!(std::fs::read(&path).unwrap(), before);
    drop(opened);
    clear(&path);
}

#[test]
fn required_semantic_records_cannot_bypass_typed_writer_validation() {
    let (path, mut opened, commit) = setup(MutationState::Applied);
    let bytes = commit
        .encode(Config::default_valid().frame_bytes_max)
        .unwrap();
    let raw = Frame::Unknown {
        kind: crate::frame::KIND_COMMIT,
        version: 1,
        payload: bytes[crate::frame::HEADER_LEN + 4..bytes.len() - 4].to_vec(),
    };
    let before = std::fs::read(&path).unwrap();
    assert!(opened.writer.append_frame(&raw).is_err());
    assert_eq!(std::fs::read(&path).unwrap(), before);
    drop(opened);
    clear(&path);
}

pub(super) fn clear(path: &Path) {
    for path in [path.to_path_buf(), lock_path(path), readers_path(path)] {
        let _ = std::fs::remove_file(path);
    }
}

#[test]
fn completion_reopens_replays_and_repairs_as_one_semantic_change() {
    for state in [
        MutationState::NotApplied,
        MutationState::Applied,
        MutationState::Unknown,
    ] {
        let (path, mut opened, commit) = setup(state);
        let Frame::Commit {
            checkpoint,
            ref entries,
        } = commit
        else {
            unreachable!()
        };
        let expected = entries.to_vec();
        opened.writer.append_frame(&commit).unwrap();
        assert!(opened.writer.append_frame(&commit).is_err());
        drop(opened);
        let reader = SessionReader::open(&path).unwrap();
        reader
            .verify_full(Config::default_valid().frame_bytes_max)
            .unwrap();
        let session = reader
            .selected_session(Config::default_valid().frame_bytes_max)
            .unwrap();
        assert_eq!(session.mutation_state(checkpoint.call_id).unwrap(), state);
        assert_eq!(session.active_branch().entries().len(), 5);
        for entry in &expected {
            let (found, _) = reader
                .find_entry(entry.id, Config::default_valid().frame_bytes_max)
                .unwrap()
                .unwrap();
            assert_eq!(found, *entry);
        }
        let mut trace = Vec::new();
        crate::trace::replay(&reader, Config::default_valid().frame_bytes_max, |event| {
            trace.push(event);
            Ok(())
        })
        .unwrap();
        assert!(
            trace
                .iter()
                .any(|event| event.kind == crate::trace::TraceKind::ToolMutationCompleted)
        );
        assert_eq!(
            reader
                .work_status(
                    checkpoint.submission_id,
                    Config::default_valid().frame_bytes_max
                )
                .unwrap(),
            Some(WorkStatus::Running)
        );
        drop(reader);
        repair_session(&path, Config::default_valid().frame_bytes_max).unwrap();
        let reader = SessionReader::open(&path).unwrap();
        reader
            .verify_full(Config::default_valid().frame_bytes_max)
            .unwrap();
        let mut repaired = Vec::new();
        crate::trace::replay(&reader, Config::default_valid().frame_bytes_max, |event| {
            repaired.push(event);
            Ok(())
        })
        .unwrap();
        assert_eq!(trace, repaired);
        drop(reader);
        let mut reopened = open_session(&path, Config::default_valid()).unwrap();
        assert!(reopened.writer.claim(checkpoint.submission_id).is_err());
        let output = EntryFrame::new(
            Some(expected[2].id),
            &EntryContent::Message(Message::with_text(Role::Assistant, "done")),
        )
        .unwrap();
        reopened
            .writer
            .settle(
                checkpoint.submission_id,
                Some(smith::stream::StopReason::EndTurn),
                Some(output),
            )
            .unwrap();
        drop(reopened);
        let reader = SessionReader::open(&path).unwrap();
        reader
            .verify_full(Config::default_valid().frame_bytes_max)
            .unwrap();
        assert_eq!(
            reader
                .work_status(
                    checkpoint.submission_id,
                    Config::default_valid().frame_bytes_max
                )
                .unwrap(),
            Some(WorkStatus::Terminal(Some(
                smith::stream::StopReason::EndTurn
            )))
        );
        drop(reader);
        clear(&path);
    }
}

#[test]
fn torn_completion_exposes_no_member_and_cannot_reclaim_effect() {
    let (path, opened, commit) = setup(MutationState::Applied);
    let Frame::Commit { checkpoint, .. } = &commit else {
        unreachable!()
    };
    let baseline = std::fs::read(&path).unwrap();
    let bytes = commit
        .encode(Config::default_valid().frame_bytes_max)
        .unwrap();
    drop(opened);
    for length in 1..bytes.len() {
        let mut source = baseline.clone();
        source.extend_from_slice(&bytes[..length]);
        std::fs::write(&path, source).unwrap();
        let reader = SessionReader::open(&path).unwrap();
        let session = reader
            .selected_session(Config::default_valid().frame_bytes_max)
            .unwrap();
        assert_eq!(
            session.active_branch().entries().len(),
            2,
            "cut at {length}"
        );
        assert_eq!(
            session.mutation_state(checkpoint.call_id).unwrap(),
            MutationState::Unknown
        );
        for entry in commit.entries() {
            assert!(
                reader
                    .find_entry(entry.id, Config::default_valid().frame_bytes_max)
                    .unwrap()
                    .is_none()
            );
        }
        drop(reader);
    }
    let mut reopened = open_session(&path, Config::default_valid()).unwrap();
    assert!(reopened.writer.claim(checkpoint.submission_id).is_err());
    drop(reopened);
    clear(&path);
}

#[test]
fn completion_sync_failure_poisoning_preserves_recovery_required_work() {
    let (path, mut opened, commit) = setup(MutationState::Applied);
    let bytes = commit
        .encode(Config::default_valid().frame_bytes_max)
        .unwrap();
    assert!(
        opened
            .writer
            .write_step(|file| {
                file.write_all(&bytes).unwrap();
                Err(admission_fault("injected completion sync failure"))
            })
            .is_err()
    );
    assert!(opened.writer.append_frame(&commit).is_err());
    drop(opened);
    let Frame::Commit { checkpoint, .. } = commit else {
        unreachable!()
    };
    let mut reopened = open_session(&path, Config::default_valid()).unwrap();
    assert!(reopened.writer.claim(checkpoint.submission_id).is_err());
    drop(reopened);
    let reader = SessionReader::open(&path).unwrap();
    assert_eq!(
        reader
            .selected_session(Config::default_valid().frame_bytes_max)
            .unwrap()
            .mutation_state(checkpoint.call_id)
            .unwrap(),
        MutationState::Applied
    );
    drop(reader);
    clear(&path);
}