Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

8.1 KB
Raw Blame
use super::*;
use serde_json::json;

#[test]
fn tool_media_pixels_are_omitted_without_changing_the_public_result() {
    let result = json!({"revision":"scene-1","modelMedia":[{"type":"image","mediaType":"image/png","data":"never-record-these-pixels"}]});
    let (captured, omitted) = bounded_json_string(&result, &Limits::default());
    assert!(omitted);
    assert!(!captured.contains("never-record-these-pixels"));
    assert!(captured.contains("image/png"));
    assert!(captured.contains("encodedBytes"));
    assert_eq!(result["modelMedia"][0]["data"], "never-record-these-pixels");
}

#[test]
fn truncate_chars_borrows_when_within_budget() {
    assert!(matches!(truncate_chars("hello", 5), Cow::Borrowed("hello")));
    assert!(matches!(truncate_chars("", 0), Cow::Borrowed("")));
}

#[test]
fn truncate_chars_cuts_on_char_boundaries_and_marks_the_cut() {
    // Multi-byte characters: the byte length exceeds the budget but the char
    // count does not, so nothing is cut.
    assert!(matches!(truncate_chars("héllo", 5), Cow::Borrowed("héllo")));
    assert_eq!(
        truncate_chars("héllo wörld", 5),
        "héllo…[truncated 6 chars]"
    );
}

#[test]
fn policy_parses_the_standard_switch() {
    assert!(ContentPolicy::parse(None).capture);
    assert!(ContentPolicy::parse(Some("true")).capture);
    assert!(ContentPolicy::parse(Some("anything")).capture);
    for off in ["false", "FALSE", " 0 ", "no", "Off"] {
        assert!(
            !ContentPolicy::parse(Some(off)).capture,
            "{off:?} should disable capture"
        );
    }
    assert_eq!(ContentPolicy::parse(None).limits, Limits::default());
}

