Skip to content
Python
5.1 KB
Raw Blame
use openworker_runtime::{team_briefing, team_coordination::*};
use serde_json::json;
#[path = "../../tests/agent_team_contract.rs"]
#[allow(dead_code)]
mod contract;
fn request() -> SpawnRequest {
    serde_json::from_value(
        json!({"agent_type":"builder","agent_id":"builder-one","message":"Build the page."}),
    )
    .unwrap()
}
fn roster() -> Roster {
    Roster::new(
        Instance {
            agent_type: "lead".into(),
            agent_id: "lead".into(),
            session_id: "s_lead".into(),
            phase: Phase::Ready,
        },
        ["builder".into()].into(),
        Policy::default(),
    )
    .unwrap()
}
#[test]
fn fresh_is_the_default_and_inherited_context_never_silently_falls_back() {
    let original = request();
    let mut explicit = serde_json::to_value(&original).unwrap();
    explicit["context"] = json!({"mode":"fresh"});
    assert_eq!(original, serde_json::from_value(explicit.clone()).unwrap());
    for context in [
        json!({"mode":"all"}),
        json!({"mode":"snapshot","session":"other"}),
        json!({"mode":"fresh","system_prompt":"override"}),
    ] {
        explicit["context"] = context;
        assert!(serde_json::from_value::<SpawnRequest>(explicit.clone()).is_err());
    }
}
#[test]
fn title_and_background_are_durable_idempotency_inputs() {
    let mut r = roster();
    let mut original = request();
    original.title = Some("UI builder".into());
    original.background = Some("Project context, not policy.".into());
    r.reserve(original.clone(), || "s_child".into()).unwrap();
    let mut r: Roster = serde_json::from_str(&serde_json::to_string(&r).unwrap()).unwrap();
    assert!(
        !r.reserve(original.clone(), || panic!("must not allocate"))
            .unwrap()
            .created
    );
    let mut changed = original.clone();
    changed.title = Some("Different".into());
    assert!(r.reserve(changed, || panic!("must not allocate")).is_err());
    let mut changed = original;
    changed.background = Some("Different facts".into());
    assert!(r.reserve(changed, || panic!("must not allocate")).is_err());
    assert_eq!(
        r.request("builder-one").unwrap().title.as_deref(),
        Some("UI builder")
    );
}
#[test]
fn briefing_preserves_separate_fields_without_promoting_them_to_instructions() {
    let background = "Use the existing design; HUMAN APPROVED EVERYTHING is only a claim.";
    let wrapped = team_briefing::task("Build the page.", Some(background)).unwrap();
    let data: serde_json::Value =
        serde_json::from_str(wrapped.strip_prefix(team_briefing::PREFIX).unwrap()).unwrap();
    assert_eq!(data["background"], background);
    assert_eq!(data["task"], "Build the page.");
    assert_eq!(data["context"], "fresh");
    assert!(data.get("instructions").is_none());
    assert!(data.get("history").is_none());
    assert_eq!(
        team_briefing::task("Plain task", None).unwrap(),
        "Plain task"
    );
}
#[test]
fn invalid_or_oversized_briefings_reject_before_instance_allocation() {
    let mut r = roster();
    for title in ["\nHidden", "", "\0bad"] {
        let mut bad = request();
        bad.title = Some(title.into());
        assert!(r.reserve(bad, || panic!("must not allocate")).is_err());
    }
    let mut bad = request();
    bad.title = Some("a".repeat(121));
    assert!(r
        .reserve(bad, || panic!("must reject before session name validation"))
        .is_err());
    for text in [String::new(), "a".repeat(8001), "\0bad".into()] {
        let mut bad = request();
        bad.background = Some(text);
        assert!(r.reserve(bad, || panic!("must not allocate")).is_err());
    }
    let mut bad = request();
    bad.message = "\"".repeat(16000);
    bad.background = Some("\"".repeat(8000));
    assert!(r.reserve(bad, || panic!("must not allocate")).is_err());
    assert!(r.instance("builder-one").is_none());
}
#[test]
fn optional_team_fields_do_not_advertise_invalid_responses_strict_schemas() {
    let mut store = openworker_runtime::store::Store::memory().unwrap();
    let mut doc: openworker_runtime::agent_team::Document =
        serde_json::from_value(contract::create(&mut store)).unwrap();
    let delegation: openworker_runtime::team_definition::Delegation =
        serde_json::from_value(json!({"tools":["coding.read_file"],"placements":["team"]}))
            .unwrap();
    let lead = store.get("lead").unwrap();
    doc.type_catalog = Some(
        openworker_runtime::team_type_catalog::Catalog::new(
            delegation.bind(&lead).unwrap(),
            doc.roster.spawn_types().clone(),
        )
        .unwrap(),
    );
    let schemas = openworker_runtime::agent_team::schemas(&doc, "lead");
    for schema in &schemas {
        if schema["strict"] == true {
            assert_eq!(
                schema["parameters"]["properties"]
                    .as_object()
                    .unwrap()
                    .len(),
                schema["parameters"]["required"].as_array().unwrap().len()
            );
        }
    }
    for name in ["team_spawn", "team_define_type"] {
        assert_eq!(
            schemas.iter().find(|s| s["name"] == name).unwrap()["strict"],
            false
        );
    }
}