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