mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-16 22:01:22 +01:00
feat(nix): the focus and moving scenarios, for every platform
focus moves the focus with focus and cycle-focus and checks that the OS and the daemon's state agree on the window that has it and that no window moved. moving swaps the focused window with its neighbor with move and puts every window back with cycle-move, and checks that the focus stays with it. Both read the windows through the Platform, so they are what kfw's suite will run. Their unit tests run against a fake daemon that follows the commands over three tiles, and against two that do not (a move that moves nothing, a move that loses the focus). core-e2e runs them after tiling on KDE: 85 checks pass on KVM.
This commit is contained in:
1 parent
bb8299410f
commit
c861f4f789
8 files changed
+287
-8
No files matched your search
@@ -153,7 +153,8 @@ the run.
|
||||
daemon, run `komorebic`, read the `Snapshot`, open a window, ask the operating
|
||||
system for its frame (`os_window`, the oracle: the daemon's state is the thing
|
||||
under test), and take a screenshot. `core/scenarios` has the scenarios written
|
||||
against it; `tiling` is the first. A method is added with the first scenario
|
||||
against it: `tiling`, `focus` and `moving`, which `core-e2e` runs on KDE and which
|
||||
scenarios of kfw's suite can run unchanged. A method is added with the first scenario
|
||||
that needs it. `KdePlatform` (`kde_platform.py`) is a `Kde` session as a
|
||||
`Platform`, and the `core-e2e` suite runs `tiling` through it after its own
|
||||
sections.
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
"""The focus moves where komorebic says, and the operating system and the daemon agree on it."""
|
||||
|
||||
from komorebi_vm.core.checks import Checks
|
||||
from komorebi_vm.core.platform import Client, Platform
|
||||
from komorebi_vm.core.scenarios.support import focus_agrees, os_focused, positions
|
||||
|
||||
|
||||
def run(platform: Platform, checks: Checks, clients: list[Client]) -> None:
|
||||
"""Moves the focus among `clients`, which are tiled windows of the first workspace, each in a
|
||||
container of its own, with `focus` and `cycle-focus`."""
|
||||
first = clients[0].title
|
||||
before = positions(platform, clients)
|
||||
|
||||
platform.activate(clients[0])
|
||||
checks.check(
|
||||
f"{first} has the focus, and the daemon agrees",
|
||||
platform.wait_for(lambda: focus_agrees(platform, clients, first)),
|
||||
)
|
||||
|
||||
platform.komorebic("focus", "right")
|
||||
checks.check(
|
||||
"after 'focus right' the operating system has given the focus to another window",
|
||||
platform.wait_for(lambda: os_focused(platform, clients) not in ("", first)),
|
||||
)
|
||||
moved_to = os_focused(platform, clients)
|
||||
checks.check(
|
||||
"... and the daemon's state focuses the same one",
|
||||
platform.wait_for(lambda: focus_agrees(platform, clients, moved_to)),
|
||||
)
|
||||
|
||||
platform.komorebic("focus", "left")
|
||||
checks.check(
|
||||
"'focus left' gives the focus back",
|
||||
platform.wait_for(lambda: focus_agrees(platform, clients, first)),
|
||||
)
|
||||
|
||||
# the next container is whichever follows in the daemon's own order
|
||||
order = [titles[0] for titles in platform.state().containers() if titles]
|
||||
after = order[(order.index(first) + 1) % len(order)]
|
||||
platform.komorebic("cycle-focus", "next")
|
||||
checks.check(
|
||||
f"'cycle-focus next' focuses {after}, the next container in the daemon's order",
|
||||
platform.wait_for(lambda: focus_agrees(platform, clients, after)),
|
||||
)
|
||||
platform.komorebic("cycle-focus", "previous")
|
||||
checks.check(
|
||||
"'cycle-focus previous' goes back",
|
||||
platform.wait_for(lambda: focus_agrees(platform, clients, first)),
|
||||
)
|
||||
checks.check("moving the focus moved no window", positions(platform, clients) == before)
|
||||
@@ -0,0 +1,45 @@
|
||||
"""Windows swap tiles on `move` and `cycle-move`, and the focus stays with the window."""
|
||||
|
||||
from komorebi_vm.core.checks import Checks
|
||||
from komorebi_vm.core.platform import Client, Platform
|
||||
from komorebi_vm.core.scenarios.support import focus_agrees, positions
|
||||
|
||||
|
||||
def run(platform: Platform, checks: Checks, clients: list[Client]) -> None:
|
||||
"""Moves the first of `clients`, which are tiled windows of the first workspace, each in a
|
||||
container of its own, to the tile on its right and back."""
|
||||
first = clients[0].title
|
||||
platform.activate(clients[0])
|
||||
platform.wait_for(lambda: focus_agrees(platform, clients, first))
|
||||
before = positions(platform, clients)
|
||||
|
||||
def swapped_with_another() -> bool:
|
||||
now = positions(platform, clients)
|
||||
return any(
|
||||
title != first
|
||||
and now[first] == before[title]
|
||||
and now[title] == before[first]
|
||||
and now[first] != before[first]
|
||||
for title in before
|
||||
)
|
||||
|
||||
platform.komorebic("move", "right")
|
||||
checks.check(
|
||||
f"after 'move right' {first} and a neighbor have swapped tiles",
|
||||
platform.wait_for(swapped_with_another, timeout=20),
|
||||
)
|
||||
checks.check(
|
||||
f"... and {first} keeps the focus",
|
||||
platform.wait_for(lambda: focus_agrees(platform, clients, first)),
|
||||
)
|
||||
others = {t: p for t, p in positions(platform, clients).items() if t != first}
|
||||
checks.check(
|
||||
"... and the other windows are on tiles of their own",
|
||||
len(set(others.values()) | {positions(platform, clients)[first]}) == len(clients),
|
||||
)
|
||||
|
||||
platform.komorebic("cycle-move", "previous")
|
||||
checks.check(
|
||||
"'cycle-move previous' puts every window back",
|
||||
platform.wait_for(lambda: positions(platform, clients) == before, timeout=20),
|
||||
)
|
||||
@@ -0,0 +1,34 @@
|
||||
"""What more than one scenario needs of a platform."""
|
||||
|
||||
from komorebi_vm.core.platform import Client, Platform
|
||||
|
||||
|
||||
def os_focused(platform: Platform, clients: list[Client]) -> str:
|
||||
"""The title of the window the operating system says has the focus, among `clients`.
|
||||
|
||||
The empty string when none of them does.
|
||||
"""
|
||||
for client in clients:
|
||||
window = platform.os_window(client)
|
||||
if window is not None and window.focused:
|
||||
return window.title
|
||||
return ""
|
||||
|
||||
|
||||
def positions(platform: Platform, clients: list[Client]) -> dict[str, tuple[int, int]]:
|
||||
"""Where the operating system has each window, by title.
|
||||
|
||||
Only the position: a client may round its size to what suits it (a terminal's cells), and
|
||||
a window that moved is told by where it is.
|
||||
"""
|
||||
found = {}
|
||||
for client in clients:
|
||||
window = platform.os_window(client)
|
||||
if window is not None:
|
||||
found[client.title] = (window.frame.x, window.frame.y)
|
||||
return found
|
||||
|
||||
|
||||
def focus_agrees(platform: Platform, clients: list[Client], title: str) -> bool:
|
||||
"""The operating system and the daemon's state both have `title` focused."""
|
||||
return os_focused(platform, clients) == title and platform.state().focused_title() == title
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
from komorebi_vm.core.checks import Checks
|
||||
from komorebi_vm.core.geometry import Rect
|
||||
from komorebi_vm.core.platform import Platform
|
||||
from komorebi_vm.core.platform import Client, Platform
|
||||
|
||||
|
||||
def _where_the_layout_says(frame: Rect, want: Rect, tolerance: int) -> bool:
|
||||
@@ -16,11 +16,12 @@ def _where_the_layout_says(frame: Rect, want: Rect, tolerance: int) -> bool:
|
||||
|
||||
def run(
|
||||
platform: Platform, checks: Checks, titles: tuple[str, ...] = ("win1", "win2", "win3")
|
||||
) -> None:
|
||||
) -> list[Client]:
|
||||
"""Opens a window for each title and checks, against the OS's own account of the frames, that
|
||||
the daemon has tiled them.
|
||||
|
||||
The daemon must be running, on a workspace with no window, with a tiling layout.
|
||||
The daemon must be running, on a workspace with no window, with a tiling layout. Returns the
|
||||
windows it opened, for a scenario that goes on from them.
|
||||
"""
|
||||
clients = [platform.spawn(title) for title in titles]
|
||||
area = platform.work_area()
|
||||
@@ -63,3 +64,4 @@ def run(
|
||||
"the windows share the work area: none takes all of its width",
|
||||
all(f.w < area.w - platform.tolerance for f in frames),
|
||||
)
|
||||
return clients
|
||||
@@ -0,0 +1,109 @@
|
||||
"""A desktop in memory with a daemon that follows the commands of the scenarios.
|
||||
|
||||
Three tiles in a row, a window in each. `focus`, `cycle-focus`, `move` and `cycle-move` do what the
|
||||
real daemon does with windows laid out left to right, so that a scenario can be run against a daemon
|
||||
that is right, and against ones that are wrong in one way.
|
||||
"""
|
||||
|
||||
from typing import Any
|
||||
|
||||
from PIL import Image
|
||||
|
||||
from komorebi_vm.core.geometry import Rect
|
||||
from komorebi_vm.core.platform import Client, OsWindow
|
||||
from komorebi_vm.core.snapshot import Snapshot, parse
|
||||
|
||||
TILES = [Rect(0, 0, 640, 1080), Rect(640, 0, 640, 1080), Rect(1280, 0, 640, 1080)]
|
||||
|
||||
|
||||
class FakePlatform:
|
||||
tolerance = 24
|
||||
|
||||
def __init__(self, *, moves: bool = True, focus_follows_move: bool = True) -> None:
|
||||
self.order: list[str] = []
|
||||
"""The titles in the order of the tiles."""
|
||||
self.focus = 0
|
||||
self.moves = moves
|
||||
self.focus_follows_move = focus_follows_move
|
||||
|
||||
def wait_for(self, predicate: Any, timeout: float = 10) -> bool:
|
||||
return bool(predicate())
|
||||
|
||||
def start_komorebi(self) -> None:
|
||||
pass
|
||||
|
||||
def spawn(self, title: str) -> Client:
|
||||
self.order.append(title)
|
||||
return Client(title)
|
||||
|
||||
def work_area(self) -> Rect:
|
||||
return Rect(0, 0, 1920, 1080)
|
||||
|
||||
def activate(self, client: Client) -> None:
|
||||
self.focus = self.order.index(client.title)
|
||||
|
||||
def screenshot(self, name: str) -> Image.Image:
|
||||
return Image.new("RGB", (4, 4))
|
||||
|
||||
def os_window(self, client: Client) -> OsWindow | None:
|
||||
if client.title not in self.order:
|
||||
return None
|
||||
i = self.order.index(client.title)
|
||||
return OsWindow(client.title, TILES[i], focused=i == self.focus)
|
||||
|
||||
def komorebic(self, *args: str) -> str:
|
||||
n = len(self.order)
|
||||
match args:
|
||||
case ("focus", "right"):
|
||||
self.focus = min(self.focus + 1, n - 1)
|
||||
case ("focus", "left"):
|
||||
self.focus = max(self.focus - 1, 0)
|
||||
case ("cycle-focus", "next"):
|
||||
self.focus = (self.focus + 1) % n
|
||||
case ("cycle-focus", "previous"):
|
||||
self.focus = (self.focus - 1) % n
|
||||
case ("move", "right"):
|
||||
self._swap(min(self.focus + 1, n - 1))
|
||||
case ("cycle-move", "previous"):
|
||||
self._swap((self.focus - 1) % n)
|
||||
case _:
|
||||
raise AssertionError(f"the fake does not know komorebic {args}")
|
||||
return ""
|
||||
|
||||
def _swap(self, other: int) -> None:
|
||||
if not self.moves:
|
||||
return
|
||||
self.order[self.focus], self.order[other] = self.order[other], self.order[self.focus]
|
||||
if self.focus_follows_move:
|
||||
self.focus = other
|
||||
|
||||
def state(self) -> Snapshot:
|
||||
windows = [
|
||||
{
|
||||
"id": i + 1,
|
||||
"rect": {"left": r.x, "top": r.y, "right": r.w, "bottom": r.h},
|
||||
"details": {"title": t, "exe": "", "class": "", "path": ""},
|
||||
}
|
||||
for i, (t, r) in enumerate(zip(self.order, TILES, strict=False))
|
||||
]
|
||||
workspace = {
|
||||
"name": None,
|
||||
"containers": {
|
||||
"elements": [
|
||||
{"id": str(i), "locked": False, "windows": {"elements": [w], "focused": 0}}
|
||||
for i, w in enumerate(windows)
|
||||
],
|
||||
"focused": self.focus,
|
||||
},
|
||||
"monocle_container": None,
|
||||
"maximized_window": None,
|
||||
"floating_windows": {"elements": [], "focused": 0},
|
||||
"layout": {"Default": "Columns"},
|
||||
"tile": True,
|
||||
"latest_layout": [
|
||||
{"left": r.x, "top": r.y, "right": r.w, "bottom": r.h} for r in TILES
|
||||
],
|
||||
}
|
||||
size = {"left": 0, "top": 0, "right": 1920, "bottom": 1080}
|
||||
monitor = {"id": 1, "size": size, "workspaces": {"elements": [workspace], "focused": 0}}
|
||||
return parse({"monitors": {"elements": [monitor], "focused": 0}})
|
||||
@@ -0,0 +1,35 @@
|
||||
"""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.scenarios import focus, moving, tiling
|
||||
from tests.fake_platform import FakePlatform
|
||||
|
||||
|
||||
def opened(platform: FakePlatform, checks: Checks): # noqa: ANN201
|
||||
return tiling.run(platform, checks)
|
||||
|
||||
|
||||
def test_a_daemon_that_is_right_passes_both() -> None:
|
||||
platform = FakePlatform()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
focus.run(platform, checks, clients)
|
||||
moving.run(platform, checks, clients)
|
||||
assert checks.failed == 0, checks.failures
|
||||
assert checks.passed > 10
|
||||
|
||||
|
||||
def test_a_move_that_moves_nothing_fails() -> None:
|
||||
platform = FakePlatform(moves=False)
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
moving.run(platform, checks, clients)
|
||||
assert any("swapped tiles" in f for f in checks.failures)
|
||||
|
||||
|
||||
def test_a_move_that_loses_the_focus_fails() -> None:
|
||||
platform = FakePlatform(focus_follows_move=False)
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
moving.run(platform, checks, clients)
|
||||
assert any("keeps the focus" in f for f in checks.failures)
|
||||
@@ -13,7 +13,7 @@
|
||||
import json
|
||||
|
||||
from komorebi_vm import Checks, Kde, Rect, daemon
|
||||
from komorebi_vm.core.scenarios import tiling
|
||||
from komorebi_vm.core.scenarios import focus, moving, tiling
|
||||
from komorebi_vm.kde_platform import KdePlatform
|
||||
|
||||
W, H = 1920, 1080
|
||||
@@ -348,12 +348,15 @@ checks.check(
|
||||
)
|
||||
report(["afterwards"])
|
||||
|
||||
print("== 12. the same tiling, through the neutral platform")
|
||||
# the scenario of komorebi_vm.core.scenarios.tiling is what runs on Windows too: it asks the
|
||||
print("== 12. tiling, focus and moving, through the neutral platform")
|
||||
# the scenarios of komorebi_vm.core.scenarios are what runs on Windows too: it asks the
|
||||
# operating system where the windows are, and not the daemon's log
|
||||
kde.close(kde.wid("afterwards"))
|
||||
checks.check("the window of the last section is closed", kde.wait_for(lambda: kde.managed() == 0))
|
||||
tiling.run(KdePlatform(kde, (W, H)), checks, titles=("neutral1", "neutral2", "neutral3"))
|
||||
platform = KdePlatform(kde, (W, H))
|
||||
neutral = tiling.run(platform, checks, titles=("neutral1", "neutral2", "neutral3"))
|
||||
focus.run(platform, checks, neutral)
|
||||
moving.run(platform, checks, neutral)
|
||||
|
||||
print("== 13. komorebic stop")
|
||||
kde.komorebic("stop")
|
||||
|
||||
Reference in new issue
Block a user