repositories / smith
smith
There are many coding harnesses - but this one is fast
owned by admin
smith-core/src/frame/commit_tests.rs
Raw//! SMH-SPEC-SPEC0001: atomic tool completion wire boundary.
use super::*;
use crate::metadata::{ToolMutationMetadata, encode};
use crate::session::{EntryContent, TOOL_MUTATION_KIND};
use smith::error::MutationState;
use smith::message::{ContentBlock, Message};
fn completion() -> (EntryId, ToolCallId, [EntryFrame; 3]) {
let submission_id = EntryId::new();
let call_id = ToolCallId::new();
let result = EntryFrame::new(
Some(submission_id),
&EntryContent::ToolResult {
call_id,
ok: true,
output: "written".into(),
},
)
.unwrap();
let evidence = EntryFrame::new(
Some(result.id),
&EntryContent::Meta {
kind: TOOL_MUTATION_KIND.into(),
detail: encode(&ToolMutationMetadata::new(call_id, MutationState::Applied)).unwrap(),
},
)
.unwrap();
let mut message = Message::new(Role::Tool);
message.add_block(ContentBlock::tool_result(call_id, true, "written"));
let conversation = EntryFrame::new(Some(evidence.id), &EntryContent::Message(message)).unwrap();
(submission_id, call_id, [result, evidence, conversation])
}
#[test]
fn required_completion_envelope_is_one_recoverable_frame() {
let (submission_id, call_id, entries) = completion();
let bytes = raw_completion(
ToolCompletionCheckpoint {
submission_id,
call_id,
},
&entries,
);
let recovered = read_frames(&mut bytes.as_slice(), DEFAULT_MAX_FRAME_BYTES);
assert!(
recovered.is_ok(),
"completion envelope must decode atomically: {recovered:?}"
);
assert_eq!(recovered.unwrap().frames.len(), 1);
}
fn raw_completion(checkpoint: ToolCompletionCheckpoint, entries: &[EntryFrame]) -> Vec<u8> {
let mut payload = checkpoint.submission_id.as_u128().to_le_bytes().to_vec();
payload.extend_from_slice(&checkpoint.call_id.as_u128().to_le_bytes());
for entry in entries {
payload.extend(
Frame::Known {
entry: entry.clone(),
}
.encode(DEFAULT_MAX_FRAME_BYTES)
.unwrap(),
);
}
Frame::Unknown {
kind: KIND_COMMIT,
version: 1,
payload,
}
.encode(DEFAULT_MAX_FRAME_BYTES)
.unwrap()
}
#[test]
fn checksum_valid_completion_schema_errors_publish_no_member() {
let (submission_id, call_id, entries) = completion();
let checkpoint = ToolCompletionCheckpoint {
submission_id,
call_id,
};
let mut wrong_role = entries.clone();
wrong_role[2] = EntryFrame::new(
Some(entries[1].id),
&EntryContent::Message(Message::with_text(Role::User, "forged")),
)
.unwrap();
let mut wrong_pair = entries.clone();
wrong_pair[1] = EntryFrame::new(
Some(entries[0].id),
&EntryContent::Meta {
kind: TOOL_MUTATION_KIND.into(),
detail: encode(&ToolMutationMetadata::new(
ToolCallId::new(),
MutationState::Unknown,
))
.unwrap(),
},
)
.unwrap();
wrong_pair[2].parent = Some(wrong_pair[1].id);
let mut extra = entries.to_vec();
extra.push(entries[0].clone());
for invalid in [wrong_role.to_vec(), wrong_pair.to_vec(), extra] {
let bytes = raw_completion(checkpoint, &invalid);
assert!(read_frames(&mut bytes.as_slice(), DEFAULT_MAX_FRAME_BYTES).is_err());
let mut seen = 0;
assert!(
visit_metadata_reporting(
&mut bytes.as_slice(),
DEFAULT_MAX_FRAME_BYTES,
|_, _| {
seen += 1;
Ok(())
},
|_| Ok(())
)
.is_err()
);
assert_eq!(seen, 0);
}
}
#[test]
fn required_completion_above_reader_limit_fails_closed() {
let (submission_id, call_id, entries) = completion();
let frame = Frame::Commit {
checkpoint: ToolCompletionCheckpoint {
submission_id,
call_id,
},
entries: Box::new(entries),
};
let bytes = frame.encode(DEFAULT_MAX_FRAME_BYTES).unwrap();
assert!(read_frames(&mut bytes.as_slice(), 1).is_err());
}
#[test]
fn completion_rejects_invalid_members_identities_order_and_byte_limit() {
let (submission_id, call_id, entries) = completion();
let checkpoint = ToolCompletionCheckpoint {
submission_id,
call_id,
};
let valid = Frame::Commit {
checkpoint,
entries: Box::new(entries.clone()),
};
let bytes = valid.encode(DEFAULT_MAX_FRAME_BYTES).unwrap();
let payload_length = bytes.len() - HEADER_LEN - BODY_PREFIX_LEN;
assert_eq!(valid.encode(payload_length).unwrap(), bytes);
assert!(valid.encode(payload_length - 1).is_err());
for (left, right) in [(0, 1), (0, 2), (1, 2)] {
let mut invalid = entries.clone();
invalid.swap(left, right);
assert!(
Frame::Commit {
checkpoint,
entries: Box::new(invalid)
}
.encode(DEFAULT_MAX_FRAME_BYTES)
.is_err()
);
}
for index in 0..3 {
let mut invalid = entries.clone();
invalid[index].id = EntryId::from_u128(0);
assert!(
Frame::Commit {
checkpoint,
entries: Box::new(invalid)
}
.encode(DEFAULT_MAX_FRAME_BYTES)
.is_err()
);
}
let mut invalid = entries.clone();
invalid[2].content = EntryFrame::new(
None,
&EntryContent::Message(Message::with_text(Role::User, "wrong role")),
)
.unwrap()
.content;
assert!(
Frame::Commit {
checkpoint,
entries: Box::new(invalid)
}
.encode(DEFAULT_MAX_FRAME_BYTES)
.is_err()
);
let mut invalid = entries.clone();
invalid[1].parent = Some(entries[2].id);
assert!(
Frame::Commit {
checkpoint,
entries: Box::new(invalid)
}
.encode(DEFAULT_MAX_FRAME_BYTES)
.is_err()
);
let mut invalid = checkpoint;
invalid.call_id = ToolCallId::new();
assert!(
Frame::Commit {
checkpoint: invalid,
entries: Box::new(entries)
}
.encode(DEFAULT_MAX_FRAME_BYTES)
.is_err()
);
}
#[test]
fn completion_corruption_and_every_torn_prefix_publish_no_member() {
let (submission_id, call_id, entries) = completion();
let frame = Frame::Commit {
checkpoint: ToolCompletionCheckpoint {
submission_id,
call_id,
},
entries: Box::new(entries),
};
let bytes = frame.encode(DEFAULT_MAX_FRAME_BYTES).unwrap();
for length in 1..bytes.len() {
let mut seen = 0;
visit_metadata_reporting(
&mut &bytes[..length],
DEFAULT_MAX_FRAME_BYTES,
|_, _| {
seen += 1;
Ok(())
},
|_| Ok(()),
)
.unwrap();
assert_eq!(seen, 0, "torn at {length}");
}
for index in 0..bytes.len() {
let mut corrupt = bytes.clone();
corrupt[index] ^= 1;
let mut seen = 0;
let result = visit_frames_reporting(
&mut corrupt.as_slice(),
DEFAULT_MAX_FRAME_BYTES,
|_| {
seen += 1;
true
},
|_| true,
);
assert!(result.is_err(), "corrupt at {index}");
assert_eq!(seen, 0);
}
}
proptest::proptest! {
#[test]
fn completion_wire_roundtrip_preserves_typed_members(root in 1u128..=(u128::MAX - 3), call in 1u128..=u128::MAX) {
let (_, _, mut entries) = completion();
let submission_id = EntryId::from_u128(root);
let call_id = ToolCallId::from_u128(call);
// Rebuild the typed evidence rather than filtering arbitrary corrupt bytes.
let result = EntryFrame::new(Some(submission_id), &EntryContent::ToolResult {
call_id, ok: true, output: "written".into(),
}).unwrap();
entries[0] = result;
entries[0].id = EntryId::from_u128(root + 1);
entries[1] = EntryFrame::new(Some(entries[0].id), &EntryContent::Meta {
kind: TOOL_MUTATION_KIND.into(),
detail: encode(&ToolMutationMetadata::new(call_id, MutationState::Applied)).unwrap(),
}).unwrap();
entries[1].id = EntryId::from_u128(root + 2);
let mut message = Message::new(Role::Tool);
message.add_block(ContentBlock::tool_result(call_id, true, "written"));
entries[2] = EntryFrame::new(Some(entries[1].id), &EntryContent::Message(message)).unwrap();
entries[2].id = EntryId::from_u128(root + 3);
let frame = Frame::Commit { checkpoint: ToolCompletionCheckpoint { submission_id, call_id }, entries: Box::new(entries) };
let bytes = frame.encode(DEFAULT_MAX_FRAME_BYTES).unwrap();
let recovered = read_frames(&mut bytes.as_slice(), DEFAULT_MAX_FRAME_BYTES).unwrap();
proptest::prop_assert_eq!(recovered.frames, vec![frame]);
}
}