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