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