Skip to content
Python
11.6 KB
Raw Blame
use openworker_runtime::team_coordination::*;
use serde_json::json;
use std::{cell::Cell, collections::BTreeSet};
fn roster(communication: Communication) -> Roster {
    Roster::new(
        Instance {
            agent_type: "coordinator".into(),
            agent_id: "lead".into(),
            session_id: "s_lead".into(),
            phase: Phase::Ready,
        },
        BTreeSet::from(["builder".into(), "verifier".into()]),
        Policy {
            communication,
            ..Default::default()
        },
    )
    .unwrap()
}
fn request(id: &str, kind: &str) -> SpawnRequest {
    SpawnRequest {
        sandbox: None,
        source: None,
        agent_type: kind.into(),
        agent_id: id.into(),
        message: format!("Task for {id}"),
        title: None,
        background: None,
        context: Default::default(),
        workspace: Default::default(),
        model: None,
    }
}
fn add(r: &mut Roster, id: &str, kind: &str) {
    let sid = format!("s_{id}");
    r.reserve(request(id, kind), || sid.clone()).unwrap();
    r.ready(id, &sid).unwrap();
}
fn recipients(r: &Roster, author: &str, body: &str) -> Vec<String> {
    r.board_recipients(author, body)
        .unwrap()
        .into_iter()
        .map(|i| i.agent_id)
        .collect()
}
#[test]
fn twenty_workers_have_distinct_identities_and_only_explicit_mentions_deliver() {
    let mut r = roster(Default::default());
    for n in 0..10 {
        add(&mut r, &format!("builder-{n}"), "builder");
        add(&mut r, &format!("verifier-{n}"), "verifier");
    }
    assert_eq!(
        recipients(&r, "lead", "@builder-3 please build; @verifier-4 check it."),
        ["builder-3", "verifier-4"]
    );
    assert_eq!(recipients(&r, "builder-3", "@lead API ready"), ["lead"]);
    assert!(recipients(&r, "builder-3", "Build done. Ownership/status changed.").is_empty());
    assert!(r
        .board_recipients("lead", "@builder ambiguous type")
        .is_err());
}
#[test]
fn spawn_retry_after_snapshot_roundtrip_keeps_original_session_without_allocation() {
    let mut r = roster(Default::default());
    let allocated = Cell::new(0);
    let first = r
        .reserve(request("builder-ui", "builder"), || {
            allocated.set(allocated.get() + 1);
            "s_original".into()
        })
        .unwrap();
    assert!(first.created);
    r.ready("builder-ui", "s_original").unwrap();
    let snapshot = serde_json::to_string(&r).unwrap();
    let mut restored: Roster = serde_json::from_str(&snapshot).unwrap();
    let again = restored
        .reserve(request("builder-ui", "builder"), || {
            allocated.set(allocated.get() + 1);
            "s_duplicate".into()
        })
        .unwrap();
    assert!(!again.created);
    assert_eq!(again.instance.session_id, "s_original");
    assert_eq!(allocated.get(), 1);
    restored.close("builder-ui").unwrap();
    let old = restored
        .reserve(request("builder-ui", "builder"), || {
            panic!("closed identity must not respawn")
        })
        .unwrap();
    assert_eq!(old.instance.phase, Phase::Closed);
}
#[test]
fn conflicting_spawn_type_task_or_session_never_rebinds_an_identity() {
    let mut r = roster(Default::default());
    add(&mut r, "builder-ui", "builder");
    let mut changed = request("builder-ui", "builder");
    changed.message = "Different work".into();
    assert!(r
        .reserve(changed, || panic!("conflict must not allocate"))
        .is_err());
    assert!(r
        .reserve(request("builder-ui", "verifier"), || panic!(
            "conflict must not allocate"
        ))
        .is_err());
    assert!(r
        .reserve(request("other", "unknown"), || panic!(
            "unknown type must not allocate"
        ))
        .is_err());
    assert!(r
        .reserve(request("other", "builder"), || "s_builder-ui".into())
        .is_err());
    assert!(r.instance("other").is_none());
    assert!(r.ready("builder-ui", "s_different").is_err());
    assert_eq!(r.instance("builder-ui").unwrap().session_id, "s_builder-ui");
}
#[test]
fn capacity_is_configurable_and_counts_the_lead() {
    let lead = Instance {
        agent_type: "lead".into(),
        agent_id: "lead".into(),
        session_id: "s_lead".into(),
        phase: Phase::Ready,
    };
    let mut r = Roster::new(
        lead.clone(),
        BTreeSet::from(["builder".into()]),
        Policy {
            max_instances: 2,
            ..Default::default()
        },
    )
    .unwrap();
    add(&mut r, "one", "builder");
    assert!(r
        .reserve(request("two", "builder"), || panic!(
            "capacity must be checked before allocation"
        ))
        .is_err());
    assert!(Roster::new(
        lead,
        BTreeSet::from(["builder".into()]),
        Policy {
            max_instances: 0,
            ..Default::default()
        }
    )
    .is_err());
}
#[test]
fn all_is_deduplicated_excludes_sender_and_is_a_post_time_snapshot() {
    let mut r = roster(Default::default());
    add(&mut r, "builder-ui", "builder");
    add(&mut r, "verifier-ui", "verifier");
    let first = recipients(&r, "builder-ui", "@all @all @lead progress");
    assert_eq!(first, ["lead", "verifier-ui"]);
    add(&mut r, "late", "builder");
    assert!(!first.contains(&"late".into()));
    assert_eq!(
        recipients(&r, "lead", "@all"),
        ["builder-ui", "late", "verifier-ui"]
    );
    r.close("late").unwrap();
    assert_eq!(
        recipients(&r, "lead", "@all"),
        ["builder-ui", "verifier-ui"]
    );
}
#[test]
fn mention_parsing_avoids_email_code_and_escaped_tokens_but_reports_bad_targets() {
    let mut r = roster(Default::default());
    add(&mut r, "builder-ui", "builder");
    assert!(recipients(
        &r,
        "lead",
        r"Email [email protected]; `@all`; \@builder-ui."
    )
    .is_empty());
    assert!(recipients(&r, "lead", "```text\n@all\n``` @builder-ui").contains(&"builder-ui".into()));
    assert!(r.board_recipients("lead", "@missing please work").is_err());
    assert!(r.board_recipients("foreign", "@all").is_err());
    r.close("builder-ui").unwrap();
    assert!(r.board_recipients("lead", "@builder-ui").is_err());
}
#[test]
fn agent_types_and_instances_cannot_claim_the_broadcast_identifier() {
    let mut r = roster(Default::default());
    assert!(r
        .reserve(request("all", "builder"), || panic!("invalid identifier"))
        .is_err());
    assert!(r
        .reserve(request("bad id", "builder"), || panic!(
            "invalid identifier"
        ))
        .is_err());
}
#[test]
fn communication_modes_are_symmetric_and_never_reroute_direct_messages() {
    for board in [false, true] {
        for direct_messages in [false, true] {
            let mut r = roster(Communication {
                board,
                direct_messages,
            });
            add(&mut r, "worker", "builder");
            for (from, to) in [("lead", "worker"), ("worker", "lead")] {
                assert_eq!(
                    r.board_recipients(from, &format!("@{to} hello")).is_ok(),
                    board
                );
                assert_eq!(
                    r.direct_recipient(from, to, "hello").is_ok(),
                    direct_messages
                );
            }
            // Spawn reservation remains available when both conversation paths are off.
            assert!(
                r.reserve(request("next", "builder"), || "s_next".into())
                    .unwrap()
                    .created
            );
        }
    }
    assert_eq!(
        serde_json::to_value(Communication::default()).unwrap(),
        json!({"board":true,"directMessages":false})
    );
}
#[test]
fn busy_idle_waiting_and_paused_inboxes_have_explicit_delivery_decisions() {
    assert_eq!(delivery(Activity::Busy), Delivery::NextModelCall);
    assert_eq!(delivery(Activity::Idle), Delivery::Wake);
    assert_eq!(delivery(Activity::Waiting), Delivery::Wake);
    for state in [Activity::Paused, Activity::Stopped, Activity::Starting] {
        assert_eq!(delivery(state), Delivery::Retain);
    }
}
fn row(n: u64) -> BoardMessage {
    BoardMessage {
        id: format!("msg_{n}"),
        sequence: n,
        sender: "lead".into(),
        body: format!("Message {n}"),
        recipients: vec![],
    }
}
fn query(anchor: Option<&str>, direction: Direction, limit: usize) -> HistoryQuery {
    HistoryQuery {
        message_id: anchor.map(str::to_owned),
        direction,
        limit,
    }
}
#[test]
fn history_before_pages_are_exclusive_chronological_and_nonoverlapping() {
    let q = query(Some("msg_21"), Direction::Before, 10);
    let first = history_page(&q, Some(21), (10..=20).rev().map(row).collect()).unwrap();
    assert_eq!(
        first
            .messages
            .iter()
            .map(|m| m.sequence)
            .collect::<Vec<_>>(),
        (11..=20).collect::<Vec<_>>()
    );
    assert!(first.has_more);
    assert_eq!(first.next_message_id.as_deref(), Some("msg_11"));
    let next = history_page(
        &query(first.next_message_id.as_deref(), Direction::Before, 10),
        Some(11),
        (1..=10).rev().map(row).collect(),
    )
    .unwrap();
    assert_eq!(
        next.messages.iter().map(|m| m.sequence).collect::<Vec<_>>(),
        (1..=10).collect::<Vec<_>>()
    );
    assert!(!next.has_more);
}
#[test]
fn history_after_and_latest_have_stable_continuation_and_bounded_defaults() {
    let p = history_page(
        &query(Some("msg_10"), Direction::After, 20),
        Some(10),
        (11..=31).map(row).collect(),
    )
    .unwrap();
    assert_eq!(p.messages.len(), 20);
    assert_eq!(p.next_message_id.as_deref(), Some("msg_30"));
    let latest: HistoryQuery = serde_json::from_value(json!({})).unwrap();
    assert_eq!(latest.limit, 20);
    let p = history_page(&latest, None, (31..=50).rev().map(row).collect()).unwrap();
    assert_eq!(p.messages.first().unwrap().sequence, 31);
    assert_eq!(p.messages.last().unwrap().sequence, 50);
    assert!(!p.has_more);
}
#[test]
fn invalid_history_anchor_order_duplicates_and_oversized_reads_are_rejected() {
    let q = query(Some("msg_10"), Direction::After, 10);
    assert!(history_page(&q, None, vec![]).is_err());
    assert!(history_page(&q, Some(0), vec![]).is_err());
    assert!(history_page(&q, Some(10), vec![row(10)]).is_err());
    assert!(history_page(&q, Some(10), vec![row(12), row(11)]).is_err());
    assert!(history_page(&q, Some(10), vec![row(11), row(11)]).is_err());
    assert!(history_page(&q, Some(10), (11..=22).map(row).collect()).is_err());
    assert!(history_page(&query(None, Direction::Before, 51), None, vec![]).is_err());
    assert!(history_page(&query(None, Direction::Before, 0), None, vec![]).is_err());
}
#[test]
fn retiring_members_hold_capacity_until_closed_and_identities_never_recycle() {
    let mut r = Roster::new(
        Instance {
            agent_type: "lead".into(),
            agent_id: "lead".into(),
            session_id: "s_lead".into(),
            phase: Phase::Ready,
        },
        ["builder".into()].into(),
        Policy {
            max_instances: 2,
            ..Default::default()
        },
    )
    .unwrap();
    add(&mut r, "first", "builder");
    r.retire("first").unwrap();
    assert!(r
        .reserve(request("second", "builder"), || panic!(
            "retiring capacity is still held"
        ))
        .is_err());
    assert!(r.ready("first", "s_first").is_err());
    assert!(r.direct_recipient("lead", "first", "new task").is_err());
    r.close("first").unwrap();
    add(&mut r, "second", "builder");
    assert_eq!(
        r.reserve(request("first", "builder"), || panic!(
            "historical id must never allocate"
        ))
        .unwrap()
        .instance
        .phase,
        Phase::Closed
    );
}