#![cfg(feature = "postgres")]
use std::path::PathBuf;
use axum::body::{to_bytes, Body, Bytes};
use axum::http::{Request, StatusCode};
use axum::Router;
use rusty_agent_server::{router, GraphRegistry, ServerConfig};
use serde_json::{json, Value};
use tower::ServiceExt;
fn database_url() -> String {
std::env::var("DATABASE_URL").expect(
"DATABASE_URL must point at a scratch Postgres database \
(e.g. postgres://user:pass@localhost/rusty_test)",
)
}
fn postgres_app() -> Router {
let store_path: PathBuf =
std::env::temp_dir().join(format!("rusty-server-pg-agents-{}", uuid::Uuid::new_v4()));
let config = ServerConfig::new("127.0.0.1:0".parse().unwrap(), store_path)
.with_postgres(database_url())
.with_tenant_key("pg-agents", "pg-agents-secret");
router(GraphRegistry::new(), config)
}
async fn call(app: &Router, method: &str, uri: &str, body: Option<Value>) -> (StatusCode, Value) {
let mut builder = Request::builder()
.method(method)
.uri(uri)
.header("x-api-key", "pg-agents-secret");
let body = match body {
Some(v) => {
builder = builder.header("content-type", "application/json");
Body::from(v.to_string())
}
None => Body::empty(),
};
let response = app
.clone()
.oneshot(builder.body(body).unwrap())
.await
.unwrap();
let status = response.status();
let bytes: Bytes = to_bytes(response.into_body(), usize::MAX).await.unwrap();
let value = if bytes.is_empty() {
Value::Null
} else {
serde_json::from_slice(&bytes).unwrap_or(Value::Null)
};
(status, value)
}
fn uniq() -> String {
uuid::Uuid::new_v4().simple().to_string()
}
fn manifest() -> Value {
json!({
"agent_kind": "researcher",
"manifest_version": "researcher/1.4.0",
"accepts": {
"summarize": {"kind": "application/json"},
"triage": {"kind": "application/json", "max_bytes": 65536}
}
})
}
async fn register(app: &Router, agent_id: &str) {
let (status, v) = call(
app,
"POST",
"/agents",
Some(json!({"agent_id": agent_id, "manifest": manifest()})),
)
.await;
assert_eq!(status, StatusCode::CREATED, "register failed: {v}");
}
async fn activate_one(app: &Router, agent_id: &str, worker: &str, lease_ms: u64) -> u64 {
let (status, v) = call(
app,
"POST",
&format!("/agents/{agent_id}/activate"),
Some(json!({"worker_id": worker, "lease_ms": lease_ms})),
)
.await;
assert_eq!(status, StatusCode::OK, "activate failed: {v}");
v["fencing"].as_u64().unwrap()
}
async fn next(app: &Router, agent_id: &str, worker: &str, fencing: u64) -> (StatusCode, Value) {
call(
app,
"POST",
&format!("/agents/{agent_id}/mailbox/next"),
Some(json!({"worker_id": worker, "fencing": fencing, "lease_ms": 30_000})),
)
.await
}
#[tokio::test]
#[ignore = "requires DATABASE_URL"]
async fn agents_registry_activation_and_mailbox_over_postgres() {
let app = postgres_app();
let agent_id = format!("pg-agent-{}", uniq());
register(&app, &agent_id).await;
let (status, v) = call(&app, "GET", &format!("/agents/{agent_id}"), None).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(v["manifest"]["agent_kind"], json!("researcher"));
let (status, _) = call(
&app,
"POST",
"/agents",
Some(json!({"agent_id": agent_id, "manifest": manifest()})),
)
.await;
assert_eq!(status, StatusCode::CONFLICT);
let (status, v) = call(&app, "GET", "/agents", None).await;
assert_eq!(status, StatusCode::OK);
assert!(v
.as_array()
.unwrap()
.iter()
.any(|r| r["agent_id"] == json!(agent_id)));
let (status, _) = call(
&app,
"POST",
&format!("/agents/{agent_id}/mailbox"),
Some(json!({"kind": "exfiltrate", "payload": {}})),
)
.await;
assert_eq!(status, StatusCode::BAD_REQUEST);
let (status, v) = call(
&app,
"POST",
&format!("/agents/{agent_id}/mailbox"),
Some(json!({"kind": "summarize", "payload": {"n": 1}})),
)
.await;
assert_eq!(status, StatusCode::CREATED, "send failed: {v}");
let first_id = v["task_id"].as_str().unwrap().to_string();
let (status, v) = call(
&app,
"POST",
&format!("/agents/{agent_id}/mailbox"),
Some(json!({"kind": "triage", "payload": {"n": 2}})),
)
.await;
assert_eq!(status, StatusCode::CREATED);
let second_id = v["task_id"].as_str().unwrap().to_string();
let (status, _) = call(
&app,
"POST",
"/tasks/claim",
Some(json!({"worker_id": "pool-worker", "lease_ms": 30_000})),
)
.await;
assert_eq!(status, StatusCode::NO_CONTENT);
let (status, _) = next(&app, &agent_id, "worker-1", 1).await;
assert_eq!(status, StatusCode::CONFLICT);
let fencing = activate_one(&app, &agent_id, "worker-1", 30_000).await;
assert_eq!(fencing, 1);
let (status, _) = call(
&app,
"POST",
&format!("/agents/{agent_id}/activate"),
Some(json!({"worker_id": "worker-2", "lease_ms": 30_000})),
)
.await;
assert_eq!(status, StatusCode::CONFLICT, "a live activation holds");
let (status, v) = call(
&app,
"POST",
&format!("/agents/{agent_id}/activate/heartbeat"),
Some(json!({"worker_id": "worker-1", "fencing": fencing, "lease_ms": 60_000})),
)
.await;
assert_eq!(status, StatusCode::OK, "heartbeat failed: {v}");
let (status, _) = call(
&app,
"POST",
&format!("/agents/{agent_id}/activate/heartbeat"),
Some(json!({"worker_id": "worker-1", "fencing": fencing + 1, "lease_ms": 60_000})),
)
.await;
assert_eq!(status, StatusCode::CONFLICT, "stale fencing must lose");
let (status, v) = next(&app, &agent_id, "worker-1", fencing).await;
assert_eq!(status, StatusCode::OK, "first turn: {v}");
assert_eq!(v["task"]["task_id"], json!(first_id));
let (status, _) = next(&app, &agent_id, "worker-1", fencing).await;
assert_eq!(
status,
StatusCode::NO_CONTENT,
"a turn in flight makes the mailbox unclaimable"
);
let (status, _) = call(
&app,
"POST",
&format!("/tasks/{first_id}/complete"),
Some(json!({"worker_id": "worker-1", "result": {"done": true}})),
)
.await;
assert_eq!(status, StatusCode::OK);
let (status, v) = next(&app, &agent_id, "worker-1", fencing).await;
assert_eq!(status, StatusCode::OK, "second turn: {v}");
assert_eq!(v["task"]["task_id"], json!(second_id));
let (status, _) = call(
&app,
"POST",
&format!("/agents/{agent_id}/activate/release"),
Some(json!({"worker_id": "worker-1", "fencing": fencing})),
)
.await;
assert_eq!(status, StatusCode::OK);
let fencing = activate_one(&app, &agent_id, "worker-2", 30_000).await;
assert_eq!(fencing, 1, "a released lease is gone, not stolen");
}
#[tokio::test]
#[ignore = "requires DATABASE_URL"]
async fn concurrent_activation_claims_exactly_one_wins() {
let app = postgres_app();
let agent_id = format!("pg-race-{}", uniq());
register(&app, &agent_id).await;
let mut handles = Vec::new();
for i in 0..16 {
let app = app.clone();
let agent_id = agent_id.clone();
handles.push(tokio::spawn(async move {
call(
&app,
"POST",
&format!("/agents/{agent_id}/activate"),
Some(json!({"worker_id": format!("racer-{i}"), "lease_ms": 30_000})),
)
.await
}));
}
let mut claimed = 0;
let mut held = 0;
for handle in handles {
let (status, _) = handle.await.unwrap();
match status {
StatusCode::OK => claimed += 1,
StatusCode::CONFLICT => held += 1,
other => panic!("unexpected activate status {other}"),
}
}
assert_eq!(claimed, 1, "exactly one racer may claim the activation");
assert_eq!(held, 15);
}
#[tokio::test]
#[ignore = "requires DATABASE_URL"]
async fn concurrent_turn_claims_lease_exactly_one_message() {
let app = postgres_app();
let agent_id = format!("pg-turn-{}", uniq());
register(&app, &agent_id).await;
for n in 1..=2 {
let (status, _) = call(
&app,
"POST",
&format!("/agents/{agent_id}/mailbox"),
Some(json!({"kind": "summarize", "payload": {"n": n}})),
)
.await;
assert_eq!(status, StatusCode::CREATED);
}
let fencing = activate_one(&app, &agent_id, "worker-1", 30_000).await;
let mut handles = Vec::new();
for _ in 0..8 {
let app = app.clone();
let agent_id = agent_id.clone();
handles.push(tokio::spawn(async move {
next(&app, &agent_id, "worker-1", fencing).await
}));
}
let mut leased = 0;
for handle in handles {
let (status, _) = handle.await.unwrap();
match status {
StatusCode::OK => leased += 1,
StatusCode::NO_CONTENT => {}
other => panic!("unexpected mailbox/next status {other}"),
}
}
assert_eq!(
leased, 1,
"turn serialization: one message at a time, even under a racing holder"
);
}