use std::process::{Command, Output};
use std::sync::Mutex;
use std::time::{Duration, Instant};
use serde_json::Value;
use tempfile::{TempDir, tempdir};
struct Fixture {
binary: String,
home: TempDir,
runtime: TempDir,
execution_id: Mutex<Option<String>>,
}
impl Fixture {
fn new() -> Self {
Self {
binary: env!("CARGO_BIN_EXE_apoc").to_string(),
home: tempdir().unwrap(),
runtime: tempdir().unwrap(),
execution_id: Mutex::new(None),
}
}
fn run(&self, args: &[&str]) -> Output {
let mut arguments = args.to_vec();
let options_end = arguments
.iter()
.position(|argument| *argument == "--")
.unwrap_or(arguments.len());
arguments.splice(
options_end..options_end,
[
"--purpose",
"Running the durable debugger contract fixture.",
],
);
Command::new(&self.binary)
.args(arguments)
.env("APOC_HOME", self.home.path())
.env("APOC_RUNTIME_DIR", self.runtime.path())
.output()
.unwrap()
}
fn json(&self, args: &[&str]) -> Value {
let output = self.run(args);
let daemon_log = std::fs::read_to_string(self.home.path().join("daemon.log"))
.unwrap_or_else(|_| "<no daemon log>".to_string());
assert!(
output.status.success(),
"command failed: {args:?}\nstdout: {}\nstderr: {}\ndaemon log:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
daemon_log
);
serde_json::from_slice(&output.stdout).unwrap()
}
fn wait_json(&self, timeout: Duration, mut call: impl FnMut() -> Option<Value>) -> Value {
let deadline = Instant::now() + timeout;
while Instant::now() < deadline {
if let Some(value) = call() {
return value;
}
std::thread::sleep(Duration::from_millis(25));
}
panic!("timed out waiting for debugger state")
}
}
impl Drop for Fixture {
fn drop(&mut self) {
if let Some(id) = self.execution_id.lock().unwrap().take() {
let _ = self.run(&[
"execution",
"cancel",
&id,
"--idempotency-key",
&format!("debugger/drop-cancel/{id}"),
"--timeout-ms",
"5000",
"--format",
"json",
]);
}
let _ = self.run(&[
"daemon",
"stop",
"--idempotency-key",
"debugger-fixture-stop",
"--format",
"json",
]);
}
}
#[test]
fn node_debugger_state_and_receipts_survive_daemon_restart() {
let apoc = Fixture::new();
let listener = std::net::TcpListener::bind(("127.0.0.1", 0)).unwrap();
let port = listener.local_addr().unwrap().port();
drop(listener);
let port_text = port.to_string();
let fixture = format!(
"{}/tests/fixtures/debugger_target.js",
env!("CARGO_MANIFEST_DIR")
);
let started = apoc.json(&[
"debugger",
"run",
"--id",
"node-main",
"--port",
&port_text,
"--idempotency-key",
"debugger/run-node-main-v1",
"--format",
"json",
"--",
"node",
&fixture,
]);
let execution_id = started["execution"]["id"].as_str().unwrap().to_string();
*apoc.execution_id.lock().unwrap() = Some(execution_id.clone());
let opened = &started["session"];
assert_eq!(opened["id"], "node-main");
assert_eq!(opened["execution_id"], execution_id);
let sessions = apoc.json(&["debugger", "list", "--format", "json"]);
assert!(
sessions
.as_array()
.is_some_and(|items| items.iter().any(|session| session["id"] == "node-main")),
"{sessions:#}"
);
let selection = apoc.json(&[
"debugger",
"select",
"node-main",
"--idempotency-key",
"debugger/select-node-main-v1",
"--format",
"json",
]);
assert_eq!(selection["session_id"], "node-main");
let selected = apoc.json(&["debugger", "selected", "--format", "json"]);
assert_eq!(selected["session_id"], "node-main");
let breakpoint = apoc.json(&[
"debugger",
"breakpoint",
"set",
"node-main",
"debugger_target.js",
"4",
"--condition",
"value >= 1",
"--idempotency-key",
"debugger/breakpoint-work-v1",
"--format",
"json",
]);
let breakpoint_id = breakpoint["id"].as_str().unwrap().to_string();
let pending_breakpoint = apoc.json(&[
"debugger",
"breakpoint",
"set",
"node-main",
"future-module.js",
"1",
"--condition",
"globalThis.futureEnabled === true",
"--idempotency-key",
"debugger/breakpoint-pending-v1",
"--format",
"json",
]);
let pending_breakpoint_id = pending_breakpoint["id"].as_str().unwrap().to_string();
assert_eq!(
pending_breakpoint["resolved"], false,
"{pending_breakpoint:#}"
);
assert!(
pending_breakpoint["backend_id"].is_string(),
"{pending_breakpoint:#}"
);
let continued = apoc.json(&[
"debugger",
"continue",
"node-main",
"--idempotency-key",
"debugger/continue-from-entry-v1",
"--format",
"json",
]);
assert_eq!(continued["state"]["phase"], "paused");
assert_eq!(continued["state"]["frames"][0]["line"], 4);
let paused = apoc.wait_json(Duration::from_secs(10), || {
let status = apoc.json(&["debugger", "status", "node-main", "--format", "json"]);
(status["state"]["phase"] == "paused").then_some(status)
});
assert_eq!(paused["state"]["frames"][0]["line"], 4);
assert!(
paused["state"]["async_frames"]
.as_array()
.is_some_and(|frames| !frames.is_empty()),
"{paused:#}"
);
let stack = apoc.json(&["debugger", "stack", "node-main", "--format", "json"]);
assert_eq!(stack[0]["function"], "work", "{stack:#}");
assert_eq!(stack[0]["line"], 4, "{stack:#}");
let scopes = apoc.json(&["debugger", "scopes", "node-main", "0", "--format", "json"]);
assert!(
scopes
.as_array()
.is_some_and(|items| items.iter().any(|scope| scope["kind"] == "local")),
"{scopes:#}"
);
let scripts = apoc.json(&["debugger", "scripts", "node-main", "--format", "json"]);
let script = scripts
.as_array()
.unwrap()
.iter()
.find(|script| script["file"] == "debugger_target.js")
.unwrap();
let script_id = script["id"].as_str().unwrap().to_string();
assert!(script["source_map_url"].is_string(), "{script:#}");
let variables = apoc.json(&[
"debugger",
"variables",
"node-main",
"0",
"--format",
"json",
]);
assert!(
variables
.as_array()
.unwrap()
.iter()
.any(|variable| variable["property"]["name"] == "value"),
"{variables:#}"
);
let this_properties = apoc.json(&["debugger", "this", "node-main", "0", "--format", "json"]);
assert!(this_properties.is_array());
let console = apoc.json(&["debugger", "console", "node-main", "--format", "json"]);
assert!(
console
.as_array()
.unwrap()
.iter()
.any(|entry| entry["text"] == "debugger fixture ready"),
"{console:#}"
);
let exceptions = apoc.json(&["debugger", "exceptions", "node-main", "--format", "json"]);
assert!(exceptions.is_array());
let evaluation = apoc.json(&[
"debugger",
"evaluate",
"node-main",
"({answer: value, nested: {x: 1}, nan: NaN})",
"--frame",
"0",
"--idempotency-key",
"debugger/evaluate-object-v1",
"--format",
"json",
]);
let object_id = evaluation["object_id"].as_str().unwrap();
assert_eq!(evaluation["kind"], "object", "{evaluation:#}");
assert!(evaluation["description"].is_string(), "{evaluation:#}");
assert!(evaluation["value"].is_null(), "{evaluation:#}");
let bigint = apoc.json(&[
"debugger",
"evaluate",
"node-main",
"9007199254740993n",
"--frame",
"0",
"--idempotency-key",
"debugger/evaluate-bigint-v1",
"--format",
"json",
]);
assert_eq!(bigint["kind"], "bigint", "{bigint:#}");
assert_eq!(
bigint["unserializable_value"], "9007199254740993n",
"{bigint:#}"
);
let negative_zero = apoc.json(&[
"debugger",
"evaluate",
"node-main",
"Number('-0')",
"--frame",
"0",
"--idempotency-key",
"debugger/evaluate-negative-zero-v1",
"--format",
"json",
]);
assert_eq!(negative_zero["kind"], "number", "{negative_zero:#}");
assert_eq!(
negative_zero["unserializable_value"], "-0",
"{negative_zero:#}"
);
let thrown = apoc.json(&[
"debugger",
"evaluate",
"node-main",
"(() => { throw new Error('evaluation boom'); })()",
"--idempotency-key",
"debugger/evaluate-exception-v1",
"--format",
"json",
]);
assert!(thrown["exception"].is_object(), "{thrown:#}");
let properties = apoc.json(&[
"debugger",
"properties",
"--format",
"json",
"--",
"node-main",
object_id,
]);
assert!(
properties
.as_array()
.unwrap()
.iter()
.any(|property| property["name"] == "nested"
&& property["value"]["object_id"].is_string()),
"{properties:#}"
);
assert!(
properties
.as_array()
.unwrap()
.iter()
.any(|property| property["name"] == "nan"
&& property["value"]["unserializable_value"] == "NaN"),
"{properties:#}"
);
let prototypes = apoc.json(&[
"debugger",
"prototypes",
"--limit",
"4",
"--format",
"json",
"--",
"node-main",
object_id,
]);
assert!(!prototypes.as_array().unwrap().is_empty());
assert_eq!(prototypes[0]["object_id"], object_id);
let source = apoc.json(&[
"debugger",
"source",
"node-main",
"--file",
"debugger_target.js",
"--from-line",
"1",
"--to-line",
"8",
"--format",
"json",
]);
assert_eq!(source["from_line"], 1);
assert!(source["lines"].as_array().unwrap().len() >= 5);
assert_eq!(source["script_id"], script_id);
assert_eq!(
source["mapped_sources"][0]["source"], "debugger_target.original.js",
"{source:#}"
);
assert!(
source["mapped_sources"][0]["content"]
.as_str()
.is_some_and(|content| content.contains("function work()")),
"{source:#}"
);
let source_by_script = apoc.json(&[
"debugger",
"source",
"node-main",
"--script-id",
&script_id,
"--from-line",
"4",
"--to-line",
"4",
"--format",
"json",
]);
assert_eq!(source_by_script["script_id"], script_id);
assert_eq!(source_by_script["from_line"], 4);
assert_eq!(source_by_script["to_line"], 4);
assert_eq!(source_by_script["lines"].as_array().unwrap().len(), 1);
let breakpoints = apoc.json(&[
"debugger",
"breakpoint",
"list",
"node-main",
"--format",
"json",
]);
let hit_breakpoint = breakpoints
.as_array()
.unwrap()
.iter()
.find(|item| item["id"] == breakpoint_id)
.unwrap();
assert!(hit_breakpoint["hits"].as_u64().unwrap() >= 1);
let trace = apoc.json(&[
"debugger",
"trace",
"node-main",
"--limit",
"1000",
"--format",
"json",
]);
assert!(
trace
.as_array()
.unwrap()
.iter()
.any(|entry| entry["method"] == "Runtime.getProperties"),
"{trace:#}"
);
apoc.json(&[
"daemon",
"stop",
"--idempotency-key",
"debugger-recovery-stop",
"--format",
"json",
]);
let recovered = apoc.wait_json(Duration::from_secs(10), || {
let output = apoc.run(&["debugger", "status", "node-main", "--format", "json"]);
output.status.success().then(|| {
let value: Value = serde_json::from_slice(&output.stdout).unwrap();
value["state"]["connected"].as_bool()?.then_some(value)
})?
});
assert_eq!(recovered["execution_id"], execution_id);
let selected = apoc.json(&["debugger", "selected", "--format", "json"]);
assert_eq!(selected["session_id"], "node-main");
let retained_trace = apoc.json(&[
"debugger",
"trace",
"node-main",
"--limit",
"1000",
"--format",
"json",
]);
assert!(
retained_trace
.as_array()
.unwrap()
.iter()
.any(|entry| entry["method"] == "Runtime.getProperties"),
"{retained_trace:#}"
);
let retained_console = apoc.json(&["debugger", "console", "node-main", "--format", "json"]);
assert!(
retained_console
.as_array()
.unwrap()
.iter()
.any(|entry| entry["text"] == "debugger fixture ready")
);
let restored = apoc.json(&[
"debugger",
"breakpoint",
"list",
"node-main",
"--format",
"json",
]);
assert!(
restored
.as_array()
.unwrap()
.iter()
.any(|item| { item["id"] == breakpoint_id && item["backend_id"].is_string() }),
"{restored:#}"
);
assert!(
restored.as_array().unwrap().iter().any(|item| {
item["id"] == pending_breakpoint_id
&& item["backend_id"].is_string()
&& item["resolved"] == false
}),
"{restored:#}"
);
let reconnected = apoc.json(&[
"debugger",
"reconnect",
"node-main",
"--idempotency-key",
"debugger/reconnect-node-main-v1",
"--format",
"json",
]);
assert_eq!(reconnected["id"], "node-main");
assert_eq!(reconnected["state"]["connected"], true, "{reconnected:#}");
let restarted = apoc.json(&[
"debugger",
"restart",
"node-main",
"--idempotency-key",
"debugger/restart-node-main-v1",
"--timeout-ms",
"10000",
"--format",
"json",
]);
let replacement_id = restarted["execution"]["id"].as_str().unwrap().to_string();
assert_ne!(replacement_id, execution_id);
assert_eq!(restarted["session"]["id"], "node-main");
assert_eq!(restarted["session"]["execution_id"], replacement_id);
*apoc.execution_id.lock().unwrap() = Some(replacement_id.clone());
let restored_after_restart = apoc.json(&[
"debugger",
"breakpoint",
"list",
"node-main",
"--format",
"json",
]);
assert!(
restored_after_restart
.as_array()
.unwrap()
.iter()
.any(|item| item["id"] == breakpoint_id && item["backend_id"].is_string()),
"{restored_after_restart:#}"
);
assert!(
restored_after_restart
.as_array()
.unwrap()
.iter()
.any(|item| {
item["id"] == pending_breakpoint_id
&& item["backend_id"].is_string()
&& item["resolved"] == false
}),
"{restored_after_restart:#}"
);
let deleted = apoc.json(&[
"debugger",
"breakpoint",
"delete",
"node-main",
&breakpoint_id,
"--idempotency-key",
"debugger/delete-work-breakpoint-v1",
"--format",
"json",
]);
assert_eq!(deleted["id"], breakpoint_id);
let deleted_pending = apoc.json(&[
"debugger",
"breakpoint",
"delete",
"node-main",
&pending_breakpoint_id,
"--idempotency-key",
"debugger/delete-pending-breakpoint-v1",
"--format",
"json",
]);
assert_eq!(deleted_pending["id"], pending_breakpoint_id);
let remaining = apoc.json(&[
"debugger",
"breakpoint",
"list",
"node-main",
"--format",
"json",
]);
assert_eq!(remaining, serde_json::json!([]));
let tap = apoc.json(&[
"debugger",
"tap",
"add",
"node-main",
"debugger_target.js",
"4",
"value",
"--idempotency-key",
"debugger/tap-value-v1",
"--format",
"json",
]);
let tap_id = tap["id"].as_str().unwrap().to_string();
assert_eq!(tap["resolved"], true, "{tap:#}");
let pending_tap = apoc.json(&[
"debugger",
"tap",
"add",
"node-main",
"future-module.js",
"1",
"1",
"--idempotency-key",
"debugger/tap-pending-v1",
"--format",
"json",
]);
let pending_tap_id = pending_tap["id"].as_str().unwrap().to_string();
assert_eq!(pending_tap["resolved"], false, "{pending_tap:#}");
assert!(pending_tap["backend_id"].is_string());
apoc.json(&[
"debugger",
"evaluate",
"node-main",
"globalThis.apocWatch = 0",
"--idempotency-key",
"debugger/watch-value-initialize-v1",
"--format",
"json",
]);
let watch = apoc.json(&[
"debugger",
"watch",
"add",
"node-main",
"globalThis.apocWatch",
"--idempotency-key",
"debugger/watch-value-v1",
"--format",
"json",
]);
let watch_id = watch["id"].as_str().unwrap().to_string();
apoc.json(&[
"debugger",
"resume",
"node-main",
"--idempotency-key",
"debugger/resume-for-taps-v1",
"--format",
"json",
]);
apoc.wait_json(Duration::from_secs(10), || {
let hits = apoc.json(&[
"debugger",
"watch",
"hits",
"node-main",
&watch_id,
"--limit",
"20",
"--format",
"json",
]);
(!hits.as_array().unwrap().is_empty()).then_some(hits)
});
apoc.json(&[
"debugger",
"evaluate",
"node-main",
"globalThis.apocWatch = 1",
"--idempotency-key",
"debugger/watch-value-change-v1",
"--format",
"json",
]);
let tap_hits = apoc.wait_json(Duration::from_secs(10), || {
let hits = apoc.json(&[
"debugger",
"tap",
"hits",
"node-main",
&tap_id,
"--limit",
"20",
"--format",
"json",
]);
(!hits.as_array().unwrap().is_empty()).then_some(hits)
});
assert!(tap_hits[0]["value"].as_str().is_some());
let watch_hits = apoc.wait_json(Duration::from_secs(10), || {
let hits = apoc.json(&[
"debugger",
"watch",
"hits",
"node-main",
&watch_id,
"--limit",
"20",
"--format",
"json",
]);
(hits.as_array().unwrap().len() >= 2).then_some(hits)
});
assert_ne!(
watch_hits[0]["new_value"],
watch_hits.as_array().unwrap().last().unwrap()["new_value"]
);
let tap_console = apoc.json(&["debugger", "console", "node-main", "--format", "json"]);
assert!(
tap_console
.as_array()
.unwrap()
.iter()
.all(|entry| !entry["text"]
.as_str()
.unwrap_or_default()
.contains("__apoc_tap:")),
"{tap_console:#}"
);
let running = apoc.json(&["debugger", "status", "node-main", "--format", "json"]);
assert_eq!(running["state"]["phase"], "running");
apoc.json(&[
"daemon",
"stop",
"--idempotency-key",
"debugger-recorder-stop",
"--format",
"json",
]);
apoc.wait_json(Duration::from_secs(10), || {
let output = apoc.run(&["debugger", "status", "node-main", "--format", "json"]);
output
.status
.success()
.then(|| serde_json::from_slice::<Value>(&output.stdout).ok())??["state"]["connected"]
.as_bool()
.unwrap_or(false)
.then(|| serde_json::from_slice(&output.stdout).unwrap())
});
let restored_taps = apoc.json(&["debugger", "tap", "list", "node-main", "--format", "json"]);
assert!(
restored_taps
.as_array()
.unwrap()
.iter()
.any(|item| item["id"] == tap_id)
);
assert!(
restored_taps
.as_array()
.unwrap()
.iter()
.any(|item| item["id"] == pending_tap_id && item["resolved"] == false)
);
let restored_watches =
apoc.json(&["debugger", "watch", "list", "node-main", "--format", "json"]);
assert!(
restored_watches
.as_array()
.unwrap()
.iter()
.any(|item| item["id"] == watch_id)
);
let final_restart = apoc.json(&[
"debugger",
"restart",
"node-main",
"--idempotency-key",
"debugger/restart-node-main-after-tap-recovery-v1",
"--timeout-ms",
"10000",
"--format",
"json",
]);
let final_execution_id = final_restart["execution"]["id"]
.as_str()
.unwrap()
.to_string();
*apoc.execution_id.lock().unwrap() = Some(final_execution_id.clone());
let disabled_tap = apoc.json(&[
"debugger",
"tap",
"remove",
"node-main",
&tap_id,
"--idempotency-key",
"debugger/tap-value-remove-v1",
"--format",
"json",
]);
assert_eq!(disabled_tap["enabled"], false);
let disabled_pending_tap = apoc.json(&[
"debugger",
"tap",
"remove",
"node-main",
&pending_tap_id,
"--idempotency-key",
"debugger/tap-pending-remove-v1",
"--format",
"json",
]);
assert_eq!(disabled_pending_tap["enabled"], false);
let disabled_watch = apoc.json(&[
"debugger",
"watch",
"remove",
"node-main",
&watch_id,
"--idempotency-key",
"debugger/watch-value-remove-v1",
"--format",
"json",
]);
assert_eq!(disabled_watch["enabled"], false);
let retained_tap_hits = apoc.json(&[
"debugger",
"tap",
"hits",
"node-main",
&tap_id,
"--format",
"json",
]);
assert!(!retained_tap_hits.as_array().unwrap().is_empty());
let retained_watch_hits = apoc.json(&[
"debugger",
"watch",
"hits",
"node-main",
&watch_id,
"--format",
"json",
]);
assert!(!retained_watch_hits.as_array().unwrap().is_empty());
let events = apoc.json(&[
"debugger",
"events",
"node-main",
"--limit",
"500",
"--format",
"json",
]);
let kinds = events
.as_array()
.unwrap()
.iter()
.filter_map(|event| event["kind"].as_str())
.collect::<Vec<_>>();
assert!(kinds.contains(&"debugger.run.intent"), "{events:#}");
assert!(kinds.contains(&"debugger.run.result"), "{events:#}");
assert!(kinds.contains(&"debugger.paused"), "{events:#}");
apoc.json(&[
"debugger",
"close",
"node-main",
"--idempotency-key",
"debugger/close-node-main-v1",
"--format",
"json",
]);
apoc.json(&[
"execution",
"cancel",
&final_execution_id,
"--idempotency-key",
"debugger/node-main-final-cancel",
"--timeout-ms",
"5000",
"--format",
"json",
]);
let exited = apoc.json(&["debugger", "status", "node-main", "--format", "json"]);
assert_eq!(exited["state"]["phase"], "exited");
let disconnected_health = apoc.json(&["debugger", "health", "node-main", "--format", "json"]);
assert!(
disconnected_health["connected_at"].is_number()
&& disconnected_health["disconnected_at"].is_number()
&& disconnected_health["requests"].as_u64().unwrap_or_default() > 0
&& disconnected_health["responses"]
.as_u64()
.unwrap_or_default()
> 0,
"{disconnected_health:#}"
);
let disconnected_trace = apoc.json(&[
"debugger",
"trace",
"node-main",
"--limit",
"1000",
"--format",
"json",
]);
assert!(
disconnected_trace
.as_array()
.unwrap()
.iter()
.any(|entry| entry["latency_ms"].is_number()),
"{disconnected_trace:#}"
);
let disconnected_events = apoc.json(&[
"debugger",
"events",
"node-main",
"--limit",
"500",
"--format",
"json",
]);
assert!(
disconnected_events
.as_array()
.unwrap()
.iter()
.any(|event| event["kind"] == "debugger.disconnected"),
"{disconnected_events:#}"
);
*apoc.execution_id.lock().unwrap() = None;
}
#[test]
fn node_debugger_pause_and_steps_return_truthful_state() {
let apoc = Fixture::new();
let listener = std::net::TcpListener::bind(("127.0.0.1", 0)).unwrap();
let port = listener.local_addr().unwrap().port();
drop(listener);
let port_text = port.to_string();
let fixture = format!(
"{}/tests/fixtures/debugger_step_target.js",
env!("CARGO_MANIFEST_DIR")
);
let started = apoc.json(&[
"debugger",
"run",
"--id",
"node-step",
"--port",
&port_text,
"--idempotency-key",
"debugger/run-node-step-v1",
"--format",
"json",
"--",
"node",
&fixture,
]);
let execution_id = started["execution"]["id"].as_str().unwrap().to_string();
*apoc.execution_id.lock().unwrap() = Some(execution_id.clone());
let breakpoint = apoc.json(&[
"debugger",
"breakpoint",
"set",
"node-step",
"debugger_step_target.js",
"9",
"--idempotency-key",
"debugger/breakpoint-step-v1",
"--format",
"json",
]);
let breakpoint_id = breakpoint["id"].as_str().unwrap().to_string();
let at_outer = apoc.json(&[
"debugger",
"continue",
"node-step",
"--idempotency-key",
"debugger/continue-to-step-v1",
"--format",
"json",
]);
assert_eq!(at_outer["state"]["phase"], "paused", "{at_outer:#}");
assert_eq!(at_outer["state"]["frames"][0]["function"], "outer");
assert_eq!(at_outer["state"]["frames"][0]["line"], 9);
let stepped_into = apoc.json(&[
"debugger",
"step",
"node-step",
"into",
"--idempotency-key",
"debugger/step-into-node-v1",
"--format",
"json",
]);
assert_eq!(stepped_into["state"]["phase"], "paused", "{stepped_into:#}");
assert_eq!(stepped_into["state"]["frames"][0]["function"], "inner");
let stepped_over = apoc.json(&[
"debugger",
"step",
"node-step",
"over",
"--idempotency-key",
"debugger/step-over-node-v1",
"--format",
"json",
]);
assert_eq!(stepped_over["state"]["phase"], "paused", "{stepped_over:#}");
assert_eq!(stepped_over["state"]["frames"][0]["function"], "inner");
let stepped_out = apoc.json(&[
"debugger",
"step",
"node-step",
"out",
"--idempotency-key",
"debugger/step-out-node-v1",
"--format",
"json",
]);
assert_eq!(stepped_out["state"]["phase"], "paused", "{stepped_out:#}");
assert_eq!(stepped_out["state"]["frames"][0]["function"], "outer");
apoc.json(&[
"debugger",
"breakpoint",
"delete",
"node-step",
&breakpoint_id,
"--idempotency-key",
"debugger/delete-step-breakpoint-v1",
"--format",
"json",
]);
let running = apoc.json(&[
"debugger",
"resume",
"node-step",
"--idempotency-key",
"debugger/resume-node-step-v1",
"--format",
"json",
]);
assert_eq!(running["state"]["phase"], "running", "{running:#}");
let paused = apoc.json(&[
"debugger",
"pause",
"node-step",
"--idempotency-key",
"debugger/pause-node-step-v1",
"--format",
"json",
]);
assert_eq!(paused["state"]["phase"], "paused", "{paused:#}");
assert_eq!(paused["state"]["connected"], true, "{paused:#}");
apoc.json(&[
"debugger",
"close",
"node-step",
"--idempotency-key",
"debugger/close-node-step-v1",
"--format",
"json",
]);
apoc.json(&[
"execution",
"cancel",
&execution_id,
"--idempotency-key",
"debugger/node-step-final-cancel",
"--timeout-ms",
"5000",
"--format",
"json",
]);
*apoc.execution_id.lock().unwrap() = None;
}
#[test]
fn evidence_traces_replay_and_move_between_apoc_stores() {
let source = Fixture::new();
let listener = std::net::TcpListener::bind(("127.0.0.1", 0)).unwrap();
let port = listener.local_addr().unwrap().port();
drop(listener);
let port_text = port.to_string();
let fixture = format!(
"{}/tests/fixtures/debugger_target.js",
env!("CARGO_MANIFEST_DIR")
);
let started = source.json(&[
"debugger",
"run",
"--id",
"trace-node",
"--port",
&port_text,
"--idempotency-key",
"debugger/run-trace-node-v1",
"--format",
"json",
"--",
"node",
&fixture,
]);
let execution_id = started["execution"]["id"].as_str().unwrap().to_string();
*source.execution_id.lock().unwrap() = Some(execution_id);
let trace = source.json(&[
"trace",
"start",
"trace-node",
"node-evidence",
"--idempotency-key",
"trace/start-node-evidence-v1",
"--format",
"json",
]);
let trace_id = trace["id"].as_str().unwrap().to_string();
assert_eq!(trace["status"], "recording");
assert_eq!(trace["session_id"], "trace-node");
let evaluation = source.json(&[
"debugger",
"evaluate",
"trace-node",
"1 + 1",
"--idempotency-key",
"debugger/evaluate-trace-node-v1",
"--format",
"json",
]);
assert_eq!(evaluation["value"], 2);
let stopped = source.json(&[
"trace",
"stop",
"trace-node",
"--idempotency-key",
"trace/stop-node-evidence-v1",
"--format",
"json",
]);
assert_eq!(stopped["status"], "complete");
let shown = source.json(&["trace", "show", &trace_id, "--format", "json"]);
let items = shown["items"].as_array().unwrap();
assert!(!items.is_empty(), "{shown:#}");
let item_kind = items.last().unwrap()["kind"].as_str().unwrap().to_string();
let item_id = items.last().unwrap()["id"].as_str().unwrap().to_string();
let anchor = format!("{item_kind}:{item_id}");
let traces = source.json(&["trace", "list", "--format", "json"]);
assert!(
traces
.as_array()
.unwrap()
.iter()
.any(|item| item["id"] == trace_id)
);
source.json(&[
"trace",
"use",
&trace_id,
"--idempotency-key",
"trace/use-node-evidence-v1",
"--format",
"json",
]);
let replayed = source.json(&[
"trace",
"replay",
&trace_id,
"--at",
&anchor,
"--idempotency-key",
"trace/replay-node-evidence-v1",
"--format",
"json",
]);
assert_eq!(replayed["cursor"]["kind"], item_kind);
assert_eq!(replayed["cursor"]["item_id"], item_id);
let cursor = source.json(&["trace", "cursor", "--format", "json"]);
assert_eq!(cursor["trace_id"], trace_id);
let moved = source.json(&[
"trace",
"move",
"back",
"--count",
"1",
"--idempotency-key",
"trace/move-node-evidence-v1",
"--format",
"json",
]);
assert_eq!(moved["trace_id"], trace_id);
let jumped = source.json(&[
"trace",
"jump",
"next",
&item_kind,
"--idempotency-key",
"trace/jump-node-evidence-v1",
"--format",
"json",
]);
assert_eq!(jumped["kind"], item_kind);
let invalid = source.run(&[
"trace",
"replay",
&trace_id,
"--at",
"missing",
"--idempotency-key",
"trace/replay-invalid-anchor-v1",
"--format",
"json",
]);
assert!(!invalid.status.success());
let exported = source.json(&[
"trace",
"export",
&trace_id,
"--idempotency-key",
"trace/export-node-evidence-v1",
"--format",
"json",
]);
let export_path = exported["artifact"]["path"].as_str().unwrap().to_string();
assert!(std::path::Path::new(&export_path).is_file());
let destination = Fixture::new();
let imported = destination.json(&[
"trace",
"import",
&export_path,
"--idempotency-key",
"trace/import-node-evidence-v1",
"--format",
"json",
]);
assert_eq!(imported["trace"]["id"], trace_id);
assert_eq!(imported["trace"]["status"], "imported");
let imported_view = destination.json(&["trace", "show", &trace_id, "--format", "json"]);
assert_eq!(imported_view["items"], shown["items"]);
let mut copy: Value = serde_json::from_slice(&std::fs::read(&export_path).unwrap()).unwrap();
let copy_id = format!("{trace_id}-copy");
copy["trace"]["id"] = Value::String(copy_id.clone());
let copy_path = destination.home.path().join("trace-copy.json");
std::fs::write(©_path, serde_json::to_vec_pretty(©).unwrap()).unwrap();
destination.json(&[
"trace",
"import",
copy_path.to_str().unwrap(),
"--idempotency-key",
"trace/import-node-evidence-copy-v1",
"--format",
"json",
]);
let gc = destination.json(&[
"trace",
"gc",
"--keep",
"1",
"--idempotency-key",
"trace/gc-imports-v1",
"--format",
"json",
]);
assert_eq!(gc["kept"], 1);
assert_eq!(gc["removed"].as_array().unwrap().len(), 1);
}