From 4835907b2ee589febd3068bd35738a21864f47a8 Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Thu, 29 Oct 2026 23:40:45 -0700 Subject: [PATCH] feat(nix): the layouts and floating scenarios layouts changes the layout of the first workspace to each of eight, with three windows and with five, and checks every window is where the daemon's layout says, inside the work area and clear of the others. floating floats a window, checks the others take its room, and that floating it again tiles it back. Both run in core-e2e: 209 checks pass on KDE. --- .../komorebi_vm/core/scenarios/floating.py | 56 +++++++++++++ .../lib/komorebi_vm/core/scenarios/layouts.py | 79 +++++++++++++++++++ nix/tests/vm/lib/tests/fake_platform.py | 25 +++++- nix/tests/vm/lib/tests/test_focus_moving.py | 48 +++++++++++ nix/tests/vm/suites/core-e2e/test.py | 4 + 5 files changed, 211 insertions(+), 1 deletion(-) create mode 100644 nix/tests/vm/lib/komorebi_vm/core/scenarios/floating.py create mode 100644 nix/tests/vm/lib/komorebi_vm/core/scenarios/layouts.py diff --git a/nix/tests/vm/lib/komorebi_vm/core/scenarios/floating.py b/nix/tests/vm/lib/komorebi_vm/core/scenarios/floating.py new file mode 100644 index 00000000..dd8d1676 --- /dev/null +++ b/nix/tests/vm/lib/komorebi_vm/core/scenarios/floating.py @@ -0,0 +1,56 @@ +"""A window that floats leaves the tiling to the others, and goes back into it when it stops.""" + +from komorebi_vm.core.checks import Checks +from komorebi_vm.core.platform import Client, Platform +from komorebi_vm.core.scenarios.layouts import tiled +from komorebi_vm.core.scenarios.support import focus_agrees + + +def run(platform: Platform, checks: Checks, clients: list[Client]) -> None: + """Floats the last of `clients`, which are tiled windows of the first workspace in a + container each, with more than one of them, and then tiles it again.""" + target = clients[-1] + others = clients[:-1] + platform.activate(target) + platform.wait_for(lambda: focus_agrees(platform, clients, target.title)) + + def area(c: Client) -> int: + window = platform.os_window(c) + return window.frame.w * window.frame.h if window is not None else 0 + + def floating() -> list[str]: + return [w.title for w in platform.state().workspace().floating] + + before = sum(area(c) for c in others) + managed = platform.state().managed() + + platform.komorebic("toggle-float") + checks.check( + f"after 'toggle-float' the daemon has {target.title} floating", + platform.wait_for(lambda: floating() == [target.title], timeout=20), + ) + checks.check("... and still manages every window", platform.state().managed() == managed) + checks.check( + "... the others take more room between them", + platform.wait_for(lambda: sum(area(c) for c in others) > before, timeout=20), + ) + frames = [w.frame for c in others if (w := platform.os_window(c)) is not None] + checks.check( + "... inside the work area and not on each other", + all(f.inside(platform.work_area()) for f in frames) + and not any(a.overlaps(b) for i, a in enumerate(frames) for b in frames[i + 1 :]), + ) + checks.check( + f"... {target.title} is still there, and not put away", + platform.os_window(target) is not None and not platform.hidden(target), + ) + + platform.komorebic("toggle-float") + checks.check( + f"after another 'toggle-float' {target.title} floats no more", + platform.wait_for(lambda: floating() == [], timeout=20), + ) + checks.check( + "... and every window is tiled where the layout says", + platform.wait_for(lambda: tiled(platform, clients), timeout=20), + ) diff --git a/nix/tests/vm/lib/komorebi_vm/core/scenarios/layouts.py b/nix/tests/vm/lib/komorebi_vm/core/scenarios/layouts.py new file mode 100644 index 00000000..45d2043e --- /dev/null +++ b/nix/tests/vm/lib/komorebi_vm/core/scenarios/layouts.py @@ -0,0 +1,79 @@ +"""Each layout the daemon has tiles the windows it is given: where it says, none over another.""" + +from komorebi_vm.core.checks import Checks +from komorebi_vm.core.platform import Client, Platform +from komorebi_vm.core.scenarios.tiling import _where_the_layout_says + +# the layouts both ports have, but for scrolling, which does not fit the work area +LAYOUTS = ( + "bsp", + "columns", + "rows", + "vertical-stack", + "horizontal-stack", + "ultrawide-vertical-stack", + "grid", + "right-main-vertical-stack", +) + + +def tiled(platform: Platform, clients: list[Client]) -> bool: + """Every window is where the daemon's own layout puts it, as the OS reports it.""" + workspace = platform.state().workspace() + layout = workspace.latest_layout + frames = [platform.os_window(c) for c in clients] + if len(layout) != len(clients) or any(f is None for f in frames): + return False + by_title = {w.title: layout[i] for i, c in enumerate(workspace.containers) for w in c[:1]} + return all( + f is not None + and f.title in by_title + and _where_the_layout_says(f.frame, by_title[f.title], platform.tolerance) + for f in frames + ) + + +def _check_layout(platform: Platform, checks: Checks, clients: list[Client], layout: str) -> None: + label = f"{layout}, {len(clients)} windows" + platform.komorebic("change-layout", layout) + checks.check( + f"{label}: every window is where the layout says", + platform.wait_for(lambda: tiled(platform, clients), timeout=20), + ) + area = platform.work_area() + frames = [w.frame for c in clients if (w := platform.os_window(c)) is not None] + checks.check(f"{label}: ... inside the work area", all(f.inside(area) for f in frames)) + checks.check( + f"{label}: ... and not on each other", + not any(a.overlaps(b) for i, a in enumerate(frames) for b in frames[i + 1 :]), + ) + + +def run(platform: Platform, checks: Checks, clients: list[Client]) -> None: + """Changes the layout of the first workspace to each of `LAYOUTS` with `clients`, which are + tiled windows in a container each, and then with two windows more, which it closes. + + The layout is `bsp` again at the end. + """ + for layout in LAYOUTS: + _check_layout(platform, checks, clients, layout) + + more = [platform.spawn("layouts-extra1"), platform.spawn("layouts-extra2")] + everyone = clients + more + checks.check( + "two windows more are managed", + platform.wait_for(lambda: platform.state().managed() == len(everyone), timeout=20), + ) + for layout in LAYOUTS: + _check_layout(platform, checks, everyone, layout) + + platform.komorebic("change-layout", "bsp") + for client in more: + platform.close(client) + checks.check( + "the two windows are closed and the others tiled again", + platform.wait_for( + lambda: platform.state().managed() == len(clients) and tiled(platform, clients), + timeout=20, + ), + ) diff --git a/nix/tests/vm/lib/tests/fake_platform.py b/nix/tests/vm/lib/tests/fake_platform.py index d444b54c..6d424b8e 100644 --- a/nix/tests/vm/lib/tests/fake_platform.py +++ b/nix/tests/vm/lib/tests/fake_platform.py @@ -79,6 +79,7 @@ class FakePlatform: self.display_count = 2 self.display_of: dict[str, int] = {} self.forgets_displays = False + self.floats: list[str] = [] self.running = True self.placement: Any = None self.moves = moves @@ -109,6 +110,8 @@ class FakePlatform: def start_komorebi(self) -> None: """A new daemon knows nothing: every window is tiled on the first workspace.""" everyone = [t for containers in self.spaces for stack in containers for t in stack] + everyone += self.floats + self.floats = [] self.spaces = [[[t] for t in everyone], [], []] self.focuses = [0, 0, 0] self.current = 0 @@ -216,6 +219,9 @@ class FakePlatform: self.display_of[title] = 0 def close(self, client: Client) -> None: + if client.title in self.floats: + self.floats.remove(client.title) + return if client.title in self.unmanaged: self.unmanaged.remove(client.title) return @@ -241,6 +247,8 @@ class FakePlatform: return self._find(title)[1] def hidden(self, client: Client) -> bool: + if client.title in self.floats: + return False if client.title in self.unmanaged: return False s, i = self._find(client.title) @@ -259,6 +267,8 @@ class FakePlatform: return Image.new("RGB", (4, 4)) def os_window(self, client: Client) -> OsWindow | None: + if client.title in self.floats: + return OsWindow(client.title, Rect(300, 300, 600, 400), focused=False) if client.title in self.unmanaged: return OsWindow(client.title, Rect(100, 100, 400, 300), focused=False) try: @@ -356,6 +366,15 @@ class FakePlatform: break case ("focus-workspace", number): self.current = int(number) + case ("toggle-float",): + if self.floats: + self.containers.insert(self.focus, [self.floats.pop()]) + else: + title = self.containers[self.focus][0] + self._find_remove(title) + self.floats.append(title) + self.focuses[self.current] = max(0, min(self.focus, len(self.containers) - 1)) + self._relayout() case ("unstack",): stack = self.containers.pop(self.focus) self.containers[self.focus : self.focus] = [[t] for t in stack] @@ -385,6 +404,7 @@ class FakePlatform: return {"left": r.x, "top": r.y, "right": r.w, "bottom": r.h} def workspace(containers: list[list[str]], focus: int, current: bool) -> dict[str, Any]: + floats = self.floats if current else [] monocle = None if current and self.monocle is not None: whole = Rect(0, 0, 1920, 1080) @@ -408,7 +428,10 @@ class FakePlatform: }, "monocle_container": monocle, "maximized_window": None, - "floating_windows": {"elements": [], "focused": 0}, + "floating_windows": { + "elements": [window(t, Rect(300, 300, 600, 400)) for t in floats], + "focused": 0, + }, "layout": {"Default": "Columns"}, "tile": True, "latest_layout": [rect(r) for r in self.tiles[: len(containers)]], diff --git a/nix/tests/vm/lib/tests/test_focus_moving.py b/nix/tests/vm/lib/tests/test_focus_moving.py index ffad76ed..b5fe6dbc 100644 --- a/nix/tests/vm/lib/tests/test_focus_moving.py +++ b/nix/tests/vm/lib/tests/test_focus_moving.py @@ -1,12 +1,15 @@ """The focus and moving scenarios against a daemon that is right, and against ones that are not.""" from komorebi_vm.core.checks import Checks +from komorebi_vm.core.geometry import Rect from komorebi_vm.core.scenarios import ( closing, commands, + floating, focus, focus_follows_mouse, hotplug, + layouts, lifecycle, monocle, moving, @@ -135,6 +138,51 @@ def test_a_daemon_that_does_not_take_its_windows_up_again_fails_lifecycle() -> N assert checks.failed > 0 +def test_a_daemon_that_is_right_passes_layouts() -> None: + platform = FakePlatform() + checks = Checks() + clients = opened(platform, checks) + layouts.run(platform, checks, clients) + assert checks.failed == 0, checks.failures + assert checks.passed > len(layouts.LAYOUTS) * 6 + + +def test_a_layout_that_puts_tiles_over_each_other_fails_layouts() -> None: + class Overlapping(FakePlatform): + def komorebic(self, *args: str) -> str: + out = super().komorebic(*args) + if args == ("change-layout", "grid"): + self.tiles = [Rect(0, 0, 1000, 1080)] * len(self.containers) + return out + + platform = Overlapping() + checks = Checks() + clients = opened(platform, checks) + layouts.run(platform, checks, clients) + assert checks.failed > 0 + + +def test_a_daemon_that_is_right_passes_floating() -> None: + platform = FakePlatform() + checks = Checks() + clients = opened(platform, checks) + floating.run(platform, checks, clients) + assert checks.failed == 0, checks.failures + assert checks.passed > 6 + + +def test_a_float_that_stays_in_the_tiling_fails_floating() -> None: + class Stubborn(FakePlatform): + def komorebic(self, *args: str) -> str: + return "" if args == ("toggle-float",) else super().komorebic(*args) + + platform = Stubborn() + checks = Checks() + clients = opened(platform, checks) + floating.run(platform, checks, clients) + assert checks.failed > 0 + + def test_a_command_the_port_lacks_is_skipped_by_name() -> None: platform = FakePlatform() checks = Checks() diff --git a/nix/tests/vm/suites/core-e2e/test.py b/nix/tests/vm/suites/core-e2e/test.py index 83f2f5dd..3d3edb67 100644 --- a/nix/tests/vm/suites/core-e2e/test.py +++ b/nix/tests/vm/suites/core-e2e/test.py @@ -17,7 +17,9 @@ from komorebi_vm.core.platform import Client from komorebi_vm.core.scenarios import ( closing, commands, + floating, focus, + layouts, lifecycle, monocle, moving, @@ -448,6 +450,8 @@ checks.check( "and unstacked", kde.wait_for(lambda: sorted(map(len, kde.containers())) == [1, 1, 1]), ) +layouts.run(platform, checks, neutral) +floating.run(platform, checks, neutral) monocle.run(platform, checks, neutral) workspaces.run(platform, checks, neutral) # the third window is on workspace 1 now: the first is closed, and the second takes its room