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