Skip to content
Python
10.4 KB
Raw Blame
use openworker_runtime::{connections::Choice, team_definition::*};
use serde_json::json;
use std::collections::{BTreeMap, BTreeSet};

fn names(values: &[&str]) -> BTreeSet<String> {
    values.iter().map(|v| (*v).into()).collect()
}
fn ceiling() -> Ceiling {
    Ceiling {
        lead_session_id: "s_lead_one".into(),
        policy_digest: "a".repeat(64),
        tools: names(&["read_file", "search_files"]),
        models: vec![Choice::new("primary", "working-model")],
        placements: BTreeSet::from([Placement::Team, Placement::Member, Placement::New]),
        profiles: BTreeMap::from([(
            "review".into(),
            Grants {
                files: names(&["project-read"]),
                network: names(&["docs-read"]),
                credentials: names(&["docs-token"]),
                cpu: 2,
                memory_mb: 2048,
            },
        )]),
    }
}
fn definition() -> Definition {
    serde_json::from_value(json!({"name":"docs-reviewer","instructions":"Review documentation; report evidence.","tools":["read_file"],"sandbox":{"mode":"new","profile":"review","files":["project-read"],"network":[],"credentials":[]}})).unwrap()
}
fn prebuilt() -> BTreeSet<String> {
    names(&["builder", "verifier"])
}

#[test]
fn proposed_shape_accepts_a_real_subset_without_provisioning_or_approval() {
    let c = ceiling();
    let d = definition();
    d.validate(&c, &prebuilt()).unwrap();
    let bound = ScopedDefinition::propose(d.clone(), 1, &c, &prebuilt()).unwrap();
    assert_eq!(bound.definition(), &d);
    assert_eq!(bound.revision(), 1);
    assert_eq!(bound.digest().len(), 64);
    // Binding material has no approval flag, global registration, credentials or
    // environment reference: storing/approving/executing is a later adapter step.
    let value = serde_json::to_value(&bound).unwrap();
    assert!(value.get("approved").is_none());
    assert!(value.get("environment_id").is_none());
    let copy: ScopedDefinition = serde_json::from_value(value).unwrap();
    copy.revalidate(&c, &prebuilt()).unwrap();
}

#[test]
fn extra_file_network_credential_tool_profile_and_resource_authority_rejects() {
    let c = ceiling();
    for (field, value) in [
        ("files", json!(["project-write"])),
        ("network", json!(["arbitrary-web"])),
        ("credentials", json!(["admin-key"])),
        ("profile", json!("host-admin")),
        ("cpu", json!(3)),
        ("memory_mb", json!(2049)),
    ] {
        let mut v = serde_json::to_value(definition()).unwrap();
        v["sandbox"][field] = value;
        let d: Definition = serde_json::from_value(v).unwrap();
        assert!(d.validate(&c, &prebuilt()).is_err(), "{field}");
    }
    let mut d = definition();
    d.tools.insert("run_shell".into());
    assert!(d.validate(&c, &prebuilt()).is_err());
}

#[test]
fn missing_grants_are_empty_not_implicit_inheritance() {
    let d:Definition=serde_json::from_value(json!({"name":"reader","instructions":"Read.","tools":[],"sandbox":{"mode":"new","profile":"review"}})).unwrap();
    match &d.sandbox {
        Sandbox::New {
            files,
            network,
            credentials,
            cpu,
            memory_mb,
            ..
        } => {
            assert!(files.is_empty() && network.is_empty() && credentials.is_empty());
            assert_eq!((*cpu, *memory_mb), (1, 512));
        }
        _ => panic!("expected new sandbox"),
    }
    d.validate(&ceiling(), &prebuilt()).unwrap();
}

#[test]
fn sandbox_placement_is_explicit_and_cannot_smuggle_policy_overrides() {
    let mut c = ceiling();
    c.placements = BTreeSet::from([Placement::Team]);
    assert!(definition().validate(&c, &prebuilt()).is_err());
    for v in [
        json!({"mode":"off"}),
        json!({"mode":"team","files":["project-read"]}),
        json!({"mode":"new","profile":"review","policy":"anything"}),
        json!({"mode":"new","profile":"review","image":"arbitrary-image"}),
        json!({"mode":"new","profile":"review","apiKey":"secret"}),
    ] {
        assert!(serde_json::from_value::<Sandbox>(v.clone()).is_err(), "{v}");
    }
    let mut d = definition();
    d.sandbox = Sandbox::Team {};
    d.validate(&c, &prebuilt()).unwrap();
    d.sandbox = Sandbox::Member {
        agent_id: "builder-ui".into(),
    };
    assert!(d.validate(&c, &prebuilt()).is_err());
    c.placements.insert(Placement::Member);
    d.validate(&c, &prebuilt()).unwrap();
    d.sandbox = Sandbox::Member {
        agent_id: "lead".into(),
    };
    d.validate(&c, &prebuilt()).unwrap();
    d.sandbox = Sandbox::Member {
        agent_id: "../another-team".into(),
    };
    assert!(d.validate(&c, &prebuilt()).is_err());
}

#[test]
fn custom_types_cannot_replace_approvers_modes_or_server_launchers() {
    for (field, value) in [
        ("approvals", json!({"mode":"bypass"})),
        ("reviewer_model", json!("agent-chosen-reviewer")),
        ("servers", json!("arbitrary-launcher")),
        ("lead_session_id", json!("another-lead")),
    ] {
        let mut v = serde_json::to_value(definition()).unwrap();
        v[field] = value;
        assert!(serde_json::from_value::<Definition>(v).is_err(), "{field}");
    }
}

