refactor: split top-5 largest files into mod.rs + tests.rs
Five files in server/src/ exceeded 1500 lines, with 50–75% of the line
count being inline `#[cfg(test)] mod tests { ... }` blocks. Agents
working on these files have to navigate huge buffers via Read calls,
costing turn budget that could go toward actual work.
Pattern: convert `foo.rs` to `foo/mod.rs` + `foo/tests.rs`.
Rust resolves `mod foo;` to either form, so no parent-module changes
needed.
Before / after (production-code lines, what an agent has to navigate
when editing the module):
crdt_sync.rs: 3672 → 1003 (mod.rs) + 2667 (tests.rs)
crdt_state.rs: 2122 → 1263 (mod.rs) + 854 (tests.rs)
io/fs/scaffold.rs: 2045 → 702 (mod.rs) + 1342 (tests.rs)
http/mcp/mod.rs: 1882 → 1410 (mod.rs) + 472 (tests.rs)
http/mcp/story_tools.rs: 1864 → 725 (mod.rs) + 1137 (tests.rs)
Side change: scaffold/mod.rs's include_str! paths got an extra `../`
because the file moved one directory deeper.
Tests: full `cargo test` suite passes (2635 passed, 0 failed).
Formatting: cargo fmt --check clean.
Motivation: today's agent thrashing on 644 / 650 / 652 was partly due to
cumulative-counting (now fixed by 650) but also genuinely due to file
size — sonnet's 50-turn budget barely covers reading these files plus
making the change. Smaller production-code files mean more turn budget
left for the actual work.
Committed straight to master because this is an enabling refactor for
agent autonomy work; running it through the normal pipeline would
require an agent that has to navigate the very files it's about to
split, defeating the purpose.
This commit is contained in:
dave
@@ -0,0 +1,472 @@
|
||||
use super::*;
|
||||
use crate::http::test_helpers::test_ctx;
|
||||
|
||||
#[test]
|
||||
fn json_rpc_response_serializes_success() {
|
||||
let resp = JsonRpcResponse::success(Some(json!(1)), json!({"ok": true}));
|
||||
let s = serde_json::to_string(&resp).unwrap();
|
||||
assert!(s.contains("\"result\""));
|
||||
assert!(!s.contains("\"error\""));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn json_rpc_response_serializes_error() {
|
||||
let resp = JsonRpcResponse::error(Some(json!(1)), -32600, "bad".into());
|
||||
let s = serde_json::to_string(&resp).unwrap();
|
||||
assert!(s.contains("\"error\""));
|
||||
assert!(!s.contains("\"result\""));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn initialize_returns_capabilities() {
|
||||
let resp = handle_initialize(
|
||||
Some(json!(1)),
|
||||
&json!({"protocolVersion": "2025-03-26", "capabilities": {}, "clientInfo": {"name": "test", "version": "1.0"}}),
|
||||
);
|
||||
let result = resp.result.unwrap();
|
||||
assert_eq!(result["protocolVersion"], "2025-03-26");
|
||||
assert!(result["capabilities"]["tools"].is_object());
|
||||
assert_eq!(result["serverInfo"]["name"], "huskies");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tools_list_returns_all_tools() {
|
||||
let resp = handle_tools_list(Some(json!(2)));
|
||||
let result = resp.result.unwrap();
|
||||
let tools = result["tools"].as_array().unwrap();
|
||||
let names: Vec<&str> = tools.iter().map(|t| t["name"].as_str().unwrap()).collect();
|
||||
assert!(names.contains(&"create_story"));
|
||||
assert!(names.contains(&"validate_stories"));
|
||||
assert!(names.contains(&"list_upcoming"));
|
||||
assert!(names.contains(&"get_story_todos"));
|
||||
assert!(names.contains(&"record_tests"));
|
||||
assert!(names.contains(&"ensure_acceptance"));
|
||||
assert!(names.contains(&"start_agent"));
|
||||
assert!(names.contains(&"stop_agent"));
|
||||
assert!(names.contains(&"list_agents"));
|
||||
assert!(names.contains(&"get_agent_config"));
|
||||
assert!(names.contains(&"reload_agent_config"));
|
||||
assert!(names.contains(&"get_agent_output"));
|
||||
assert!(names.contains(&"wait_for_agent"));
|
||||
assert!(names.contains(&"get_agent_remaining_turns_and_budget"));
|
||||
assert!(names.contains(&"create_worktree"));
|
||||
assert!(names.contains(&"list_worktrees"));
|
||||
assert!(names.contains(&"remove_worktree"));
|
||||
assert!(names.contains(&"get_editor_command"));
|
||||
assert!(!names.contains(&"report_completion"));
|
||||
assert!(names.contains(&"accept_story"));
|
||||
assert!(names.contains(&"check_criterion"));
|
||||
assert!(names.contains(&"add_criterion"));
|
||||
assert!(names.contains(&"update_story"));
|
||||
assert!(names.contains(&"create_spike"));
|
||||
assert!(names.contains(&"create_bug"));
|
||||
assert!(names.contains(&"list_bugs"));
|
||||
assert!(names.contains(&"close_bug"));
|
||||
assert!(names.contains(&"create_refactor"));
|
||||
assert!(names.contains(&"list_refactors"));
|
||||
assert!(names.contains(&"merge_agent_work"));
|
||||
assert!(names.contains(&"get_merge_status"));
|
||||
assert!(names.contains(&"move_story_to_merge"));
|
||||
assert!(names.contains(&"report_merge_failure"));
|
||||
assert!(names.contains(&"request_qa"));
|
||||
assert!(names.contains(&"approve_qa"));
|
||||
assert!(names.contains(&"reject_qa"));
|
||||
assert!(names.contains(&"launch_qa_app"));
|
||||
assert!(names.contains(&"get_server_logs"));
|
||||
assert!(names.contains(&"prompt_permission"));
|
||||
assert!(names.contains(&"get_pipeline_status"));
|
||||
assert!(names.contains(&"rebuild_and_restart"));
|
||||
assert!(names.contains(&"get_token_usage"));
|
||||
assert!(names.contains(&"move_story"));
|
||||
assert!(names.contains(&"unblock_story"));
|
||||
assert!(names.contains(&"delete_story"));
|
||||
assert!(names.contains(&"run_command"));
|
||||
assert!(names.contains(&"run_tests"));
|
||||
assert!(names.contains(&"get_test_result"));
|
||||
assert!(names.contains(&"run_build"));
|
||||
assert!(names.contains(&"run_lint"));
|
||||
assert!(names.contains(&"git_status"));
|
||||
assert!(names.contains(&"git_diff"));
|
||||
assert!(names.contains(&"git_add"));
|
||||
assert!(names.contains(&"git_commit"));
|
||||
assert!(names.contains(&"git_log"));
|
||||
assert!(names.contains(&"status"));
|
||||
assert!(names.contains(&"loc_file"));
|
||||
assert!(names.contains(&"dump_crdt"));
|
||||
assert!(names.contains(&"get_version"));
|
||||
assert!(names.contains(&"remove_criterion"));
|
||||
assert_eq!(tools.len(), 66);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tools_list_schemas_have_required_fields() {
|
||||
let resp = handle_tools_list(Some(json!(1)));
|
||||
let tools = resp.result.unwrap()["tools"].as_array().unwrap().clone();
|
||||
for tool in &tools {
|
||||
assert!(tool["name"].is_string(), "tool missing name");
|
||||
assert!(tool["description"].is_string(), "tool missing description");
|
||||
assert!(tool["inputSchema"].is_object(), "tool missing inputSchema");
|
||||
assert_eq!(tool["inputSchema"]["type"], "object");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn handle_tools_call_unknown_tool() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ctx = test_ctx(tmp.path());
|
||||
let rt = tokio::runtime::Runtime::new().unwrap();
|
||||
let resp = rt.block_on(handle_tools_call(
|
||||
Some(json!(1)),
|
||||
&json!({"name": "bogus_tool", "arguments": {}}),
|
||||
&ctx,
|
||||
));
|
||||
let result = resp.result.unwrap();
|
||||
assert_eq!(result["isError"], true);
|
||||
assert!(
|
||||
result["content"][0]["text"]
|
||||
.as_str()
|
||||
.unwrap()
|
||||
.contains("Unknown tool")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn to_sse_response_wraps_in_data_prefix() {
|
||||
let resp = JsonRpcResponse::success(Some(json!(1)), json!({"ok": true}));
|
||||
let http_resp = to_sse_response(resp);
|
||||
assert_eq!(
|
||||
http_resp.headers().get("content-type").unwrap(),
|
||||
"text/event-stream"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wants_sse_detects_accept_header() {
|
||||
// Can't easily construct a Request in tests without TestClient,
|
||||
// so test the logic indirectly via to_sse_response format
|
||||
let resp = JsonRpcResponse::success(Some(json!(1)), json!("ok"));
|
||||
let json_resp = to_json_response(resp);
|
||||
assert_eq!(
|
||||
json_resp.headers().get("content-type").unwrap(),
|
||||
"application/json"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn json_rpc_error_response_builds_json_response() {
|
||||
let resp = json_rpc_error_response(Some(json!(42)), -32600, "test error".into());
|
||||
assert_eq!(resp.status(), poem::http::StatusCode::OK);
|
||||
assert_eq!(
|
||||
resp.headers().get("content-type").unwrap(),
|
||||
"application/json"
|
||||
);
|
||||
}
|
||||
|
||||
// ── HTTP handler tests (TestClient) ───────────────────────────
|
||||
|
||||
fn test_mcp_app(ctx: std::sync::Arc<AppContext>) -> impl poem::Endpoint {
|
||||
use poem::EndpointExt;
|
||||
poem::Route::new()
|
||||
.at("/mcp", poem::post(mcp_post_handler).get(mcp_get_handler))
|
||||
.data(ctx)
|
||||
}
|
||||
|
||||
async fn read_body_json(resp: poem::test::TestResponse) -> Value {
|
||||
let body = resp.0.into_body().into_string().await.unwrap();
|
||||
serde_json::from_str(&body).unwrap()
|
||||
}
|
||||
|
||||
async fn post_json_mcp<E: poem::Endpoint>(cli: &poem::test::TestClient<E>, payload: &str) -> Value {
|
||||
let resp = cli
|
||||
.post("/mcp")
|
||||
.header("content-type", "application/json")
|
||||
.body(payload.to_string())
|
||||
.send()
|
||||
.await;
|
||||
read_body_json(resp).await
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_get_handler_returns_405() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ctx = std::sync::Arc::new(test_ctx(tmp.path()));
|
||||
let cli = poem::test::TestClient::new(test_mcp_app(ctx));
|
||||
let resp = cli.get("/mcp").send().await;
|
||||
assert_eq!(resp.0.status(), poem::http::StatusCode::METHOD_NOT_ALLOWED);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_post_invalid_content_type_returns_error() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ctx = std::sync::Arc::new(test_ctx(tmp.path()));
|
||||
let cli = poem::test::TestClient::new(test_mcp_app(ctx));
|
||||
let resp = cli
|
||||
.post("/mcp")
|
||||
.header("content-type", "text/plain")
|
||||
.body("{}")
|
||||
.send()
|
||||
.await;
|
||||
let body = read_body_json(resp).await;
|
||||
assert!(body.get("error").is_some(), "expected error field: {body}");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_post_invalid_json_returns_parse_error() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ctx = std::sync::Arc::new(test_ctx(tmp.path()));
|
||||
let cli = poem::test::TestClient::new(test_mcp_app(ctx));
|
||||
let resp = cli
|
||||
.post("/mcp")
|
||||
.header("content-type", "application/json")
|
||||
.body("not-valid-json")
|
||||
.send()
|
||||
.await;
|
||||
let body = read_body_json(resp).await;
|
||||
assert!(body.get("error").is_some(), "expected error field: {body}");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_post_wrong_jsonrpc_version_returns_error() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ctx = std::sync::Arc::new(test_ctx(tmp.path()));
|
||||
let cli = poem::test::TestClient::new(test_mcp_app(ctx));
|
||||
let body = post_json_mcp(
|
||||
&cli,
|
||||
r#"{"jsonrpc":"1.0","id":1,"method":"initialize","params":{}}"#,
|
||||
)
|
||||
.await;
|
||||
assert!(
|
||||
body["error"]["message"]
|
||||
.as_str()
|
||||
.unwrap_or("")
|
||||
.contains("version"),
|
||||
"expected version error: {body}"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_post_notification_with_null_id_returns_accepted() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ctx = std::sync::Arc::new(test_ctx(tmp.path()));
|
||||
let cli = poem::test::TestClient::new(test_mcp_app(ctx));
|
||||
let resp = cli
|
||||
.post("/mcp")
|
||||
.header("content-type", "application/json")
|
||||
.body(r#"{"jsonrpc":"2.0","method":"notifications/initialized","params":{}}"#)
|
||||
.send()
|
||||
.await;
|
||||
assert_eq!(resp.0.status(), poem::http::StatusCode::ACCEPTED);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_post_notification_with_explicit_null_id_returns_accepted() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ctx = std::sync::Arc::new(test_ctx(tmp.path()));
|
||||
let cli = poem::test::TestClient::new(test_mcp_app(ctx));
|
||||
let resp = cli
|
||||
.post("/mcp")
|
||||
.header("content-type", "application/json")
|
||||
.body(r#"{"jsonrpc":"2.0","id":null,"method":"notifications/initialized","params":{}}"#)
|
||||
.send()
|
||||
.await;
|
||||
assert_eq!(resp.0.status(), poem::http::StatusCode::ACCEPTED);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_post_missing_id_non_notification_returns_error() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ctx = std::sync::Arc::new(test_ctx(tmp.path()));
|
||||
let cli = poem::test::TestClient::new(test_mcp_app(ctx));
|
||||
let body = post_json_mcp(
|
||||
&cli,
|
||||
r#"{"jsonrpc":"2.0","method":"initialize","params":{}}"#,
|
||||
)
|
||||
.await;
|
||||
assert!(body.get("error").is_some(), "expected error: {body}");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_post_unknown_method_returns_error() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ctx = std::sync::Arc::new(test_ctx(tmp.path()));
|
||||
let cli = poem::test::TestClient::new(test_mcp_app(ctx));
|
||||
let body = post_json_mcp(
|
||||
&cli,
|
||||
r#"{"jsonrpc":"2.0","id":1,"method":"bogus/method","params":{}}"#,
|
||||
)
|
||||
.await;
|
||||
assert!(
|
||||
body["error"]["message"]
|
||||
.as_str()
|
||||
.unwrap_or("")
|
||||
.contains("Unknown method"),
|
||||
"expected unknown method error: {body}"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_post_initialize_returns_capabilities() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ctx = std::sync::Arc::new(test_ctx(tmp.path()));
|
||||
let cli = poem::test::TestClient::new(test_mcp_app(ctx));
|
||||
let body = post_json_mcp(
|
||||
&cli,
|
||||
r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}"#,
|
||||
)
|
||||
.await;
|
||||
assert_eq!(body["result"]["protocolVersion"], "2025-03-26");
|
||||
assert_eq!(body["result"]["serverInfo"]["name"], "huskies");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_post_tools_list_returns_tools() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ctx = std::sync::Arc::new(test_ctx(tmp.path()));
|
||||
let cli = poem::test::TestClient::new(test_mcp_app(ctx));
|
||||
let body = post_json_mcp(
|
||||
&cli,
|
||||
r#"{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}"#,
|
||||
)
|
||||
.await;
|
||||
assert!(body["result"]["tools"].is_array());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_post_sse_returns_event_stream_content_type() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ctx = std::sync::Arc::new(test_ctx(tmp.path()));
|
||||
let cli = poem::test::TestClient::new(test_mcp_app(ctx));
|
||||
let resp = cli
|
||||
.post("/mcp")
|
||||
.header("content-type", "application/json")
|
||||
.header("accept", "text/event-stream")
|
||||
.body(r#"{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}"#)
|
||||
.send()
|
||||
.await;
|
||||
assert_eq!(
|
||||
resp.0.headers().get("content-type").unwrap(),
|
||||
"text/event-stream"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_post_sse_get_agent_output_missing_story_id() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ctx = std::sync::Arc::new(test_ctx(tmp.path()));
|
||||
let cli = poem::test::TestClient::new(test_mcp_app(ctx));
|
||||
let resp = cli
|
||||
.post("/mcp")
|
||||
.header("content-type", "application/json")
|
||||
.header("accept", "text/event-stream")
|
||||
.body(r#"{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_agent_output","arguments":{}}}"#)
|
||||
.send()
|
||||
.await;
|
||||
assert_eq!(
|
||||
resp.0.headers().get("content-type").unwrap(),
|
||||
"text/event-stream",
|
||||
"expected SSE content-type"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_post_sse_get_agent_output_without_agent_name_returns_disk_content() {
|
||||
// Without agent_name the SSE live-streaming intercept is skipped and
|
||||
// the disk-based handler runs. The transport still wraps the result in
|
||||
// SSE format (data: …\n\n) because the client sent Accept: text/event-stream,
|
||||
// but the content should be a valid JSON-RPC result, not a subscribe error.
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ctx = std::sync::Arc::new(test_ctx(tmp.path()));
|
||||
let cli = poem::test::TestClient::new(test_mcp_app(ctx));
|
||||
let resp = cli
|
||||
.post("/mcp")
|
||||
.header("content-type", "application/json")
|
||||
.header("accept", "text/event-stream")
|
||||
.body(r#"{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_agent_output","arguments":{"story_id":"1_test"}}}"#)
|
||||
.send()
|
||||
.await;
|
||||
let body = resp.0.into_body().into_string().await.unwrap();
|
||||
// Body is SSE-wrapped: "data: {…}\n\n" — strip the prefix and verify it's
|
||||
// a valid JSON-RPC result (not an error about missing agent_name).
|
||||
let json_part = body
|
||||
.trim_start_matches("data: ")
|
||||
.trim_end_matches("\n\n")
|
||||
.trim();
|
||||
let parsed: serde_json::Value = serde_json::from_str(json_part)
|
||||
.unwrap_or_else(|_| panic!("expected JSON-RPC in SSE body, got: {body}"));
|
||||
assert!(
|
||||
parsed.get("result").is_some(),
|
||||
"expected JSON-RPC result (disk-based handler ran): {parsed}"
|
||||
);
|
||||
// Must NOT be an error about missing agent_name (agent_name is now optional)
|
||||
assert!(
|
||||
parsed.get("error").is_none(),
|
||||
"unexpected error when agent_name omitted: {parsed}"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_post_sse_get_agent_output_no_agent_no_logs_returns_not_found() {
|
||||
// Agent not in pool and no log files → SSE success with "No log files found" message.
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ctx = std::sync::Arc::new(test_ctx(tmp.path()));
|
||||
let cli = poem::test::TestClient::new(test_mcp_app(ctx));
|
||||
let resp = cli
|
||||
.post("/mcp")
|
||||
.header("content-type", "application/json")
|
||||
.header("accept", "text/event-stream")
|
||||
.body(r#"{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_agent_output","arguments":{"story_id":"99_nope","agent_name":"bot"}}}"#)
|
||||
.send()
|
||||
.await;
|
||||
assert_eq!(
|
||||
resp.0.headers().get("content-type").unwrap(),
|
||||
"text/event-stream"
|
||||
);
|
||||
let body = resp.0.into_body().into_string().await.unwrap();
|
||||
assert!(body.contains("data:"), "expected SSE data prefix: {body}");
|
||||
// Must NOT return isError — should be a success result with "No log files found"
|
||||
assert!(
|
||||
!body.contains("isError"),
|
||||
"expected no isError for missing agent: {body}"
|
||||
);
|
||||
assert!(
|
||||
body.contains("No log files found"),
|
||||
"expected not-found message: {body}"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_post_sse_get_agent_output_exited_agent_reads_disk_logs() {
|
||||
use crate::agent_log::AgentLogWriter;
|
||||
use crate::agents::AgentEvent;
|
||||
// Agent has exited (not in pool) but wrote logs to disk.
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path();
|
||||
let mut writer = AgentLogWriter::new(root, "42_story_foo", "coder-1", "sess-sse").unwrap();
|
||||
writer
|
||||
.write_event(&AgentEvent::Output {
|
||||
story_id: "42_story_foo".to_string(),
|
||||
agent_name: "coder-1".to_string(),
|
||||
text: "disk output".to_string(),
|
||||
})
|
||||
.unwrap();
|
||||
drop(writer);
|
||||
|
||||
let ctx = std::sync::Arc::new(test_ctx(root));
|
||||
let cli = poem::test::TestClient::new(test_mcp_app(ctx));
|
||||
let resp = cli
|
||||
.post("/mcp")
|
||||
.header("content-type", "application/json")
|
||||
.header("accept", "text/event-stream")
|
||||
.body(r#"{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_agent_output","arguments":{"story_id":"42_story_foo","agent_name":"coder-1"}}}"#)
|
||||
.send()
|
||||
.await;
|
||||
let body = resp.0.into_body().into_string().await.unwrap();
|
||||
assert!(
|
||||
body.contains("disk output"),
|
||||
"expected disk log content in SSE response: {body}"
|
||||
);
|
||||
assert!(
|
||||
!body.contains("isError"),
|
||||
"expected no error for exited agent with logs: {body}"
|
||||
);
|
||||
}
|
||||
Reference in New Issue
Block a user