use std::io::{Read, Write};
use std::net::TcpListener;
use std::path::Path;
use std::process::{Child, Command, ExitStatus, Stdio};
use std::thread;
use std::time::{Duration, Instant};
use tempfile::TempDir;
const ADOPTION_LOG_RELATIVE: &str = ".symforge/hook-adoption.log";
const PORT_FILE_RELATIVE: &str = ".symforge/sidecar.port";
const READ_PAYLOAD: &str = r#"{"tool_name":"Read","tool_input":{"file_path":"src/foo.rs"}}"#;
#[test]
fn run_hook_no_sidecar_writes_source_read_no_sidecar_event() {
let tmp = TempDir::new().expect("tempdir creation");
let contents = run_hook_in_tempdir(tmp.path(), READ_PAYLOAD);
assert!(
contents.contains("\tsource-read\tno-sidecar"),
"log must contain a tab-separated `source-read\\tno-sidecar` entry \
(regression: record_hook_outcome_with_detail removed from the \
port-file-missing dispatch branch); got:\n{contents}"
);
}
#[test]
fn run_hook_stale_port_writes_source_read_no_sidecar_event() {
let tmp = TempDir::new().expect("tempdir creation");
std::fs::create_dir_all(tmp.path().join(".symforge")).expect("create .symforge dir");
let listener = TcpListener::bind("127.0.0.1:0").expect("bind stale-port listener");
let stale_port = listener.local_addr().expect("stale-port local_addr").port();
std::fs::write(tmp.path().join(PORT_FILE_RELATIVE), stale_port.to_string())
.expect("write stale port file");
let contents = run_hook_in_tempdir(tmp.path(), READ_PAYLOAD);
drop(listener);
assert!(
contents.contains("\tsource-read\tno-sidecar"),
"log must contain a tab-separated `source-read\\tno-sidecar` entry \
(regression: record_hook_outcome_with_detail removed from the \
stale-port dispatch branch); got:\n{contents}"
);
}
#[test]
fn run_hook_routed_success_writes_source_read_routed_event() {
let listener = TcpListener::bind("127.0.0.1:0").expect("bind mock sidecar listener");
let port = listener
.local_addr()
.expect("mock sidecar local_addr")
.port();
let mock = thread::spawn(move || {
if let Ok((mut stream, _)) = listener.accept() {
let _ = stream.set_read_timeout(Some(Duration::from_millis(500)));
let mut buf = [0u8; 2048];
let _ = stream.read(&mut buf);
let _ = stream.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n");
}
});
let tmp = TempDir::new().expect("tempdir creation");
std::fs::create_dir_all(tmp.path().join(".symforge")).expect("create .symforge dir");
std::fs::write(tmp.path().join(PORT_FILE_RELATIVE), port.to_string())
.expect("write mock port file");
let contents = run_hook_in_tempdir(tmp.path(), READ_PAYLOAD);
drop(mock);
assert!(
contents.contains("\tsource-read\trouted"),
"log must contain a tab-separated `source-read\\trouted` entry \
(regression: record_hook_outcome removed from the success \
dispatch branch); got:\n{contents}"
);
}
#[test]
fn run_hook_stale_sidecar_with_live_daemon_routes_via_daemon_fallback() {
let dead_sidecar = TcpListener::bind("127.0.0.1:0").expect("bind dead sidecar listener");
let stale_port = dead_sidecar
.local_addr()
.expect("dead sidecar local_addr")
.port();
let daemon = TcpListener::bind("127.0.0.1:0").expect("bind mock daemon listener");
let daemon_port = daemon.local_addr().expect("daemon local_addr").port();
let tmp = TempDir::new().expect("tempdir creation");
std::fs::create_dir_all(tmp.path().join(".symforge")).expect("create .symforge dir");
std::fs::write(tmp.path().join(PORT_FILE_RELATIVE), stale_port.to_string())
.expect("write stale port file");
let canonical_root = std::fs::canonicalize(tmp.path())
.unwrap_or_else(|_| tmp.path().to_path_buf())
.to_string_lossy()
.replace('\\', "/");
let home = TempDir::new().expect("home tempdir creation");
let daemon_port_file = home
.path()
.join(format!("daemon.{}.port", std::env::consts::OS));
std::fs::write(&daemon_port_file, daemon_port.to_string()).expect("write daemon port file");
let daemon_thread = thread::spawn(move || serve_mock_daemon(daemon, &canonical_root));
let (stdout, log) = run_hook_in_tempdir_with_env(
tmp.path(),
READ_PAYLOAD,
&[("SYMFORGE_HOME", home.path().to_string_lossy().as_ref())],
);
drop(dead_sidecar);
let _ = daemon_thread.join();
assert!(
stdout.contains(ENRICHED_MARKER),
"stdout must contain the daemon-served enriched body marker \
`{ENRICHED_MARKER}` (regression: stale-sidecar path failed open \
instead of routing through the daemon); got:\n{stdout}"
);
assert!(
log.contains("\tsource-read\tdaemon-fallback"),
"log must contain a tab-separated `source-read\\tdaemon-fallback` \
entry (regression: stale sidecar served via daemon must record \
DaemonFallback, not no-sidecar); got:\n{log}"
);
assert!(
!log.contains("\tsource-read\tno-sidecar"),
"stale sidecar with a live daemon must NOT record no-sidecar; got:\n{log}"
);
}
#[test]
fn run_hook_stale_sidecar_and_dead_daemon_degrades_to_pass_through() {
let dead_sidecar = TcpListener::bind("127.0.0.1:0").expect("bind dead sidecar listener");
let stale_port = dead_sidecar
.local_addr()
.expect("dead sidecar local_addr")
.port();
let dead_daemon = TcpListener::bind("127.0.0.1:0").expect("bind dead daemon listener");
let dead_daemon_port = dead_daemon
.local_addr()
.expect("dead daemon local_addr")
.port();
let tmp = TempDir::new().expect("tempdir creation");
std::fs::create_dir_all(tmp.path().join(".symforge")).expect("create .symforge dir");
std::fs::write(tmp.path().join(PORT_FILE_RELATIVE), stale_port.to_string())
.expect("write stale port file");
let home = TempDir::new().expect("home tempdir creation");
std::fs::write(
home.path()
.join(format!("daemon.{}.port", std::env::consts::OS)),
dead_daemon_port.to_string(),
)
.expect("write daemon port file");
let (stdout, log) = run_hook_in_tempdir_with_env(
tmp.path(),
READ_PAYLOAD,
&[("SYMFORGE_HOME", home.path().to_string_lossy().as_ref())],
);
drop(dead_sidecar);
drop(dead_daemon);
assert!(
!stdout.contains(ENRICHED_MARKER),
"no enrichment source is reachable, so stdout must not contain the \
daemon marker; got:\n{stdout}"
);
assert!(
log.contains("\tsource-read\tno-sidecar"),
"both sidecar and daemon unreachable must degrade to no-sidecar; \
got:\n{log}"
);
}
#[test]
fn run_hook_stdin_held_open_exits_fail_open_within_deadline() {
let tmp = TempDir::new().expect("tempdir creation");
let bin = env!("CARGO_BIN_EXE_symforge");
let mut child = Command::new(bin)
.arg("hook")
.current_dir(tmp.path())
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("symforge binary should spawn");
let status = wait_with_timeout(&mut child, Duration::from_secs(5))
.expect("wait on hook subprocess")
.expect("hook must exit fail-open despite stdin held open, not hang");
assert!(
status.success(),
"hook with held-open stdin must exit zero (fail-open): {status:?}"
);
drop(child.stdin.take());
}
const ENRICHED_MARKER: &str = "MOCK_DAEMON_ENRICHED_OUTLINE";
fn serve_mock_daemon(listener: TcpListener, canonical_root: &str) {
listener
.set_nonblocking(true)
.expect("set mock daemon listener non-blocking");
let deadline = Instant::now() + Duration::from_secs(10);
while Instant::now() < deadline {
let (mut stream, _) = match listener.accept() {
Ok(pair) => pair,
Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
thread::sleep(Duration::from_millis(10));
continue;
}
Err(_) => return,
};
let _ = stream.set_nonblocking(false);
let _ = stream.set_read_timeout(Some(Duration::from_millis(500)));
let mut buf = [0u8; 4096];
let n = stream.read(&mut buf).unwrap_or(0);
let request = String::from_utf8_lossy(&buf[..n]);
let path = request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.unwrap_or("");
let body: String = if path.starts_with("/v1/projects/") && path.contains("/sessions") {
r#"[{"session_id":"mock-session","last_seen_at_unix_secs":1}]"#.to_string()
} else if path.starts_with("/v1/projects") {
format!(
r#"[{{"project_id":"mock-project","canonical_root":"{}","session_count":1}}]"#,
canonical_root.replace('"', "\\\"")
)
} else {
let last = path.contains("sidecar");
let out = format!("{{\"enriched\":\"{ENRICHED_MARKER}\"}}");
write_http_ok(&mut stream, &out);
if last {
return;
}
continue;
};
write_http_ok(&mut stream, &body);
}
}
fn write_http_ok(stream: &mut std::net::TcpStream, body: &str) {
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
let _ = stream.write_all(response.as_bytes());
let _ = stream.flush();
}
fn run_hook_in_tempdir(cwd: &Path, payload: &str) -> String {
run_hook_in_tempdir_with_env(cwd, payload, &[]).1
}
fn run_hook_in_tempdir_with_env(
cwd: &Path,
payload: &str,
extra_env: &[(&str, &str)],
) -> (String, String) {
let bin = env!("CARGO_BIN_EXE_symforge");
let mut command = Command::new(bin);
command
.arg("hook")
.current_dir(cwd)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped());
for (key, value) in extra_env {
command.env(key, value);
}
let mut child = command.spawn().expect("symforge binary should spawn");
child
.stdin
.as_mut()
.expect("piped stdin")
.write_all(payload.as_bytes())
.expect("write hook payload to child stdin");
drop(child.stdin.take());
let status = wait_with_timeout(&mut child, Duration::from_secs(15))
.expect("hook subprocess should exit within 15s")
.expect("hook subprocess status readable");
assert!(
status.success(),
"symforge hook exited non-zero: {status:?}"
);
let mut stdout = String::new();
if let Some(mut out) = child.stdout.take() {
let _ = out.read_to_string(&mut stdout);
}
let log_path = cwd.join(ADOPTION_LOG_RELATIVE);
assert!(
log_path.exists(),
"run_hook must append to {ADOPTION_LOG_RELATIVE} under the child's cwd; \
missing at {}. This usually means a record_hook_outcome* call was \
removed from the run_hook dispatch branch being exercised.",
log_path.display()
);
let log = std::fs::read_to_string(&log_path).expect("log readable");
(stdout, log)
}
fn wait_with_timeout(child: &mut Child, timeout: Duration) -> std::io::Result<Option<ExitStatus>> {
let start = Instant::now();
loop {
match child.try_wait()? {
Some(status) => return Ok(Some(status)),
None => {
if start.elapsed() >= timeout {
let _ = child.kill();
let _ = child.wait();
return Ok(None);
}
thread::sleep(Duration::from_millis(25));
}
}
}
}