repositories / smith
smith
There are many coding harnesses - but this one is fast
owned by admin
smith-core/src/tools/commit_tests.rs
Raw//! SMH-SPEC-SPEC0001: atomic completion acknowledgement and dispatch poisoning.
use super::*;
use crate::frame::Frame;
use crate::session::{EntryContent, EntryKind};
use smith::message::{Message, Role};
struct PrimitiveDispatcher;
impl ToolDispatcher for PrimitiveDispatcher {
fn begin_provider_round(&mut self) -> Result<ToolDispatcherSnapshot> {
test_tool_snapshot()
}
fn invoke(
&mut self,
name: &str,
input: &ToolArguments,
effects: &mut ToolEffectContext<'_>,
) -> Result<String> {
effects.invoke(name, input)
}
}
#[test]
fn atomic_completion_recording_failure_keeps_intent_without_adopting_partial_results() {
let dir = std::env::temp_dir().join(format!(
"smith-atomic-completion-failure-{}",
std::process::id()
));
std::fs::create_dir_all(&dir).unwrap();
let mut tools = ToolSession::new(&dir);
tools.set_dispatcher(Box::new(PrimitiveDispatcher));
tools.begin_provider_round().unwrap();
let input = tools
.session
.append(EntryContentRef::Message(&Message::with_text(
Role::User,
"write",
)))
.unwrap()
.id;
let commits = Arc::new(AtomicUsize::new(0));
let observed = Arc::clone(&commits);
let mut tools = tools.with_completion_boundary(input, move |frame| {
if matches!(frame, Frame::NestedCommit { .. }) {
return Ok(());
}
let Frame::Commit {
checkpoint,
entries,
} = frame
else {
panic!("expected completion")
};
assert_eq!(checkpoint.submission_id, input);
assert_eq!(entries.len(), 3);
observed.fetch_add(1, Ordering::Relaxed);
Err(tool_error(
smith::error::ToolCode::Validation,
"injected completion recording failure",
))
});
let arguments = ToolArguments::from_serializable(
&serde_json::json!({"path":"written.txt","content":"once"}),
)
.unwrap();
let call_id = ToolCallId::new();
let error = tools
.invoke_local(call_id, "write", &arguments, &arguments, str::to_string)
.unwrap_err();
assert!(matches!(
error,
SmithError::RecordFailed {
mutation_state: MutationState::Applied,
..
}
));
assert_eq!(
std::fs::read_to_string(dir.join("written.txt")).unwrap(),
"once"
);
assert_eq!(commits.load(Ordering::Relaxed), 1);
assert_eq!(tools.session.active_branch().entries().len(), 4);
assert!(matches!(
tools.session.active_branch().entries()[1].kind,
EntryKind::ToolCall { .. }
));
assert_eq!(
tools.session.mutation_state(call_id).unwrap(),
MutationState::Unknown
);
assert!(
tools
.invoke_local(
ToolCallId::new(),
"write",
&arguments,
&arguments,
str::to_string
)
.is_err()
);
assert_eq!(commits.load(Ordering::Relaxed), 1);
assert_eq!(tools.session.active_branch().entries().len(), 4);
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn admitted_call_without_dispatcher_rejects_before_intent_or_filesystem_effect() {
let dir = std::env::temp_dir().join(format!(
"smith-atomic-no-dispatcher-{}",
smith::id::SessionId::new()
));
std::fs::create_dir_all(&dir).unwrap();
let mut tools = ToolSession::new(&dir);
let root = tools
.session
.append(EntryContentRef::Message(&Message::with_text(
Role::User,
"write",
)))
.unwrap()
.id;
let mut tools = tools.with_completion_boundary(root, |_| Ok(()));
let arguments =
ToolArguments::from_serializable(&serde_json::json!({"path":"never.txt","content":"bad"}))
.unwrap();
assert!(
tools
.invoke_local(
ToolCallId::new(),
"write",
&arguments,
&arguments,
str::to_string,
)
.is_err()
);
assert_eq!(tools.session.active_branch().entries().len(), 1);
assert!(!dir.join("never.txt").exists());
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn admitted_call_identity_is_validated_before_filesystem_dispatch() {
let dir = std::env::temp_dir().join(format!(
"smith-atomic-call-validation-{}",
std::process::id()
));
std::fs::create_dir_all(&dir).unwrap();
let mut tools = ToolSession::new(&dir);
tools.set_dispatcher(Box::new(PrimitiveDispatcher));
tools.begin_provider_round().unwrap();
let root = tools
.session
.append(EntryContentRef::Message(&Message::with_text(
Role::User,
"write",
)))
.unwrap()
.id;
let mut tools = tools.with_completion_boundary(root, |_| Ok(()));
let arguments =
ToolArguments::from_serializable(&serde_json::json!({"path":"never.txt","content":"bad"}))
.unwrap();
assert!(
tools
.invoke_local(
ToolCallId::from_u128(0),
"write",
&arguments,
&arguments,
str::to_string
)
.is_err()
);
assert!(!dir.join("never.txt").exists());
let call_id = ToolCallId::new();
let first =
ToolArguments::from_serializable(&serde_json::json!({"path":"once.txt","content":"once"}))
.unwrap();
tools
.invoke_local(call_id, "write", &first, &first, str::to_string)
.unwrap();
assert!(
tools
.invoke_local(call_id, "write", &arguments, &arguments, str::to_string)
.is_err()
);
assert!(!dir.join("never.txt").exists());
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn admitted_context_rejects_uncheckpointed_nested_effects_before_dispatch() {
let dir = std::env::temp_dir().join(format!(
"smith-atomic-nested-rejection-{}",
std::process::id()
));
std::fs::create_dir_all(&dir).unwrap();
let mut tools =
ToolSession::new(&dir).with_completion_boundary(smith::id::EntryId::new(), |_| Ok(()));
let mut effects = ToolEffectContext::for_operation(&mut tools, "write");
let log = smith::http::PluginLogRecord {
plugin_id: "fixture".into(),
level: "info".into(),
message: "not executed".into(),
};
assert!(
effects
.record_plugin_log(&log)
.unwrap_err()
.to_string()
.contains("requires an outer call")
);
let first =
ToolArguments::from_serializable(&serde_json::json!({"path":"first.txt","content":"once"}))
.unwrap();
let second = ToolArguments::from_serializable(
&serde_json::json!({"path":"second.txt","content":"never"}),
)
.unwrap();
assert!(effects.invoke("write", &first).is_err());
assert!(
effects
.invoke("write", &second)
.unwrap_err()
.to_string()
.contains("requires an outer call")
);
assert_eq!(effects.mutation_state, MutationState::NotApplied);
assert!(!dir.join("first.txt").exists());
assert!(!dir.join("second.txt").exists());
#[cfg(target_arch = "x86_64")]
assert_eq!(std::mem::size_of::<CompletionBoundary>(), 32);
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn atomic_completion_adopts_exactly_one_paired_conversation_result_after_acknowledgement() {
let mut tools = ToolSession::new(std::env::temp_dir());
tools.set_dispatcher(Box::new(PrimitiveDispatcher));
tools.begin_provider_round().unwrap();
let input = tools
.session
.append(EntryContentRef::Message(&Message::with_text(
Role::User,
"read",
)))
.unwrap()
.id;
let mut tools = tools.with_completion_boundary(input, |frame| {
assert!(matches!(
frame,
Frame::Commit { .. } | Frame::NestedCommit { .. }
));
Ok(())
});
let arguments = ToolArguments::from_serializable(
&serde_json::json!({"path":"certainly-missing-smith-atomic-file"}),
)
.unwrap();
let call_id = ToolCallId::new();
let outcome = tools
.invoke_local(call_id, "read", &arguments, &arguments, str::to_string)
.unwrap();
assert!(!outcome.ok);
assert_eq!(tools.session.active_branch().entries().len(), 7);
let results: Vec<_> = tools
.session
.active_branch()
.entries()
.iter()
.filter_map(|entry| match tools.session.content(entry).unwrap() {
EntryContent::Message(message) if message.role == Role::Tool => Some(message),
_ => None,
})
.collect();
assert_eq!(results.len(), 1);
assert_eq!(results[0].blocks.len(), 1);
}