Skip to content
Python
10.3 KB
Raw Blame
#![cfg(all(feature = "test-support", unix))]
use futures_util::FutureExt;
use openworker_sdk::agents::*;
use serde_json::{json, Value};
use std::{path::Path, time::Duration};
fn git(root: &Path, args: &[&str]) -> String {
    let o = std::process::Command::new("/usr/bin/git")
        .args(args)
        .current_dir(root)
        .output()
        .unwrap();
    assert!(o.status.success(), "{}", String::from_utf8_lossy(&o.stderr));
    String::from_utf8(o.stdout).unwrap().trim().into()
}
fn plan(name: &str, args: Value) -> String {
    format!(
        "TEST_RESOURCE_GRANTS {}",
        json!([{"name":name,"arguments":args}])
    )
}
async fn host(
    root: &Path,
    managed: bool,
    storage: Storage,
    preset: &coding::SharedPreset,
) -> Harness {
    let executable = root.join("test-host");
    // Executable is immutable while subprocesses use it, including if another
    // test command rebuilds sdk-test-host in the shared Cargo target.
    if !executable.exists() {
        std::fs::copy(env!("CARGO_BIN_EXE_sdk-test-host"), &executable).unwrap();
    }
    let mut b = Harness::builder()
        .state_dir(root.join("state"))
        .executable(executable.clone())
        .sandbox(Sandbox::Off)
        .storage(storage)
        .scripted(true)
        .agent(coding::single("solo").approvals(Approvals::Never));
    for a in preset.agents() {
        b = b.agent(a.approvals(Approvals::Never));
    }
    if managed {
        b.managed(executable, Default::default()).await.unwrap()
    } else {
        b.embedded().await.unwrap()
    }
}
async fn scenario(managed: bool, storage: Storage) {
    let temp = tempfile::tempdir().unwrap();
    let root = temp.path().canonicalize().unwrap();
    let work = root.join("work");
    let source = work.join("source");
    std::fs::create_dir_all(&source).unwrap();
    git(&source, &["init", "--quiet"]);
    std::fs::write(source.join("proof.txt"), "base").unwrap();
    git(&source, &["add", "proof.txt"]);
    git(
        &source,
        &[
            "-c",
            "user.name=Fixture",
            "-c",
            "[email protected]",
            "commit",
            "--quiet",
            "-m",
            "base",
        ],
    );
    let sha = git(&source, &["rev-parse", "HEAD"]);
    let preset = coding::shared("game", "source", &sha).unwrap();
    storage.migrate().unwrap();
    let h = host(&root, managed, storage.clone(), &preset).await;
    let solo = h.session("solo", &work).await.unwrap();
    assert_eq!(solo.run(&plan("coding__write_file",json!({"path":"index.html","content":"<!doctype html><title>Small game</title><button>Play</button>"}))).await.unwrap().status,RunStatus::Completed);
    assert!(std::fs::read_to_string(work.join("index.html"))
        .unwrap()
        .contains("<button>Play</button>"));
    let team = h
        .new_team(preset.lead.id(), &work, preset.team.clone())
        .await
        .unwrap();
    assert_eq!(
        team.snapshot().await.unwrap()["roster"]["instances"]
            .as_object()
            .unwrap()
            .len(),
        1
    );
    let mut children = vec![];
    for id in ["ui", "api"] {
        let task = plan(
            "coding__write_file",
            json!({"path":"proof.txt","content":id}),
        );
        let r = team
            .spawn(id, preset.builder.id(), id, &task)
            .await
            .unwrap();
        assert_eq!(
            team.spawn(id, preset.builder.id(), id, &task)
                .await
                .unwrap(),
            r
        );
        assert_eq!(r["workspace"]["base"], sha);
        assert_eq!(r["workspace"]["mode"], "worktree");
        children.push((id, r));
    }
    let wait = format!(
        "TEST_RESOURCE_GRANTS {}",
        json!([
            {"name":"team_wait_agent","arguments":{"agent_ids":["ui"],"timeout_ms":20000}},
            {"name":"team_wait_agent","arguments":{"agent_ids":["api"],"timeout_ms":20000}}
        ])
    );
    let result = tokio::time::timeout(Duration::from_secs(60), team.lead().run(&wait))
        .await
        .unwrap()
        .unwrap();
    assert_eq!(result.status, RunStatus::Completed);
    for (id, r) in &children {
        let path = r["workspace"]["path"].as_str().unwrap();
        assert_eq!(
            std::fs::read_to_string(work.join(path).join("proof.txt")).unwrap(),
            *id
        );
        let child = h
            .client()
            .snapshot(r["instance"]["session_id"].as_str().unwrap())
            .await
            .unwrap();
        assert_eq!(
            child["session"]["workspace"],
            work.join(path).to_str().unwrap()
        );
        assert_eq!(git(&work.join(path), &["rev-parse", "HEAD"]), sha);
    }
    assert_ne!(
        children[0].1["workspace"]["path"],
        children[1].1["workspace"]["path"]
    );
    assert_eq!(
        std::fs::read_to_string(source.join("proof.txt")).unwrap(),
        "base"
    );
    let mut changed = preset.team.clone();
    changed.workspace_defaults.as_mut().unwrap().base = "f".repeat(40);
    assert!(h.attach_team(team.lead().clone(), changed).await.is_err());
    let reference = team.reference();
    h.shutdown().await.unwrap();
    let h = host(&root, managed, storage, &preset).await;
    let resumed = h.resume_team(reference).await.unwrap();
    assert_eq!(
        resumed.snapshot().await.unwrap()["roster"]["instances"]
            .as_object()
            .unwrap()
            .len(),
        3
    );
    h.shutdown().await.unwrap();
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn sqlite_embedded() {
    scenario(false, Storage::Sqlite).await
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn sqlite_managed() {
    scenario(true, Storage::Sqlite).await
}
fn pg() -> Storage {
    Storage::Postgres {
        connection_env: "OW_PG_TEST_URL".into(),
        schema: format!("ow_presets_{}", openworker_runtime::id("x")),
        ca_file: None,
        loopback_plaintext: true,
    }
}
async fn postgres_scenario(managed: bool) {
    let storage = pg();
    let Storage::Postgres { schema, .. } = &storage else {
        unreachable!()
    };
    let schema = schema.clone();
    let outcome = std::panic::AssertUnwindSafe(scenario(managed, storage))
        .catch_unwind()
        .await;
    tokio::task::spawn_blocking(move || {
        // This helper generates the name; never interpolate application input.
        assert!(
            schema.starts_with("ow_presets_x_")
                && schema
                    .bytes()
                    .all(|b| b.is_ascii_alphanumeric() || b == b'_')
        );
        let mut pg =
            postgres::Client::connect(&std::env::var("OW_PG_TEST_URL").unwrap(), postgres::NoTls)
                .unwrap();
        pg.batch_execute(&format!("DROP SCHEMA IF EXISTS {schema} CASCADE"))
            .unwrap();
    })
    .await
    .unwrap();
    if let Err(panic) = outcome {
        std::panic::resume_unwind(panic);
    }
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
#[ignore = "requires disposable OW_PG_TEST_URL"]
async fn postgres_embedded() {
    postgres_scenario(false).await
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
#[ignore = "requires disposable OW_PG_TEST_URL"]
async fn postgres_managed() {
    postgres_scenario(true).await
}
#[test]
fn preset_configuration_is_safe_customizable_and_service_conversion_is_explicit() {
    let agent = coding::single("solo");
    let data = serde_json::to_value(&agent).unwrap();
    assert_eq!(data["approvals"]["mode"], "always");
    assert!(data.get("subagents").is_none());
    assert!(data.get("model").is_none());
    let profile: openworker_sdk::service::RuntimeProfile = serde_json::from_value(
        json!({"id":"shared@1","provider":"openshell","cpu":1,"memoryMB":512,"sharing":"shared"}),
    )
    .unwrap();
    let agent = agent.default_model(ModelChoice::new("Local", "chosen"));
    let r = coding::service_release(&agent, "1", &profile).unwrap();
    assert_eq!(r.default_model.unwrap().model, "chosen");
    assert!(
        coding::service_release(&agent.clone().approvals(Approvals::Never), "1", &profile).is_err()
    );
    assert!(coding::service_release(&agent.memory(true), "1", &profile).is_err());
    assert!(coding::shared("game", "source", "HEAD").is_err());
    assert!(coding::shared("../game", "source", &"a".repeat(40)).is_err());
    assert!(coding::shared("1game", "source", &"a".repeat(40)).is_err());
    let mut auto = profile;
    auto.approval_mode = openworker_runtime::permissions::Mode::AutoApprove;
    let separate = coding::single("reviewed")
        .default_model(ModelChoice::new("Work", "coding-model"))
        .approvals(Approvals::Auto(ModelChoice::new("Review", "review-model")));
    let release = coding::service_release(&separate, "1", &auto).unwrap();
    assert_eq!(release.default_model.unwrap().connection, "Work");
    assert_eq!(release.reviewer_model.unwrap().connection, "Review");
}

#[test]
fn isolated_service_preset_uses_artifact_defaults_and_no_linked_worktree() {
    let source:openworker_sdk::service::CodingSource=serde_json::from_value(json!({"repository":"org/game","directory":"source","object_format":"sha1","commit":"a".repeat(40)})).unwrap();
    let sandbox =
        serde_json::from_value(json!({"mode":"new","profile":"small@1","cpu":1,"memory_mb":512}))
            .unwrap();
    let delegation=serde_json::from_value(json!({"tools":["coding.read_file"],"placements":["team","new"],"profiles":{"small@1":{"files":[],"network":[],"credentials":[],"cpu":1,"memory_mb":512}}})).unwrap();
    let p = coding::isolated_service("game", source, sandbox, delegation, "1").unwrap();
    assert!(p.team.workspace_defaults.is_none());
    let defaults = p.team.coding.as_ref().unwrap();
    assert_eq!(
        defaults.agent_types["game-verifier"].source,
        openworker_runtime::coding_handoff::config::DefaultSource::RequireSubmission
    );
    assert_eq!(
        defaults.agent_types["game-builder"].source,
        openworker_runtime::coding_handoff::config::DefaultSource::Initial
    );
    assert!(serde_json::to_value(p.lead).unwrap()["instructions"]
        .as_str()
        .unwrap()
        .contains("team_receive_submission"));
    let options: ChildOptions =
        serde_json::from_value(json!({"source":{"kind":"submission","id":"hs_original"}})).unwrap();
    assert_eq!(
        serde_json::to_value(options).unwrap()["source"]["id"],
        "hs_original"
    );
}