From 92943f7cbacf90fc2121880e7e2d481ca7a814db Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Sat, 31 Oct 2026 15:02:46 -0700 Subject: [PATCH] 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. --- .../tests/workspace_containers.rs | 669 ++++++++++++++++++ 1 file changed, 669 insertions(+) create mode 100644 crates/komorebi-core/tests/workspace_containers.rs diff --git a/crates/komorebi-core/tests/workspace_containers.rs b/crates/komorebi-core/tests/workspace_containers.rs new file mode 100644 index 00000000..290108c0 --- /dev/null +++ b/crates/komorebi-core/tests/workspace_containers.rs @@ -0,0 +1,669 @@ +//! Characterization of `Workspace

`: 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, 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::::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 = 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::::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::::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::::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::::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::::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::::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> = 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> = 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()); +}