use super::*;
use crate::workflow::parse::parse;
fn no_ask(_: &str) -> AskOutcome {
AskOutcome::Unavailable
}
fn no_log(_: serde_json::Value) {}
async fn eval_capture(
name: &str,
src: &str,
tools: Vec<ToolDef>,
workflows: HashMap<String, Workflow>,
ask: &AskHandler<'_>,
) -> (
Result<serde_json::Value, WorkflowError>,
Vec<serde_json::Value>,
) {
let wf = parse(src).expect("parse failed");
let registry = Registry::default();
let client = crate::ai::Client::new();
let keys = HashMap::new();
let inputs = HashMap::new();
let events = std::cell::RefCell::new(Vec::new());
let result = {
let sink = |e: serde_json::Value| events.borrow_mut().push(e);
eval(
name, &wf, ®istry, &tools, &client, &keys, &inputs, &workflows, ask, &sink,
)
.await
};
(result, events.into_inner())
}
fn event_names(events: &[serde_json::Value]) -> Vec<&str> {
events
.iter()
.map(|e| e["event"].as_str().unwrap())
.collect()
}
async fn eval_src(src: &str) -> Result<serde_json::Value, WorkflowError> {
let wf = parse(src).expect("parse failed");
let registry = Registry::default();
let client = crate::ai::Client::new();
let keys = HashMap::new();
let inputs = HashMap::new();
let workflows = HashMap::new();
eval(
"test",
&wf,
®istry,
&[],
&client,
&keys,
&inputs,
&workflows,
&no_ask,
&no_log,
)
.await
}
#[tokio::test]
async fn evaluates_string_literal() {
let v = eval_src(r#"x = "hello""#).await.unwrap();
assert_eq!(v, serde_json::json!("hello"));
}
#[tokio::test]
async fn evaluates_number_literal() {
let v = eval_src("x = 42").await.unwrap();
assert_eq!(v, serde_json::json!(42.0));
}
#[tokio::test]
async fn evaluates_bool_literal() {
let v = eval_src("x = true").await.unwrap();
assert_eq!(v, serde_json::json!(true));
}
#[tokio::test]
async fn seeds_declared_inputs_into_scope() {
let wf = parse("# inputs: CITY:string\n\ngreeting = \"hi \" + CITY").unwrap();
let registry = Registry::default();
let client = crate::ai::Client::new();
let keys = HashMap::new();
let mut inputs = HashMap::new();
inputs.insert("CITY".to_string(), serde_json::json!("Portland"));
let workflows = HashMap::new();
let v = eval(
"test",
&wf,
®istry,
&[],
&client,
&keys,
&inputs,
&workflows,
&no_ask,
&no_log,
)
.await
.unwrap();
assert_eq!(v, serde_json::json!("hi Portland"));
}
#[tokio::test]
async fn evaluates_string_concatenation() {
let v = eval_src(r#"x = "hello" + " " + "world""#).await.unwrap();
assert_eq!(v, serde_json::json!("hello world"));
}
#[tokio::test]
async fn evaluates_equality_and_comparison() {
let cases = [
("x = 1 == 1", true),
("x = 1 == 2", false),
("x = 1 != 2", true),
(r#"x = "a" == "a""#, true),
(r#"x = "a" != "a""#, false),
("x = true == true", true),
("x = 1 < 2", true),
("x = 2 < 1", false),
("x = 2 <= 2", true),
("x = 3 > 2", true),
("x = 2 >= 3", false),
(r#"x = "a" < "b""#, true),
(r#"x = "b" < "a""#, false),
];
for (src, expected) in cases {
let v = eval_src(src)
.await
.unwrap_or_else(|e| panic!("eval failed for `{src}`: {e}"));
assert_eq!(v, serde_json::json!(expected), "for source `{src}`");
}
}
#[tokio::test]
async fn equality_treats_integer_and_float_as_equal() {
let wf = parse("# inputs: N:number\n\nx = N == 1").unwrap();
let registry = Registry::default();
let client = crate::ai::Client::new();
let keys = HashMap::new();
let mut inputs = HashMap::new();
inputs.insert("N".to_string(), serde_json::json!(1)); let workflows = HashMap::new();
let v = eval(
"test",
&wf,
®istry,
&[],
&client,
&keys,
&inputs,
&workflows,
&no_ask,
&no_log,
)
.await
.unwrap();
assert_eq!(v, serde_json::json!(true));
}
#[tokio::test]
async fn evaluates_arithmetic() {
let v = eval_src("x = 2 + 3 * 4").await.unwrap();
assert_eq!(v, serde_json::json!(20.0));
}
#[tokio::test]
async fn evaluates_power() {
let v = eval_src("x = 2 ^ 10").await.unwrap();
assert_eq!(v, serde_json::json!(1024.0));
}
#[tokio::test]
async fn evaluates_logical_ops() {
let v = eval_src("x = true && false").await.unwrap();
assert_eq!(v, serde_json::json!(false));
let v = eval_src("x = false || true").await.unwrap();
assert_eq!(v, serde_json::json!(true));
}
#[tokio::test]
async fn evaluates_not() {
let v = eval_src("x = !true").await.unwrap();
assert_eq!(v, serde_json::json!(false));
}
#[tokio::test]
async fn evaluates_object_literal() {
let v = eval_src(r#"x = { "a": 1, "b": "hi" }"#).await.unwrap();
assert_eq!(v, serde_json::json!({"a": 1.0, "b": "hi"}));
}
#[tokio::test]
async fn evaluates_variable_reference() {
let v = eval_src("city = \"Portland\"\n\nname = city")
.await
.unwrap();
assert_eq!(v, serde_json::json!("Portland"));
}
#[tokio::test]
async fn last_statement_value_is_returned() {
let v = eval_src("a = 1\n\nb = 2\n\nc = 3").await.unwrap();
assert_eq!(v, serde_json::json!(3.0));
}
#[tokio::test]
async fn evaluates_member_access() {
let v = eval_src("obj = { \"x\": 42 }\n\nv = obj.x").await.unwrap();
assert_eq!(v, serde_json::json!(42.0));
}
#[tokio::test]
async fn evaluates_array_index_access() {
let arr = serde_json::json!([10, 20, 30]);
let registry = Registry::default();
let client = crate::ai::Client::new();
let keys = HashMap::new();
let workflows = HashMap::new();
let ctx = EvalCtx {
registry: ®istry,
tools: &[],
client: &client,
keys: &keys,
workflows: &workflows,
ask: &no_ask,
log: &no_log,
};
let frame = Frame {
wf: "test",
stmt: "val",
};
let val = eval_access(
arr,
&AccessKey::Index(1),
Env::new(),
&ctx,
Vec::new(),
frame,
)
.await
.unwrap();
assert_eq!(val, serde_json::json!(20));
}
#[tokio::test]
async fn computed_index_accepts_float_backed_whole_number() {
let arr = serde_json::json!([10, 20, 30]);
let registry = Registry::default();
let client = crate::ai::Client::new();
let keys = HashMap::new();
let workflows = HashMap::new();
let ctx = EvalCtx {
registry: ®istry,
tools: &[],
client: &client,
keys: &keys,
workflows: &workflows,
ask: &no_ask,
log: &no_log,
};
let frame = Frame {
wf: "test",
stmt: "val",
};
let index = Expr::BinOp {
op: crate::workflow::BinOp::Sub,
lhs: Box::new(Expr::Num(1.0)),
rhs: Box::new(Expr::Num(1.0)),
};
let val = eval_access(
arr,
&AccessKey::Computed(Box::new(index)),
Env::new(),
&ctx,
Vec::new(),
frame,
)
.await
.unwrap();
assert_eq!(val, serde_json::json!(10));
}
#[tokio::test]
async fn evaluates_if_true_branch() {
let v = eval_src(r#"v = if (true) "yes", (_) "no""#).await.unwrap();
assert_eq!(v, serde_json::json!("yes"));
}
#[tokio::test]
async fn evaluates_if_default_branch() {
let v = eval_src(r#"v = if (false) "yes", (_) "no""#).await.unwrap();
assert_eq!(v, serde_json::json!("no"));
}
#[tokio::test]
async fn evaluates_for_as_map() {
let wf = parse("doubled = for [x: nums] (x)").unwrap();
let mut env = Env::new();
env.insert("nums".to_string(), serde_json::json!([1, 2, 3]));
let registry = Registry::default();
let client = crate::ai::Client::new();
let keys = HashMap::new();
let workflows = HashMap::new();
let ctx = EvalCtx {
registry: ®istry,
tools: &[],
client: &client,
keys: &keys,
workflows: &workflows,
ask: &no_ask,
log: &no_log,
};
let mut last = serde_json::Value::Null;
for stmt in &wf.statements {
let frame = Frame {
wf: "test",
stmt: &stmt.name,
};
let val = eval_expr(&stmt.expr, env.clone(), &ctx, Vec::new(), frame)
.await
.unwrap();
last = val.clone();
env.insert(stmt.name.clone(), val);
}
assert_eq!(last, serde_json::json!([1, 2, 3]));
}
#[tokio::test]
async fn do_runs_once_then_stops_when_while_is_false() {
let v = eval_src("answer = do (false) while (answer) max (5)")
.await
.unwrap();
assert_eq!(v, serde_json::json!(false));
}
#[tokio::test]
async fn do_rejects_max_below_one() {
let err = eval_src("answer = do (true) while (false) max (0)")
.await
.unwrap_err();
assert!(err.0.contains("at least 1"));
}
fn polling_tool() -> (ToolDef, std::path::PathBuf, std::path::PathBuf) {
use std::os::unix::fs::PermissionsExt;
let nonce = format!(
"{}_{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
);
let counter_path = std::env::temp_dir().join(format!("sp_wf_do_cnt_{nonce}"));
let script_path = std::env::temp_dir().join(format!("sp_wf_do_{nonce}.sh"));
std::fs::write(
&script_path,
format!(
"#!/bin/sh\nn=$(cat {cnt} 2>/dev/null || echo 0)\nn=$((n+1))\necho $n > {cnt}\n\
if [ $n -ge 3 ]; then d=true; else d=false; fi\n\
printf '{{\"done\":%s,\"count\":%s}}' $d $n > \"$SP_OUTPUT_PATH\"\n",
cnt = counter_path.display()
),
)
.unwrap();
std::fs::set_permissions(&script_path, std::fs::Permissions::from_mode(0o755)).unwrap();
let tool = ToolDef {
name: "poll".to_string(),
script: script_path.clone(),
description: String::new(),
params: vec![],
output: Some(crate::types::Type::Object(vec![
("done".to_string(), crate::types::Type::Bool),
("count".to_string(), crate::types::Type::Number),
])),
exits: vec![],
};
(tool, script_path, counter_path)
}
#[tokio::test]
async fn do_loops_until_while_reads_done_via_assigned_var() {
let (tool, script_path, counter_path) = polling_tool();
let val = eval_with_tool(
"result = do (run tool poll {}) while (!result.done) max (10)",
tool,
)
.await
.unwrap();
std::fs::remove_file(&script_path).ok();
std::fs::remove_file(&counter_path).ok();
assert_eq!(val, serde_json::json!({ "done": true, "count": 3 }));
}
#[tokio::test]
async fn do_caps_iterations_at_max() {
let (tool, script_path, counter_path) = polling_tool();
let val = eval_with_tool(
"result = do (run tool poll {}) while (!result.done) max (2)",
tool,
)
.await
.unwrap();
std::fs::remove_file(&script_path).ok();
std::fs::remove_file(&counter_path).ok();
assert_eq!(val, serde_json::json!({ "done": false, "count": 2 }));
}
#[tokio::test]
async fn run_tool_runs_script_and_reads_output() {
use std::os::unix::fs::PermissionsExt;
let script_path = std::env::temp_dir().join(format!(
"sp_wf_tool_{}_{}.sh",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
std::fs::write(
&script_path,
"#!/bin/sh\nprintf '{\"greeting\":\"hello %s\"}' \"$NAME\" > \"$SP_OUTPUT_PATH\"\n",
)
.unwrap();
std::fs::set_permissions(&script_path, std::fs::Permissions::from_mode(0o755)).unwrap();
let tool_def = ToolDef {
name: "greet".to_string(),
script: script_path.clone(),
description: String::new(),
params: vec![crate::types::Param {
name: "NAME".to_string(),
ty: crate::types::Type::String,
}],
output: Some(crate::types::Type::Object(vec![(
"greeting".to_string(),
crate::types::Type::String,
)])),
exits: vec![],
};
let wf = parse(r#"result = run tool greet { NAME: "world" }"#).unwrap();
let registry = Registry::default();
let client = crate::ai::Client::new();
let keys = HashMap::new();
let inputs = HashMap::new();
let workflows = HashMap::new();
let val = eval(
"test",
&wf,
®istry,
&[tool_def],
&client,
&keys,
&inputs,
&workflows,
&no_ask,
&no_log,
)
.await
.unwrap();
std::fs::remove_file(&script_path).ok();
assert_eq!(val, serde_json::json!({"greeting": "hello world"}));
}
#[tokio::test]
async fn run_tool_errors_when_sp_output_path_omitted() {
use std::os::unix::fs::PermissionsExt;
let script_path = std::env::temp_dir().join(format!(
"sp_wf_noout_{}_{}.sh",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
std::fs::write(&script_path, "#!/bin/sh\necho ok\n").unwrap();
std::fs::set_permissions(&script_path, std::fs::Permissions::from_mode(0o755)).unwrap();
let tool_def = ToolDef {
name: "silent".to_string(),
script: script_path.clone(),
description: String::new(),
params: vec![],
output: Some(crate::types::Type::String),
exits: vec![],
};
let wf = parse("result = run tool silent {}").unwrap();
let registry = Registry::default();
let client = crate::ai::Client::new();
let keys = HashMap::new();
let inputs = HashMap::new();
let workflows = HashMap::new();
let err = eval(
"test",
&wf,
®istry,
&[tool_def],
&client,
&keys,
&inputs,
&workflows,
&no_ask,
&no_log,
)
.await
.unwrap_err();
std::fs::remove_file(&script_path).ok();
assert!(err.0.contains("SP_OUTPUT_PATH"));
}
#[cfg(test)]
fn exiting_tool(code: i32) -> (ToolDef, std::path::PathBuf) {
use std::os::unix::fs::PermissionsExt;
let script_path = std::env::temp_dir().join(format!(
"sp_wf_exit_{}_{}.sh",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
std::fs::write(&script_path, format!("#!/bin/sh\nexit {code}\n")).unwrap();
std::fs::set_permissions(&script_path, std::fs::Permissions::from_mode(0o755)).unwrap();
let tool = ToolDef {
name: "ping".to_string(),
script: script_path.clone(),
description: String::new(),
params: vec![],
output: Some(crate::types::Type::Object(vec![(
"ms".to_string(),
crate::types::Type::Number,
)])),
exits: vec![
crate::types::ExitCode {
code: 1,
name: "unreachable".to_string(),
desc: None,
},
crate::types::ExitCode {
code: 2,
name: "badArgs".to_string(),
desc: None,
},
],
};
(tool, script_path)
}
#[cfg(test)]
async fn eval_with_tool(src: &str, tool: ToolDef) -> Result<serde_json::Value, WorkflowError> {
let wf = parse(src).expect("parse failed");
let registry = Registry::default();
let client = crate::ai::Client::new();
let keys = HashMap::new();
let inputs = HashMap::new();
let workflows = HashMap::new();
eval(
"test",
&wf,
®istry,
&[tool],
&client,
&keys,
&inputs,
&workflows,
&no_ask,
&no_log,
)
.await
}
#[tokio::test]
async fn run_tool_recovers_via_named_else_arm() {
let (tool, script_path) = exiting_tool(1); let val = eval_with_tool(
r#"r = run tool ping {} else { unreachable: { "ms": 0 }, badArgs: { "ms": 1 } }"#,
tool,
)
.await
.unwrap();
std::fs::remove_file(&script_path).ok();
assert_eq!(val, serde_json::json!({ "ms": 0.0 }));
}
#[tokio::test]
async fn run_tool_recovers_undeclared_exit_via_default_arm() {
let (tool, script_path) = exiting_tool(7); let val = eval_with_tool(r#"r = run tool ping {} else { _: { "ms": 99 } }"#, tool)
.await
.unwrap();
std::fs::remove_file(&script_path).ok();
assert_eq!(val, serde_json::json!({ "ms": 99.0 }));
}
#[tokio::test]
async fn run_tool_aborts_on_unhandled_nonzero_exit() {
let (tool, script_path) = exiting_tool(1);
let err = eval_with_tool("r = run tool ping {}", tool)
.await
.unwrap_err();
std::fs::remove_file(&script_path).ok();
assert!(err.0.contains("no `else` arm handles it"));
}
#[cfg(test)]
fn echo_tool() -> (ToolDef, std::path::PathBuf) {
use std::os::unix::fs::PermissionsExt;
let script_path = std::env::temp_dir().join(format!(
"sp_wf_echo_{}_{}.sh",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
std::fs::write(
&script_path,
"#!/bin/sh\nprintf '{\"v\":\"%s\"}' \"$NAME\" > \"$SP_OUTPUT_PATH\"\n",
)
.unwrap();
std::fs::set_permissions(&script_path, std::fs::Permissions::from_mode(0o755)).unwrap();
let tool = ToolDef {
name: "echo".to_string(),
script: script_path.clone(),
description: String::new(),
params: vec![crate::types::Param {
name: "NAME".to_string(),
ty: crate::types::Type::String,
}],
output: Some(crate::types::Type::Object(vec![(
"v".to_string(),
crate::types::Type::String,
)])),
exits: vec![],
};
(tool, script_path)
}
#[tokio::test]
async fn run_nests_a_workflow_passing_inputs() {
let (tool, script_path) = echo_tool();
let inner = parse("# inputs: WHO:string\n\nout = run tool echo { NAME: WHO }").unwrap();
let outer = parse(r#"r = run workflow inner { WHO: "world" }"#).unwrap();
let mut workflows = HashMap::new();
workflows.insert("inner".to_string(), inner);
let registry = Registry::default();
let client = crate::ai::Client::new();
let keys = HashMap::new();
let inputs = HashMap::new();
let val = eval(
"test",
&outer,
®istry,
&[tool],
&client,
&keys,
&inputs,
&workflows,
&no_ask,
&no_log,
)
.await
.unwrap();
std::fs::remove_file(&script_path).ok();
assert_eq!(val, serde_json::json!({"v": "world"}));
}
#[tokio::test]
async fn run_detects_a_cycle() {
let a = parse("x = run workflow b {}").unwrap();
let b = parse("y = run workflow a {}").unwrap();
let mut workflows = HashMap::new();
workflows.insert("a".to_string(), a.clone());
workflows.insert("b".to_string(), b);
let registry = Registry::default();
let client = crate::ai::Client::new();
let keys = HashMap::new();
let inputs = HashMap::new();
let err = eval(
"test",
&a,
®istry,
&[],
&client,
&keys,
&inputs,
&workflows,
&no_ask,
&no_log,
)
.await
.unwrap_err();
assert!(err.0.contains("cycle"), "{}", err.0);
}
async fn eval_src_with_ask(
src: &str,
ask: &AskHandler<'_>,
) -> Result<serde_json::Value, WorkflowError> {
let wf = parse(src).expect("parse failed");
let registry = Registry::default();
let client = crate::ai::Client::new();
let keys = HashMap::new();
let inputs = HashMap::new();
let workflows = HashMap::new();
eval(
"test",
&wf,
®istry,
&[],
&client,
&keys,
&inputs,
&workflows,
ask,
&no_log,
)
.await
}
#[tokio::test]
async fn ask_returns_the_user_answer() {
let answer = |_: &str| AskOutcome::Answered("Boston".to_string());
let v = eval_src_with_ask(r#"c = ask "Which city?""#, &answer)
.await
.unwrap();
assert_eq!(v, serde_json::json!("Boston"));
}
#[tokio::test]
async fn ask_empty_answer_is_the_empty_string() {
let answer = |_: &str| AskOutcome::Answered(String::new());
let v = eval_src_with_ask(r#"c = ask "Which city?""#, &answer)
.await
.unwrap();
assert_eq!(v, serde_json::json!(""));
}
#[tokio::test]
async fn ask_evaluates_its_prompt_and_passes_it_to_the_handler() {
let echo = |p: &str| AskOutcome::Answered(format!("got:{p}"));
let v = eval_src_with_ask(r#"c = ask ("Which " + "city?")"#, &echo)
.await
.unwrap();
assert_eq!(v, serde_json::json!("got:Which city?"));
}
#[tokio::test]
async fn ask_unavailable_falls_back_to_else() {
let v = eval_src_with_ask(r#"c = ask "Which city?" else "Portland""#, &no_ask)
.await
.unwrap();
assert_eq!(v, serde_json::json!("Portland"));
}
#[tokio::test]
async fn ask_unavailable_without_else_aborts() {
let err = eval_src_with_ask(r#"c = ask "Which city?""#, &no_ask)
.await
.unwrap_err();
assert!(err.0.contains("ask couldn't be answered"), "{}", err.0);
}
#[tokio::test]
async fn logs_workflow_and_tool_lifecycle() {
let (tool, script_path) = echo_tool();
let (result, events) = eval_capture(
"greet",
r#"out = run tool echo { NAME: "world" }"#,
vec![tool],
HashMap::new(),
&no_ask,
)
.await;
std::fs::remove_file(&script_path).ok();
result.unwrap();
assert_eq!(
event_names(&events),
["workflow.start", "tool.call", "tool.done", "workflow.done"]
);
assert_eq!(events[0]["wf"], "greet");
assert_eq!(events[0]["inputs"], serde_json::json!({}));
let call = &events[1];
assert_eq!(call["wf"], "greet");
assert_eq!(call["stmt"], "out");
assert!(call["specialist"].is_null());
assert_eq!(call["tool"], "echo");
assert_eq!(call["args"], serde_json::json!({ "NAME": "world" }));
let done = &events[2];
assert_eq!(done["success"], true);
assert_eq!(done["exit_code"], 0);
assert!(done["elapsed_ms"].is_number());
}
#[tokio::test]
async fn logs_workflow_error_with_tool_exit_code() {
let (tool, script_path) = exiting_tool(1); let (result, events) = eval_capture(
"pinger",
"r = run tool ping {}",
vec![tool],
HashMap::new(),
&no_ask,
)
.await;
std::fs::remove_file(&script_path).ok();
result.unwrap_err();
assert_eq!(
event_names(&events),
["workflow.start", "tool.call", "tool.done", "workflow.error"]
);
let done = &events[2];
assert_eq!(done["success"], false);
assert_eq!(done["exit_code"], 1);
assert_eq!(events[3]["wf"], "pinger");
assert!(events[3]["error"].as_str().unwrap().contains("else"));
}
#[tokio::test]
async fn logs_sub_workflow_sharing_the_run_with_a_distinct_wf() {
let (tool, script_path) = echo_tool();
let inner = parse("# inputs: WHO:string\n\nout = run tool echo { NAME: WHO }").unwrap();
let mut workflows = HashMap::new();
workflows.insert("inner".to_string(), inner);
let (result, events) = eval_capture(
"outer",
r#"r = run workflow inner { WHO: "world" }"#,
vec![tool],
workflows,
&no_ask,
)
.await;
std::fs::remove_file(&script_path).ok();
result.unwrap();
assert_eq!(
event_names(&events),
[
"workflow.start", "workflow.start", "tool.call",
"tool.done",
"workflow.done", "workflow.done", ]
);
assert_eq!(events[0]["wf"], "outer");
assert_eq!(events[1]["wf"], "inner");
assert_eq!(events[1]["inputs"], serde_json::json!({ "WHO": "world" }));
assert_eq!(events[2]["wf"], "inner");
}
#[tokio::test]
async fn logs_ask_prompt_and_answer() {
let answer = |_: &str| AskOutcome::Answered("Boston".to_string());
let (result, events) = eval_capture(
"asker",
r#"c = ask "Which city?""#,
vec![],
HashMap::new(),
&answer,
)
.await;
result.unwrap();
assert_eq!(
event_names(&events),
[
"workflow.start",
"ask.prompt",
"ask.answer",
"workflow.done"
]
);
assert_eq!(events[1]["prompt"], "Which city?");
assert_eq!(events[1]["stmt"], "c");
assert_eq!(events[2]["answered"], true);
}
#[tokio::test]
async fn logs_ask_answer_false_when_unavailable() {
let (result, events) = eval_capture(
"asker",
r#"c = ask "Which city?" else "Portland""#,
vec![],
HashMap::new(),
&no_ask,
)
.await;
result.unwrap();
let answer = events.iter().find(|e| e["event"] == "ask.answer").unwrap();
assert_eq!(answer["answered"], false);
}