repositories / smith
smith
There are many coding harnesses - but this one is fast
owned by admin
smith-core/tests/context_edits.rs
Raw//! SMH-SPEC-SPEC0001: Sessions, Context edits and Effective request context.
use smith::config::Config;
use smith::message::{Message, Role};
use smith_core::context::{ContextEdit, ContextReplacement};
use smith_core::session::{EntryContent, Session};
use smith_core::store::{SessionReader, create_session};
#[test]
fn durable_replace_and_omit_preserve_raw_history() {
let home = std::env::temp_dir().join(format!("smith-context-{}", smith::id::SessionId::new()));
std::fs::create_dir(&home).unwrap();
let path = home.join("context.smh");
let mut session = Session::new();
let original = Message::with_text(Role::User, "original");
let target = session
.append(&EntryContent::Message(original.clone()))
.unwrap()
.id;
let mut opened = create_session(&path, &session, Config::default_valid()).unwrap();
opened
.writer
.edit_context(&[ContextEdit {
target,
replacement: Some(ContextReplacement::Text("replacement".into())),
}])
.unwrap();
let reader = SessionReader::open(&path).unwrap();
let projected = reader
.selected_session(Config::default_valid().frame_bytes_max)
.unwrap();
let message = &projected.projected_messages().unwrap()[0];
assert_eq!(message.id, original.id);
assert_eq!(message.role, original.role);
assert_eq!(message.timestamp_ms, original.timestamp_ms);
assert_eq!(
message.blocks,
Message::with_text(Role::User, "replacement").blocks
);
assert_eq!(
projected
.content(&projected.active_branch().entries()[0])
.unwrap(),
EntryContent::Message(original)
);
opened
.writer
.edit_context(&[ContextEdit {
target,
replacement: None,
}])
.unwrap();
let projected = SessionReader::open(&path)
.unwrap()
.selected_session(Config::default_valid().frame_bytes_max)
.unwrap();
assert!(projected.projected_messages().unwrap().is_empty());
}
#[test]
fn rejected_batches_leave_file_and_projection_unchanged() {
use smith::id::{EntryId, ToolCallId};
use smith::message::ContentBlock;
use smith::structured::ToolArguments;
let home = std::env::temp_dir().join(format!(
"sce-invalid-{:x}",
smith::id::SessionId::new().as_u128()
));
std::fs::create_dir(&home).unwrap();
let path = home.join("context.smh");
let mut session = Session::new();
let root = session
.append(&EntryContent::Message(Message::with_text(
Role::User,
"root",
)))
.unwrap()
.id;
let call_id = ToolCallId::new();
let mut call = Message::new(Role::Assistant);
call.add_block(ContentBlock::tool_use(
"read",
ToolArguments::empty_object(),
call_id,
));
let call = session.append(&EntryContent::Message(call)).unwrap().id;
let mut result = Message::new(Role::Tool);
result.add_block(ContentBlock::ToolResult {
call_id,
ok: true,
output: "evidence".into(),
});
let result = session.append(&EntryContent::Message(result)).unwrap().id;
let mut opened = create_session(&path, &session, Config::default_valid()).unwrap();
let baseline = std::fs::read(&path).unwrap();
let cases = [
vec![ContextEdit {
target: call,
replacement: None,
}],
vec![ContextEdit {
target: result,
replacement: None,
}],
vec![ContextEdit {
target: call,
replacement: Some(ContextReplacement::Text("invalid schema".into())),
}],
vec![ContextEdit {
target: EntryId::new(),
replacement: None,
}],
vec![
ContextEdit {
target: root,
replacement: None
};
65
],
vec![ContextEdit {
target: root,
replacement: Some(ContextReplacement::Text("x".repeat(65536))),
}],
vec![
ContextEdit {
target: root,
replacement: None
};
2
],
vec![],
];
for batch in cases {
assert!(opened.writer.edit_context(&batch).is_err());
assert_eq!(std::fs::read(&path).unwrap(), baseline);
let projected = SessionReader::open(&path)
.unwrap()
.selected_session(Config::default_valid().frame_bytes_max)
.unwrap();
assert_eq!(
projected.projected_messages().unwrap(),
session.projected_messages().unwrap()
);
}
opened.writer.select_entry(root).unwrap();
let navigated = std::fs::read(&path).unwrap();
assert!(
opened
.writer
.edit_context(&[ContextEdit {
target: result,
replacement: None
}])
.is_err()
);
assert_eq!(std::fs::read(&path).unwrap(), navigated);
opened.writer.select_entry(result).unwrap();
opened
.writer
.edit_context(&[
ContextEdit {
target: call,
replacement: None,
},
ContextEdit {
target: result,
replacement: None,
},
])
.unwrap();
let projected = SessionReader::open(&path)
.unwrap()
.selected_session(Config::default_valid().frame_bytes_max)
.unwrap();
assert_eq!(projected.projected_messages().unwrap().len(), 1);
assert!(projected.provider_call_ids().unwrap().is_empty());
}
#[test]
fn generic_append_cannot_bypass_batch_validation() {
let mut session = Session::new();
let before = session.clone();
assert!(
session
.append(&EntryContent::ContextEdit(vec![ContextEdit {
target: smith::id::EntryId::new(),
replacement: None
}]))
.is_err()
);
assert_eq!(session, before);
}
#[test]
fn codec_rejects_unknown_required_semantics_and_trailing_bytes() {
use smith_core::context::ContextBatchView;
assert!(ContextBatchView::decode(&[1, 1, 0]).is_err());
let mut bytes = vec![2, 1, 0];
bytes.extend_from_slice(&1u128.to_le_bytes());
bytes.push(2);
assert!(ContextBatchView::decode(&bytes).is_err());
bytes[19] = 0;
assert!(ContextBatchView::decode(&bytes).is_ok());
bytes.push(0);
assert!(ContextBatchView::decode(&bytes).is_err());
}
#[cfg(unix)]
#[test]
fn readonly_session_cannot_admit_edit() {
use std::os::unix::fs::PermissionsExt;
let home = std::env::temp_dir().join(format!(
"sce-ro-{:x}",
smith::id::SessionId::new().as_u128()
));
std::fs::create_dir(&home).unwrap();
let path = home.join("context.smh");
let opened = create_session(&path, &Session::new(), Config::default_valid()).unwrap();
drop(opened);
let before = std::fs::read(&path).unwrap();
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o400)).unwrap();
assert!(smith_core::store::SessionWriter::open(&path, Config::default_valid()).is_err());
assert_eq!(std::fs::read(&path).unwrap(), before);
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).unwrap();
std::fs::remove_dir_all(home).unwrap();
}
proptest::proptest! {
#[test]
fn rejected_batch_preserves_projection(text in ".{0,128}", replacement in ".{0,128}") {
let mut session = Session::new();
let target = session.append(&EntryContent::Message(Message::with_text(Role::User, &text))).unwrap().id;
let before = session.clone();
let result = session.edit_context_with(&[ContextEdit {
target, replacement: None,
}, ContextEdit {
target: smith::id::EntryId::new(),
replacement: Some(ContextReplacement::Text(replacement)),
}], |_, _| panic!("rejected batch reached persistence"));
proptest::prop_assert!(result.is_err());
proptest::prop_assert_eq!(session, before);
}
#[test]
fn typed_edit_codec_roundtrips(text in ".{0,256}", kind in 0u8..4, identity in 1u128..) {
use smith_core::session::EntryFrame;
use smith_core::frame::{Frame, visit_frames};
let content = EntryContent::ContextEdit(vec![ContextEdit {
target: smith::id::EntryId::from_u128(identity),
replacement: match kind { 0 => None, 1 => Some(ContextReplacement::Text(text)), 2 => Some(ContextReplacement::AssistantText(text)), _ => Some(ContextReplacement::ToolResultOutput { call_id: smith::id::ToolCallId::from_u128(identity), output: text }) },
}]);
let entry = EntryFrame::new(None, &content).unwrap();
proptest::prop_assert_eq!(EntryContent::decode(&entry.content).unwrap(), content);
let frame = Frame::Known { entry };
let encoded = frame.encode(1 << 20).unwrap();
proptest::prop_assert_eq!(u16::from_le_bytes([encoded[4], encoded[5]]), smith_core::frame::KIND_CONTEXT_EDIT);
let mut decoded = None;
visit_frames(&mut encoded.as_slice(), 1 << 20, |frame| { decoded = Some(frame); false }).unwrap();
proptest::prop_assert_eq!(decoded, Some(frame));
}
}
#[cfg(target_arch = "x86_64")]
#[test]
fn edit_layout_bounds() {
assert_eq!(std::mem::size_of::<ContextEdit>(), 56);
assert_eq!(
std::mem::size_of::<smith_core::context::ContextBatchView<'_>>(),
16
);
}
#[test]
fn worker_ack_failure_preserves_projection_and_readonly_authority_rejects() {
use smith_core::tools::ToolSession;
let mut session = Session::new();
let target = session
.append(&EntryContent::Message(Message::with_text(
Role::User,
"original",
)))
.unwrap()
.id;
let before = session.clone();
let mut tools = ToolSession::with_persist(std::env::temp_dir(), session, |_, _| {
Err(smith::error::SmithError::Cancelled)
});
assert!(
tools
.edit_context(&[ContextEdit {
target,
replacement: None
}])
.is_err()
);
assert_eq!(tools.session, before);
assert!(
tools
.edit_context(&[ContextEdit {
target,
replacement: None
}])
.is_err()
);
let mut readonly = ToolSession::new(std::env::temp_dir());
let target = readonly
.session
.append(&EntryContent::Message(Message::with_text(
Role::User,
"readonly",
)))
.unwrap()
.id;
assert!(
readonly
.edit_context(&[ContextEdit {
target,
replacement: None
}])
.is_err()
);
assert_eq!(readonly.session.projected_messages().unwrap().len(), 1);
}
#[test]
fn exact_wire_bound_and_latest_edit_precedence() {
let mut session = Session::new();
let target = session
.append(&EntryContent::Message(Message::with_text(
Role::User,
"original",
)))
.unwrap()
.id;
// 3-byte header + 16-byte ID + 1-byte tag + 4-byte length.
let text = "x".repeat(smith_core::context::CONTEXT_EDIT_BYTES_MAX - 24);
let first = session
.edit_context_with(
&[ContextEdit {
target,
replacement: Some(ContextReplacement::Text(text.clone())),
}],
|_, _| Ok(()),
)
.unwrap();
assert_eq!(
session.projected_messages().unwrap()[0].blocks,
vec![smith::message::ContentBlock::Text(text)]
);
session
.edit_context_with(
&[ContextEdit {
target,
replacement: None,
}],
|_, _| Ok(()),
)
.unwrap();
assert!(session.projected_messages().unwrap().is_empty());
let before_edit = session.fork_at(target).unwrap();
assert_eq!(
before_edit.projected_messages().unwrap()[0].blocks,
vec![smith::message::ContentBlock::Text("original".into())]
);
let first_edit = session.fork_at(first).unwrap();
assert_eq!(first_edit.projected_messages().unwrap().len(), 1);
}
#[test]
fn unedited_projection_rejects_invalid_tool_pairing() {
use smith::id::ToolCallId;
use smith::message::ContentBlock;
use smith::structured::ToolArguments;
let call_id = ToolCallId::new();
let call = |role| {
let mut message = Message::new(role);
message.add_block(ContentBlock::tool_use(
"read",
ToolArguments::empty_object(),
call_id,
));
message
};
let result = |role| {
let mut message = Message::new(role);
message.add_block(ContentBlock::ToolResult {
call_id,
ok: true,
output: "result".into(),
});
message
};
for messages in [
vec![Message::with_text(Role::Tool, "missing result")],
vec![result(Role::Tool)],
vec![call(Role::User)],
vec![result(Role::User)],
vec![call(Role::Assistant)],
vec![
call(Role::Assistant),
Message::with_text(Role::User, "interruption"),
result(Role::Tool),
],
vec![
call(Role::Assistant),
result(Role::Tool),
call(Role::Assistant),
result(Role::Tool),
],
] {
let mut session = Session::new();
for message in messages {
session.append(&EntryContent::Message(message)).unwrap();
}
assert!(matches!(
session.projected_messages(),
Err(smith::SmithError::Session {
code: smith::error::SessionCode::SessionIncompleteContext,
..
})
));
}
}
#[test]
fn resulting_context_rejects_tool_role_without_result_schema() {
let mut session = Session::new();
let target = session
.append(&EntryContent::Message(Message::with_text(
Role::Tool,
"not a paired result",
)))
.unwrap()
.id;
let before = session.clone();
assert!(
session
.edit_context_with(
&[ContextEdit {
target,
replacement: Some(ContextReplacement::Text("still not a result".into())),
}],
|_, _| Ok(())
)
.is_err()
);
assert_eq!(session, before);
}
#[test]
fn unknown_required_edit_envelope_fails_both_readers() {
use smith_core::frame::{Frame, KIND_CONTEXT_EDIT, read_frames, visit_metadata_reporting};
for version in [0, 1, 3, u16::MAX] {
let bytes = Frame::Unknown {
kind: KIND_CONTEXT_EDIT,
version,
payload: vec![0; 32],
}
.encode(1 << 20)
.unwrap();
assert!(read_frames(&mut bytes.as_slice(), 1 << 20).is_err());
assert!(
visit_metadata_reporting(&mut bytes.as_slice(), 1 << 20, |_, _| Ok(()), |_| Ok(()))
.is_err()
);
}
}
#[test]
fn forged_edit_metadata_is_rejected_before_writing() {
use smith_core::frame::Frame;
use smith_core::session::{EntryFrame, EntryKind};
let home = std::env::temp_dir().join(format!("sce-forged-{}", smith::id::SessionId::new()));
std::fs::create_dir(&home).unwrap();
let path = home.join("context.smh");
let mut session = Session::new();
let target = session
.append(&EntryContent::Message(Message::with_text(
Role::User,
"raw",
)))
.unwrap()
.id;
let mut opened = create_session(&path, &session, Config::default_valid()).unwrap();
let baseline = std::fs::read(&path).unwrap();
let mut entry = EntryFrame::new(
Some(target),
&EntryContent::ContextEdit(vec![ContextEdit {
target,
replacement: None,
}]),
)
.unwrap();
entry.kind = EntryKind::Meta { compaction: true };
assert!(opened.writer.append_frame(&Frame::Known { entry }).is_err());
assert_eq!(std::fs::read(&path).unwrap(), baseline);
std::fs::remove_dir_all(home).unwrap();
}
#[test]
fn checksummed_invalid_edits_fail_selected_restore() {
use smith_core::frame::Frame;
use smith_core::session::EntryFrame;
use std::io::Write;
for case in ["unknown", "offbranch", "duplicate", "future"] {
let home =
std::env::temp_dir().join(format!("sce-restore-{}", smith::id::SessionId::new()));
std::fs::create_dir(&home).unwrap();
let path = home.join("context.smh");
let mut session = Session::new();
let root = session
.append(&EntryContent::Message(Message::with_text(
Role::User,
"root",
)))
.unwrap()
.id;
let mut opened = create_session(&path, &session, Config::default_valid()).unwrap();
let sibling = EntryFrame::new(
Some(root),
&EntryContent::Message(Message::with_text(Role::User, "sibling")),
)
.unwrap();
if case == "offbranch" {
opened
.writer
.append_frame(&Frame::Known {
entry: sibling.clone(),
})
.unwrap();
}
drop(opened);
let future = EntryFrame::new(
None,
&EntryContent::Message(Message::with_text(Role::User, "future")),
)
.unwrap();
let target = match case {
"duplicate" => root,
"offbranch" => sibling.id,
"future" => future.id,
_ => smith::id::EntryId::new(),
};
let edit = ContextEdit {
target,
replacement: Some(ContextReplacement::Text("edited".into())),
};
let entry = EntryFrame::new(
Some(root),
&EntryContent::ContextEdit(if case == "duplicate" {
vec![edit.clone(), edit]
} else {
vec![edit]
}),
)
.unwrap();
let id = entry.id;
let encoded = Frame::Known { entry }.encode(1 << 20).unwrap();
// Low-level checksummed fixture deliberately bypasses the typed writer guard.
let bytes = Frame::Unknown {
kind: smith_core::frame::KIND_CONTEXT_EDIT,
version: smith_core::frame::VERSION_CONTEXT_EDIT,
payload: encoded[16..encoded.len() - 4].to_vec(),
}
.encode(1 << 20)
.unwrap();
let mut file = std::fs::OpenOptions::new()
.append(true)
.open(&path)
.unwrap();
file.write_all(&bytes).unwrap();
if case == "future" {
let mut future = future;
future.parent = Some(id);
file.write_all(&Frame::Known { entry: future }.encode(1 << 20).unwrap())
.unwrap();
}
drop(file);
let restored =
SessionReader::open(&path).and_then(|reader| reader.selected_session(1 << 20));
assert!(restored.is_err(), "accepted {case} edit");
std::fs::remove_dir_all(home).unwrap();
}
}
#[test]
fn typed_tool_replacements_preserve_identity_schema_and_raw_evidence() {
use smith::id::ToolCallId;
use smith::message::ContentBlock;
use smith::structured::ToolArguments;
let mut session = Session::new();
let call_id = ToolCallId::new();
let mut call = Message::with_text(Role::Assistant, "raw prose");
call.add_block(ContentBlock::tool_use(
"read",
ToolArguments::empty_object(),
call_id,
));
let call_target = session
.append(&EntryContent::Message(call.clone()))
.unwrap()
.id;
let mut result = Message::new(Role::Tool);
result.add_block(ContentBlock::ToolResult {
call_id,
ok: true,
output: "raw output".into(),
});
let result_target = session
.append(&EntryContent::Message(result.clone()))
.unwrap()
.id;
let prose: ContextReplacement =
serde_json::from_value(serde_json::json!({"AssistantText": "edited prose"})).unwrap();
let output: ContextReplacement = serde_json::from_value(
serde_json::json!({"ToolResultOutput": {"call_id": call_id, "output": "edited output"}}),
)
.unwrap();
session
.edit_context_with(
&[
ContextEdit {
target: call_target,
replacement: Some(prose),
},
ContextEdit {
target: result_target,
replacement: Some(output),
},
],
|_, _| Ok(()),
)
.unwrap();
let before = session.clone();
for (target, replacement) in [
(
result_target,
ContextReplacement::ToolResultOutput {
call_id: ToolCallId::new(),
output: "retargeted".into(),
},
),
(
call_target,
ContextReplacement::ToolResultOutput {
call_id,
output: "role change".into(),
},
),
(
result_target,
ContextReplacement::AssistantText("role change".into()),
),
] {
assert!(
session
.edit_context_with(
&[ContextEdit {
target,
replacement: Some(replacement)
}],
|_, _| panic!("invalid replacement reached persistence")
)
.is_err()
);
assert_eq!(session, before);
}
let projected = session.projected_messages().unwrap();
assert_eq!(
(
projected[0].id,
projected[0].role,
projected[0].timestamp_ms
),
(call.id, call.role, call.timestamp_ms)
);
assert_eq!(projected[0].blocks[1], call.blocks[1]);
assert_eq!(
projected[0].blocks[0],
ContentBlock::Text("edited prose".into())
);
assert_eq!(
(
projected[1].id,
projected[1].role,
projected[1].timestamp_ms
),
(result.id, result.role, result.timestamp_ms)
);
assert_eq!(
projected[1].blocks[0],
ContentBlock::ToolResult {
call_id,
ok: true,
output: "edited output".into()
}
);
assert_eq!(
session
.content(&session.active_branch().entries()[0])
.unwrap(),
EntryContent::Message(call)
);
assert_eq!(
session
.content(&session.active_branch().entries()[1])
.unwrap(),
EntryContent::Message(result)
);
}
#[test]
fn tool_output_replacement_enforces_exact_encoded_byte_bound() {
use smith_core::context::CONTEXT_EDIT_BYTES_MAX;
use smith_core::session::EntryFrame;
// Header 3 + target 16 + tag 1 + call identity 16 + text length 4.
let replacement = |length| {
EntryContent::ContextEdit(vec![ContextEdit {
target: smith::id::EntryId::from_u128(1),
replacement: Some(ContextReplacement::ToolResultOutput {
call_id: smith::id::ToolCallId::from_u128(2),
output: "x".repeat(length),
}),
}])
};
let exact = replacement(CONTEXT_EDIT_BYTES_MAX - 40);
let encoded = EntryFrame::new(None, &exact).unwrap();
assert_eq!(encoded.content.len(), CONTEXT_EDIT_BYTES_MAX + 1);
assert_eq!(EntryContent::decode(&encoded.content).unwrap(), exact);
assert!(EntryFrame::new(None, &replacement(CONTEXT_EDIT_BYTES_MAX - 39)).is_err());
}
#[test]
fn file_backed_live_edits_keep_raw_schema_and_transactional_publication() {
use smith::message::ContentBlock;
let home = std::env::temp_dir().join(format!("sce-source-{}", smith::id::SessionId::new()));
std::fs::create_dir(&home).unwrap();
let path = home.join("context.smh");
let config = Config::default_valid();
let mut initial = Session::new();
let mut raw = Message::with_text(Role::Assistant, "raw prose");
raw.add_block(ContentBlock::Thinking("raw thinking".into()));
let target = initial
.append(&EntryContent::Message(raw.clone()))
.unwrap()
.id;
let mut opened = create_session(&path, &initial, config.clone()).unwrap();
opened
.writer
.edit_context(&[ContextEdit {
target,
replacement: Some(ContextReplacement::Text("first".into())),
}])
.unwrap();
let reader = SessionReader::open(&path).unwrap();
let mut session = reader.selected_session(config.frame_bytes_max).unwrap();
let old_edit = *session.active_branch().selected_entry().unwrap();
let raw_record = session.active_branch().entries()[0];
assert!(session.bytes(&raw_record).is_empty());
assert_eq!(
EntryContent::decode(&session.raw_bytes(&raw_record).unwrap()).unwrap(),
EntryContent::Message(raw.clone())
);
let next = session
.append_with(
&EntryContent::Message(Message::with_text(Role::User, "new raw")),
|entry, bytes| opened.writer.append_entry(entry, bytes),
)
.unwrap()
.id;
let edits = [
ContextEdit {
target,
replacement: Some(ContextReplacement::AssistantText("latest".into())),
},
ContextEdit {
target: next,
replacement: Some(ContextReplacement::Text("new effective".into())),
},
];
let before = session.clone();
assert!(
session
.edit_context_with(&edits, |_, _| Err(smith::error::SmithError::Cancelled))
.is_err()
);
assert_eq!(session, before);
session
.edit_context_with(&edits, |entry, bytes| {
opened.writer.append_entry(entry, bytes)
})
.unwrap();
let projected = session.projected_messages().unwrap();
assert_eq!(
projected[0].blocks,
vec![
ContentBlock::Text("latest".into()),
ContentBlock::Thinking("raw thinking".into())
]
);
assert_eq!(
projected[1].blocks,
Message::with_text(Role::User, "new effective").blocks
);
assert!(matches!(
session.content(&old_edit).unwrap(),
EntryContent::ContextEdit(_)
));
assert_eq!(
session.content(&raw_record).unwrap(),
EntryContent::Message(raw)
);
assert_eq!(
SessionReader::open(&path)
.unwrap()
.selected_session(config.frame_bytes_max)
.unwrap()
.projected_messages()
.unwrap(),
projected
);
let archived_live_edit = *session.active_branch().selected_entry().unwrap();
session
.edit_context_with(&edits, |entry, bytes| {
opened.writer.append_entry(entry, bytes)
})
.unwrap();
assert!(matches!(
session.content(&archived_live_edit).unwrap(),
EntryContent::ContextEdit(_)
));
assert_eq!(
session
.fork_at(target)
.unwrap()
.projected_messages()
.unwrap(),
initial.projected_messages().unwrap()
);
assert_eq!(
session
.fork_at(archived_live_edit.id)
.unwrap()
.projected_messages()
.unwrap(),
projected
);
drop(before);
drop(session);
drop(reader);
drop(opened);
std::fs::remove_dir_all(home).unwrap();
}