use serde_json::json;
use wiremock::matchers::{method, path, query_param};
use wiremock::{Mock, MockServer, ResponseTemplate};
use taskfast_cli::cmd::events::{run, AckArgs, Command, PollArgs, SchemaArgs};
use taskfast_cli::cmd::{CmdError, Ctx};
use taskfast_cli::{Envelope, Environment};
fn ctx_for(server: &MockServer, key: Option<&str>) -> Ctx {
Ctx {
api_key: key.map(String::from),
environment: Environment::Local,
api_base: Some(server.uri()),
config_path: std::path::PathBuf::from("/dev/null"),
dry_run: false,
quiet: true,
..Default::default()
}
}
fn envelope_value(env: &Envelope) -> serde_json::Value {
serde_json::to_value(env).expect("serialize envelope")
}
#[tokio::test]
async fn poll_forwards_cursor_and_limit_and_returns_events() {
let server = MockServer::start().await;
let event = json!({
"event_id": "00000000-0000-0000-0000-0000000000e1",
"event": "task_disputed",
"occurred_at": "2026-04-13T21:00:00Z",
"task_id": "00000000-0000-0000-0000-0000000000aa",
"data": { "reason": "late" },
});
Mock::given(method("GET"))
.and(path("/agents/me/events"))
.and(query_param("cursor", "abc"))
.and(query_param("limit", "3"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"data": [event],
"meta": { "next_cursor": "next-abc", "has_more": true, "total_count": 1 },
})))
.mount(&server)
.await;
let args = PollArgs {
cursor: Some("abc".into()),
limit: 3,
};
let envelope = run(&ctx_for(&server, Some("test-key")), Command::Poll(args))
.await
.expect("poll should succeed");
let v = envelope_value(&envelope);
assert_eq!(v["ok"], true);
assert_eq!(v["data"]["meta"]["next_cursor"], "next-abc");
assert_eq!(v["data"]["events"][0]["event"], "task_disputed");
}
#[tokio::test]
async fn poll_empty_page_returns_empty_events() {
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/agents/me/events"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"data": [],
"meta": { "next_cursor": null, "has_more": false, "total_count": 0 },
})))
.mount(&server)
.await;
let envelope = run(
&ctx_for(&server, Some("test-key")),
Command::Poll(PollArgs {
cursor: None,
limit: 25,
}),
)
.await
.expect("poll should succeed");
let v = envelope_value(&envelope);
assert_eq!(v["data"]["events"], json!([]));
assert_eq!(v["data"]["meta"]["has_more"], false);
}
#[tokio::test]
async fn poll_401_surfaces_as_auth_error() {
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/agents/me/events"))
.respond_with(ResponseTemplate::new(401).set_body_json(json!({
"error": "invalid_api_key",
"message": "bad key",
})))
.mount(&server)
.await;
let err = run(
&ctx_for(&server, Some("test-key")),
Command::Poll(PollArgs {
cursor: None,
limit: 25,
}),
)
.await
.expect_err("401 must surface as Auth");
match err {
CmdError::Auth(_) => {}
other => panic!("expected Auth, got {other:?}"),
}
}
#[tokio::test]
async fn poll_missing_api_key_errors_before_any_http_call() {
let server = MockServer::start().await;
let err = run(
&ctx_for(&server, None),
Command::Poll(PollArgs {
cursor: None,
limit: 25,
}),
)
.await
.expect_err("no key → MissingApiKey");
assert!(matches!(err, CmdError::MissingApiKey), "got {err:?}");
}
#[tokio::test]
async fn ack_is_unsupported_and_points_to_ack_stdin() {
let server = MockServer::start().await;
let err = run(
&ctx_for(&server, Some("test-key")),
Command::Ack(AckArgs {
event_id: "00000000-0000-0000-0000-0000000000e1".into(),
}),
)
.await
.expect_err("ack → Usage");
match err {
CmdError::Usage(msg) => assert!(msg.contains("--ack-stdin"), "{msg}"),
other => panic!("expected Usage, got {other:?}"),
}
assert!(server.received_requests().await.unwrap().is_empty());
}
#[tokio::test]
async fn schema_returns_full_spec_by_default() {
let server = MockServer::start().await;
let spec = json!({
"asyncapi": "2.6.0",
"info": { "title": "TaskFast Agent Events", "version": "1" },
"components": {
"messages": {
"TaskAssigned": { "payload": { "type": "object" } },
"BidAccepted": { "payload": { "type": "object" } },
}
},
});
Mock::given(method("GET"))
.and(path("/asyncapi.json"))
.respond_with(ResponseTemplate::new(200).set_body_json(spec.clone()))
.mount(&server)
.await;
let envelope = run(
&ctx_for(&server, Some("test-key")),
Command::Schema(SchemaArgs { event: None }),
)
.await
.expect("schema should succeed");
let v = envelope_value(&envelope);
assert_eq!(v["data"]["asyncapi"], "2.6.0");
assert!(v["data"]["components"]["messages"]["TaskAssigned"].is_object());
}
#[tokio::test]
async fn schema_filters_by_event_key() {
let server = MockServer::start().await;
let spec = json!({
"asyncapi": "2.6.0",
"components": {
"messages": {
"TaskAssigned": { "payload": { "type": "object", "required": ["task_id"] } },
}
},
});
Mock::given(method("GET"))
.and(path("/asyncapi.json"))
.respond_with(ResponseTemplate::new(200).set_body_json(spec))
.mount(&server)
.await;
let envelope = run(
&ctx_for(&server, Some("test-key")),
Command::Schema(SchemaArgs {
event: Some("TaskAssigned".into()),
}),
)
.await
.expect("schema filter should succeed");
let v = envelope_value(&envelope);
assert_eq!(v["data"]["event"], "TaskAssigned");
assert_eq!(v["data"]["message"]["payload"]["required"][0], "task_id");
}
#[tokio::test]
async fn schema_unknown_event_is_validation_error() {
let server = MockServer::start().await;
let spec = json!({
"asyncapi": "2.6.0",
"components": { "messages": {} },
});
Mock::given(method("GET"))
.and(path("/asyncapi.json"))
.respond_with(ResponseTemplate::new(200).set_body_json(spec))
.mount(&server)
.await;
let err = run(
&ctx_for(&server, Some("test-key")),
Command::Schema(SchemaArgs {
event: Some("MadeUpEvent".into()),
}),
)
.await
.expect_err("unknown event → Validation");
match err {
CmdError::Validation { code, .. } => assert_eq!(code, "unknown_event"),
other => panic!("expected Validation, got {other:?}"),
}
}
#[tokio::test]
async fn poll_tolerates_malformed_event_and_surfaces_unparseable() {
let server = MockServer::start().await;
let good = json!({
"event_id": "00000000-0000-0000-0000-0000000000e1",
"event": "task_disputed",
"occurred_at": "2026-04-20T00:00:00Z",
"data": {},
});
let bad = json!({
"event": "task_disputed",
"occurred_at": "2026-04-20T00:00:00Z",
"data": {},
});
Mock::given(method("GET"))
.and(path("/agents/me/events"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"data": [good, bad],
"meta": { "next_cursor": null, "has_more": false, "total_count": 2 },
})))
.mount(&server)
.await;
let envelope = run(
&ctx_for(&server, Some("test-key")),
Command::Poll(PollArgs {
cursor: None,
limit: 25,
}),
)
.await
.expect("tolerant poll should succeed");
let v = envelope_value(&envelope);
assert_eq!(v["ok"], true);
assert_eq!(v["data"]["events"].as_array().unwrap().len(), 1);
assert_eq!(v["data"]["events"][0]["event"], "task_disputed");
assert_eq!(v["data"]["unparseable"].as_array().unwrap().len(), 1);
assert!(v["data"]["unparseable"][0]["error"]
.as_str()
.unwrap()
.contains("event_id"));
}
#[tokio::test]
async fn poll_skips_event_already_printed() {
let server = MockServer::start().await;
let event = json!({
"event_id": "00000000-0000-0000-0000-0000000000e1",
"event": "task_disputed",
"occurred_at": "2026-04-13T21:00:00Z",
"task_id": "00000000-0000-0000-0000-0000000000aa",
"data": {},
});
Mock::given(method("GET"))
.and(path("/agents/me/events"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"data": [event],
"meta": { "next_cursor": null, "has_more": false, "total_count": 1 },
})))
.mount(&server)
.await;
let dir = tempfile::tempdir().unwrap();
let mut ctx = ctx_for(&server, Some("test-key"));
ctx.config_path = dir.path().join("config.json");
let poll = || PollArgs {
cursor: None,
limit: 25,
};
let first = run(&ctx, Command::Poll(poll())).await.unwrap();
assert_eq!(
envelope_value(&first)["data"]["events"]
.as_array()
.unwrap()
.len(),
1
);
let second = run(&ctx, Command::Poll(poll())).await.unwrap();
assert_eq!(envelope_value(&second)["data"]["events"], json!([]));
}
#[tokio::test]
async fn poll_with_explicit_cursor_prints_seen_events() {
let server = MockServer::start().await;
let event = json!({
"event_id": "00000000-0000-0000-0000-0000000000e2",
"event": "task_disputed",
"occurred_at": "2026-04-13T21:00:00Z",
"task_id": "00000000-0000-0000-0000-0000000000aa",
"data": {},
});
Mock::given(method("GET"))
.and(path("/agents/me/events"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"data": [event],
"meta": { "next_cursor": null, "has_more": false, "total_count": 1 },
})))
.mount(&server)
.await;
let dir = tempfile::tempdir().unwrap();
let mut ctx = ctx_for(&server, Some("test-key"));
ctx.config_path = dir.path().join("config.json");
let args = |cursor: Option<&str>| PollArgs {
cursor: cursor.map(String::from),
limit: 25,
};
let count = |env: &Envelope| {
envelope_value(env)["data"]["events"]
.as_array()
.unwrap()
.len()
};
for _ in 0..2 {
let env = run(&ctx, Command::Poll(args(Some("c1")))).await.unwrap();
assert_eq!(count(&env), 1);
}
let env = run(&ctx, Command::Poll(args(None))).await.unwrap();
assert_eq!(count(&env), 0);
}