Skip to content
Python
12.2 KB
Raw Blame
#![cfg(feature = "compliance")]
use openworker_runtime::{
    compliance::Query,
    store::{Session, StateStore},
};
use openworker_store_postgres::{
    auth::{Role, Scope, Spec},
    Config, PostgresStore, Tls,
};
use serde_json::json;
const ADMIN: &str = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
const READER: &str = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
const AUDITOR: &str = "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc";
const OTHER: &str = "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd";
fn session(id: &str) -> Session {
    serde_json::from_value(json!({"id":id,"name":"Test","workspace":"/work","coworker":"test","bundle_digest":"b","schema_digest":null,"interactions":[],"turn":null,"sandbox":null,"closed":false,"compliance":{},"resource_policy":openworker_runtime::resource_policy::Resolved::default()})).unwrap()
}
#[test]
#[ignore = "requires isolated OW_PG_TEST_URL"]
fn durable_projection_content_scope_and_read_audit() {
    let mut c = Config::new(
        std::env::var("OW_PG_TEST_URL").unwrap(),
        format!("ow_compliance_{}", uuid::Uuid::new_v4().simple()),
    );
    c.tls = Tls::LoopbackPlaintext;
    PostgresStore::migrate(&c).unwrap();
    PostgresStore::migrate(&c).unwrap();
    let mut root = PostgresStore::open(c.clone()).unwrap();
    root.auth_bootstrap(ADMIN, "admin").unwrap();
    let admin = root.authorized(ADMIN).unwrap();
    let mut s = session("s_one");
    s.history
        .push(json!({"role":"user","content":"PRIVATE_ACCEPTED_TEXT"}));
    s.history
        .push(json!({"type":"reasoning","encrypted_content":"OPAQUE_REASONING"}));
    root.save(
        &s,
        "session_created",
        json!({"text":"PRIVATE_ACCEPTED_TEXT"}),
    )
    .unwrap();
    root.save(&session("s_two"), "session_created", json!({}))
        .unwrap();
    for (i, (key, role, scope)) in [
        (
            READER,
            Role::ComplianceReader,
            Scope::Sessions {
                ids: vec!["s_one".into()],
            },
        ),
        (
            AUDITOR,
            Role::ComplianceAuditor,
            Scope::Sessions {
                ids: vec!["s_one".into()],
            },
        ),
        (OTHER, Role::Observer, Scope::All),
    ]
    .into_iter()
    .enumerate()
    {
        admin
            .auth_issue(
                &format!("credential-{i}"),
                Spec {
                    principal: format!("principal-{i}"),
                    role,
                    scope,
                    environments: vec![],
                    expires_at: None,
                },
                key,
            )
            .unwrap();
    }
    let e=root.append_event("s_one","safety_evaluation",json!({"phase":"model_output","outcome":"blocked","code":"PII","text":"PRIVATE_REJECTED_TEXT"})).unwrap();
    root.append_event("s_one", "assistant_delta", json!({"text":"PRIVATE_DELTA"}))
        .unwrap();
    let reader = root.authorized(READER).unwrap();
    let auditor = root.authorized(AUDITOR).unwrap();
    let observer = root.authorized(OTHER).unwrap();
    let page = reader.compliance_page("s_one", Query::default()).unwrap();
    assert_eq!(page["activities"].as_array().unwrap().len(), 2);
    assert!(!page.to_string().contains("PRIVATE"));
    assert!(!page.to_string().contains("OPAQUE"));
    assert_eq!(page["nextAfter"], e.event_id);
    assert!(reader.compliance_page("s_two", Query::default()).is_err());
    assert!(reader.compliance_content("s_one", 0).is_err());
    assert!(reader.read_snapshot("s_one").is_err());
    assert!(observer.compliance_page("s_one", Query::default()).is_err());
    let content = auditor.compliance_content("s_one", 0).unwrap();
    assert!(content.to_string().contains("PRIVATE_ACCEPTED_TEXT"));
    assert!(!content.to_string().contains("PRIVATE_REJECTED_TEXT"));
    assert!(!content.to_string().contains("OPAQUE"));
    let mut db = postgres::Client::connect(&c.connection, postgres::NoTls).unwrap();
    db.batch_execute(&format!("SET search_path={},pg_catalog", c.schema))
        .unwrap();
    let reads:i64=db.query_one("SELECT count(*) FROM api_security_audit WHERE action IN ('compliance.read','compliance.content.read')",&[]).unwrap().get(0);
    assert_eq!(reads, 2);
    db.batch_execute("CREATE FUNCTION reject_evidence() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RAISE EXCEPTION 'audit storage failed'; END $$; CREATE TRIGGER reject_evidence BEFORE INSERT ON compliance_events FOR EACH ROW EXECUTE FUNCTION reject_evidence();").unwrap();
    assert!(root
        .append_event("s_one", "tool_started", json!({"call_id":"call-1"}))
        .is_err());
    assert_eq!(
        db.query_one(
            "SELECT count(*) FROM events WHERE session_id='s_one' AND kind='tool_started'",
            &[]
        )
        .unwrap()
        .get::<_, i64>(0),
        0
    );
    db.batch_execute("DROP TRIGGER reject_evidence ON compliance_events")
        .unwrap();
    let reopened = PostgresStore::open(c.clone())
        .unwrap()
        .authorized(READER)
        .unwrap();
    assert_eq!(
        reopened.compliance_page("s_one", Query::default()).unwrap()["activities"],
        page["activities"]
    );
    let admin = PostgresStore::open(c.clone())
        .unwrap()
        .authorized(ADMIN)
        .unwrap();
    let mut exporter = admin.clone();
    let first = exporter
        .claim_compliance_export("s_one", "siem-v1", "binding", "one")
        .unwrap()
        .unwrap();
    assert!(exporter
        .claim_compliance_export("s_one", "siem-v1", "binding", "two")
        .unwrap()
        .is_none());
    exporter
        .settle_compliance_export("s_one", "siem-v1", "one", false)
        .unwrap();
    assert_eq!(
        admin.compliance_delivery_health("s_one").unwrap()["sinks"][0]["cursor"],
        0
    );
    db.execute(
        "UPDATE compliance_delivery SET data=jsonb_set(data,'{nextAtMs}','0')",
        &[],
    )
    .unwrap();
    let mut reopened = PostgresStore::open(c.clone())
        .unwrap()
        .authorized(ADMIN)
        .unwrap();
    let retry = reopened
        .claim_compliance_export("s_one", "siem-v1", "binding", "retry")
        .unwrap()
        .unwrap();
    assert_eq!(retry.activities, first.activities);
    assert!(reopened
        .settle_compliance_export("s_one", "siem-v1", "one", true)
        .is_err());
    reopened
        .settle_compliance_export("s_one", "siem-v1", "retry", true)
        .unwrap();
    assert_eq!(
        admin.compliance_delivery_health("s_one").unwrap()["sinks"][0]["pending"],
        0
    );
    let mut reader = PostgresStore::open(c.clone())
        .unwrap()
        .authorized(READER)
        .unwrap();
    assert!(reader
        .claim_compliance_export("s_one", "unapproved", "binding", "forged")
        .is_err());
    db.batch_execute(&format!("DROP SCHEMA {} CASCADE", c.schema))
        .unwrap();
}

