test(core): pin Workspace container ring, placement, stacking and promote

tests/workspace_containers.rs (41 tests) over the recording stub: where a new
window goes (empty, after the focused container, scrolling hook index,
preselection, every initial placement rule incl. the 1-based index and its
fallback), resize-slot bookkeeping on insert and remove, locked containers
keeping their index on insert, swap and promote, the note_scrolling_departure
hook before a removal, the focus index after remove_container (idx-1 of the
FOCUSED container, not of the removed one), stacking (move_window_to_container)
and unstacking with the exact hide/restore call order and the hide spot passed,
focus by window, window lookup across containers, monocle, maximized and
floating windows, location_from_exe order, visible_windows order, directions
with and without layout flip, cycling and the pointer lookup.

Verified: cargo test -p komorebi-core --test workspace_containers, 41 passed.
No non-test source changed.
This commit is contained in:
LGUG2Z committed 2026-11-05 15:03:26 -08:00
1 parent d20432f087
commit 92943f7cba
1 file changed
+669
@@ -0,0 +1,669 @@
//! Characterization of `Workspace<P>`: the ring of containers, the index and focus invariants of
//! adding, removing, stacking and moving them, and the resize adjustments that follow them.
mod common;
use common::*;
use komorebi_config::placement::InitialWindowPlacementRules;
use komorebi_config::placement::PlacementTarget;
use komorebi_config::placement::WindowPlacement;
use komorebi_core::Container;
use komorebi_core::Lockable;
use komorebi_core::Workspace;
use komorebi_layouts::CycleDirection;
use komorebi_layouts::DefaultLayout;
use komorebi_layouts::Layout;
use komorebi_layouts::OperationDirection;
use komorebi_layouts::Rect;
fn w(id: u32) -> StubWindow {
StubWindow { id }
}
fn mark(workspace: &mut Workspace<StubPlatform>, n: i32) {
workspace.resize_dimensions = (0..n)
.map(|i| {
Some(Rect {
left: i + 1,
top: i + 1,
right: i + 1,
bottom: i + 1,
})
})
.collect();
}
#[test]
fn an_empty_workspace_has_nothing_in_it() {
fresh();
let workspace = Workspace::<StubPlatform>::default();
assert!(workspace.is_empty());
assert_eq!(workspace.focused_container_idx(), 0);
assert!(workspace.focused_container().is_none());
assert!(workspace.visible_windows().iter().all(Option::is_none));
assert!(!workspace.contains_window(1));
assert_eq!(workspace.container_idx_for_window(1), None);
}
#[test]
fn the_first_window_goes_to_index_zero_and_each_next_after_the_focused_container() {
fresh();
let mut workspace = workspace_of(&[1]);
assert_eq!(layout_of(&workspace), [[1]]);
workspace.new_container_for_window(w(2)).unwrap();
workspace.focus_container(0);
workspace.new_container_for_window(w(3)).unwrap();
assert_eq!(layout_of(&workspace), [vec![1], vec![3], vec![2]]);
assert_eq!(workspace.focused_container_idx(), 1);
}
#[test]
fn a_new_container_is_focused_and_gets_an_empty_resize_slot_at_its_index() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
mark(&mut workspace, 2);
workspace.focus_container(0);
workspace.new_container_for_window(w(3)).unwrap();
assert_eq!(workspace.focused_container_idx(), 1);
assert_eq!(workspace.resize_dimensions.len(), 3);
assert!(workspace.resize_dimensions[1].is_none());
assert!(workspace.resize_dimensions[0].is_some());
assert!(workspace.resize_dimensions[2].is_some());
}
#[test]
fn the_scrolling_hook_chooses_the_index_of_a_new_container_in_a_non_empty_workspace() {
fresh();
let mut workspace = workspace_of(&[1, 2, 3]);
set_scrolling_insertion_idx(Some(0));
workspace.new_container_for_window(w(4)).unwrap();
assert_eq!(layout_of(&workspace)[0], [4]);
}
#[test]
fn a_new_window_takes_the_container_a_preselection_reserved() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
workspace.preselect_container_idx(1);
assert_eq!(workspace.containers().len(), 3);
assert!(workspace.containers()[1].is_preselect());
assert_eq!(workspace.preselected_container_idx, Some(1));
workspace.new_container_for_window(w(3)).unwrap();
assert_eq!(layout_of(&workspace), [vec![1], vec![3], vec![2]]);
assert_eq!(workspace.preselected_container_idx, None);
assert!(!workspace.containers().iter().any(Container::is_preselect));
}
#[test]
fn cancelling_a_preselection_removes_its_container_and_does_nothing_without_one() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
workspace.cancel_preselect();
assert_eq!(workspace.containers().len(), 2);
workspace.preselect_container_idx(0);
workspace.cancel_preselect();
assert_eq!(layout_of(&workspace), [vec![1], vec![2]]);
assert_eq!(workspace.preselected_container_idx, None);
}
#[test]
fn initial_placement_rules_choose_where_a_new_window_goes() {
fresh();
let cases = [
(WindowPlacement::AfterFocused, vec![1, 2, 9, 3]),
(WindowPlacement::BeforeFocused, vec![1, 9, 2, 3]),
(WindowPlacement::Last, vec![1, 2, 3, 9]),
(WindowPlacement::Primary, vec![9, 1, 2, 3]),
];
for (placement, order) in cases {
let mut workspace = workspace_of(&[1, 2, 3]);
workspace.focus_container(1);
workspace.initial_window_placement_rules = Some(InitialWindowPlacementRules::Target(
PlacementTarget::Placement(placement),
));
workspace.new_container_for_window(w(9)).unwrap();
let firsts: Vec<u32> = layout_of(&workspace).iter().map(|c| c[0]).collect();
assert_eq!(firsts, order, "{placement:?}");
}
}
#[test]
fn a_one_based_placement_index_is_zero_based_and_out_of_range_falls_back_after_the_focused() {
fresh();
let mut workspace = workspace_of(&[1, 2, 3]);
workspace.focus_container(0);
workspace.initial_window_placement_rules = Some(InitialWindowPlacementRules::Target(
PlacementTarget::Index(3),
));
assert_eq!(workspace.resolve_placement_index(&w(9)), 2);
// index 0 saturates to the first place
workspace.initial_window_placement_rules = Some(InitialWindowPlacementRules::Target(
PlacementTarget::Index(0),
));
assert_eq!(workspace.resolve_placement_index(&w(9)), 0);
// one more than the containers is the end, two more falls back to after the focused one
workspace.initial_window_placement_rules = Some(InitialWindowPlacementRules::Target(
PlacementTarget::Index(4),
));
assert_eq!(workspace.resolve_placement_index(&w(9)), 3);
workspace.initial_window_placement_rules = Some(InitialWindowPlacementRules::Target(
PlacementTarget::Index(5),
));
assert_eq!(workspace.resolve_placement_index(&w(9)), 1);
}
#[test]
fn with_no_rules_a_window_goes_after_the_focused_container() {
fresh();
let mut workspace = workspace_of(&[1, 2, 3]);
workspace.focus_container(0);
assert_eq!(workspace.resolve_placement_index(&w(9)), 1);
}
#[test]
fn inserting_past_the_end_appends_and_pushes_a_resize_slot() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
mark(&mut workspace, 2);
let idx = workspace.insert_container_at_idx(9, container_of(&[3]));
assert_eq!(idx, 2);
assert_eq!(workspace.focused_container_idx(), 2);
assert_eq!(workspace.resize_dimensions.len(), 3);
assert!(workspace.resize_dimensions[2].is_none());
}
#[test]
fn a_locked_container_keeps_its_index_when_another_is_inserted_before_it() {
fresh();
let mut workspace = workspace_of(&[1, 2, 3]);
workspace.containers_mut()[1].set_locked(true);
let idx = workspace.insert_container_at_idx(0, container_of(&[9]));
assert_eq!(layout_of(&workspace), [vec![9], vec![2], vec![1], vec![3]]);
assert_eq!(idx, 0);
}
#[test]
fn removing_a_container_tells_the_scrolling_hook_first_and_drops_its_resize_slot() {
fresh();
let mut workspace = workspace_of(&[1, 2, 3]);
mark(&mut workspace, 3);
let removed = workspace.remove_container_by_idx(1).unwrap();
assert_eq!(removed.windows()[0].id, 2);
assert_eq!(log(), ["note_scrolling_departure 1"]);
assert_eq!(workspace.resize_dimensions.len(), 2);
assert_eq!(workspace.resize_dimensions[1].unwrap().left, 3);
}
#[test]
fn removing_past_the_end_removes_nothing() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
mark(&mut workspace, 2);
assert!(workspace.remove_container_by_idx(7).is_none());
assert_eq!(workspace.containers().len(), 2);
assert_eq!(workspace.resize_dimensions.len(), 2);
}
#[test]
fn removing_a_container_focuses_the_one_before_the_focused_container_not_before_the_removed_one() {
fresh();
// the focus was on the last of four containers: whichever is removed, it moves to the index
// before the old focus, which can name a different container than the one that was focused
for removed in 0..4 {
let mut workspace = workspace_of(&[1, 2, 3, 4]);
workspace.remove_container(removed).unwrap();
assert_eq!(workspace.focused_container_idx(), 2, "removed {removed}");
}
// with the focus on the first, it stays there
let mut workspace = workspace_of(&[1, 2, 3, 4]);
workspace.focus_container(0);
workspace.remove_container(2).unwrap();
assert_eq!(workspace.focused_container_idx(), 0);
}
#[test]
fn removing_the_focused_container_focuses_the_one_before_it_and_the_last_leaves_none() {
fresh();
let mut workspace = workspace_of(&[1, 2, 3]);
workspace.focus_container(1);
let removed = workspace.remove_focused_container().unwrap();
assert_eq!(removed.windows()[0].id, 2);
assert_eq!(workspace.focused_container_idx(), 0);
workspace.remove_focused_container();
workspace.remove_focused_container();
assert!(workspace.containers().is_empty());
assert_eq!(workspace.focused_container_idx(), 0);
assert!(workspace.remove_focused_container().is_none());
}
#[test]
fn a_container_added_to_the_back_or_the_front_takes_the_focus() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
workspace.add_container_to_back(container_of(&[3]));
assert_eq!(workspace.focused_container_idx(), 2);
workspace.add_container_to_front(container_of(&[4]));
assert_eq!(workspace.focused_container_idx(), 0);
assert_eq!(layout_of(&workspace), [vec![4], vec![1], vec![2], vec![3]]);
}
#[test]
fn focusing_the_first_last_and_previous_container_on_an_empty_workspace_stays_at_zero() {
fresh();
let mut workspace = Workspace::<StubPlatform>::default();
workspace.focus_last_container();
assert_eq!(workspace.focused_container_idx(), 0);
workspace.focus_previous_container();
assert_eq!(workspace.focused_container_idx(), 0);
workspace.focus_first_container();
assert_eq!(workspace.focused_container_idx(), 0);
}
#[test]
fn swapping_containers_focuses_the_second_and_the_lock_stays_with_the_position() {
fresh();
let mut workspace = workspace_of(&[1, 2, 3]);
workspace.containers_mut()[0].set_locked(true);
workspace.swap_containers(0, 2);
assert_eq!(layout_of(&workspace), [vec![3], vec![2], vec![1]]);
assert_eq!(workspace.focused_container_idx(), 2);
assert!(workspace.containers()[0].locked);
assert!(!workspace.containers()[2].locked);
}
#[test]
fn cycling_wraps_around_and_an_empty_workspace_has_nowhere_to_cycle() {
fresh();
let mut workspace = workspace_of(&[1, 2, 3]);
assert_eq!(
workspace.new_idx_for_cycle_direction(CycleDirection::Next),
Some(0)
);
workspace.focus_container(0);
assert_eq!(
workspace.new_idx_for_cycle_direction(CycleDirection::Previous),
Some(2)
);
assert_eq!(
Workspace::<StubPlatform>::default().new_idx_for_cycle_direction(CycleDirection::Next),
None
);
}
#[test]
fn directions_follow_the_layout_and_the_flip() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
workspace.focus_container(0);
assert_eq!(
workspace.new_idx_for_direction(OperationDirection::Right),
Some(1)
);
assert_eq!(
workspace.new_idx_for_direction(OperationDirection::Left),
None
);
workspace.layout_flip = Some(komorebi_layouts::Axis::Horizontal);
assert_eq!(
workspace.new_idx_for_direction(OperationDirection::Left),
Some(1)
);
assert_eq!(
workspace.new_idx_for_direction(OperationDirection::Right),
None
);
assert_eq!(
Workspace::<StubPlatform>::default().new_idx_for_direction(OperationDirection::Left),
None
);
}
#[test]
fn stacking_moves_the_focused_window_in_front_of_the_target_and_hides_the_one_it_covers() {
fresh();
let mut workspace = workspace_of(&[1, 2, 3]);
workspace.state.spot = 4;
workspace.focus_container(2);
workspace.move_window_to_container(0).unwrap();
// container 2 is empty and goes; container 0 now holds 1 and 3, 3 in front
assert_eq!(layout_of(&workspace), [vec![1, 3], vec![2]]);
assert_eq!(workspace.focused_container_idx(), 0);
assert_eq!(workspace.containers()[0].focused_window_idx(), 1);
assert_eq!(
log(),
[
"note_scrolling_departure 2",
"hide 1 @4",
"hide_stacked 1 @4",
"restore_stacked 3",
]
);
}
#[test]
fn stacking_onto_a_later_container_counts_its_index_after_the_emptied_one_went() {
fresh();
let mut workspace = workspace_of(&[1, 2, 3]);
workspace.focus_container(0);
// after container 0 is removed, the target 2 is the old container 3 at index 1
workspace.move_window_to_container(2).unwrap();
assert_eq!(layout_of(&workspace), [vec![2], vec![3, 1]]);
assert_eq!(workspace.focused_container_idx(), 1);
}
#[test]
fn stacking_out_of_a_stack_shows_the_next_window_of_the_container_it_left() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
workspace.containers_mut()[0].add_window(w(5), 0).unwrap();
workspace.focus_container(0);
log();
workspace.move_window_to_container(1).unwrap();
assert_eq!(layout_of(&workspace), [vec![1], vec![2, 5]]);
assert_eq!(
log(),
[
"restore_stacked 1",
"hide 2 @0",
"hide_stacked 2 @0",
"restore_stacked 5",
]
);
}
#[test]
fn stacking_onto_a_container_that_does_not_exist_is_an_error_after_the_window_left() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
workspace.focus_container(1);
let result = workspace.move_window_to_container(9);
assert!(result.is_err());
// the window is out of its container, which was removed: it is lost to the workspace
assert_eq!(layout_of(&workspace), [vec![1]]);
}
#[test]
fn stacking_in_an_empty_workspace_is_an_error() {
fresh();
let mut workspace = Workspace::<StubPlatform>::default();
assert!(workspace.move_window_to_container(0).is_err());
}
#[test]
fn unstacking_puts_the_focused_window_in_a_container_after_the_one_it_left() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
workspace.containers_mut()[0].add_window(w(5), 0).unwrap();
workspace.focus_container(0);
log();
workspace.new_container_for_focused_window().unwrap();
assert_eq!(layout_of(&workspace), [vec![1], vec![5], vec![2]]);
assert_eq!(workspace.focused_container_idx(), 1);
assert_eq!(log(), ["restore_stacked 1"]);
}
#[test]
fn unstacking_a_single_window_container_moves_nothing_but_still_succeeds() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
workspace.focus_container(0);
workspace.new_container_for_focused_window().unwrap();
// the container left empty is removed, the window gets a container after the focused one
assert_eq!(workspace.containers().len(), 2);
assert!(workspace.contains_window(1));
}
#[test]
fn promoting_puts_the_focused_container_first_and_focuses_it() {
fresh();
let mut workspace = workspace_of(&[1, 2, 3]);
workspace.focus_container(1);
workspace.promote_container().unwrap();
assert_eq!(layout_of(&workspace), [vec![2], vec![1], vec![3]]);
assert_eq!(workspace.focused_container_idx(), 0);
}
#[test]
fn promoting_with_no_container_is_an_error() {
fresh();
let mut workspace = Workspace::<StubPlatform>::default();
assert!(workspace.promote_container().is_err());
}
#[test]
fn a_locked_container_keeps_its_place_when_another_is_promoted() {
fresh();
let mut workspace = workspace_of(&[1, 2, 3]);
workspace.containers_mut()[0].set_locked(true);
workspace.focus_container(2);
workspace.promote_container().unwrap();
assert_eq!(layout_of(&workspace)[0], [1]);
}
#[test]
fn windows_are_found_in_containers_monocle_maximized_and_floating() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
workspace.monocle_container = Some(container_of(&[3]));
workspace.maximized_window = Some(w(4));
workspace.floating_windows_mut().push_back(w(5));
for id in [1, 2, 3, 4, 5] {
assert!(workspace.contains_window(id), "{id}");
}
// the floating window is not one that komorebi tiles
for id in [1, 2, 3, 4] {
assert!(workspace.contains_managed_window(id), "{id}");
}
assert!(!workspace.contains_managed_window(5));
assert!(!workspace.contains_window(6));
assert!(!workspace.is_empty());
}
#[test]
fn a_workspace_with_only_a_floating_window_is_not_empty() {
fresh();
let mut workspace = Workspace::<StubPlatform>::default();
workspace.floating_windows_mut().push_back(w(5));
assert!(!workspace.is_empty());
}
#[test]
fn the_location_of_an_executable_is_looked_for_in_the_order_of_the_layers() {
use komorebi_core::WorkspaceWindowLocation as Location;
fresh();
let mut workspace = workspace_of(&[1, 2]);
workspace.maximized_window = Some(w(4));
workspace.monocle_container = Some(container_of(&[3]));
workspace.floating_windows_mut().push_back(w(5));
assert!(matches!(
workspace.location_from_exe("exe2"),
Some(Location::Container(1, 0))
));
assert!(matches!(
workspace.location_from_exe("exe4"),
Some(Location::Maximized)
));
assert!(matches!(
workspace.location_from_exe("exe3"),
Some(Location::Monocle(0))
));
assert!(matches!(
workspace.location_from_exe("exe5"),
Some(Location::Floating(0))
));
assert!(workspace.location_from_exe("nothing").is_none());
}
#[test]
fn the_last_container_that_has_a_window_is_the_one_found_for_it() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
workspace.containers_mut()[0].add_window(w(2), 0).unwrap();
assert_eq!(workspace.container_idx_for_window(2), Some(1));
}
#[test]
fn focusing_by_window_brings_a_stacked_window_to_the_front_and_loads_the_stack() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
workspace.state.spot = 6;
workspace.containers_mut()[0].add_window(w(5), 6).unwrap();
workspace.containers_mut()[0].focus_window(1);
log();
workspace.focus_container_by_window(1).unwrap();
assert_eq!(workspace.focused_container_idx(), 0);
assert_eq!(workspace.containers()[0].focused_window_idx(), 0);
assert_eq!(log(), ["restore_stacked 1", "hide_stacked 5 @6"]);
}
#[test]
fn focusing_by_a_window_already_in_front_loads_nothing() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
workspace.focus_container_by_window(1).unwrap();
assert_eq!(workspace.focused_container_idx(), 0);
assert!(log().is_empty());
}
#[test]
fn focusing_by_an_unknown_window_is_an_error_and_changes_nothing() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
assert!(workspace.focus_container_by_window(9).is_err());
assert_eq!(workspace.focused_container_idx(), 1);
}
#[test]
fn the_pointer_finds_the_container_whose_last_laid_out_tile_it_is_in() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
workspace.latest_layout = vec![
Rect {
left: 0,
top: 0,
right: 100,
bottom: 100,
},
Rect {
left: 100,
top: 0,
right: 100,
bottom: 100,
},
];
assert_eq!(workspace.container_idx_from_current_point(), None);
set_cursor(Some((150, 50)));
assert_eq!(workspace.container_idx_from_current_point(), Some(1));
set_cursor(Some((50, 50)));
assert_eq!(workspace.container_idx_from_current_point(), Some(0));
set_cursor(Some((500, 50)));
assert_eq!(workspace.container_idx_from_current_point(), None);
}
#[test]
fn the_visible_windows_are_maximized_then_monocle_then_each_container_then_floating() {
fresh();
let mut workspace = workspace_of(&[1, 2]);
workspace.containers_mut()[0].add_window(w(5), 0).unwrap();
workspace.maximized_window = Some(w(4));
workspace.monocle_container = Some(container_of(&[3]));
workspace.floating_windows_mut().push_back(w(6));
let ids: Vec<Option<u32>> = workspace
.visible_windows()
.iter()
.map(|w| w.map(|w| w.id))
.collect();
assert_eq!(ids, [Some(4), Some(3), Some(5), Some(2), Some(6)]);
}
#[test]
fn without_a_maximized_window_the_first_visible_entry_is_none() {
fresh();
let workspace = workspace_of(&[1]);
let ids: Vec<Option<u32>> = workspace
.visible_windows()
.iter()
.map(|w| w.map(|w| w.id))
.collect();
assert_eq!(ids, [None, Some(1)]);
}
#[test]
fn only_the_default_layouts_are_the_scrolling_layout_when_it_is_scrolling() {
fresh();
let mut workspace = workspace_of(&[1]);
assert!(!workspace.is_scrolling());
workspace.layout = Layout::Default(DefaultLayout::Scrolling);
assert!(workspace.is_scrolling());
}