mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-19 07:08:48 +01:00
The daemon takes its settings from a komorebi.json: the file --config names, or the one in the config home ($KOMOREBI_CONFIG_HOME, else ~/.config/komorebi). Without a file it runs on its defaults, as before. StaticConfig reads the file in three steps, because the monitors are known only after the backend has been asked. preload makes the window manager and applies the settings that are process-wide, postload gives each monitor and workspace the entry of its place (by the index display_index_preferences gives a monitor's serial number id, else in order), and main asks KWin for a desktop for each workspace the file lists. A watcher on the file sends the daemon a ReloadStaticConfiguration about two seconds after it changes, whether an editor wrote the file in place or renamed a new one over it, and a file that does not parse changes nothing. A workspace can change its layout, its work area offset and its layout options with the number of its containers, from the file or with komorebic (workspace-layout-rule, its named form and the two that clear), and layout_defaults gives every workspace of a layout the options it sets none of. One file is meant to serve every platform, so a key that does nothing on Plasma is accepted and ignored. config_parity checks the example and the files of other platforms; the keys of features that are not in yet are listed there, and the test fails when a list names a key that is read. The file also sets what the stacks, the float override, the floating layer and monocle set while the daemon runs: window_container_behaviour, with its rules by container count in a workspace, float_override, float_override_placement, floating_layer_behaviour (for a monitor and a workspace too), floating_layer_placement and monocle_focus_behaviour. Their features come before this commit, but a file to put the keys in does not, so they are part of this one. komorebic gains configuration, generate-static-config and start --config. The NixOS module gets configFile, which the unit gives the daemon as --config.
979 lines
30 KiB
Rust
979 lines
30 KiB
Rust
//! `komorebic` as a person runs it, against a socket the test serves in place of the daemon: what
|
|
//! each subcommand writes on the socket, and what it prints.
|
|
|
|
use std::io::Read;
|
|
use std::io::Write;
|
|
use std::os::unix::net::UnixListener;
|
|
use std::path::Path;
|
|
use std::path::PathBuf;
|
|
use std::process::Command;
|
|
use std::process::Output;
|
|
use std::sync::atomic::AtomicU32;
|
|
use std::sync::atomic::Ordering;
|
|
use std::thread::JoinHandle;
|
|
|
|
/// A runtime directory for one test, short enough for a unix socket path on macOS, with the
|
|
/// `komorebi` directory the daemon would make in it
|
|
struct Runtime(PathBuf);
|
|
|
|
impl Runtime {
|
|
fn new() -> Self {
|
|
static NEXT: AtomicU32 = AtomicU32::new(0);
|
|
let dir = PathBuf::from(format!(
|
|
"/tmp/komorebic-test-{}-{}",
|
|
std::process::id(),
|
|
NEXT.fetch_add(1, Ordering::SeqCst)
|
|
));
|
|
let _ = std::fs::remove_dir_all(&dir);
|
|
std::fs::create_dir_all(dir.join("komorebi")).unwrap();
|
|
Self(dir)
|
|
}
|
|
|
|
/// Listens on the daemon's socket, takes one connection, and answers what it reads on it with
|
|
/// `answer`. The thread returns what it read.
|
|
fn serve(&self, answer: &'static str) -> JoinHandle<String> {
|
|
let listener = UnixListener::bind(self.0.join("komorebi").join("komorebi.sock")).unwrap();
|
|
|
|
std::thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
let mut message = String::new();
|
|
stream.read_to_string(&mut message).unwrap();
|
|
stream.write_all(answer.as_bytes()).unwrap();
|
|
message
|
|
})
|
|
}
|
|
|
|
fn komorebic(&self, args: &[&str]) -> Output {
|
|
Command::new(env!("CARGO_BIN_EXE_komorebic"))
|
|
.args(args)
|
|
.env("XDG_RUNTIME_DIR", &self.0)
|
|
.output()
|
|
.unwrap()
|
|
}
|
|
|
|
/// Runs `komorebic` with `KOMOREBI_CONFIG_HOME` set to `home`
|
|
fn komorebic_with_config_home(&self, home: &Path, args: &[&str]) -> Output {
|
|
Command::new(env!("CARGO_BIN_EXE_komorebic"))
|
|
.args(args)
|
|
.env("XDG_RUNTIME_DIR", &self.0)
|
|
.env("KOMOREBI_CONFIG_HOME", home)
|
|
.output()
|
|
.unwrap()
|
|
}
|
|
}
|
|
|
|
impl Drop for Runtime {
|
|
fn drop(&mut self) {
|
|
let _ = std::fs::remove_dir_all(&self.0);
|
|
}
|
|
}
|
|
|
|
fn stdout(output: &Output) -> String {
|
|
String::from_utf8_lossy(&output.stdout).into_owned()
|
|
}
|
|
|
|
#[test]
|
|
fn state_prints_the_answer_of_the_daemon() {
|
|
let runtime = Runtime::new();
|
|
let daemon = runtime.serve(r#"{"monitors":{"elements":[],"focused":0}}"#);
|
|
|
|
let output = runtime.komorebic(&["state"]);
|
|
|
|
assert!(output.status.success(), "{output:?}");
|
|
assert_eq!(daemon.join().unwrap(), r#"{"type":"State"}"#);
|
|
assert_eq!(
|
|
stdout(&output),
|
|
"{\"monitors\":{\"elements\":[],\"focused\":0}}\n"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn query_asks_the_question_it_is_given() {
|
|
let runtime = Runtime::new();
|
|
let daemon = runtime.serve("1");
|
|
|
|
let output = runtime.komorebic(&["query", "focused-workspace-index"]);
|
|
|
|
assert!(output.status.success(), "{output:?}");
|
|
assert_eq!(
|
|
daemon.join().unwrap(),
|
|
r#"{"type":"Query","content":"FocusedWorkspaceIndex"}"#
|
|
);
|
|
assert_eq!(stdout(&output), "1\n");
|
|
}
|
|
|
|
#[test]
|
|
fn monitor_information_prints_the_answer_of_the_daemon() {
|
|
let runtime = Runtime::new();
|
|
let daemon = runtime.serve("[]");
|
|
|
|
let output = runtime.komorebic(&["monitor-info"]);
|
|
|
|
assert!(output.status.success(), "{output:?}");
|
|
assert_eq!(daemon.join().unwrap(), r#"{"type":"MonitorInformation"}"#);
|
|
assert_eq!(stdout(&output), "[]\n");
|
|
}
|
|
|
|
#[test]
|
|
fn stop_and_retile_send_their_message_and_print_nothing() {
|
|
for (subcommand, message) in [
|
|
("stop", r#"{"type":"Stop"}"#),
|
|
("retile", r#"{"type":"Retile"}"#),
|
|
] {
|
|
let runtime = Runtime::new();
|
|
let daemon = runtime.serve("");
|
|
|
|
let output = runtime.komorebic(&[subcommand]);
|
|
|
|
assert!(output.status.success(), "{subcommand}: {output:?}");
|
|
assert_eq!(daemon.join().unwrap(), message, "{subcommand}");
|
|
assert_eq!(stdout(&output), "", "{subcommand}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn stop_with_ignore_restore_sends_the_message_that_leaves_the_hidden_windows_hidden() {
|
|
let runtime = Runtime::new();
|
|
let daemon = runtime.serve("");
|
|
|
|
let output = runtime.komorebic(&["stop", "--ignore-restore"]);
|
|
|
|
assert!(output.status.success(), "{output:?}");
|
|
assert_eq!(daemon.join().unwrap(), r#"{"type":"StopIgnoreRestore"}"#);
|
|
assert_eq!(stdout(&output), "");
|
|
}
|
|
|
|
#[test]
|
|
fn subscribe_socket_and_unsubscribe_socket_send_the_name_they_are_given() {
|
|
for (subcommand, message) in [
|
|
(
|
|
"subscribe-socket",
|
|
r#"{"type":"AddSubscriberSocket","content":"bar.sock"}"#,
|
|
),
|
|
(
|
|
"unsubscribe-socket",
|
|
r#"{"type":"RemoveSubscriberSocket","content":"bar.sock"}"#,
|
|
),
|
|
] {
|
|
let runtime = Runtime::new();
|
|
let daemon = runtime.serve("");
|
|
|
|
let output = runtime.komorebic(&[subcommand, "bar.sock"]);
|
|
|
|
assert!(output.status.success(), "{subcommand}: {output:?}");
|
|
assert_eq!(daemon.join().unwrap(), message, "{subcommand}");
|
|
assert_eq!(stdout(&output), "", "{subcommand}");
|
|
}
|
|
}
|
|
|
|
/// Runs `komorebic` with `args` against a daemon that answers nothing, and checks that it wrote
|
|
/// `message` on the socket, printed nothing and exited with status 0
|
|
fn sends(args: &[&str], message: &str) {
|
|
let runtime = Runtime::new();
|
|
let daemon = runtime.serve("");
|
|
|
|
let output = runtime.komorebic(args);
|
|
|
|
assert!(output.status.success(), "{args:?}: {output:?}");
|
|
assert_eq!(daemon.join().unwrap(), message, "{args:?}");
|
|
assert_eq!(stdout(&output), "", "{args:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn focus_and_cycle_focus_send_the_direction_they_are_given() {
|
|
sends(
|
|
&["focus", "left"],
|
|
r#"{"type":"FocusWindow","content":"Left"}"#,
|
|
);
|
|
sends(
|
|
&["focus", "down"],
|
|
r#"{"type":"FocusWindow","content":"Down"}"#,
|
|
);
|
|
sends(
|
|
&["cycle-focus", "next"],
|
|
r#"{"type":"CycleFocusWindow","content":"Next"}"#,
|
|
);
|
|
sends(
|
|
&["cycle-focus", "previous"],
|
|
r#"{"type":"CycleFocusWindow","content":"Previous"}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn move_and_cycle_move_send_the_direction_they_are_given() {
|
|
sends(
|
|
&["move", "right"],
|
|
r#"{"type":"MoveWindow","content":"Right"}"#,
|
|
);
|
|
sends(&["move", "up"], r#"{"type":"MoveWindow","content":"Up"}"#);
|
|
sends(
|
|
&["cycle-move", "previous"],
|
|
r#"{"type":"CycleMoveWindow","content":"Previous"}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_layout_subcommands_send_the_layout_axis_or_direction_they_are_given() {
|
|
sends(
|
|
&["change-layout", "vertical-stack"],
|
|
r#"{"type":"ChangeLayout","content":"VerticalStack"}"#,
|
|
);
|
|
sends(
|
|
&["change-layout", "bsp"],
|
|
r#"{"type":"ChangeLayout","content":"BSP"}"#,
|
|
);
|
|
sends(
|
|
&["cycle-layout", "next"],
|
|
r#"{"type":"CycleLayout","content":"Next"}"#,
|
|
);
|
|
sends(
|
|
&["flip-layout", "horizontal-and-vertical"],
|
|
r#"{"type":"FlipLayout","content":"HorizontalAndVertical"}"#,
|
|
);
|
|
sends(&["toggle-tiling"], r#"{"type":"ToggleTiling"}"#);
|
|
sends(&["toggle-float"], r#"{"type":"ToggleFloat"}"#);
|
|
sends(
|
|
&["toggle-workspace-layer"],
|
|
r#"{"type":"ToggleWorkspaceLayer"}"#,
|
|
);
|
|
sends(&["toggle-lock"], r#"{"type":"ToggleLock"}"#);
|
|
sends(
|
|
&["preselect-direction", "up"],
|
|
r#"{"type":"PreselectDirection","content":"Up"}"#,
|
|
);
|
|
sends(&["cancel-preselect"], r#"{"type":"CancelPreselect"}"#);
|
|
}
|
|
|
|
#[test]
|
|
fn the_stack_subcommands_send_the_direction_or_the_index_they_are_given() {
|
|
sends(
|
|
&["stack", "left"],
|
|
r#"{"type":"StackWindow","content":"Left"}"#,
|
|
);
|
|
sends(
|
|
&["stack", "down"],
|
|
r#"{"type":"StackWindow","content":"Down"}"#,
|
|
);
|
|
sends(&["unstack"], r#"{"type":"UnstackWindow"}"#);
|
|
sends(&["stack-all"], r#"{"type":"StackAll"}"#);
|
|
sends(&["unstack-all"], r#"{"type":"UnstackAll"}"#);
|
|
sends(
|
|
&["cycle-stack", "next"],
|
|
r#"{"type":"CycleStack","content":"Next"}"#,
|
|
);
|
|
sends(
|
|
&["cycle-stack", "previous"],
|
|
r#"{"type":"CycleStack","content":"Previous"}"#,
|
|
);
|
|
sends(
|
|
&["cycle-stack-index", "next"],
|
|
r#"{"type":"CycleStackIndex","content":"Next"}"#,
|
|
);
|
|
sends(
|
|
&["focus-stack-window", "2"],
|
|
r#"{"type":"FocusStackWindow","content":2}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_subcommands_for_new_windows_send_their_message() {
|
|
sends(
|
|
&["toggle-window-container-behaviour"],
|
|
r#"{"type":"ToggleWindowContainerBehaviour"}"#,
|
|
);
|
|
sends(
|
|
&["toggle-workspace-window-container-behaviour"],
|
|
r#"{"type":"ToggleWorkspaceWindowContainerBehaviour"}"#,
|
|
);
|
|
sends(
|
|
&["toggle-float-override"],
|
|
r#"{"type":"ToggleFloatOverride"}"#,
|
|
);
|
|
sends(
|
|
&["toggle-workspace-float-override"],
|
|
r#"{"type":"ToggleWorkspaceFloatOverride"}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn scrolling_layout_columns_and_layout_ratios_send_what_they_are_given() {
|
|
sends(
|
|
&["scrolling-layout-columns", "3"],
|
|
r#"{"type":"ScrollingLayoutColumns","content":3}"#,
|
|
);
|
|
sends(
|
|
&["layout-ratios", "--columns", "0.6", "0.25", "--rows", "0.5"],
|
|
r#"{"type":"LayoutRatios","content":[[0.6,0.25],[0.5]]}"#,
|
|
);
|
|
sends(
|
|
&["layout-ratios", "--rows", "0.3"],
|
|
r#"{"type":"LayoutRatios","content":[null,[0.3]]}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn layout_ratios_without_ratios_sends_nothing_and_says_so() {
|
|
let runtime = Runtime::new();
|
|
|
|
let output = runtime.komorebic(&["layout-ratios"]);
|
|
|
|
assert!(output.status.success(), "{output:?}");
|
|
assert!(
|
|
stdout(&output).starts_with("No ratios provided"),
|
|
"{output:?}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn scrolling_layout_columns_refuses_zero() {
|
|
let runtime = Runtime::new();
|
|
|
|
let output = runtime.komorebic(&["scrolling-layout-columns", "0"]);
|
|
|
|
assert!(!output.status.success(), "{output:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn the_resize_subcommands_send_what_they_are_given() {
|
|
sends(
|
|
&["resize-edge", "left", "increase"],
|
|
r#"{"type":"ResizeWindowEdge","content":["Left","Increase"]}"#,
|
|
);
|
|
sends(
|
|
&["resize", "down", "decrease"],
|
|
r#"{"type":"ResizeWindowEdge","content":["Down","Decrease"]}"#,
|
|
);
|
|
sends(
|
|
&["resize-axis", "horizontal-and-vertical", "increase"],
|
|
r#"{"type":"ResizeWindowAxis","content":["HorizontalAndVertical","Increase"]}"#,
|
|
);
|
|
sends(
|
|
&["resize-delta", "75"],
|
|
r#"{"type":"ResizeDelta","content":75}"#,
|
|
);
|
|
sends(&["quick-save-resize"], r#"{"type":"QuickSave"}"#);
|
|
sends(&["quick-load"], r#"{"type":"QuickLoad"}"#);
|
|
sends(
|
|
&["save-resize", "/tmp/sizes.json"],
|
|
r#"{"type":"Save","content":"/tmp/sizes.json"}"#,
|
|
);
|
|
sends(
|
|
&["load", "/tmp/sizes.json"],
|
|
r#"{"type":"Load","content":"/tmp/sizes.json"}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_promote_subcommands_send_their_message() {
|
|
sends(&["promote"], r#"{"type":"Promote"}"#);
|
|
sends(&["promote-swap"], r#"{"type":"PromoteSwap"}"#);
|
|
sends(&["promote-focus"], r#"{"type":"PromoteFocus"}"#);
|
|
sends(
|
|
&["promote-window", "right"],
|
|
r#"{"type":"PromoteWindow","content":"Right"}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_padding_subcommands_send_the_workspace_and_the_pixels_they_are_given() {
|
|
sends(
|
|
&["focused-workspace-padding", "20"],
|
|
r#"{"type":"FocusedWorkspacePadding","content":20}"#,
|
|
);
|
|
sends(
|
|
&["focused-workspace-container-padding", "10"],
|
|
r#"{"type":"FocusedWorkspaceContainerPadding","content":10}"#,
|
|
);
|
|
sends(
|
|
&["workspace-padding", "0", "1", "12"],
|
|
r#"{"type":"WorkspacePadding","content":[0,1,12]}"#,
|
|
);
|
|
sends(
|
|
&["container-padding", "1", "0", "8"],
|
|
r#"{"type":"ContainerPadding","content":[1,0,8]}"#,
|
|
);
|
|
sends(
|
|
&["named-workspace-padding", "mail", "12"],
|
|
r#"{"type":"NamedWorkspacePadding","content":["mail",12]}"#,
|
|
);
|
|
sends(
|
|
&["named-workspace-container-padding", "mail", "8"],
|
|
r#"{"type":"NamedWorkspaceContainerPadding","content":["mail",8]}"#,
|
|
);
|
|
sends(
|
|
&["adjust-workspace-padding", "increase", "5"],
|
|
r#"{"type":"AdjustWorkspacePadding","content":["Increase",5]}"#,
|
|
);
|
|
sends(
|
|
&["adjust-container-padding", "decrease", "3"],
|
|
r#"{"type":"AdjustContainerPadding","content":["Decrease",3]}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_offset_subcommands_send_the_offset_they_are_given() {
|
|
sends(
|
|
&["global-work-area-offset", "10", "20", "30", "40"],
|
|
r#"{"type":"WorkAreaOffset","content":{"left":10,"top":20,"right":30,"bottom":40}}"#,
|
|
);
|
|
sends(
|
|
&["monitor-work-area-offset", "1", "10", "20", "30", "40"],
|
|
r#"{"type":"MonitorWorkAreaOffset","content":[1,{"left":10,"top":20,"right":30,"bottom":40}]}"#,
|
|
);
|
|
sends(
|
|
&[
|
|
"workspace-work-area-offset",
|
|
"1",
|
|
"2",
|
|
"10",
|
|
"20",
|
|
"30",
|
|
"40",
|
|
],
|
|
r#"{"type":"WorkspaceWorkAreaOffset","content":[1,2,{"left":10,"top":20,"right":30,"bottom":40}]}"#,
|
|
);
|
|
sends(
|
|
&["toggle-window-based-work-area-offset"],
|
|
r#"{"type":"ToggleWindowBasedWorkAreaOffset"}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_rule_subcommands_send_the_application_they_are_given() {
|
|
sends(
|
|
&["ignore-rule", "exe", "steam"],
|
|
r#"{"type":"IgnoreRule","content":["Exe","steam"]}"#,
|
|
);
|
|
sends(
|
|
&["float-rule", "class", "org.kde.kcalc"],
|
|
r#"{"type":"IgnoreRule","content":["Class","org.kde.kcalc"]}"#,
|
|
);
|
|
sends(
|
|
&["manage-rule", "title", "Picture-in-Picture"],
|
|
r#"{"type":"ManageRule","content":["Title","Picture-in-Picture"]}"#,
|
|
);
|
|
sends(&["session-float-rule"], r#"{"type":"SessionFloatRule"}"#);
|
|
sends(
|
|
&["clear-session-float-rules"],
|
|
r#"{"type":"ClearSessionFloatRules"}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn global_state_and_session_float_rules_print_the_answer_of_the_daemon() {
|
|
for (args, message) in [
|
|
("global-state", r#"{"type":"GlobalState"}"#),
|
|
("session-float-rules", r#"{"type":"SessionFloatRules"}"#),
|
|
] {
|
|
let runtime = Runtime::new();
|
|
let daemon = runtime.serve("[]");
|
|
|
|
let output = runtime.komorebic(&[args]);
|
|
|
|
assert!(output.status.success(), "{output:?}");
|
|
assert_eq!(daemon.join().unwrap(), message);
|
|
assert_eq!(stdout(&output), "[]\n");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn the_subcommands_about_the_focused_window_and_pausing_send_their_message() {
|
|
sends(&["minimize"], r#"{"type":"Minimize"}"#);
|
|
sends(&["close"], r#"{"type":"Close"}"#);
|
|
sends(&["manage"], r#"{"type":"ManageFocusedWindow"}"#);
|
|
sends(&["unmanage"], r#"{"type":"UnmanageFocusedWindow"}"#);
|
|
sends(&["toggle-pause"], r#"{"type":"TogglePause"}"#);
|
|
sends(
|
|
&["unmanaged-window-operation-behaviour", "no-op"],
|
|
r#"{"type":"UnmanagedWindowOperationBehaviour","content":"NoOp"}"#,
|
|
);
|
|
sends(
|
|
&["unmanaged-window-operation-behaviour", "op"],
|
|
r#"{"type":"UnmanagedWindowOperationBehaviour","content":"Op"}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_monocle_subcommands_send_their_message() {
|
|
sends(&["toggle-monocle"], r#"{"type":"ToggleMonocle"}"#);
|
|
sends(
|
|
&["monocle-focus-behaviour", "cycle"],
|
|
r#"{"type":"MonocleFocusBehaviour","content":"Cycle"}"#,
|
|
);
|
|
sends(
|
|
&["monocle-focus-behaviour", "no-op"],
|
|
r#"{"type":"MonocleFocusBehaviour","content":"NoOp"}"#,
|
|
);
|
|
sends(
|
|
&["toggle-monocle-focus-behaviour"],
|
|
r#"{"type":"ToggleMonocleFocusBehaviour"}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn toggle_maximize_sends_its_message() {
|
|
sends(&["toggle-maximize"], r#"{"type":"ToggleMaximize"}"#);
|
|
}
|
|
|
|
#[test]
|
|
fn mouse_follows_focus_is_set_with_enable_and_disable_or_toggled() {
|
|
sends(
|
|
&["mouse-follows-focus", "enable"],
|
|
r#"{"type":"MouseFollowsFocus","content":true}"#,
|
|
);
|
|
sends(
|
|
&["mouse-follows-focus", "disable"],
|
|
r#"{"type":"MouseFollowsFocus","content":false}"#,
|
|
);
|
|
sends(
|
|
&["toggle-mouse-follows-focus"],
|
|
r#"{"type":"ToggleMouseFollowsFocus"}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_workspace_subcommands_send_the_index_they_are_given() {
|
|
sends(
|
|
&["focus-workspace", "1"],
|
|
r#"{"type":"FocusWorkspaceNumber","content":1}"#,
|
|
);
|
|
sends(
|
|
&["move-to-workspace", "2"],
|
|
r#"{"type":"MoveContainerToWorkspaceNumber","content":2}"#,
|
|
);
|
|
sends(
|
|
&["send-to-workspace", "0"],
|
|
r#"{"type":"SendContainerToWorkspaceNumber","content":0}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_other_workspace_subcommands_send_what_they_are_given() {
|
|
sends(
|
|
&["cycle-workspace", "next"],
|
|
r#"{"type":"CycleFocusWorkspace","content":"Next"}"#,
|
|
);
|
|
sends(
|
|
&["cycle-empty-workspace", "previous"],
|
|
r#"{"type":"CycleFocusEmptyWorkspace","content":"Previous"}"#,
|
|
);
|
|
sends(
|
|
&["cycle-move-to-workspace", "next"],
|
|
r#"{"type":"CycleMoveContainerToWorkspace","content":"Next"}"#,
|
|
);
|
|
sends(
|
|
&["cycle-send-to-workspace", "previous"],
|
|
r#"{"type":"CycleSendContainerToWorkspace","content":"Previous"}"#,
|
|
);
|
|
sends(
|
|
&["focus-last-workspace"],
|
|
r#"{"type":"FocusLastWorkspace"}"#,
|
|
);
|
|
sends(
|
|
&["move-to-last-workspace"],
|
|
r#"{"type":"MoveContainerToLastWorkspace"}"#,
|
|
);
|
|
sends(
|
|
&["send-to-last-workspace"],
|
|
r#"{"type":"SendContainerToLastWorkspace"}"#,
|
|
);
|
|
sends(
|
|
&["focus-workspaces", "2"],
|
|
r#"{"type":"FocusWorkspaceNumbers","content":2}"#,
|
|
);
|
|
sends(&["new-workspace"], r#"{"type":"NewWorkspace"}"#);
|
|
sends(&["close-workspace"], r#"{"type":"CloseWorkspace"}"#);
|
|
}
|
|
|
|
#[test]
|
|
fn the_named_workspace_subcommands_send_the_names_they_are_given() {
|
|
sends(
|
|
&["workspace-name", "0", "1", "mail"],
|
|
r#"{"type":"WorkspaceName","content":[0,1,"mail"]}"#,
|
|
);
|
|
sends(
|
|
&["focus-named-workspace", "mail"],
|
|
r#"{"type":"FocusNamedWorkspace","content":"mail"}"#,
|
|
);
|
|
sends(
|
|
&["ensure-workspaces", "0", "3"],
|
|
r#"{"type":"EnsureWorkspaces","content":[0,3]}"#,
|
|
);
|
|
sends(
|
|
&["ensure-named-workspaces", "0", "web", "code"],
|
|
r#"{"type":"EnsureNamedWorkspaces","content":[0,["web","code"]]}"#,
|
|
);
|
|
sends(
|
|
&["workspace-layout", "0", "1", "columns"],
|
|
r#"{"type":"WorkspaceLayout","content":[0,1,"Columns"]}"#,
|
|
);
|
|
sends(
|
|
&["named-workspace-layout", "mail", "rows"],
|
|
r#"{"type":"NamedWorkspaceLayout","content":["mail","Rows"]}"#,
|
|
);
|
|
sends(
|
|
&["workspace-tiling", "0", "1", "disable"],
|
|
r#"{"type":"WorkspaceTiling","content":[0,1,false]}"#,
|
|
);
|
|
sends(
|
|
&["named-workspace-tiling", "mail", "enable"],
|
|
r#"{"type":"NamedWorkspaceTiling","content":["mail",true]}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_layout_rule_subcommands_send_what_they_are_given() {
|
|
sends(
|
|
&["workspace-layout-rule", "0", "1", "3", "columns"],
|
|
r#"{"type":"WorkspaceLayoutRule","content":[0,1,3,"Columns"]}"#,
|
|
);
|
|
sends(
|
|
&["named-workspace-layout-rule", "mail", "2", "rows"],
|
|
r#"{"type":"NamedWorkspaceLayoutRule","content":["mail",2,"Rows"]}"#,
|
|
);
|
|
sends(
|
|
&["clear-workspace-layout-rules", "0", "1"],
|
|
r#"{"type":"ClearWorkspaceLayoutRules","content":[0,1]}"#,
|
|
);
|
|
sends(
|
|
&["clear-named-workspace-layout-rules", "mail"],
|
|
r#"{"type":"ClearNamedWorkspaceLayoutRules","content":"mail"}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn generate_static_config_prints_the_answer_of_the_daemon() {
|
|
let runtime = Runtime::new();
|
|
let daemon = runtime.serve(r#"{"resize_delta":50}"#);
|
|
|
|
let output = runtime.komorebic(&["generate-static-config"]);
|
|
|
|
assert!(output.status.success(), "{output:?}");
|
|
assert_eq!(daemon.join().unwrap(), r#"{"type":"GenerateStaticConfig"}"#);
|
|
assert_eq!(stdout(&output), "{\"resize_delta\":50}\n");
|
|
}
|
|
|
|
#[test]
|
|
fn configuration_shows_the_path_of_komorebi_json_when_there_is_one() {
|
|
let runtime = Runtime::new();
|
|
let home = runtime.0.join("config");
|
|
std::fs::create_dir_all(&home).unwrap();
|
|
|
|
// `config` is another name for it
|
|
for name in ["configuration", "config"] {
|
|
let output = runtime.komorebic_with_config_home(&home, &[name]);
|
|
assert!(output.status.success(), "{output:?}");
|
|
assert_eq!(stdout(&output), "", "no file, nothing to show");
|
|
}
|
|
|
|
std::fs::write(home.join("komorebi.json"), "{}").unwrap();
|
|
|
|
for name in ["configuration", "config"] {
|
|
let output = runtime.komorebic_with_config_home(&home, &[name]);
|
|
assert!(output.status.success(), "{output:?}");
|
|
assert_eq!(
|
|
stdout(&output),
|
|
format!("{}\n", home.join("komorebi.json").display())
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn a_config_home_that_is_not_a_directory_is_refused() {
|
|
let runtime = Runtime::new();
|
|
let home = runtime.0.join("not-there");
|
|
|
|
let output = runtime.komorebic_with_config_home(&home, &["configuration"]);
|
|
|
|
assert!(!output.status.success(), "{output:?}");
|
|
assert!(
|
|
String::from_utf8_lossy(&output.stderr).contains("which is not a valid directory"),
|
|
"{output:?}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_monitor_subcommands_send_what_they_are_given() {
|
|
sends(
|
|
&["focus-monitor", "1"],
|
|
r#"{"type":"FocusMonitorNumber","content":1}"#,
|
|
);
|
|
sends(
|
|
&["cycle-monitor", "next"],
|
|
r#"{"type":"CycleFocusMonitor","content":"Next"}"#,
|
|
);
|
|
sends(
|
|
&["focus-monitor-at-cursor"],
|
|
r#"{"type":"FocusMonitorAtCursor"}"#,
|
|
);
|
|
sends(
|
|
&["focus-monitor-workspace", "1", "2"],
|
|
r#"{"type":"FocusMonitorWorkspaceNumber","content":[1,2]}"#,
|
|
);
|
|
sends(
|
|
&["move-to-monitor", "1"],
|
|
r#"{"type":"MoveContainerToMonitorNumber","content":1}"#,
|
|
);
|
|
sends(
|
|
&["send-to-monitor", "0"],
|
|
r#"{"type":"SendContainerToMonitorNumber","content":0}"#,
|
|
);
|
|
sends(
|
|
&["cycle-move-to-monitor", "previous"],
|
|
r#"{"type":"CycleMoveContainerToMonitor","content":"Previous"}"#,
|
|
);
|
|
sends(
|
|
&["cycle-send-to-monitor", "next"],
|
|
r#"{"type":"CycleSendContainerToMonitor","content":"Next"}"#,
|
|
);
|
|
sends(
|
|
&["move-to-monitor-workspace", "1", "0"],
|
|
r#"{"type":"MoveContainerToMonitorWorkspaceNumber","content":[1,0]}"#,
|
|
);
|
|
sends(
|
|
&["send-to-monitor-workspace", "0", "1"],
|
|
r#"{"type":"SendContainerToMonitorWorkspaceNumber","content":[0,1]}"#,
|
|
);
|
|
sends(
|
|
&["move-to-named-workspace", "mail"],
|
|
r#"{"type":"MoveContainerToNamedWorkspace","content":"mail"}"#,
|
|
);
|
|
sends(
|
|
&["send-to-named-workspace", "mail"],
|
|
r#"{"type":"SendContainerToNamedWorkspace","content":"mail"}"#,
|
|
);
|
|
sends(
|
|
&["move-workspace-to-monitor", "1"],
|
|
r#"{"type":"MoveWorkspaceToMonitorNumber","content":1}"#,
|
|
);
|
|
sends(
|
|
&["cycle-move-workspace-to-monitor", "next"],
|
|
r#"{"type":"CycleMoveWorkspaceToMonitor","content":"Next"}"#,
|
|
);
|
|
sends(
|
|
&["swap-workspaces-with-monitor", "1"],
|
|
r#"{"type":"SwapWorkspacesToMonitorNumber","content":1}"#,
|
|
);
|
|
sends(
|
|
&["cross-monitor-move-behaviour", "insert"],
|
|
r#"{"type":"CrossMonitorMoveBehaviour","content":"Insert"}"#,
|
|
);
|
|
sends(
|
|
&["toggle-cross-monitor-move-behaviour"],
|
|
r#"{"type":"ToggleCrossMonitorMoveBehaviour"}"#,
|
|
);
|
|
sends(
|
|
&["display-index-preference", "1", "DP-2"],
|
|
r#"{"type":"DisplayIndexPreference","content":[1,"DP-2"]}"#,
|
|
);
|
|
sends(
|
|
&["eager-focus", "firefox"],
|
|
r#"{"type":"EagerFocus","content":"firefox"}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn without_a_daemon_a_question_fails() {
|
|
let runtime = Runtime::new();
|
|
|
|
let output = runtime.komorebic(&["state"]);
|
|
|
|
assert!(!output.status.success(), "{output:?}");
|
|
assert_eq!(stdout(&output), "");
|
|
}
|
|
|
|
#[test]
|
|
fn data_directory_shows_where_the_socket_is() {
|
|
let runtime = Runtime::new();
|
|
|
|
let output = runtime.komorebic(&["data-directory"]);
|
|
|
|
assert!(output.status.success(), "{output:?}");
|
|
assert_eq!(
|
|
stdout(&output),
|
|
format!("{}\n", runtime.0.join("komorebi").display())
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn docgen_writes_the_help_of_every_subcommand_in_a_text_fence() {
|
|
let runtime = Runtime::new();
|
|
let docs = runtime.0.join("cli");
|
|
|
|
let output = runtime.komorebic(&["docgen", "--output", docs.to_str().unwrap()]);
|
|
|
|
assert!(output.status.success(), "{output:?}");
|
|
let mut pages = std::fs::read_dir(&docs)
|
|
.unwrap()
|
|
.map(|entry| entry.unwrap().file_name().into_string().unwrap())
|
|
.collect::<Vec<_>>();
|
|
pages.sort();
|
|
assert_eq!(
|
|
pages,
|
|
[
|
|
"adjust-container-padding.md",
|
|
"adjust-workspace-padding.md",
|
|
"cancel-preselect.md",
|
|
"change-layout.md",
|
|
"clear-named-workspace-layout-rules.md",
|
|
"clear-session-float-rules.md",
|
|
"clear-workspace-layout-rules.md",
|
|
"close-workspace.md",
|
|
"close.md",
|
|
"completions.md",
|
|
"configuration.md",
|
|
"container-padding.md",
|
|
"cross-monitor-move-behaviour.md",
|
|
"cycle-empty-workspace.md",
|
|
"cycle-focus.md",
|
|
"cycle-layout.md",
|
|
"cycle-monitor.md",
|
|
"cycle-move-to-monitor.md",
|
|
"cycle-move-to-workspace.md",
|
|
"cycle-move-workspace-to-monitor.md",
|
|
"cycle-move.md",
|
|
"cycle-send-to-monitor.md",
|
|
"cycle-send-to-workspace.md",
|
|
"cycle-stack-index.md",
|
|
"cycle-stack.md",
|
|
"cycle-workspace.md",
|
|
"data-directory.md",
|
|
"display-index-preference.md",
|
|
"eager-focus.md",
|
|
"ensure-named-workspaces.md",
|
|
"ensure-workspaces.md",
|
|
"flip-layout.md",
|
|
"focus-last-workspace.md",
|
|
"focus-monitor-at-cursor.md",
|
|
"focus-monitor-workspace.md",
|
|
"focus-monitor.md",
|
|
"focus-named-workspace.md",
|
|
"focus-stack-window.md",
|
|
"focus-workspace.md",
|
|
"focus-workspaces.md",
|
|
"focus.md",
|
|
"focused-workspace-container-padding.md",
|
|
"focused-workspace-padding.md",
|
|
"generate-static-config.md",
|
|
"global-state.md",
|
|
"global-work-area-offset.md",
|
|
"ignore-rule.md",
|
|
"layout-ratios.md",
|
|
"load-resize.md",
|
|
"log.md",
|
|
"manage-rule.md",
|
|
"manage.md",
|
|
"minimize.md",
|
|
"monitor-information.md",
|
|
"monitor-work-area-offset.md",
|
|
"monocle-focus-behaviour.md",
|
|
"mouse-follows-focus.md",
|
|
"move-to-last-workspace.md",
|
|
"move-to-monitor-workspace.md",
|
|
"move-to-monitor.md",
|
|
"move-to-named-workspace.md",
|
|
"move-to-workspace.md",
|
|
"move-workspace-to-monitor.md",
|
|
"move.md",
|
|
"named-workspace-container-padding.md",
|
|
"named-workspace-layout-rule.md",
|
|
"named-workspace-layout.md",
|
|
"named-workspace-padding.md",
|
|
"named-workspace-tiling.md",
|
|
"new-workspace.md",
|
|
"preselect-direction.md",
|
|
"promote-focus.md",
|
|
"promote-swap.md",
|
|
"promote-window.md",
|
|
"promote.md",
|
|
"query.md",
|
|
"quick-load-resize.md",
|
|
"quick-save-resize.md",
|
|
"resize-axis.md",
|
|
"resize-delta.md",
|
|
"resize-edge.md",
|
|
"retile.md",
|
|
"save-resize.md",
|
|
"scrolling-layout-columns.md",
|
|
"send-to-last-workspace.md",
|
|
"send-to-monitor-workspace.md",
|
|
"send-to-monitor.md",
|
|
"send-to-named-workspace.md",
|
|
"send-to-workspace.md",
|
|
"session-float-rule.md",
|
|
"session-float-rules.md",
|
|
"stack-all.md",
|
|
"stack.md",
|
|
"start.md",
|
|
"state.md",
|
|
"stop.md",
|
|
"subscribe-socket.md",
|
|
"swap-workspaces-with-monitor.md",
|
|
"toggle-cross-monitor-move-behaviour.md",
|
|
"toggle-float-override.md",
|
|
"toggle-float.md",
|
|
"toggle-lock.md",
|
|
"toggle-maximize.md",
|
|
"toggle-monocle-focus-behaviour.md",
|
|
"toggle-monocle.md",
|
|
"toggle-mouse-follows-focus.md",
|
|
"toggle-pause.md",
|
|
"toggle-tiling.md",
|
|
"toggle-window-based-work-area-offset.md",
|
|
"toggle-window-container-behaviour.md",
|
|
"toggle-workspace-float-override.md",
|
|
"toggle-workspace-layer.md",
|
|
"toggle-workspace-window-container-behaviour.md",
|
|
"unmanage.md",
|
|
"unmanaged-window-operation-behaviour.md",
|
|
"unstack-all.md",
|
|
"unstack.md",
|
|
"unsubscribe-socket.md",
|
|
"workspace-layout-rule.md",
|
|
"workspace-layout.md",
|
|
"workspace-name.md",
|
|
"workspace-padding.md",
|
|
"workspace-tiling.md",
|
|
"workspace-work-area-offset.md",
|
|
]
|
|
);
|
|
|
|
let query = std::fs::read_to_string(Path::new(&docs).join("query.md")).unwrap();
|
|
assert!(query.starts_with("```text\n"), "{query}");
|
|
assert!(query.ends_with("\n```\n"), "{query}");
|
|
assert!(query.contains("focused-workspace-index"), "{query}");
|
|
}
|
|
|
|
#[test]
|
|
fn docgen_writes_the_same_pages_whatever_the_width_of_the_terminal() {
|
|
let runtime = Runtime::new();
|
|
// without a terminal, clap wraps the help at the width in COLUMNS
|
|
let query_page = |columns: &str| {
|
|
let docs = runtime.0.join(format!("cli-{columns}"));
|
|
let output = Command::new(env!("CARGO_BIN_EXE_komorebic"))
|
|
.args(["docgen", "--output", docs.to_str().unwrap()])
|
|
.env("COLUMNS", columns)
|
|
.output()
|
|
.unwrap();
|
|
assert!(output.status.success(), "{output:?}");
|
|
std::fs::read_to_string(docs.join("query.md")).unwrap()
|
|
};
|
|
|
|
let narrow = query_page("40");
|
|
|
|
assert_eq!(narrow, query_page("250"));
|
|
// the possible values of a query are wrapped at 100 columns
|
|
assert!(narrow.lines().any(|line| line.len() > 40), "{narrow}");
|
|
assert!(narrow.lines().all(|line| line.len() <= 100), "{narrow}");
|
|
}
|
|
|
|
#[test]
|
|
fn completions_are_a_script_that_knows_the_subcommands() {
|
|
let runtime = Runtime::new();
|
|
|
|
let output = runtime.komorebic(&["completions", "bash"]);
|
|
|
|
assert!(output.status.success(), "{output:?}");
|
|
assert!(stdout(&output).contains("monitor-information"));
|
|
}
|