The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.
Rust agent-orchestrationai-agentsai-assistantdesktopllmlocal-firstmcppersonal-aiprivacyrustsecond-braintauri
use super::{
current_rpc_token, default_core_port, generate_rpc_token, is_expected_port_clash,
is_openhuman_root_body, parse_netstat_pid, parse_ps_comm, parse_tasklist_name,
validate_kill_target, CoreProcessHandle, PortOwner, RecoveryOutcome,
};
// lsof is a unix tool, so its parser is only compiled there.
#[cfg(unix)]
use super::parse_lsof_pid;
use crate::test_env::env_lock;
/// Builds the same worker runtime that the desktop host uses. Some core-process
/// tests start an embedded agent server; Tokio's default 2 MiB worker stack is
/// insufficient for its nested turn setup.
fn core_test_runtime() -> tokio::runtime::Runtime {
tokio::runtime::Builder::new_multi_thread()
.enable_all()
.thread_stack_size(openhuman_rpc::embed::process::AGENT_WORKER_STACK_BYTES)
.max_blocking_threads(openhuman_rpc::embed::process::MAX_BLOCKING_THREADS)
.build()
.expect("build core test runtime")
}
struct EnvGuard {
key: &'static str,
old: Option<String>,
}
impl EnvGuard {
fn set(key: &'static str, value: &str) -> Self {
let old = std::env::var(key).ok();
std::env::set_var(key, value);
Self { key, old }
}
fn unset(key: &'static str) -> Self {
let old = std::env::var(key).ok();
std::env::remove_var(key);
Self { key, old }
}
}
impl Drop for EnvGuard {
fn drop(&mut self) {
match &self.old {
Some(v) => std::env::set_var(self.key, v),
None => std::env::remove_var(self.key),
}
}
}
/// A private, unsigned-in workspace and loopback-only backend keep embedded
/// boot tests independent of the operator's profile and other test cleanup.
struct TestWorkspace {
_env: EnvGuard,
_backend: EnvGuard,
_api_key: EnvGuard,
_session: EnvGuard,
_storage: EnvGuard,
_rpc_url: EnvGuard,
_directory: tempfile::TempDir,
}
fn test_workspace() -> TestWorkspace {
// Empty values also prevent dotenv from restoring inherited credentials
// or an external storage backend during boot.
let directory = tempfile::tempdir().expect("test workspace");
TestWorkspace {
_env: EnvGuard::set(
"OPENHUMAN_WORKSPACE",
directory.path().to_str().expect("workspace path"),
),
_backend: EnvGuard::set("BACKEND_URL", "http://127.0.0.1:9"),
_api_key: EnvGuard::set("OPENHUMAN_BACKEND_API_KEY", ""),
_session: EnvGuard::set("OPENHUMAN_BACKEND_SESSION_TOKEN", ""),
_storage: EnvGuard::set("OPENHUMAN_STORAGE_URL", ""),
_rpc_url: EnvGuard::unset("OPENHUMAN_CORE_RPC_URL"),
_directory: directory,
}
}
#[test]
fn default_core_port_env_and_fallback() {
let _env_lock = env_lock();
let _unset = EnvGuard::unset("OPENHUMAN_CORE_PORT");
assert_eq!(default_core_port(), 7788);
let _set = EnvGuard::set("OPENHUMAN_CORE_PORT", "8899");
assert_eq!(default_core_port(), 8899);
}
#[test]
fn core_process_handle_new_creates_instance() {
let handle = CoreProcessHandle::new(9999);
assert_eq!(handle.port(), 9999);
assert_eq!(handle.rpc_url(), "http://127.0.0.1:9999/rpc");
}
#[test]
fn ready_signal_updates_runtime_port_and_fallback_notice() {
let _env_lock = env_lock();
let _rpc_url = EnvGuard::unset("OPENHUMAN_CORE_RPC_URL");
let handle = CoreProcessHandle::new(7788);
handle.apply_embedded_ready_signal(openhuman_rpc::host::EmbeddedReadySignal {
port: 7789,
fallback_from: Some(7788),
});
assert_eq!(handle.port(), 7789);
assert_eq!(handle.rpc_url(), "http://127.0.0.1:7789/rpc");
let notice = handle
.take_last_port_fallback_notice()
.expect("fallback notice should be present");
assert_eq!(notice.preferred_port, 7788);
assert_eq!(notice.chosen_port, 7789);
assert!(
handle.take_last_port_fallback_notice().is_none(),
"fallback notice should be consumed once"
);
}
/// Regression: `ensure_running` must NOT publish the per-launch RPC bearer
/// to the `OPENHUMAN_CORE_TOKEN` environment variable.
///
/// The bearer is now handed to the in-process core in-memory via
/// `DesktopOptions::rpc_token` of `openhuman_rpc::host::desktop`; setting it on
/// the process env would put it within reach of any same-UID process
/// reading `/proc/<pid>/environ` (Linux) or `sysctl KERN_PROCARGS2` /
/// `ps eww -p <pid>` (macOS).
#[test]
fn ensure_running_does_not_publish_token_to_env() {
let _env_lock = env_lock();
let _unset = EnvGuard::unset("OPENHUMAN_CORE_REUSE_EXISTING");
let _workspace = test_workspace();
// Force a clean slate so we can assert on the post-spawn value.
let _wipe = EnvGuard::unset("OPENHUMAN_CORE_TOKEN");
let rt = core_test_runtime();
let (result, env_after, env_during_spawn) = rt.block_on(async {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind test listener");
let port = listener.local_addr().expect("local addr").port();
drop(listener);
// Brief yield to let the OS fully release the port.
tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
let handle = CoreProcessHandle::new(port);
let startup = handle.ensure_running();
tokio::pin!(startup);
let mut token_seen_during_spawn = false;
let result = loop {
token_seen_during_spawn |= std::env::var_os("OPENHUMAN_CORE_TOKEN").is_some();
tokio::select! {
result = &mut startup => break result,
_ = tokio::time::sleep(std::time::Duration::from_millis(1)) => {}
}
};
let env_after = std::env::var_os("OPENHUMAN_CORE_TOKEN");
handle.shutdown().await;
(result, env_after, token_seen_during_spawn)
});
assert!(
result.is_ok(),
"ensure_running should succeed against a freed port: {result:?}"
);
assert!(
env_after.is_none(),
"ensure_running must NOT publish OPENHUMAN_CORE_TOKEN to the process env \
(sidecar-era leak channel removed)"
);
assert!(
!env_during_spawn,
"OPENHUMAN_CORE_TOKEN must remain unset during spawn"
);
}
#[test]
fn ensure_running_preserves_an_inherited_token_without_publishing_its_bearer() {
let _env_lock = env_lock();
let _unset = EnvGuard::unset("OPENHUMAN_CORE_REUSE_EXISTING");
let _workspace = test_workspace();
let _inherited = EnvGuard::set("OPENHUMAN_CORE_TOKEN", "inherited-test-token");
let rt = core_test_runtime();
rt.block_on(async {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind test listener");
let port = listener.local_addr().expect("local addr").port();
drop(listener);
let handle = CoreProcessHandle::new(port);
assert_ne!(handle.rpc_token(), "inherited-test-token");
let result = handle.ensure_running().await;
let inherited_preserved = std::env::var("OPENHUMAN_CORE_TOKEN")
.is_ok_and(|value| value == "inherited-test-token");
handle.shutdown().await;
assert!(
result.is_ok(),
"embedded core must become ready: {result:?}"
);
assert!(
inherited_preserved,
"startup must leave inherited token configuration unchanged"
);
});
}
/// Issue #1613: when the preferred port is occupied by a non-OpenHuman
/// listener, startup should fall back to a nearby port instead of failing.
#[test]
fn ensure_running_falls_back_for_unknown_listener_on_port() {
let _env_lock = env_lock();
let _unset = EnvGuard::unset("OPENHUMAN_CORE_REUSE_EXISTING");
let _workspace = test_workspace();
let rt = core_test_runtime();
let (result, chosen_port, notice) = rt.block_on(async {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind test listener");
let port = listener.local_addr().expect("local addr").port();
let handle = CoreProcessHandle::new(port);
let result = handle.ensure_running().await;
let chosen_port = handle.port();
let notice = handle.take_last_port_fallback_notice();
handle.shutdown().await;
(result, chosen_port, notice)
});
assert!(
result.is_ok(),
"ensure_running should recover via fallback when preferred port is occupied: {result:?}"
);
assert!(
notice.is_some(),
"fallback notice should be set when preferred port is occupied"
);
let notice = notice.expect("notice set");
assert_ne!(
chosen_port, notice.preferred_port,
"fallback must choose a different port"
);
assert_eq!(
chosen_port, notice.chosen_port,
"chosen port should match fallback notice payload"
);
}
#[test]
fn ensure_running_falls_back_to_7789_when_7788_is_busy() {
let _env_lock = env_lock();
let _unset = EnvGuard::unset("OPENHUMAN_CORE_REUSE_EXISTING");
let _workspace = test_workspace();
let rt = core_test_runtime();
rt.block_on(async {
let listener = match tokio::net::TcpListener::bind("127.0.0.1:7788").await {
Ok(listener) => listener,
Err(err) => {
eprintln!(
"[core_process tests] skipping fixed-port fallback test; 7788 unavailable: {err}"
);
return;
}
};
let handle = CoreProcessHandle::new(7788);
let result = handle.ensure_running().await;
assert!(
result.is_ok(),
"ensure_running should recover by binding a fallback port: {result:?}"
);
// Accept any port in the configured fallback range 7789..=7798 — a
// parallel test or environmental squatter on a single fallback port
// shouldn't fail the broader contract that fallback recovery works.
let chosen = handle.port();
assert!(
(7789..=7798).contains(&chosen),
"with 7788 occupied, core should bind to a fallback in 7789..=7798, got {chosen}"
);
let notice = handle
.take_last_port_fallback_notice()
.expect("fallback notice should be present");
assert_eq!(notice.preferred_port, 7788);
assert_eq!(
notice.chosen_port, chosen,
"fallback notice payload should match the bound port"
);
assert!(
(7789..=7798).contains(¬ice.chosen_port),
"fallback notice chosen_port should be in 7789..=7798, got {}",
notice.chosen_port
);
handle.shutdown().await;
drop(listener);
});
}
/// Escape hatch: setting `OPENHUMAN_CORE_REUSE_EXISTING=1` opts back into
/// the legacy attach-to-anything behavior for manual harnesses.
#[test]
fn ensure_running_reuses_unknown_listener_when_override_set() {
let _env_lock = env_lock();
let _override = EnvGuard::set("OPENHUMAN_CORE_REUSE_EXISTING", "1");
let rt = core_test_runtime();
let result = rt.block_on(async {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind test listener");
let port = listener.local_addr().expect("local addr").port();
let handle = CoreProcessHandle::new(port);
handle.ensure_running().await
});
assert!(
result.is_ok(),
"override should restore legacy fast-path: {result:?}"
);
}
// ---------------------------------------------------------------------------
// Listener fingerprinting (issue #1130)
// ---------------------------------------------------------------------------
#[test]
fn is_openhuman_root_body_matches_canonical_root_response() {
// Mirrors the JSON shape produced by `openhuman-rpc/src/server/http/mod.rs::root_handler`.
let body = r#"{
"name": "openhuman",
"ok": true,
"endpoints": {"health": "/health", "rpc": "/rpc"}
}"#;
assert!(is_openhuman_root_body(body));
}
#[test]
fn is_openhuman_root_body_rejects_other_services() {
assert!(!is_openhuman_root_body(r#"{"name": "something-else"}"#));
assert!(!is_openhuman_root_body(r#"{"ok": true}"#));
assert!(!is_openhuman_root_body("not json at all"));
assert!(!is_openhuman_root_body(""));
// Wrong type for `name`.
assert!(!is_openhuman_root_body(r#"{"name": 42}"#));
}
#[test]
fn expected_port_clash_classifier_matches_benign_probe_shapes() {
assert!(is_expected_port_clash(
"probe GET / failed: error sending request for url (http://127.0.0.1:7788/)"
));
assert!(is_expected_port_clash(
"probe GET / failed: connection refused"
));
assert!(is_expected_port_clash(
"probe GET / returned status 404 Not Found"
));
assert!(is_expected_port_clash("probe GET / returned status 200 OK"));
assert!(is_expected_port_clash(
"probe GET / body did not identify as openhuman (\"hello\")"
));
}
#[test]
fn expected_port_clash_classifier_matches_windows_acl_bind_shapes() {
assert!(is_expected_port_clash(
"Failed to bind to 127.0.0.1:7788: access denied (os error 10013)"
));
assert!(is_expected_port_clash(
"Failed to bind to 127.0.0.1:7788: WSAEACCES"
));
}
#[test]
fn expected_port_clash_classifier_rejects_unknown_probe_shapes() {
assert!(!is_expected_port_clash(
"probe GET / failed: TLS handshake failed: protocol error"
));
assert!(!is_expected_port_clash(
"probe GET / body read failed: unexpected eof"
));
}
#[cfg(unix)]
#[test]
fn parse_lsof_pid_picks_first_pid() {
assert_eq!(parse_lsof_pid("12345\n"), Some(12345));
// Multiple pids — pick the first non-empty line. lsof can emit several
// when multiple sockets share the port (IPv4/IPv6).
assert_eq!(parse_lsof_pid("\n 9876 \n12345\n"), Some(9876));
assert_eq!(parse_lsof_pid(""), None);
assert_eq!(parse_lsof_pid("not-a-pid\n"), None);
}
#[test]
fn parse_netstat_pid_finds_listening_entry() {
// Sample shape from `netstat -ano -p TCP` on Windows.
let stdout = "\
Active Connections
Proto Local Address Foreign Address State PID
TCP 0.0.0.0:135 0.0.0.0:0 LISTENING 1024
TCP 127.0.0.1:7788 0.0.0.0:0 LISTENING 4242
TCP 127.0.0.1:50000 127.0.0.1:7788 ESTABLISHED 5555
";
assert_eq!(parse_netstat_pid(stdout, 7788), Some(4242));
assert_eq!(parse_netstat_pid(stdout, 9999), None);
}
#[test]
fn parse_netstat_pid_skips_protected_kernel_pids() {
// HTTP.sys / driver-level reservations occasionally show as LISTENING
// under PID 4 (NT Kernel) or PID 0 (System Idle). Returning those pids
// would lead startup recovery to call taskkill on a process that cannot
// be signalled from user mode — aborting the entire takeover flow.
// The parser must treat these entries as "no owner" so callers fall
// back to the port-reroute path instead of trying to kill the kernel.
let stdout = "\
Active Connections
Proto Local Address Foreign Address State PID
TCP 127.0.0.1:7788 0.0.0.0:0 LISTENING 4
TCP 127.0.0.1:7789 0.0.0.0:0 LISTENING 0
TCP 127.0.0.1:7790 0.0.0.0:0 LISTENING 1234
";
assert_eq!(parse_netstat_pid(stdout, 7788), None);
assert_eq!(parse_netstat_pid(stdout, 7789), None);
assert_eq!(parse_netstat_pid(stdout, 7790), Some(1234));
}
#[test]
fn parse_netstat_pid_falls_through_protected_to_real_owner_on_dual_stack() {
// Real-world dual-stack listener: kernel-reserved entry sits ahead of
// the actual user-mode owner on the same port. The parser must keep
// scanning past the protected pid and return the genuine owner.
let stdout = "\
Proto Local Address Foreign Address State PID
TCP [::]:7788 [::]:0 LISTENING 4
TCP 127.0.0.1:7788 0.0.0.0:0 LISTENING 9999
";
assert_eq!(parse_netstat_pid(stdout, 7788), Some(9999));
}
// ---------------------------------------------------------------------------
// Windows end-to-end port-takeover test
//
// Spawns a real child process that occupies a TCP port, then walks the same
// path the Tauri host walks at startup (find_pid_on_port → kill_pid_force →
// is_port_open) and asserts the port is actually freed. This is the
// behavior the user reported broken — a unit-only parser test is not enough
// to catch netstat/taskkill drift on real Windows machines.
// ---------------------------------------------------------------------------
#[cfg(windows)]
#[test]
fn windows_port_takeover_finds_and_kills_listener() {
use crate::process_kill::kill_pid_force;
use std::net::TcpListener;
use std::os::windows::process::CommandExt;
use std::time::{Duration, Instant};
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
// Bind in this process first to claim an ephemeral free port the OS
// picks for us, capture the port, then drop the listener so the child
// can bind to the same port. There is a tiny TOCTOU window here but
// ephemeral ports on Windows are not aggressively recycled so it is
// robust enough for a single-shot test.
let probe = TcpListener::bind("127.0.0.1:0").expect("bind probe");
let port = probe.local_addr().expect("probe addr").port();
drop(probe);
// Use PowerShell to spawn a listener that holds the port open for 60s.
// PowerShell ships with every supported Windows version.
let script = format!(
"$l = [System.Net.Sockets.TcpListener]::new([System.Net.IPAddress]::Loopback, {port}); \
$l.Start(); Start-Sleep -Seconds 60; $l.Stop()"
);
let mut child = std::process::Command::new("powershell")
.args(["-NoProfile", "-NonInteractive", "-Command", &script])
.creation_flags(CREATE_NO_WINDOW)
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.stdin(std::process::Stdio::null())
.spawn()
.expect("spawn powershell listener");
// Wait until the listener is actually bound (PowerShell startup is slow).
let deadline = Instant::now() + Duration::from_secs(15);
let mut bound = false;
while Instant::now() < deadline {
if std::net::TcpStream::connect_timeout(
&format!("127.0.0.1:{port}").parse().unwrap(),
Duration::from_millis(100),
)
.is_ok()
{
bound = true;
break;
}
std::thread::sleep(Duration::from_millis(100));
}
if !bound {
let _ = child.kill();
let _ = child.wait();
panic!("child listener never bound to 127.0.0.1:{port}");
}
// Walk the production path: pid lookup via netstat, then force-kill.
let pid = match super::find_pid_on_port(port) {
Some(pid) => pid,
None => {
let _ = child.kill();
let _ = child.wait();
panic!("find_pid_on_port returned None for port {port}");
}
};
// The pid we discovered won't be `child.id()` directly — the powershell
// process is the listener, and on Windows `child.id()` IS that pid.
// Sanity-check they match so a future netstat parser regression is loud.
// Tear down the child *before* panicking so a 60s listener doesn't leak
// into the rest of the test suite.
if pid != child.id() {
let expected = child.id();
let _ = child.kill();
let _ = child.wait();
panic!("find_pid_on_port returned pid {pid}, expected child pid {expected}");
}
kill_pid_force(pid).expect("force-kill listener");
// Verify the port is actually free within a reasonable window — this is
// the assertion that fails when taskkill mis-reports success or when
// /T fails to take down the powershell subtree.
let deadline = Instant::now() + Duration::from_secs(5);
let mut freed = false;
while Instant::now() < deadline {
if std::net::TcpStream::connect_timeout(
&format!("127.0.0.1:{port}").parse().unwrap(),
Duration::from_millis(100),
)
.is_err()
{
freed = true;
break;
}
std::thread::sleep(Duration::from_millis(100));
}
let _ = child.wait();
assert!(
freed,
"port {port} still bound after kill_pid_force(pid={pid})"
);
// Idempotency: kill the same pid again — must be Ok, not Err, because
// the process is already gone and recovery code calls force-kill after
// a re-validation that may race.
kill_pid_force(pid).expect("kill_pid_force on dead pid must be idempotent");
}
// ---------------------------------------------------------------------------
// Token generation tests
// ---------------------------------------------------------------------------
/// `generate_rpc_token` must produce a 64-character lowercase hex string
/// (32 bytes × 2 hex digits = 64 chars), matching the format expected by the
/// core's auth middleware.
#[test]
fn generate_rpc_token_produces_64_hex_chars() {
let token = generate_rpc_token();
assert_eq!(
token.len(),
64,
"256-bit token → 64 hex chars, got {token:?}"
);
assert!(
token.chars().all(|c| c.is_ascii_hexdigit()),
"token must be hex, got {token:?}"
);
assert!(
token.chars().all(|c| !c.is_uppercase()),
"token must be lowercase hex, got {token:?}"
);
}
/// Each call generates a different token (CSPRNG — not a constant).
#[test]
fn generate_rpc_token_is_not_constant() {
assert_ne!(
generate_rpc_token(),
generate_rpc_token(),
"two consecutive tokens must differ"
);
}
/// `CoreProcessHandle::new` must produce a non-empty, correctly-formatted
/// bearer token immediately — no file I/O or timing dependency.
#[test]
fn core_process_handle_new_token_is_valid() {
let handle = CoreProcessHandle::new(19001);
let token = handle.rpc_token();
assert_eq!(token.len(), 64, "handle token must be 64 hex chars");
assert!(
token.chars().all(|c| c.is_ascii_hexdigit()),
"handle token must be hex"
);
}
/// `CoreProcessHandle::new()` must NOT publish the token to the global
/// `CURRENT_RPC_TOKEN`. The global is set only after `ensure_running()`
/// successfully spawns the embedded server with its in-memory bearer. Advertising the token before spawn would 401 against any process
/// already listening on the port that never received this token.
#[test]
fn new_does_not_publish_global_token() {
let _env_lock = env_lock();
let before = current_rpc_token();
let handle = CoreProcessHandle::new(19002);
let after = current_rpc_token();
assert_ne!(
after.as_deref(),
Some(handle.rpc_token()),
"new() must not publish its token to CURRENT_RPC_TOKEN before ensure_running() spawns"
);
assert_eq!(
before, after,
"new() must leave CURRENT_RPC_TOKEN unchanged"
);
}
/// Two handles constructed sequentially must each have a unique token.
#[test]
fn each_handle_has_unique_token() {
let h1 = CoreProcessHandle::new(19003);
let h2 = CoreProcessHandle::new(19004);
assert_ne!(
h1.rpc_token(),
h2.rpc_token(),
"each handle must have a unique token"
);
}
#[test]
fn send_terminate_signal_cancels_shutdown_token() {
let rt = core_test_runtime();
rt.block_on(async {
let handle = CoreProcessHandle::new(19005);
assert!(!handle.shutdown_token_is_cancelled().await);
handle.send_terminate_signal().await;
assert!(
handle.shutdown_token_is_cancelled().await,
"send_terminate_signal must cancel graceful Axum shutdown before aborting the task"
);
});
}
#[test]
fn startup_timeout_cleanup_aborts_task_and_clears_slot() {
let rt = core_test_runtime();
rt.block_on(async {
let handle = CoreProcessHandle::new(19006);
let task = tokio::spawn(async {
tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;
Ok::<(), anyhow::Error>(())
});
{
let mut guard = handle.task.lock().await;
*guard = Some(task);
}
let message = handle.cleanup_startup_timeout(false, false, 2).await;
// One loose check that the human-readable diagnostic names the failure,
// instead of pinning six exact substrings of its formatting (plan.md
// §3) — the wording of the diagnostic is not a contract.
assert!(
message.contains("core process did not become ready within"),
"timeout message should name the readiness failure: {message}"
);
// Load-bearing behaviour (skeptic-flagged, must stay): cleanup clears
// the managed task slot so a retry can spawn fresh, and cancels the
// startup shutdown token before aborting.
assert!(
handle.task.lock().await.is_none(),
"cleanup must clear the managed task slot so retry can spawn fresh"
);
assert!(
handle.shutdown_token_is_cancelled().await,
"cleanup must cancel the startup token before aborting"
);
});
}
// ---------------------------------------------------------------------------
// RecoveryOutcome serialization tests
// ---------------------------------------------------------------------------
#[test]
fn recovery_outcome_serializes_correctly() {
let outcome = RecoveryOutcome {
success: true,
message: "Core recovered on port 7789".to_string(),
new_port: Some(7789),
foreign_owner: None,
};
let json = serde_json::to_value(&outcome).expect("serialize");
assert_eq!(json["success"], serde_json::json!(true));
assert_eq!(
json["message"],
serde_json::json!("Core recovered on port 7789")
);
assert_eq!(json["new_port"], serde_json::json!(7789));
}
#[test]
fn recovery_outcome_failure_serializes_with_null_port() {
let outcome = RecoveryOutcome {
success: false,
message: "Recovery failed: port still busy".to_string(),
new_port: None,
foreign_owner: None,
};
let json = serde_json::to_value(&outcome).expect("serialize");
assert_eq!(json["success"], serde_json::json!(false));
assert!(
json["new_port"].is_null(),
"new_port should be null when None"
);
assert!(
json["foreign_owner"].is_null(),
"foreign_owner should be null when None"
);
}
#[test]
fn recovery_outcome_serializes_foreign_owner() {
let outcome = RecoveryOutcome {
success: false,
message: "Recovery failed: port still busy".to_string(),
new_port: None,
foreign_owner: Some(PortOwner {
pid: 4242,
name: "Skype.exe".to_string(),
}),
};
let json = serde_json::to_value(&outcome).expect("serialize");
assert_eq!(json["foreign_owner"]["pid"], serde_json::json!(4242));
assert_eq!(
json["foreign_owner"]["name"],
serde_json::json!("Skype.exe")
);
}
#[test]
fn parse_tasklist_name_extracts_image_name() {
assert_eq!(
parse_tasklist_name("\"chrome.exe\",\"1234\",\"Console\",\"1\",\"123,456 K\"\r\n"),
Some("chrome.exe".to_string())
);
// Leading blank lines are skipped.
assert_eq!(
parse_tasklist_name("\n\"node.exe\",\"42\",\"Console\",\"1\",\"9,000 K\""),
Some("node.exe".to_string())
);
}
#[test]
fn parse_tasklist_name_rejects_no_tasks_sentinel_and_blanks() {
assert_eq!(
parse_tasklist_name("INFO: No tasks are running which match the specified criteria.\r\n"),
None
);
assert_eq!(parse_tasklist_name(""), None);
assert_eq!(parse_tasklist_name("\"\",\"1\""), None);
}
#[test]
fn parse_ps_comm_takes_basename() {
assert_eq!(parse_ps_comm("nginx\n"), Some("nginx".to_string()));
assert_eq!(
parse_ps_comm("/usr/lib/postgresql/16/bin/postgres\n"),
Some("postgres".to_string())
);
assert_eq!(parse_ps_comm(" \n"), None);
assert_eq!(parse_ps_comm(""), None);
}
#[test]
fn validate_kill_target_accepts_unchanged_owner() {
assert_eq!(validate_kill_target(Some(1234), 1234, 999), Ok(1234));
}
#[test]
fn validate_kill_target_refuses_when_owner_gone_or_changed() {
// Port freed between surfacing the owner and confirming.
assert!(validate_kill_target(None, 1234, 999).is_err());
// A different process now holds the port — never kill what the user did
// not consent to (PID-reuse / race guard).
assert!(validate_kill_target(Some(5678), 1234, 999).is_err());
}
#[test]
fn validate_kill_target_refuses_self_pid() {
let err = validate_kill_target(Some(999), 999, 999).unwrap_err();
assert!(err.contains("own process"), "got: {err}");
}
#[test]
fn validate_kill_target_refuses_protected_pids() {
// Low/kernel pids must never be signalled even if the user "consented":
// 0 (kill(0) hits the process group on Unix), 1 (init/launchd), 4 (NT kernel).
assert!(validate_kill_target(Some(0), 0, 999).is_err());
assert!(validate_kill_target(Some(1), 1, 999).is_err());
assert!(validate_kill_target(Some(4), 4, 999).is_err());
}
#[test]
fn recover_port_conflict_succeeds_when_port_is_free() {
let _env_lock = env_lock();
let _unset = EnvGuard::unset("OPENHUMAN_CORE_REUSE_EXISTING");
let _workspace = test_workspace();
let rt = core_test_runtime();
let outcome = rt.block_on(async {
// Bind a port, then release it so it's free when recover_port_conflict runs.
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind");
let port = listener.local_addr().expect("addr").port();
drop(listener);
// Brief yield to let the OS fully release the port.
tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
let handle = CoreProcessHandle::new(port);
let outcome = handle.recover_port_conflict().await;
handle.shutdown().await;
outcome
});
assert!(
outcome.success,
"recovery should succeed when port is free: {}",
outcome.message
);
assert!(
outcome.new_port.is_some(),
"new_port should be set on success"
);
}