569 lines
19 KiB
Rust
569 lines
19 KiB
Rust
use std::os::unix::net::UnixListener;
|
|
use std::path::Path;
|
|
use std::process::{Command, Output};
|
|
use std::thread;
|
|
|
|
use ferese_ipc::{Request, Response, read_frame, write_frame};
|
|
use serde_json::json;
|
|
|
|
fn ctl(args: &[&str]) -> Command {
|
|
let mut command = Command::new(env!("CARGO_BIN_EXE_feresectl"));
|
|
command
|
|
.args(args)
|
|
.env_remove("FERESE_SOCKET")
|
|
.env_remove("XDG_RUNTIME_DIR");
|
|
command
|
|
}
|
|
|
|
fn serve(path: &Path, expected: &'static str, value: serde_json::Value) -> thread::JoinHandle<()> {
|
|
let listener = UnixListener::bind(path).unwrap();
|
|
thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
stream
|
|
.set_read_timeout(Some(std::time::Duration::from_secs(2)))
|
|
.unwrap();
|
|
let request: Request = read_frame(&mut stream).unwrap();
|
|
assert_eq!(request.command, expected);
|
|
write_frame(&mut stream, &Response::success(request.id, value)).unwrap();
|
|
})
|
|
}
|
|
|
|
fn success(output: Output) -> String {
|
|
assert!(
|
|
output.status.success(),
|
|
"{}",
|
|
String::from_utf8_lossy(&output.stderr)
|
|
);
|
|
String::from_utf8(output.stdout).unwrap()
|
|
}
|
|
|
|
#[test]
|
|
fn help_exits_successfully_without_a_session_and_has_hidden_legacy_aliases() {
|
|
for args in [
|
|
&["--help"][..],
|
|
&["theme", "--help"],
|
|
&["launcher", "--help"],
|
|
&["media", "--help"],
|
|
&["xwayland", "--help"],
|
|
&["screenshot", "--help"],
|
|
&["focus-floating", "--help"],
|
|
] {
|
|
let text = success(ctl(args).output().unwrap());
|
|
assert!(text.contains("Usage:"));
|
|
assert!(!text.contains("get-outputs"));
|
|
}
|
|
let output = ctl(&["widows"]).output().unwrap();
|
|
assert_eq!(output.status.code(), Some(2));
|
|
let error = String::from_utf8(output.stderr).unwrap();
|
|
assert!(error.contains("windows"), "{error}");
|
|
}
|
|
|
|
#[test]
|
|
fn focus_floating_sends_a_parameterless_action_and_rejects_cycle_arguments() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let socket = directory.path().join("control.sock");
|
|
let listener = UnixListener::bind(&socket).unwrap();
|
|
let worker = thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
stream
|
|
.set_read_timeout(Some(std::time::Duration::from_secs(2)))
|
|
.unwrap();
|
|
let request: Request = read_frame(&mut stream).unwrap();
|
|
assert_eq!(request.command, "focus-floating");
|
|
assert_eq!(request.args, json!({}));
|
|
write_frame(&mut stream, &Response::success(request.id, json!({}))).unwrap();
|
|
});
|
|
success(
|
|
ctl(&["--socket", socket.to_str().unwrap(), "focus-floating"])
|
|
.output()
|
|
.unwrap(),
|
|
);
|
|
worker.join().unwrap();
|
|
let output = ctl(&["focus-floating", "next"]).output().unwrap();
|
|
assert_eq!(output.status.code(), Some(2));
|
|
}
|
|
|
|
#[test]
|
|
fn explicit_socket_targets_the_nested_instance_for_queries_and_theme_commands() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let nested = directory.path().join("nested.sock");
|
|
let host = directory.path().join("host.sock");
|
|
let host_listener = UnixListener::bind(&host).unwrap();
|
|
host_listener.set_nonblocking(true).unwrap();
|
|
for args in [
|
|
vec!["--socket", nested.to_str().unwrap(), "-j", "windows"],
|
|
vec![
|
|
"theme",
|
|
"mode",
|
|
"dark",
|
|
"--socket",
|
|
nested.to_str().unwrap(),
|
|
"--json",
|
|
],
|
|
] {
|
|
let worker = serve(
|
|
&nested,
|
|
if args[0] == "theme" {
|
|
"theme-set-mode"
|
|
} else {
|
|
"get-windows"
|
|
},
|
|
json!({"instance": "nested"}),
|
|
);
|
|
let output = success(ctl(&args).env("FERESE_SOCKET", &host).output().unwrap());
|
|
assert_eq!(
|
|
serde_json::from_str::<serde_json::Value>(&output).unwrap(),
|
|
json!({"instance": "nested"})
|
|
);
|
|
worker.join().unwrap();
|
|
std::fs::remove_file(&nested).unwrap();
|
|
assert_eq!(
|
|
host_listener.accept().unwrap_err().kind(),
|
|
std::io::ErrorKind::WouldBlock
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn socket_environment_and_runtime_fallback_use_the_same_query_path() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
std::fs::create_dir(directory.path().join("ferese")).unwrap();
|
|
let socket = directory.path().join("ferese/control.sock");
|
|
for environment in ["FERESE_SOCKET", "XDG_RUNTIME_DIR"] {
|
|
let worker = serve(
|
|
&socket,
|
|
"outputs",
|
|
json!([{"name": "nested", "enabled": true}]),
|
|
);
|
|
let target = if environment == "FERESE_SOCKET" {
|
|
socket.as_path()
|
|
} else {
|
|
directory.path()
|
|
};
|
|
let output = success(ctl(&["outputs"]).env(environment, target).output().unwrap());
|
|
assert!(output.contains("name: nested"));
|
|
assert!(!output.contains('"'));
|
|
worker.join().unwrap();
|
|
std::fs::remove_file(&socket).unwrap();
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn legacy_queries_are_hidden_aliases_with_an_explicit_json_flag() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let socket = directory.path().join("control.sock");
|
|
let worker = serve(&socket, "get-workspaces", json!([]));
|
|
let output = ctl(&["--socket", socket.to_str().unwrap(), "get-workspaces", "-j"])
|
|
.output()
|
|
.unwrap();
|
|
assert!(String::from_utf8_lossy(&output.stderr).contains("deprecated; use workspaces"));
|
|
assert_eq!(success(output).trim(), "[]");
|
|
worker.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn event_stream_uses_the_selected_socket_and_prints_complete_json_lines() {
|
|
use ferese_ipc::events::{Change, Event, VERSION};
|
|
use std::io::{BufRead, BufReader};
|
|
use std::process::Stdio;
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let socket = directory.path().join("events.sock");
|
|
let listener = UnixListener::bind(&socket).unwrap();
|
|
let event = Event {
|
|
version: VERSION,
|
|
generation: 7,
|
|
last: true,
|
|
change: Change::LockChanged {
|
|
lock: ferese_ipc::events::LockState {
|
|
phase: "locked".into(),
|
|
sleeping: false,
|
|
},
|
|
},
|
|
};
|
|
let expected = event.clone();
|
|
let (stop, stopped) = std::sync::mpsc::channel();
|
|
let worker = thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
let request: Request = read_frame(&mut stream).unwrap();
|
|
assert_eq!(request.command, "event-stream");
|
|
assert_eq!(request.args["version"], VERSION);
|
|
write_frame(
|
|
&mut stream,
|
|
&Response::success(request.id, json!({"version": VERSION})),
|
|
)
|
|
.unwrap();
|
|
write_frame(&mut stream, &event).unwrap();
|
|
stopped
|
|
.recv_timeout(std::time::Duration::from_secs(5))
|
|
.unwrap();
|
|
});
|
|
let mut child = ctl(&["event-stream", "--socket", socket.to_str().unwrap()])
|
|
.stdout(Stdio::piped())
|
|
.spawn()
|
|
.unwrap();
|
|
let mut line = String::new();
|
|
BufReader::new(child.stdout.take().unwrap())
|
|
.read_line(&mut line)
|
|
.unwrap();
|
|
assert_eq!(serde_json::from_str::<Event>(&line).unwrap(), expected);
|
|
child.kill().unwrap();
|
|
child.wait().unwrap();
|
|
stop.send(()).unwrap();
|
|
worker.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn activity_start_uses_versioned_framing_and_parent_scope() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let socket = dir.path().join("activity.sock");
|
|
let listener = UnixListener::bind(&socket).unwrap();
|
|
let server = thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
let request: Request = read_frame(&mut stream).unwrap();
|
|
assert_eq!(request.version, ferese_ipc::VERSION);
|
|
assert_eq!(request.command, "activity-publish");
|
|
let wire: ferese_ipc::activities::Request = serde_json::from_value(request.args).unwrap();
|
|
assert!(matches!(
|
|
wire.owner,
|
|
ferese_ipc::activities::OwnerScope::Parent
|
|
));
|
|
match wire.publish {
|
|
ferese_ipc::activities::Publish::Start { local, data, .. } => {
|
|
assert_eq!(local, "build");
|
|
assert_eq!(data.value, ferese_activities::Value::Indeterminate);
|
|
}
|
|
_ => panic!("wrong activity action"),
|
|
}
|
|
write_frame(
|
|
&mut stream,
|
|
&Response::success(request.id, json!({"handle":{"generation":1}})),
|
|
)
|
|
.unwrap();
|
|
});
|
|
success(
|
|
ctl(&[
|
|
"--socket",
|
|
socket.to_str().unwrap(),
|
|
"activity",
|
|
"start",
|
|
"build",
|
|
"--title",
|
|
"Build",
|
|
])
|
|
.output()
|
|
.unwrap(),
|
|
);
|
|
server.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn run_preserves_arguments_cwd_environment_output_and_exit_when_publishing_fails() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let output = ctl(&[
|
|
"--socket",
|
|
"/missing/ferese.sock",
|
|
"run",
|
|
"--title",
|
|
"Test",
|
|
"--",
|
|
"sh",
|
|
"-c",
|
|
"printf '%s|%s|%s' \"$1\" \"$ACTIVITY_TEST_VALUE\" \"$PWD\"; printf stderr >&2; exit 17",
|
|
"sh",
|
|
"argument with spaces;$literal",
|
|
])
|
|
.env("ACTIVITY_TEST_VALUE", "preserved")
|
|
.current_dir(dir.path())
|
|
.output()
|
|
.unwrap();
|
|
assert_eq!(output.status.code(), Some(17));
|
|
assert_eq!(
|
|
String::from_utf8(output.stdout).unwrap(),
|
|
format!(
|
|
"argument with spaces;$literal|preserved|{}",
|
|
dir.path().display()
|
|
)
|
|
);
|
|
assert_eq!(output.stderr, b"stderr");
|
|
}
|
|
|
|
#[test]
|
|
fn run_preserves_child_exit_and_signal_status() {
|
|
use std::os::unix::process::ExitStatusExt;
|
|
let output = ctl(&[
|
|
"run",
|
|
"--",
|
|
"sh",
|
|
"-c",
|
|
"printf '{\"reason\":\"build-finished\",\"success\":true}\\n'; exit 19",
|
|
])
|
|
.output()
|
|
.unwrap();
|
|
assert_eq!(output.status.code(), Some(19));
|
|
let output = ctl(&["run", "--", "sh", "-c", "kill -TERM $$"])
|
|
.output()
|
|
.unwrap();
|
|
assert_eq!(output.status.signal(), Some(libc::SIGTERM));
|
|
}
|
|
|
|
#[test]
|
|
fn wrapper_forwards_termination_and_preserves_job_control_group() {
|
|
use std::os::unix::process::{CommandExt, ExitStatusExt};
|
|
let mut command = ctl(&["run", "--", "sh", "-c", "kill -STOP $$; sleep 30"]);
|
|
unsafe {
|
|
command.pre_exec(|| {
|
|
libc::setpgid(0, 0);
|
|
Ok(())
|
|
});
|
|
}
|
|
let mut child = command.spawn().unwrap();
|
|
std::thread::sleep(std::time::Duration::from_millis(150));
|
|
let pid = child.id() as i32;
|
|
assert_eq!(unsafe { libc::kill(-pid, libc::SIGCONT) }, 0);
|
|
assert_eq!(unsafe { libc::kill(pid, libc::SIGTERM) }, 0);
|
|
assert_eq!(child.wait().unwrap().signal(), Some(libc::SIGTERM));
|
|
}
|
|
|
|
#[test]
|
|
fn terminal_ctrl_c_reaches_child_and_wrapper_returns_sigint() {
|
|
use std::os::unix::process::{CommandExt, ExitStatusExt};
|
|
let mut command = ctl(&["run", "--", "sleep", "30"]);
|
|
unsafe {
|
|
command.pre_exec(|| {
|
|
libc::setpgid(0, 0);
|
|
Ok(())
|
|
});
|
|
}
|
|
let mut child = command.spawn().unwrap();
|
|
std::thread::sleep(std::time::Duration::from_millis(150));
|
|
assert_eq!(unsafe { libc::kill(-(child.id() as i32), libc::SIGINT) }, 0);
|
|
assert_eq!(child.wait().unwrap().signal(), Some(libc::SIGINT));
|
|
}
|
|
|
|
#[test]
|
|
fn a_silent_broker_cannot_prevent_or_change_command_execution() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let socket = directory.path().join("blocked.sock");
|
|
let listener = UnixListener::bind(&socket).unwrap();
|
|
let worker = thread::spawn(move || {
|
|
let (_stream, _) = listener.accept().unwrap();
|
|
std::thread::sleep(std::time::Duration::from_secs(3));
|
|
});
|
|
let began = std::time::Instant::now();
|
|
let result = ctl(&[
|
|
"--socket",
|
|
socket.to_str().unwrap(),
|
|
"run",
|
|
"--",
|
|
"sh",
|
|
"-c",
|
|
"printf executed; exit 23",
|
|
])
|
|
.output()
|
|
.unwrap();
|
|
assert_eq!(result.stdout, b"executed");
|
|
assert_eq!(result.status.code(), Some(23));
|
|
assert!(began.elapsed() < std::time::Duration::from_secs(3));
|
|
worker.join().unwrap();
|
|
}
|
|
|
|
fn fake_cargo(dir: &Path, script: &str) -> String {
|
|
use std::os::unix::fs::PermissionsExt;
|
|
let path = dir.join("cargo");
|
|
std::fs::write(&path, script).unwrap();
|
|
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
|
|
format!(
|
|
"{}:{}",
|
|
dir.display(),
|
|
std::env::var("PATH").unwrap_or_default()
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn cargo_adapter_completion_does_not_wait_for_descendant_stdout() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = fake_cargo(
|
|
dir.path(),
|
|
"#!/bin/sh\nsleep 5 &\necho $! > descendant\nprintf captured\nexit 23\n",
|
|
);
|
|
let output = dir.path().join("output");
|
|
let mut child = ctl(&[
|
|
"--socket",
|
|
"/missing/activity.sock",
|
|
"run",
|
|
"--cargo-json",
|
|
"--",
|
|
"cargo",
|
|
"build",
|
|
])
|
|
.env("PATH", path)
|
|
.current_dir(dir.path())
|
|
.stdout(std::fs::File::create(&output).unwrap())
|
|
.stderr(std::process::Stdio::null())
|
|
.spawn()
|
|
.unwrap();
|
|
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(2);
|
|
let status = loop {
|
|
if let Some(status) = child.try_wait().unwrap() {
|
|
break Some(status);
|
|
}
|
|
if std::time::Instant::now() >= deadline {
|
|
child.kill().unwrap();
|
|
child.wait().unwrap();
|
|
break None;
|
|
}
|
|
thread::sleep(std::time::Duration::from_millis(10));
|
|
};
|
|
let descendant: i32 = std::fs::read_to_string(dir.path().join("descendant"))
|
|
.unwrap()
|
|
.trim()
|
|
.parse()
|
|
.unwrap();
|
|
unsafe {
|
|
libc::kill(descendant, libc::SIGTERM);
|
|
}
|
|
assert_eq!(
|
|
status.and_then(|status| status.code()),
|
|
Some(23),
|
|
"waited for descendant EOF"
|
|
);
|
|
assert_eq!(std::fs::read(&output).unwrap(), b"captured");
|
|
}
|
|
|
|
#[test]
|
|
fn stalled_progress_acknowledgements_do_not_block_cargo_stdout() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = fake_cargo(
|
|
dir.path(),
|
|
r##"#!/usr/bin/env python3
|
|
import json, time, sys
|
|
start = time.monotonic()
|
|
time.sleep(.3)
|
|
for _ in range(20000):
|
|
print('{"reason":"compiler-artifact"}')
|
|
sys.stdout.flush()
|
|
with open('elapsed', 'w') as f:
|
|
f.write(str(time.monotonic() - start))
|
|
print('{"reason":"build-finished","success":true}')
|
|
print('child output')
|
|
print(json.dumps({'reason': 'compiler-message', 'message': {'rendered': 'diagnostic\n'}}))
|
|
sys.exit(19)
|
|
"##,
|
|
);
|
|
let socket = dir.path().join("broker.sock");
|
|
let listener = UnixListener::bind(&socket).unwrap();
|
|
listener.set_nonblocking(true).unwrap();
|
|
let server = thread::spawn(move || {
|
|
let mut stalled = Vec::new();
|
|
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
|
|
while std::time::Instant::now() < deadline {
|
|
let Ok((mut stream, _)) = listener.accept() else {
|
|
thread::sleep(std::time::Duration::from_millis(5));
|
|
continue;
|
|
};
|
|
stream
|
|
.set_read_timeout(Some(std::time::Duration::from_secs(1)))
|
|
.unwrap();
|
|
let request: Request = read_frame(&mut stream).unwrap();
|
|
match request.args["publish"]["action"].as_str().unwrap() {
|
|
"run" => {
|
|
let handle = ferese_activities::Id {
|
|
owner: ferese_activities::Owner { pid: 1, birth: 1 },
|
|
local: request.args["publish"]["local"].as_str().unwrap().into(),
|
|
session: 1,
|
|
generation: 1,
|
|
};
|
|
write_frame(
|
|
&mut stream,
|
|
&Response::success(
|
|
request.id,
|
|
json!({"handle":handle,"progress":"cargo-json"}),
|
|
),
|
|
)
|
|
.unwrap();
|
|
}
|
|
"update" => stalled.push(stream), // Accept the update but never acknowledge it.
|
|
"end" => {
|
|
assert_eq!(request.args["publish"]["result"], "failed");
|
|
write_frame(&mut stream, &Response::success(request.id, json!({}))).unwrap();
|
|
return stalled.len();
|
|
}
|
|
_ => panic!("unexpected publication"),
|
|
}
|
|
}
|
|
panic!("completion was not published");
|
|
});
|
|
let output = ctl(&[
|
|
"--socket",
|
|
socket.to_str().unwrap(),
|
|
"run",
|
|
"--",
|
|
"cargo",
|
|
"build",
|
|
])
|
|
.env("PATH", path)
|
|
.current_dir(dir.path())
|
|
.output()
|
|
.unwrap();
|
|
assert_eq!(output.status.code(), Some(19));
|
|
assert_eq!(output.stdout, b"child output\ndiagnostic\n");
|
|
assert!(
|
|
server.join().unwrap() > 0,
|
|
"probe must exercise progress publishing"
|
|
);
|
|
let elapsed: f64 = std::fs::read_to_string(dir.path().join("elapsed"))
|
|
.unwrap()
|
|
.parse()
|
|
.unwrap();
|
|
assert!(
|
|
elapsed < 1.5,
|
|
"stdout reader stalled the child for {elapsed}s"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn launcher_toggle_uses_the_shell_command() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let path = directory.path().join("ipc.sock");
|
|
let server = serve(&path, "toggle-launcher", json!({}));
|
|
success(
|
|
ctl(&["launcher", "toggle"])
|
|
.env("FERESE_SOCKET", &path)
|
|
.output()
|
|
.unwrap(),
|
|
);
|
|
server.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn pomodoro_commands_use_the_versioned_session_api() {
|
|
for action in [
|
|
"start", "pause", "resume", "next", "stop", "reset", "status",
|
|
] {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let socket = directory.path().join("control.sock");
|
|
let listener = UnixListener::bind(&socket).unwrap();
|
|
let worker = thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
let request: Request = read_frame(&mut stream).unwrap();
|
|
assert_eq!(request.command, "pomodoro");
|
|
assert_eq!(
|
|
request.args,
|
|
json!({"version":1,"action":action,"session":null})
|
|
);
|
|
write_frame(
|
|
&mut stream,
|
|
&Response::success(request.id, json!({"phase":"work"})),
|
|
)
|
|
.unwrap();
|
|
});
|
|
success(
|
|
ctl(&["--socket", socket.to_str().unwrap(), "pomodoro", action])
|
|
.output()
|
|
.unwrap(),
|
|
);
|
|
worker.join().unwrap();
|
|
}
|
|
success(ctl(&["pomodoro", "--help"]).output().unwrap());
|
|
}
|