#![cfg(feature = "server")]
use std::io::{Read, Write};
use std::net::TcpListener;
use std::path::Path;
use std::process::{Child, ExitStatus, Stdio};
use std::thread;
use std::time::{Duration, Instant};
use tempfile::TempDir;
const ADOPTION_LOG_FILE: &str = "hook-adoption.log";
fn write_sidecar_descriptor(control_root: &Path, project_root: &Path, port: u16) {
let control_state = symforge::domain::ControlStateDir::new(control_root.to_path_buf());
symforge::sidecar::port_file::write_session_descriptor(
&control_state,
port,
Some("hook-subprocess-test"),
Some(project_root),
None,
)
.expect("write sidecar session descriptor");
}
fn write_daemon_port(control_root: &Path, port: u16) {
let control_state = symforge::domain::ControlStateDir::new(control_root.to_path_buf());
let daemon_dir = symforge::paths::control_state_path(&control_state, "daemon");
std::fs::create_dir_all(&daemon_dir).expect("create daemon control directory");
std::fs::write(
daemon_dir.join(symforge::paths::os_tagged_runtime_file_name(
"daemon", "port",
)),
port.to_string(),
)
.expect("write daemon port file");
}
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");
let home = TempDir::new().expect("control-state tempdir creation");
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();
write_sidecar_descriptor(home.path(), tmp.path(), stale_port);
let contents = run_hook_in_tempdir_with_env(
tmp.path(),
READ_PAYLOAD,
&[("SYMFORGE_HOME", home.path().to_string_lossy().as_ref())],
)
.1;
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 || {
for _ in 0..4 {
let Ok((mut stream, _)) = listener.accept() else {
return;
};
let _ = stream.set_read_timeout(Some(Duration::from_millis(500)));
let mut buf = [0u8; 2048];
let Ok(read) = stream.read(&mut buf) else {
return;
};
if read == 0 {
continue;
}
if buf.starts_with(b"GET /health ") {
let body = br#"{"project_count":0,"session_count":0,"daemon_version":"10.1.0","executable_path":"x","auth_required":true,"pid":0}"#;
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
String::from_utf8_lossy(body)
);
let _ = stream.write_all(response.as_bytes());
} else {
let _ = stream.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n");
return;
}
}
});
let tmp = TempDir::new().expect("tempdir creation");
let home = TempDir::new().expect("control-state tempdir creation");
write_sidecar_descriptor(home.path(), tmp.path(), port);
let contents = run_hook_in_tempdir_with_env(
tmp.path(),
READ_PAYLOAD,
&[("SYMFORGE_HOME", home.path().to_string_lossy().as_ref())],
)
.1;
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");
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");
write_sidecar_descriptor(home.path(), tmp.path(), stale_port);
write_daemon_port(home.path(), daemon_port);
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");
let home = TempDir::new().expect("home tempdir creation");
write_sidecar_descriptor(home.path(), tmp.path(), stale_port);
write_daemon_port(home.path(), dead_daemon_port);
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 = symforge::process_util::hidden_command(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 {
let home = TempDir::new().expect("control-state tempdir creation");
run_hook_in_tempdir_with_env(
cwd,
payload,
&[("SYMFORGE_HOME", home.path().to_string_lossy().as_ref())],
)
.1
}
fn run_hook_in_tempdir_with_env(
cwd: &Path,
payload: &str,
extra_env: &[(&str, &str)],
) -> (String, String) {
let control_root = extra_env
.iter()
.rev()
.find_map(|(key, value)| (*key == "SYMFORGE_HOME").then_some(Path::new(*value)))
.expect("hook subprocess tests must inject an isolated SYMFORGE_HOME");
let bin = env!("CARGO_BIN_EXE_symforge");
let mut command = symforge::process_util::hidden_command(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 = control_root.join(ADOPTION_LOG_FILE);
assert!(
log_path.exists(),
"run_hook must append to {ADOPTION_LOG_FILE} under the injected control-state root; \
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));
}
}
}
}