Luigit
repositories / smith

smith

There are many coding harnesses - but this one is fast

owned by admin

plugins/protocol-openai-responses/src/tests.rs

Raw
//! Pure Responses state laws (`SMH-SPEC-PLUG0001`, `SMH-SPEC-SPEC0001`).

use super::*;
use proptest::prelude::*;
use smith_alloc::{Counting, Scope, measure};

#[global_allocator]
static ALLOCATOR: Counting = Counting;

#[test]
fn failed_responses_preserve_structured_error_code_without_untrusted_message() {
    let mut decoder = Decoder::restore(&[]).unwrap();
    let error = decoder.event(
        r#"{"type":"response.failed","response":{"error":{"code":"subscription_sharing_usage_limit_exceeded","message":"untrusted diagnostic"}}}"#,
        &mut Vec::new(),
    ).unwrap_err();
    assert!(error.contains("subscription_sharing_usage_limit_exceeded"));
    assert!(!error.contains("untrusted diagnostic"));
}

#[test]
fn completed_decode_allocation_count_is_pinned() {
    let chunk = b"data: {\"type\":\"response.completed\",\"response\":{\"status\":\"completed\",\"usage\":{\"input_tokens\":1,\"output_tokens\":1}}}\n\n".to_vec();
    let (step, cost) = measure(Scope::KernelCall, || {
        ResponsesProtocol::decode_response(Vec::new(), chunk, true)
    });
    assert!(step.is_ok());
    // One native codec call, excluding caller-owned input allocation and Wasm engine setup.
    assert_eq!(cost.allocations, 19);
}

proptest! {
    #[test]
    fn codec_state_roundtrips(
        pending in prop::collection::vec(any::<u8>(), 0..128),
        indexes in any::<u128>(),
        completed in any::<bool>(),
        refusal in any::<bool>(),
    ) {
        let original = Decoder { pending, tool_indexes:indexes, completed, refusal };
        let bytes = original.save();
        let restored = Decoder::restore(&bytes).unwrap();
        prop_assert_eq!(&original.pending, &restored.pending);
        prop_assert_eq!(original.tool_indexes, restored.tool_indexes);
        prop_assert_eq!(original.completed, restored.completed);
        prop_assert_eq!(original.refusal, restored.refusal);
        prop_assert_eq!(bytes, restored.save());
    }

    #[test]
    fn decoding_is_independent_of_chunk_partition(
        text in ".{0,32}",
        cuts in prop::collection::vec(any::<usize>(), 0..16),
    ) {
        let stream = format!("data: {}\n\ndata: {}\n\n",
            json!({"type":"response.output_text.delta", "delta":text}),
            json!({"type":"response.completed", "response":{
                "status":"completed", "usage":{"input_tokens":1, "output_tokens":1}
            }}));
        let bytes = stream.as_bytes();
        let expected = ResponsesProtocol::decode_response(Vec::new(), bytes.to_vec(), true).unwrap();
        let mut offsets: Vec<_> = cuts.iter().map(|cut| cut % (bytes.len() + 1)).collect();
        offsets.sort_unstable();
        offsets.push(bytes.len());
        let mut state = Vec::new();
        let mut events = Vec::new();
        let mut start = 0;
        for end in offsets {
            let step = ResponsesProtocol::decode_response(state, bytes[start..end].to_vec(), false).unwrap();
            state = step.state;
            events.extend(step.events);
            start = end;
        }
        let step = ResponsesProtocol::decode_response(state, Vec::new(), true).unwrap();
        events.extend(step.events);
        prop_assert_eq!(format!("{events:?}"), format!("{:?}", expected.events));
        prop_assert_eq!(step.state, expected.state);
    }
}

#[test]
#[cfg(target_arch = "x86_64")]
fn decoder_scratch_layout_is_pinned() {
    assert_eq!(std::mem::size_of::<Decoder>(), 48);
}

#[test]
fn multiline_sse_data_preserves_json_whitespace() {
    let data = sse_data(b": heartbeat\r\ndata: {\r\ndata: \"type\":\"response.created\"}\r\n\r\n")
        .unwrap();
    assert_eq!(data, "{\n\"type\":\"response.created\"}");
    let mut decoder = Decoder::restore(&[]).unwrap();
    decoder.event(&data, &mut Vec::new()).unwrap();
}

#[test]
fn invalid_state_versions_flags_and_lengths_are_rejected() {
    for length in 1..STATE_HEADER_BYTES {
        assert!(Decoder::restore(&vec![0; length]).is_err());
    }
    let mut state = vec![0; STATE_HEADER_BYTES];
    assert!(Decoder::restore(&state).is_err());
    state[0] = 1;
    state[1] = 4;
    assert!(Decoder::restore(&state).is_err());
    state[1] = 0;
    state.resize(STATE_HEADER_BYTES + FRAME_BYTES_MAX + 1, 0);
    assert!(Decoder::restore(&state).is_err());
}