#[test]
fn names_cannot_shadow_prebuilt_or_reserved_roles() {
    for name in [
        "builder",
        "verifier",
        "lead",
        "all",
        "user",
        "board",
        "../x",
        "session:x",
        "",
    ] {
        let mut d = definition();
        d.name = name.into();
        assert!(d.validate(&ceiling(), &prebuilt()).is_err(), "{name}");
    }
    let mut d = definition();
    d.name = "reader-2".into();
    d.validate(&ceiling(), &prebuilt()).unwrap();
}

#[test]
fn model_selection_is_optional_and_bounded_by_the_leads_delegated_models() {
    let mut d = definition();
    d.model = Some(Choice::new("primary", "working-model"));
    d.validate(&ceiling(), &prebuilt()).unwrap();
    for m in [
        Choice::new("other-connection", "working-model"),
        Choice::new("primary", "other-model"),
    ] {
        d.model = Some(m);
        assert!(d.validate(&ceiling(), &prebuilt()).is_err());
    }
}

#[test]
fn approval_binding_is_session_scoped_and_invalidates_on_policy_revocation() {
    let c = ceiling();
    let bound = ScopedDefinition::propose(definition(), 1, &c, &prebuilt()).unwrap();
    let mut other = c.clone();
    other.lead_session_id = "s_other_lead".into();
    assert!(bound.revalidate(&other, &prebuilt()).is_err());
    other = c.clone();
    other.policy_digest = "b".repeat(64);
    assert!(bound.revalidate(&other, &prebuilt()).is_err());
    // Even if a buggy adapter forgets to change the digest, current ceiling
    // validation refuses a grant that is no longer permitted.
    other = c.clone();
    other.tools.clear();
    assert!(bound.revalidate(&other, &prebuilt()).is_err());
    other = c.clone();
    other.profiles.get_mut("review").unwrap().files.clear();
    assert!(bound.revalidate(&other, &prebuilt()).is_err());
    let mut collisions = prebuilt();
    collisions.insert("docs-reviewer".into());
    assert!(bound.revalidate(&c, &collisions).is_err());
}

#[test]
fn digest_binds_prompt_tools_revision_model_scope_and_policy_not_set_order() {
    let c = ceiling();
    let base = ScopedDefinition::propose(definition(), 1, &c, &prebuilt()).unwrap();
    let mut variants = vec![];
    let mut d = definition();
    d.instructions.push_str(" Different instructions.");
    variants.push(d);
    let mut d = definition();
    d.tools.insert("search_files".into());
    variants.push(d);
    let mut d = definition();
    d.model = Some(Choice::new("primary", "working-model"));
    variants.push(d);
    let mut d = definition();
    d.sandbox = Sandbox::Team {};
    variants.push(d);
    for d in variants {
        assert_ne!(
            base.digest(),
            ScopedDefinition::propose(d, 1, &c, &prebuilt())
                .unwrap()
                .digest()
        );
    }
    assert_ne!(
        base.digest(),
        ScopedDefinition::propose(definition(), 2, &c, &prebuilt())
            .unwrap()
            .digest()
    );
    let mut other = c.clone();
    other.lead_session_id = "s_second".into();
    assert_ne!(
        base.digest(),
        ScopedDefinition::propose(definition(), 1, &other, &prebuilt())
            .unwrap()
            .digest()
    );
    other = c.clone();
    other.policy_digest = "b".repeat(64);
    assert_ne!(
        base.digest(),
        ScopedDefinition::propose(definition(), 1, &other, &prebuilt())
            .unwrap()
            .digest()
    );
    let mut a = definition();
    a.tools = names(&["search_files", "read_file"]);
    let mut b = definition();
    b.tools = names(&["read_file", "search_files"]);
    assert_eq!(
        ScopedDefinition::propose(a, 1, &c, &prebuilt())
            .unwrap()
            .digest(),
        ScopedDefinition::propose(b, 1, &c, &prebuilt())
            .unwrap()
            .digest()
    );
}

#[test]
fn modified_serialized_definitions_cannot_reuse_binding_material() {
    let c = ceiling();
    let bound = ScopedDefinition::propose(definition(), 1, &c, &prebuilt()).unwrap();
    let mut v = serde_json::to_value(&bound).unwrap();
    v["definition"]["instructions"] = json!("Changed after approval");
    assert!(serde_json::from_value::<ScopedDefinition>(v)
        .unwrap()
        .revalidate(&c, &prebuilt())
        .is_err());
    assert!(ScopedDefinition::propose(definition(), 0, &c, &prebuilt()).is_err());
}

#[test]
fn hard_policy_sharing_requires_resolved_fingerprints_not_matching_labels() {
    require_shared_scope(&"a".repeat(64), &"a".repeat(64)).unwrap();
    assert!(require_shared_scope(&"a".repeat(64), &"b".repeat(64)).is_err());
    assert!(require_shared_scope("review", "review").is_err());
    assert!(require_shared_scope("", "").is_err());
}

#[test]
fn oversized_or_malformed_definitions_and_ceilings_are_refused() {
    for text in [
        "".to_owned(),
        " ".into(),
        "x".repeat(32001),
        "hidden\0text".into(),
    ] {
        let mut d = definition();
        d.instructions = text;
        assert!(d.validate(&ceiling(), &prebuilt()).is_err());
    }
    let mut d = definition();
    d.tools = (0..65).map(|i| format!("tool-{i}")).collect();
    assert!(d.validate(&ceiling(), &prebuilt()).is_err());
    let mut c = ceiling();
    c.policy_digest.clear();
    assert!(definition().validate(&c, &prebuilt()).is_err());
    c = ceiling();
    c.profiles.get_mut("review").unwrap().cpu = 0;
    assert!(definition().validate(&c, &prebuilt()).is_err());
}