#[test]
#[ignore = "requires isolated OW_PG_TEST_URL"]
fn schema_fence_blocks_old_clients_and_preserves_existing_records() {
    let mut c = Config::new(
        std::env::var("OW_PG_TEST_URL").unwrap(),
        format!("ow_cupgrade_{}", uuid::Uuid::new_v4().simple()),
    );
    c.tls = Tls::LoopbackPlaintext;
    PostgresStore::migrate(&c).unwrap();
    let mut store = PostgresStore::open(c.clone()).unwrap();
    store
        .save(&session("upgrade"), "session_created", json!({}))
        .unwrap();
    let mut db = postgres::Client::connect(&c.connection, postgres::NoTls).unwrap();
    db.batch_execute(&format!("SET search_path={},pg_catalog", c.schema))
        .unwrap();
    assert!(db
        .execute("UPDATE sessions SET data=data WHERE id='upgrade'", &[])
        .is_err());
    assert!(db.execute("INSERT INTO events(session_id,cursor,kind,data) VALUES('upgrade',99,'tool_started','{}')",&[]).is_err());
    db.batch_execute("UPDATE version SET version=5 WHERE singleton")
        .unwrap();
    assert!(
        PostgresStore::migrate(&c).is_err(),
        "Do not upgrade under a live owner"
    );
    db.batch_execute("UPDATE version SET version=7 WHERE singleton")
        .unwrap();
    // Emulate a drained old schema without altering its session payload.
    store.release("upgrade").unwrap();
    drop(store);
    db.batch_execute("UPDATE version SET version=5 WHERE singleton")
        .unwrap();
    PostgresStore::migrate(&c).unwrap();
    assert_eq!(
        db.query_one("SELECT version FROM version", &[])
            .unwrap()
            .get::<_, i32>(0),
        7
    );
    let store = PostgresStore::open(c.clone()).unwrap();
    assert_eq!(
        store.read_snapshot("upgrade").unwrap()["session"]["id"],
        "upgrade"
    );
    db.batch_execute(&format!("DROP SCHEMA {} CASCADE", c.schema))
        .unwrap();
}