#[test]
fn bounded_json_string_cuts_leaves_then_the_whole_value() {
    let limits = Limits {
        max_part_chars: 4,
        max_attribute_bytes: 1_000,
    };
    let (json, cut) = bounded_json_string(&json!({"a": "abcdefgh", "n": 1}), &limits);
    assert!(cut);
    assert_eq!(json, r#"{"a":"abcd…[truncated 4 chars]","n":1}"#);

    let (json, cut) = bounded_json_string(&json!({"a": "ab"}), &limits);
    assert!(!cut);
    assert_eq!(json, r#"{"a":"ab"}"#);

    // A bare string is recorded unquoted.
    let (json, cut) = bounded_json_string(&json!("plain"), &limits);
    assert!(cut);
    assert_eq!(json, "plai…[truncated 1 chars]");

    let tight = Limits {
        max_part_chars: 1_000,
        max_attribute_bytes: 10,
    };
    let (json, cut) = bounded_json_string(&json!({"key": "value"}), &tight);
    assert!(cut);
    assert!(json.starts_with(r#"{"key"#), "{json}");
    assert!(json.ends_with("bytes]"), "{json}");
}

fn message(role: &str, text: &str) -> serde_json::Value {
    json!({"role": role, "parts": [{"type": "text", "content": text}]})
}

#[test]
fn bound_messages_keeps_everything_within_budget() {
    let bounded = bound_messages(
        vec![message("user", "hi"), message("assistant", "hello")],
        &Limits::default(),
    );
    assert_eq!(bounded.omitted, 0);
    assert!(!bounded.truncated);
    let parsed: Vec<serde_json::Value> = serde_json::from_str(&bounded.json).unwrap();
    assert_eq!(parsed.len(), 2);
}

#[test]
fn bound_messages_drops_the_oldest_messages_first_and_never_the_last() {
    let messages = vec![
        message("user", "first"),
        message("assistant", "second"),
        message("user", "third"),
    ];
    let one_message_budget = serde_json::to_string(&vec![message("user", "third")])
        .unwrap()
        .len();
    let limits = Limits {
        max_part_chars: 1_000,
        max_attribute_bytes: one_message_budget,
    };
    let bounded = bound_messages(messages, &limits);
    assert_eq!(bounded.omitted, 2);
    assert!(bounded.truncated);
    let parsed: Vec<serde_json::Value> = serde_json::from_str(&bounded.json).unwrap();
    assert_eq!(parsed, vec![message("user", "third")]);
}

#[test]
fn bound_messages_cuts_long_parts() {
    let limits = Limits {
        max_part_chars: 3,
        max_attribute_bytes: 10_000,
    };
    let bounded = bound_messages(vec![message("user", "abcdef")], &limits);
    assert_eq!(bounded.omitted, 0);
    assert!(bounded.truncated);
    let parsed: Vec<serde_json::Value> = serde_json::from_str(&bounded.json).unwrap();
    assert_eq!(parsed[0]["parts"][0]["content"], "abc…[truncated 3 chars]");
}

fn definition(name: &str) -> serde_json::Value {
    json!({
        "type": "function",
        "name": name,
        "description": format!("does {name}"),
        "parameters": {"type": "object", "properties": {"q": {"type": "string", "description": "a long schema description"}}}
    })
}

#[test]
fn bound_tool_definitions_keeps_schemas_within_budget() {
    let (json, cut) =
        bound_tool_definitions(vec![definition("a"), definition("b")], &Limits::default());
    assert!(!cut);
    let parsed: Vec<serde_json::Value> = serde_json::from_str(&json).unwrap();
    assert!(parsed.iter().all(|d| d.get("parameters").is_some()));
}

#[test]
fn bound_tool_definitions_drops_parameters_before_names_and_descriptions() {
    let full = serde_json::to_string(&vec![definition("a"), definition("b")]).unwrap();
    let limits = Limits {
        max_part_chars: 1_000,
        max_attribute_bytes: full.len() - 1,
    };
    let (json, cut) = bound_tool_definitions(vec![definition("a"), definition("b")], &limits);
    assert!(cut);
    let parsed: Vec<serde_json::Value> = serde_json::from_str(&json).unwrap();
    assert_eq!(parsed.len(), 2);
    assert!(parsed.iter().all(|d| d.get("parameters").is_none()));
    assert_eq!(parsed[0]["name"], "a");
    assert_eq!(parsed[0]["description"], "does a");
}

#[test]
fn truncate_bytes_respects_the_byte_budget_on_char_boundaries() {
    assert!(matches!(truncate_bytes("héllo", 6), Cow::Borrowed("héllo")));
    let emoji = "😀".repeat(1_000);
    let cut = truncate_bytes(&emoji, 200);
    assert!(cut.len() <= 200, "{} bytes", cut.len());
    assert!(cut.starts_with("😀"), "cut on a character boundary");
    assert!(cut.contains("…[truncated"), "{cut}");
}

#[test]
fn bounded_json_string_enforces_bytes_not_chars() {
    let limits = Limits {
        max_part_chars: 100_000,
        max_attribute_bytes: 500,
    };
    let (json, cut) = bounded_json_string(&json!("😀".repeat(1_000)), &limits);
    assert!(cut);
    assert!(json.len() <= 500, "{} bytes", json.len());
}

#[test]
fn an_oversized_last_message_is_shrunk_into_valid_json() {
    let limits = Limits {
        max_part_chars: 100_000,
        max_attribute_bytes: 300,
    };
    let big = json!({
        "role": "user",
        "parts": [
            {"type": "text", "content": "a".repeat(400)},
            {"type": "text", "content": "b".repeat(400)},
        ]
    });
    let bounded = bound_messages(vec![message("assistant", "earlier"), big], &limits);
    assert!(bounded.truncated);
    assert_eq!(bounded.omitted, 1);
    assert!(bounded.json.len() <= 300, "{} bytes", bounded.json.len());
    let parsed: Vec<serde_json::Value> =
        serde_json::from_str(&bounded.json).expect("valid JSON: {bounded.json}");
    assert_eq!(parsed.len(), 1);
    assert_eq!(parsed[0]["role"], "user");

    // Even a budget too small for any of its content leaves a note behind.
    let bounded = bound_messages(
        vec![message("user", &"x".repeat(1_000))],
        &Limits {
            max_part_chars: 100_000,
            max_attribute_bytes: 60,
        },
    );
    let parsed: Vec<serde_json::Value> = serde_json::from_str(&bounded.json).expect("valid JSON");
    assert!(
        parsed[0]["parts"][0]["content"]
            .as_str()
            .is_some_and(|content| content.starts_with("[content omitted")),
        "{}",
        bounded.json
    );
}

#[test]
fn an_overlong_tool_list_drops_definitions_but_stays_valid_json() {
    let definitions: Vec<_> = (0..50).map(|i| definition(&format!("tool_{i}"))).collect();
    let limits = Limits {
        max_part_chars: 1_000,
        max_attribute_bytes: 600,
    };
    let (json, cut) = bound_tool_definitions(definitions, &limits);
    assert!(cut);
    assert!(json.len() <= 600, "{} bytes", json.len());
    let parsed: Vec<serde_json::Value> = serde_json::from_str(&json).expect("valid JSON");
    assert!(!parsed.is_empty());
    assert_eq!(parsed[0]["name"], "tool_0");
}