Skip to content
Python
6.4 KB
Raw Blame
#![cfg(all(feature = "test-support", unix))]
use openworker_sdk::agents::*;
use serde_json::json;
use std::{path::Path, time::Duration};
fn git(root: &Path, args: &[&str]) {
    let output = std::process::Command::new("/usr/bin/git")
        .args(args)
        .current_dir(root)
        .output()
        .unwrap();
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
}
async fn host(root: &Path, managed: bool, storage: Storage) -> Harness {
    let executable = std::path::PathBuf::from(env!("CARGO_BIN_EXE_sdk-test-host"));
    let builder = Harness::builder()
        .state_dir(root.join("state"))
        .executable(executable.clone())
        .sandbox(Sandbox::Off)
        .scripted(true)
        .storage(storage)
        .agent(
            Agent::new("lead")
                .instructions("Coordinate.")
                .planning(true)
                .approvals(Approvals::Never),
        )
        .agent(
            Agent::new("builder")
                .instructions("Read evidence.")
                .tool("coding.read_file")
                .approvals(Approvals::Never),
        );
    if managed {
        builder
            .managed(executable, Default::default())
            .await
            .unwrap()
    } else {
        builder.embedded().await.unwrap()
    }
}
async fn scenario(managed: bool, storage: Storage) {
    let tmp = tempfile::tempdir().unwrap();
    let root = tmp.path().canonicalize().unwrap();
    let work = root.join("work");
    std::fs::create_dir_all(work.join("source")).unwrap();
    std::fs::write(work.join("source/proof.txt"), "workspace-scoped proof").unwrap();
    git(&work.join("source"), &["init", "--quiet"]);
    git(&work.join("source"), &["add", "proof.txt"]);
    git(
        &work.join("source"),
        &[
            "-c",
            "user.name=Fixture",
            "-c",
            "[email protected]",
            "-c",
            "core.hooksPath=/dev/null",
            "commit",
            "--quiet",
            "-m",
            "base",
        ],
    );
    storage.migrate().unwrap();
    let h = host(&root, managed, storage.clone()).await;
    let team = h
        .new_team("lead", &work, TeamOptions::new(["builder"]))
        .await
        .unwrap();
    let task = format!(
        "TEST_RESOURCE_GRANTS {}",
        json!([{"name":"coding__read_file","arguments":{"path":"proof.txt"}}])
    );
    for (id, selection, cwd) in [
        (
            "reader-dir",
            json!({"mode":"directory","path":"source"}),
            "source",
        ),
        (
            "reader-tree",
            json!({"mode":"worktree","path":"workers/ui","repository":"source","branch":"ui"}),
            "workers/ui",
        ),
    ] {
        let options: ChildOptions = serde_json::from_value(json!({"workspace":selection})).unwrap();
        let receipt = team
            .spawn_with_options(id, "builder", id, &task, options.clone())
            .await
            .unwrap();
        assert_eq!(
            receipt,
            team.spawn_with_options(id, "builder", id, &task, options)
                .await
                .unwrap()
        );
        let sid = receipt["instance"]["session_id"].as_str().unwrap();
        let prompt = format!(
            "TEST_RESOURCE_GRANTS {}",
            json!([{"name":"team_wait_agent","arguments":{"agent_ids":[id],"timeout_ms":15000}}])
        );
        let run = tokio::time::timeout(Duration::from_secs(40), team.lead().run(&prompt))
            .await
            .unwrap()
            .unwrap();
        assert_eq!(run.status, RunStatus::Completed, "{run:?}");
        let child = h.client().snapshot(sid).await.unwrap();
        assert_eq!(
            child["session"]["workspace"],
            work.join(cwd).to_str().unwrap()
        );
        let events = h
            .client()
            .request("event/read", json!({"session_id":sid,"after":0}))
            .await
            .unwrap();
        assert!(
            events.to_string().contains("workspace-scoped proof"),
            "{events}"
        );
        assert!(team
            .spawn_with_options("changed", "builder", id, &task, ChildOptions::default())
            .await
            .is_err());
    }
    let failed = team
        .spawn_with_options(
            "missing",
            "builder",
            "missing",
            &task,
            serde_json::from_value(json!({"workspace":{"mode":"directory","path":"absent"}}))
                .unwrap(),
        )
        .await
        .unwrap();
    let wait = format!(
        "TEST_RESOURCE_GRANTS {}",
        json!([{"name":"team_wait_agent","arguments":{"agent_ids":["missing"],"timeout_ms":15000}}])
    );
    team.lead().run(&wait).await.unwrap();
    let snapshot = team.snapshot().await.unwrap();
    assert_eq!(
        snapshot["roster"]["instances"]["missing"]["phase"],
        "closed"
    );
    assert!(snapshot["failures"]["missing"]
        .as_str()
        .unwrap()
        .contains("Workspace preparation stopped"));
    assert!(h
        .client()
        .snapshot(failed["instance"]["session_id"].as_str().unwrap())
        .await
        .is_err());
    assert!(snapshot.get("workspaces").is_none());
    let reference = team.reference();
    h.shutdown().await.unwrap();
    let h = host(&root, managed, storage).await;
    let resumed = h.resume_team(reference).await.unwrap();
    assert_eq!(
        resumed.snapshot().await.unwrap()["roster"],
        snapshot["roster"]
    );
    assert!(work.join("workers/ui/proof.txt").is_file());
    h.shutdown().await.unwrap();
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn sqlite_embedded_workspace_children() {
    scenario(false, Storage::Sqlite).await;
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn sqlite_managed_workspace_children() {
    scenario(true, Storage::Sqlite).await;
}
fn postgres() -> Storage {
    Storage::Postgres {
        connection_env: "OW_PG_TEST_URL".into(),
        schema: format!("ow_ws_{}", openworker_runtime::id("x")),
        ca_file: None,
        loopback_plaintext: true,
    }
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
#[ignore = "requires isolated OW_PG_TEST_URL"]
async fn postgres_embedded_workspace_children() {
    scenario(false, postgres()).await;
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
#[ignore = "requires isolated OW_PG_TEST_URL"]
async fn postgres_managed_workspace_children() {
    scenario(true, postgres()).await;
}