#[test]
#[ignore = "requires isolated OW_PG_TEST_URL"]
fn export_backpressure_leaves_the_connection_available_for_delivery() {
    let mut c = Config::new(
        std::env::var("OW_PG_TEST_URL").unwrap(),
        format!("ow_cpressure_{}", uuid::Uuid::new_v4().simple()),
    );
    c.tls = Tls::LoopbackPlaintext;
    PostgresStore::migrate(&c).unwrap();
    let mut store = PostgresStore::open(c.clone()).unwrap();
    let mut s = session("pressure");
    s.compliance.as_mut().unwrap().max_pending_events = 100;
    store.save(&s, "session_created", json!({})).unwrap();
    let first = store
        .claim_compliance_export(&s.id, "sink", "binding", "first")
        .unwrap()
        .unwrap();
    store
        .settle_compliance_export(&s.id, "sink", &first.token, false)
        .unwrap();
    for _ in 0..99 {
        store
            .append_event(&s.id, "tool_finished", json!({}))
            .unwrap();
    }
    assert!(store
        .append_event(&s.id, "tool_started", json!({}))
        .is_err());
    store
        .append_event(&s.id, "turn_completed", json!({"status":"cancelled"}))
        .unwrap();
    let mut db = postgres::Client::connect(&c.connection, postgres::NoTls).unwrap();
    db.batch_execute(&format!("SET search_path={},pg_catalog; UPDATE compliance_delivery SET data=jsonb_set(data,'{{nextAtMs}}','0'::jsonb)",c.schema)).unwrap();
    let retry = store
        .claim_compliance_export(&s.id, "sink", "binding", "retry")
        .unwrap()
        .unwrap();
    store
        .settle_compliance_export(&s.id, "sink", &retry.token, true)
        .unwrap();
    store
        .append_event(&s.id, "tool_started", json!({}))
        .unwrap();
    db.batch_execute(&format!("DROP SCHEMA {} CASCADE", c.schema))
        .unwrap();
}

#[test]
#[cfg(feature = "guardrails")]
#[ignore = "requires isolated OW_PG_TEST_URL"]
fn observer_receipts_survive_reconnect_and_reject_stale_owners() {
    use openworker_runtime::safety::{HandlerRef, Hook, HookPhase};
    let mut c = Config::new(
        std::env::var("OW_PG_TEST_URL").unwrap(),
        format!("ow_cobserve_{}", uuid::Uuid::new_v4().simple()),
    );
    c.tls = Tls::LoopbackPlaintext;
    PostgresStore::migrate(&c).unwrap();
    let mut owner = PostgresStore::open(c.clone()).unwrap();
    let mut s = session("observed");
    s.safety.hooks.push(Hook::new(
        "audit",
        HookPhase::OnEvent,
        HandlerRef {
            name: "audit".into(),
            version: "1".into(),
        },
    ));
    owner
        .save(&s, "session_created", json!({"text":"HIDDEN_SENTINEL"}))
        .unwrap();
    let receipt = owner.pending_observers(&s.id).unwrap().remove(0);
    assert!(!receipt.to_string().contains("HIDDEN_SENTINEL"));
    owner.settle_observer(&s.id, &receipt, false).unwrap();
    owner.release(&s.id).unwrap();
    let mut replacement = PostgresStore::open(c.clone()).unwrap();
    replacement.claim(&s.id).unwrap();
    assert!(owner.settle_observer(&s.id, &receipt, true).is_err());
    let resumed = replacement
        .pending_observers(&s.id)
        .unwrap()
        .into_iter()
        .find(|v| v["cursor"] == receipt["cursor"])
        .unwrap();
    assert_eq!(resumed["attempts"], 1);
    assert_eq!(resumed["hook"], receipt["hook"]);
    replacement.settle_observer(&s.id, &resumed, true).unwrap();
    assert!(!replacement
        .pending_observers(&s.id)
        .unwrap()
        .iter()
        .any(|v| v["cursor"] == receipt["cursor"]));
    let mut db = postgres::Client::connect(&c.connection, postgres::NoTls).unwrap();
    db.batch_execute(&format!("DROP SCHEMA {} CASCADE", c.schema))
        .unwrap();
}