mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-16 13:51:19 +01:00
feat(e2e): sync the neutral core from kfde f07c3eb8
Takes in kfde's revs d2745b80 (layouts, floating), 22e0ed01 (minimizing), 06e16878 (padding), 59777d7d (maximizing), 789e2a51 (workspace_moves), 7420cb58 (resize_commands), b66fe560 (promoting), 6f310858 (flipping), 33697a67 (pausing), d423f99b (tiling_off), aebdf2b0 (lifecycle_hidden), cdac999a (scrolling), a9e5bd80 (rules_class) and f07c3eb8 (rules_exe, config_reload, locking).
This commit is contained in:
1 parent
a8d0a5096d
commit
ca2bb69587
22 files changed
+1499
-23
No files matched your search
@@ -68,8 +68,8 @@ class Platform(Protocol):
|
||||
"""A machine with a desktop and a daemon to test."""
|
||||
|
||||
def has(self, feature: str) -> bool:
|
||||
"""Whether the platform can do what a scenario needs of it (`"pointer"`), so that a
|
||||
scenario that needs it is skipped, with the reason, where it cannot."""
|
||||
"""Whether the platform can do what a scenario needs of it (`"pointer"`, `"lock"`), so
|
||||
that a scenario that needs it is skipped, with the reason, where it cannot."""
|
||||
...
|
||||
|
||||
@property
|
||||
@@ -101,6 +101,12 @@ class Platform(Protocol):
|
||||
"""
|
||||
...
|
||||
|
||||
def rewrite_config(self, config: dict[str, Any]) -> None:
|
||||
"""Writes `config` over the `komorebi.json` that `restart_with` gave the daemon, which
|
||||
the daemon watches and reloads when it changes. It returns once the file is written; a
|
||||
scenario waits for the state to follow."""
|
||||
...
|
||||
|
||||
def komorebic(self, *args: str) -> str:
|
||||
"""Runs `komorebic` with `args` and returns what it printed. Fails if it does."""
|
||||
...
|
||||
@@ -114,8 +120,16 @@ class Platform(Protocol):
|
||||
"""The daemon's state."""
|
||||
...
|
||||
|
||||
def spawn(self, title: str) -> Client:
|
||||
"""Opens a window with this title and waits until the platform has it."""
|
||||
def spawn(self, title: str, app_id: str | None = None, exe: str | None = None) -> Client:
|
||||
"""Opens a window with this title and waits until the platform has it.
|
||||
|
||||
`app_id` is the class of the window (its app id on Wayland, its window class on Windows)
|
||||
for a rule that matches by it; the platform's own when there is none.
|
||||
|
||||
`exe` is the name of the program that opens it, without an extension (`e2e-exe` is
|
||||
`e2e-exe.exe` on Windows and `e2e-exe` on Linux), for a rule that matches by it. The
|
||||
platform makes a program of that name; a rule's `id` is the same on every platform.
|
||||
"""
|
||||
...
|
||||
|
||||
def os_window(self, client: Client) -> OsWindow | None:
|
||||
@@ -151,6 +165,26 @@ class Platform(Protocol):
|
||||
"""Closes the window, as its close button would."""
|
||||
...
|
||||
|
||||
def minimize(self, client: Client) -> None:
|
||||
"""Minimizes the window, as its title bar button would. `activate` restores it."""
|
||||
...
|
||||
|
||||
def lock(self) -> None:
|
||||
"""Locks the screen, as the user's lock shortcut would, and returns when it is locked.
|
||||
Only where `has("lock")`."""
|
||||
...
|
||||
|
||||
def unlock(self) -> None:
|
||||
"""Unlocks the screen, as the user's password would, and returns when it is unlocked.
|
||||
Only where `has("lock")`."""
|
||||
...
|
||||
|
||||
def move_window(self, client: Client, x: int, y: int) -> None:
|
||||
"""Moves the window so that its top left corner is at (x, y) of the desktop, as the
|
||||
compositor or the shell would, not as the user's pointer would. The window keeps its
|
||||
size."""
|
||||
...
|
||||
|
||||
def work_area(self) -> Rect:
|
||||
"""The area of the first display that windows may take."""
|
||||
...
|
||||
|
||||
@@ -0,0 +1,76 @@
|
||||
"""The daemon reloads its `komorebi.json` when the file changes: names, layout, rules."""
|
||||
|
||||
from typing import Any
|
||||
|
||||
from komorebi_vm.core.checks import Checks
|
||||
from komorebi_vm.core.platform import Platform
|
||||
|
||||
|
||||
def _config(names: list[str], layout: str, rule: str | None = None) -> dict[str, Any]:
|
||||
workspaces: list[dict[str, Any]] = [{"name": name, "layout": layout} for name in names]
|
||||
if rule is not None:
|
||||
matcher = {"kind": "Title", "id": rule, "matching_strategy": "StartsWith"}
|
||||
workspaces[1]["workspace_rules"] = [matcher]
|
||||
return {"monitors": [{"workspaces": workspaces}]}
|
||||
|
||||
|
||||
def _names(platform: Platform) -> list[str | None]:
|
||||
return [w.name for w in platform.state().monitors[0].workspaces]
|
||||
|
||||
|
||||
def run(platform: Platform, checks: Checks) -> None:
|
||||
"""Starts the daemon from a file with two workspaces, a window open, and rewrites the file
|
||||
three times: with new names and a third workspace and another layout, with a workspace rule
|
||||
that sends the windows of a title to the second workspace, and with the rule gone.
|
||||
|
||||
The daemon is left running on that file, with the window open on the first workspace, which
|
||||
is in view. The daemon must have been running, with no window but the one it is given.
|
||||
"""
|
||||
stay = platform.spawn("reload-stays")
|
||||
platform.restart_with(_config(["one", "two"], "BSP"))
|
||||
checks.check(
|
||||
"the daemon starts with the workspaces of the file",
|
||||
_names(platform)[:2] == ["one", "two"],
|
||||
)
|
||||
checks.check(
|
||||
"the window that was open is managed",
|
||||
platform.wait_for(lambda: platform.state().workspace_of(stay.title) == 0, timeout=30),
|
||||
)
|
||||
|
||||
platform.rewrite_config(_config(["uno", "dos", "tres"], "Columns"))
|
||||
checks.check(
|
||||
"a file with other names and one workspace more is loaded",
|
||||
platform.wait_for(lambda: _names(platform) == ["uno", "dos", "tres"], timeout=30),
|
||||
)
|
||||
checks.check(
|
||||
"... with the layout the file gives the first workspace",
|
||||
platform.wait_for(lambda: platform.state().workspace().layout == "Columns", timeout=30),
|
||||
)
|
||||
checks.check(
|
||||
"... and the window that was open stays where it was",
|
||||
platform.state().workspace_of(stay.title) == 0 and not platform.hidden(stay),
|
||||
)
|
||||
|
||||
platform.rewrite_config(_config(["uno", "dos", "tres"], "Columns", rule="reload-sent"))
|
||||
sent = platform.spawn("reload-sent-1")
|
||||
checks.check(
|
||||
"a rule the file gained sends a window that opens to its workspace",
|
||||
platform.wait_for(lambda: platform.state().workspace_of(sent.title) == 1, timeout=30),
|
||||
)
|
||||
|
||||
platform.rewrite_config(_config(["uno", "dos", "tres"], "Columns"))
|
||||
# the reload does not say when it is done: the next window shows whether the rule is
|
||||
platform.wait_for(lambda: False, timeout=3)
|
||||
later = platform.spawn("reload-sent-2")
|
||||
checks.check(
|
||||
"once the file loses the rule, a window of that title stays on the first workspace",
|
||||
platform.wait_for(lambda: platform.state().workspace_of(later.title) == 0, timeout=30),
|
||||
)
|
||||
|
||||
platform.komorebic("change-layout", "bsp")
|
||||
for client in (sent, later):
|
||||
platform.close(client)
|
||||
checks.check(
|
||||
"the two windows are closed",
|
||||
platform.wait_for(lambda: platform.state().managed() == 1, timeout=20),
|
||||
)
|
||||
@@ -0,0 +1,46 @@
|
||||
"""A flipped layout is the layout mirrored, and flipping it back gives the layout back."""
|
||||
|
||||
from komorebi_vm.core.checks import Checks
|
||||
from komorebi_vm.core.platform import Client, Platform
|
||||
from komorebi_vm.core.scenarios.layouts import tiled
|
||||
|
||||
|
||||
def run(platform: Platform, checks: Checks, clients: list[Client]) -> None:
|
||||
"""Flips the layout of the first workspace, which has `clients` tiled in a container each,
|
||||
horizontally and back."""
|
||||
area = platform.work_area()
|
||||
|
||||
def centres() -> dict[str, int]:
|
||||
found = {}
|
||||
for client in clients:
|
||||
window = platform.os_window(client)
|
||||
if window is not None:
|
||||
found[client.title] = window.frame.x + window.frame.w // 2
|
||||
return found
|
||||
|
||||
before = centres()
|
||||
|
||||
def mirrored() -> bool:
|
||||
now = centres()
|
||||
return len(now) == len(before) and all(
|
||||
abs((2 * area.x + area.w - before[t]) - now[t]) <= platform.tolerance for t in before
|
||||
)
|
||||
|
||||
platform.komorebic("flip-layout", "horizontal")
|
||||
checks.check(
|
||||
"after 'flip-layout horizontal' every window is where the mirror of its place is",
|
||||
platform.wait_for(mirrored, timeout=20),
|
||||
)
|
||||
checks.check(
|
||||
"... and every window is where the layout says",
|
||||
platform.wait_for(lambda: tiled(platform, clients), timeout=20),
|
||||
)
|
||||
|
||||
platform.komorebic("flip-layout", "horizontal")
|
||||
checks.check(
|
||||
"flipped again, every window is where it was",
|
||||
platform.wait_for(
|
||||
lambda: all(abs(centres()[t] - before[t]) <= platform.tolerance for t in before),
|
||||
timeout=20,
|
||||
),
|
||||
)
|
||||
@@ -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),
|
||||
)
|
||||
@@ -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,
|
||||
),
|
||||
)
|
||||
@@ -0,0 +1,50 @@
|
||||
"""A window that was put away on another workspace is not lost when the daemon restarts."""
|
||||
|
||||
from komorebi_vm.core.checks import Checks
|
||||
from komorebi_vm.core.platform import Client, Platform
|
||||
from komorebi_vm.core.scenarios.support import focus_agrees
|
||||
|
||||
|
||||
def run(platform: Platform, checks: Checks, clients: list[Client]) -> None:
|
||||
"""Sends the last of `clients`, which are tiled windows of workspace 0, to workspace 1,
|
||||
stops the daemon and starts it again.
|
||||
|
||||
Where the daemon puts the window afterwards is not asked for, only that it manages every
|
||||
window again and that the ones in view are inside the work area and clear of each other.
|
||||
"""
|
||||
target = clients[-1]
|
||||
platform.activate(target)
|
||||
platform.wait_for(lambda: focus_agrees(platform, clients, target.title))
|
||||
platform.komorebic("send-to-workspace", "1")
|
||||
checks.check(
|
||||
f"{target.title} is put away on workspace 1",
|
||||
platform.wait_for(lambda: platform.state().containers(1) == [[target.title]], timeout=20),
|
||||
)
|
||||
|
||||
platform.komorebic("stop")
|
||||
checks.check(
|
||||
"the daemon stops answering",
|
||||
platform.wait_for(lambda: platform.komorebic_status("state")[0] != 0, timeout=20),
|
||||
)
|
||||
platform.start_komorebi()
|
||||
checks.check(
|
||||
"the daemon manages every window again, the one that was put away too",
|
||||
platform.wait_for(lambda: platform.state().managed() >= len(clients), timeout=30),
|
||||
)
|
||||
checks.check(
|
||||
f"... and it has {target.title} on a workspace",
|
||||
platform.wait_for(lambda: platform.state().workspace_of(target.title) is not None),
|
||||
)
|
||||
area = platform.work_area()
|
||||
frames = [
|
||||
w.frame
|
||||
for c in clients
|
||||
if not platform.hidden(c) and (w := platform.os_window(c)) is not None
|
||||
]
|
||||
checks.check(
|
||||
"... the windows in view are inside the work area", all(f.inside(area) for f in frames)
|
||||
)
|
||||
checks.check(
|
||||
"... and not on each other",
|
||||
not any(a.overlaps(b) for i, a in enumerate(frames) for b in frames[i + 1 :]),
|
||||
)
|
||||
@@ -0,0 +1,55 @@
|
||||
"""The screen is locked and unlocked: the lock screen is not tiled, nothing the daemon does while
|
||||
it is locked changes the layout, and the desktop is put right when it is unlocked."""
|
||||
|
||||
from komorebi_vm.core.checks import Checks
|
||||
from komorebi_vm.core.platform import Client, Platform
|
||||
from komorebi_vm.core.scenarios.layouts import tiled
|
||||
|
||||
|
||||
def _focus_agrees(platform: Platform, clients: list[Client]) -> bool:
|
||||
"""The window the daemon says has the focus is the one the operating system says does."""
|
||||
workspace = platform.state().workspace()
|
||||
if not workspace.containers:
|
||||
return False
|
||||
stack = workspace.containers[workspace.focused_container]
|
||||
top = stack[workspace.focused_windows[workspace.focused_container]].title
|
||||
return any(
|
||||
(w := platform.os_window(c)) is not None and w.focused and w.title == top for c in clients
|
||||
)
|
||||
|
||||
|
||||
def run(platform: Platform, checks: Checks, clients: list[Client]) -> None:
|
||||
"""Locks the screen with `clients` tiled windows on the first workspace, moves the first
|
||||
while it is locked, unlocks, and checks the windows are in their tiles and the focus is
|
||||
agreed on.
|
||||
|
||||
The daemon must be running, with only `clients`, tiled. Needs `has("lock")`.
|
||||
"""
|
||||
checks.check(
|
||||
"the windows are tiled before the lock",
|
||||
platform.wait_for(lambda: tiled(platform, clients), timeout=30),
|
||||
)
|
||||
before = [w.frame for c in clients if (w := platform.os_window(c)) is not None]
|
||||
|
||||
platform.lock()
|
||||
checks.check(
|
||||
"while the screen is locked the daemon has the same windows: the lock screen is not one",
|
||||
platform.state().managed() == len(clients),
|
||||
)
|
||||
platform.move_window(clients[0], 400, 300)
|
||||
after = [platform.os_window(c) for c in clients]
|
||||
checks.check(
|
||||
"the others did not move for it",
|
||||
all(w is not None and w.frame == f for w, f in zip(after[1:], before[1:], strict=True)),
|
||||
)
|
||||
|
||||
platform.unlock()
|
||||
checks.check(
|
||||
"once it is unlocked the window that was moved is in its tile again",
|
||||
platform.wait_for(lambda: tiled(platform, clients), timeout=30),
|
||||
)
|
||||
checks.check("... with the windows the daemon had", platform.state().managed() == len(clients))
|
||||
checks.check(
|
||||
"the daemon's idea of the focus is the operating system's",
|
||||
platform.wait_for(lambda: _focus_agrees(platform, clients), timeout=30),
|
||||
)
|
||||
@@ -0,0 +1,53 @@
|
||||
"""A maximized window has the work area, with the others left where they are behind it."""
|
||||
|
||||
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, positions
|
||||
|
||||
|
||||
def run(platform: Platform, checks: Checks, clients: list[Client]) -> None:
|
||||
"""Toggles maximize on the last of `clients`, which are tiled windows of the first workspace,
|
||||
each in a container of its own, and toggles it off again."""
|
||||
target = clients[-1]
|
||||
others = [c for c in clients if c != target]
|
||||
platform.activate(target)
|
||||
platform.wait_for(lambda: focus_agrees(platform, clients, target.title))
|
||||
area = platform.work_area()
|
||||
behind = positions(platform, others)
|
||||
|
||||
def fills() -> bool:
|
||||
window = platform.os_window(target)
|
||||
return (
|
||||
window is not None
|
||||
and window.frame.w >= area.w - platform.tolerance
|
||||
and window.frame.h >= area.h - platform.tolerance
|
||||
)
|
||||
|
||||
def maximized() -> str | None:
|
||||
window = platform.state().workspace().maximized
|
||||
return window.title if window else None
|
||||
|
||||
platform.komorebic("toggle-maximize")
|
||||
checks.check(
|
||||
f"after 'toggle-maximize' {target.title} fills the work area",
|
||||
platform.wait_for(fills, timeout=20),
|
||||
)
|
||||
checks.check(
|
||||
"... and the daemon has it as the maximized window",
|
||||
platform.wait_for(lambda: maximized() == target.title, timeout=20),
|
||||
)
|
||||
checks.check(
|
||||
"... the others stay where they were",
|
||||
positions(platform, others) == behind,
|
||||
)
|
||||
|
||||
platform.komorebic("toggle-maximize")
|
||||
checks.check(
|
||||
"toggled again, the daemon has no maximized window",
|
||||
platform.wait_for(lambda: maximized() is None, timeout=20),
|
||||
)
|
||||
checks.check(
|
||||
"... and every window is tiled where the layout says",
|
||||
platform.wait_for(lambda: tiled(platform, clients), timeout=20),
|
||||
)
|
||||
@@ -0,0 +1,40 @@
|
||||
"""A window that is minimized leaves its room to the others, and takes it back when restored."""
|
||||
|
||||
from komorebi_vm.core.checks import Checks
|
||||
from komorebi_vm.core.platform import Client, Platform
|
||||
from komorebi_vm.core.scenarios.layouts import tiled
|
||||
|
||||
|
||||
def run(platform: Platform, checks: Checks, clients: list[Client]) -> None:
|
||||
"""Minimizes the first of `clients`, which are tiled windows of the first workspace in a
|
||||
container each, with more than two of them, and restores it."""
|
||||
target = clients[0]
|
||||
others = clients[1:]
|
||||
|
||||
def area(c: Client) -> int:
|
||||
window = platform.os_window(c)
|
||||
return window.frame.w * window.frame.h if window is not None else 0
|
||||
|
||||
before = sum(area(c) for c in others)
|
||||
platform.minimize(target)
|
||||
checks.check(
|
||||
f"with {target.title} minimized 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 :]),
|
||||
)
|
||||
|
||||
platform.activate(target)
|
||||
checks.check(
|
||||
f"restored, {target.title} and the others are tiled where the layout says",
|
||||
platform.wait_for(lambda: tiled(platform, clients), timeout=20),
|
||||
)
|
||||
frames = [w.frame for c in clients if (w := platform.os_window(c)) is not None]
|
||||
checks.check(
|
||||
"... and not on each other",
|
||||
not any(a.overlaps(b) for i, a in enumerate(frames) for b in frames[i + 1 :]),
|
||||
)
|
||||
@@ -0,0 +1,81 @@
|
||||
"""The padding of a workspace and of its containers moves the windows in from the edges and from
|
||||
each other."""
|
||||
|
||||
from komorebi_vm.core.checks import Checks
|
||||
from komorebi_vm.core.geometry import Rect
|
||||
from komorebi_vm.core.platform import Client, Platform
|
||||
from komorebi_vm.core.scenarios.layouts import tiled
|
||||
|
||||
|
||||
def run(
|
||||
platform: Platform,
|
||||
checks: Checks,
|
||||
clients: list[Client],
|
||||
configured: tuple[int, int] = (0, 0),
|
||||
) -> None:
|
||||
"""Raises the workspace padding and then the container padding of the first workspace, which
|
||||
has `clients` tiled in a container each, and sets them back to what the daemon says they were
|
||||
(`configured` is the workspace and container padding for a daemon that does not say)."""
|
||||
state = platform.state().workspace()
|
||||
workspace = configured[0] if state.workspace_padding is None else state.workspace_padding
|
||||
container = configured[1] if state.container_padding is None else state.container_padding
|
||||
print(f" padding of the workspace {workspace}, of its containers {container}")
|
||||
area = platform.work_area()
|
||||
|
||||
def frames() -> list[Rect]:
|
||||
return [w.frame for c in clients if (w := platform.os_window(c)) is not None]
|
||||
|
||||
def margin() -> int:
|
||||
"""How far the windows are from the left edge of the work area: the padding of the
|
||||
workspace and that of the first container."""
|
||||
return min(f.x for f in frames()) - area.x
|
||||
|
||||
def room() -> int:
|
||||
return sum(f.w * f.h for f in frames())
|
||||
|
||||
def near(value: int, want: int) -> bool:
|
||||
return abs(value - want) <= 10
|
||||
|
||||
# what the windows are measured against is what these commands give, not what the config said
|
||||
platform.komorebic("focused-workspace-padding", str(workspace))
|
||||
platform.komorebic("focused-workspace-container-padding", str(container))
|
||||
checks.check(
|
||||
"the windows are inside the work area, tiled where the layout says",
|
||||
platform.wait_for(lambda: tiled(platform, clients), timeout=20),
|
||||
)
|
||||
start = margin()
|
||||
print(f" margin {start} with the padding as it is")
|
||||
base = room()
|
||||
|
||||
platform.komorebic("focused-workspace-padding", str(workspace + 40))
|
||||
checks.check(
|
||||
"a workspace padding 40 px more moves the windows 40 px in from the edge",
|
||||
platform.wait_for(lambda: near(margin(), start + 40), timeout=20),
|
||||
)
|
||||
checks.check(
|
||||
"... and they stay where the layout says",
|
||||
platform.wait_for(lambda: tiled(platform, clients), timeout=20),
|
||||
)
|
||||
|
||||
platform.komorebic("focused-workspace-padding", str(workspace))
|
||||
platform.komorebic("focused-workspace-container-padding", str(container + 30))
|
||||
checks.check(
|
||||
"a container padding 30 px more leaves the windows less room",
|
||||
platform.wait_for(lambda: room() < base - 5000, timeout=20),
|
||||
)
|
||||
checks.check(
|
||||
"... and none is over another, or outside the work area",
|
||||
all(f.inside(area) for f in frames())
|
||||
and not any(a.overlaps(b) for i, a in enumerate(frames()) for b in frames()[i + 1 :]),
|
||||
)
|
||||
|
||||
platform.komorebic("focused-workspace-container-padding", str(container))
|
||||
checks.check(
|
||||
"with the padding as it was, the windows are as far from the edge as they were",
|
||||
platform.wait_for(lambda: near(margin(), start), timeout=20),
|
||||
)
|
||||
print(f" margin {margin()} (was {start}), room {room()} (was {base})")
|
||||
checks.check(
|
||||
"... and have the room they had",
|
||||
platform.wait_for(lambda: abs(room() - base) <= 2000, timeout=20),
|
||||
)
|
||||
@@ -0,0 +1,39 @@
|
||||
"""A paused daemon leaves new windows alone, and an unpaused one takes them up."""
|
||||
|
||||
from komorebi_vm.core.checks import Checks
|
||||
from komorebi_vm.core.platform import Client, Platform
|
||||
from komorebi_vm.core.scenarios.layouts import tiled
|
||||
|
||||
# how long a daemon that is paused has to leave a window alone for it to count
|
||||
QUIET = 3
|
||||
|
||||
|
||||
def run(platform: Platform, checks: Checks, clients: list[Client]) -> None:
|
||||
"""Pauses the daemon, opens a window, unpauses it and opens another, with `clients` tiled
|
||||
on the first workspace. Closes both."""
|
||||
managed = platform.state().managed()
|
||||
|
||||
platform.komorebic("toggle-pause")
|
||||
paused = platform.spawn("while-paused")
|
||||
checks.check(
|
||||
"a window that opens while the daemon is paused is not managed",
|
||||
not platform.wait_for(lambda: platform.state().managed() > managed, timeout=QUIET),
|
||||
)
|
||||
|
||||
platform.komorebic("toggle-pause")
|
||||
after = platform.spawn("after-the-pause")
|
||||
checks.check(
|
||||
"after 'toggle-pause' again the next window is managed",
|
||||
platform.wait_for(lambda: platform.state().managed() > managed, timeout=20),
|
||||
)
|
||||
checks.check(
|
||||
"... and every window it had is still tiled where the layout says",
|
||||
platform.wait_for(lambda: tiled(platform, [*clients, after]), timeout=20),
|
||||
)
|
||||
|
||||
platform.close(paused)
|
||||
platform.close(after)
|
||||
checks.check(
|
||||
"the two windows are closed and the daemon has the ones it had",
|
||||
platform.wait_for(lambda: platform.state().managed() == managed, timeout=20),
|
||||
)
|
||||
@@ -0,0 +1,35 @@
|
||||
"""A promoted window takes the first tile, and keeps the focus."""
|
||||
|
||||
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:
|
||||
"""Promotes the last of `clients`, which are tiled windows of the first workspace in a
|
||||
container each, with more than one of them."""
|
||||
target = clients[-1]
|
||||
platform.activate(target)
|
||||
platform.wait_for(lambda: focus_agrees(platform, clients, target.title))
|
||||
first = platform.state().workspace().latest_layout[0]
|
||||
|
||||
platform.komorebic("promote")
|
||||
checks.check(
|
||||
f"after 'promote' the daemon has {target.title} in the first container",
|
||||
platform.wait_for(lambda: platform.state().containers()[0] == [target.title], timeout=20),
|
||||
)
|
||||
|
||||
def on_the_first_tile() -> bool:
|
||||
window = platform.os_window(target)
|
||||
return window is not None and (window.frame.x, window.frame.y) == (first.x, first.y)
|
||||
|
||||
checks.check("... and the window is on the first tile", platform.wait_for(on_the_first_tile))
|
||||
checks.check(
|
||||
"... every window is where the layout says",
|
||||
platform.wait_for(lambda: tiled(platform, clients), timeout=20),
|
||||
)
|
||||
checks.check(
|
||||
"... and the window still has the focus",
|
||||
platform.wait_for(lambda: focus_agrees(platform, clients, target.title), timeout=20),
|
||||
)
|
||||
@@ -0,0 +1,43 @@
|
||||
"""The resize commands move an edge of the focused window, with no pointer."""
|
||||
|
||||
from komorebi_vm.core.checks import Checks
|
||||
from komorebi_vm.core.platform import Client, Platform
|
||||
from komorebi_vm.core.scenarios.support import focus_agrees
|
||||
|
||||
# how much wider the window must get for the command to have done something
|
||||
MIN_STEP = 10
|
||||
|
||||
|
||||
def run(platform: Platform, checks: Checks, clients: list[Client]) -> None:
|
||||
"""Resizes the first of `clients`, which are tiled windows of the first workspace, with
|
||||
`resize-axis horizontal increase` and `decrease`."""
|
||||
target = clients[0]
|
||||
platform.activate(target)
|
||||
platform.wait_for(lambda: focus_agrees(platform, clients, target.title))
|
||||
|
||||
def width() -> int:
|
||||
window = platform.os_window(target)
|
||||
return window.frame.w if window is not None else 0
|
||||
|
||||
def clear() -> bool:
|
||||
frames = [w.frame for c in clients if (w := platform.os_window(c)) is not None]
|
||||
area = platform.work_area()
|
||||
return all(f.inside(area) for f in frames) and not any(
|
||||
a.overlaps(b) for i, a in enumerate(frames) for b in frames[i + 1 :]
|
||||
)
|
||||
|
||||
before = width()
|
||||
platform.komorebic("resize-axis", "horizontal", "increase")
|
||||
checks.check(
|
||||
f"after 'resize-axis horizontal increase' {target.title} is wider",
|
||||
platform.wait_for(lambda: width() >= before + MIN_STEP, timeout=20),
|
||||
)
|
||||
print(f" width {before} -> {width()}")
|
||||
checks.check("... and every window is inside the work area, none over another", clear())
|
||||
|
||||
platform.komorebic("resize-axis", "horizontal", "decrease")
|
||||
checks.check(
|
||||
"after 'decrease' it has the width it had",
|
||||
platform.wait_for(lambda: abs(width() - before) <= platform.tolerance, timeout=20),
|
||||
)
|
||||
checks.check("... and every window is inside the work area, none over another", clear())
|
||||
@@ -0,0 +1,49 @@
|
||||
"""Rules that match a window by its class (its app id on Wayland) decide where it goes, or that it
|
||||
is left alone."""
|
||||
|
||||
from komorebi_vm.core.checks import Checks
|
||||
from komorebi_vm.core.platform import Platform
|
||||
|
||||
|
||||
def run(platform: Platform, checks: Checks) -> None:
|
||||
"""Gives the daemon a workspace rule and an ignore rule by class, opens a window of each
|
||||
class and one of neither, and checks where each went.
|
||||
|
||||
The daemon must be running, on the first workspace, which is the one in view, with no window,
|
||||
and with workspaces 0 and 1. The rules are cleared afterwards.
|
||||
"""
|
||||
platform.komorebic("ensure-workspaces", "0", "2")
|
||||
platform.komorebic("workspace-rule", "class", "e2e-sent", "0", "1")
|
||||
platform.komorebic("ignore-rule", "class", "e2e-left")
|
||||
|
||||
sent = platform.spawn("by-class-sent", app_id="e2e-sent")
|
||||
checks.check(
|
||||
"a window a class rule matches goes to the workspace the rule names",
|
||||
platform.wait_for(lambda: platform.state().workspace_of(sent.title) == 1, timeout=20),
|
||||
)
|
||||
checks.check(
|
||||
"... where it is put away while another workspace is in view",
|
||||
platform.wait_for(lambda: platform.hidden(sent)),
|
||||
)
|
||||
|
||||
left = platform.spawn("by-class-left", app_id="e2e-left")
|
||||
checks.check(
|
||||
"a window an ignore rule by class matches is not managed",
|
||||
not platform.wait_for(
|
||||
lambda: platform.state().workspace_of(left.title) is not None, timeout=3
|
||||
),
|
||||
)
|
||||
|
||||
plain = platform.spawn("by-class-plain", app_id="e2e-other")
|
||||
checks.check(
|
||||
"a window of another class stays on the first workspace",
|
||||
platform.wait_for(lambda: platform.state().workspace_of(plain.title) == 0, timeout=20),
|
||||
)
|
||||
|
||||
platform.komorebic("clear-all-workspace-rules")
|
||||
for client in (sent, left, plain):
|
||||
platform.close(client)
|
||||
checks.check(
|
||||
"the three windows are closed",
|
||||
platform.wait_for(lambda: platform.state().managed() == 0, timeout=20),
|
||||
)
|
||||
@@ -0,0 +1,53 @@
|
||||
"""Rules that match a window by the program that opened it decide where it goes, or that it is
|
||||
left alone. The program is `e2e-exe-sent.exe` on Windows and `e2e-exe-sent` on Linux, and the
|
||||
rule is the same.
|
||||
|
||||
The names differ from those of `rules_class`: `ignore-rule` drops a rule whose id an earlier
|
||||
rule has, whatever its kind."""
|
||||
|
||||
from komorebi_vm.core.checks import Checks
|
||||
from komorebi_vm.core.platform import Platform
|
||||
|
||||
|
||||
def run(platform: Platform, checks: Checks) -> None:
|
||||
"""Gives the daemon a workspace rule and an ignore rule by exe, opens a window of each
|
||||
program and one of neither, and checks where each went.
|
||||
|
||||
The daemon must be running, on the first workspace, which is the one in view, with no window,
|
||||
and with workspaces 0 and 1. The rules are cleared afterwards.
|
||||
"""
|
||||
platform.komorebic("ensure-workspaces", "0", "2")
|
||||
platform.komorebic("workspace-rule", "exe", "e2e-exe-sent", "0", "1")
|
||||
platform.komorebic("ignore-rule", "exe", "e2e-exe-left")
|
||||
|
||||
sent = platform.spawn("by-exe-sent", exe="e2e-exe-sent")
|
||||
checks.check(
|
||||
"a window an exe rule matches goes to the workspace the rule names",
|
||||
platform.wait_for(lambda: platform.state().workspace_of(sent.title) == 1, timeout=20),
|
||||
)
|
||||
checks.check(
|
||||
"... where it is put away while another workspace is in view",
|
||||
platform.wait_for(lambda: platform.hidden(sent)),
|
||||
)
|
||||
|
||||
left = platform.spawn("by-exe-left", exe="e2e-exe-left")
|
||||
checks.check(
|
||||
"a window an ignore rule by exe matches is not managed",
|
||||
not platform.wait_for(
|
||||
lambda: platform.state().workspace_of(left.title) is not None, timeout=3
|
||||
),
|
||||
)
|
||||
|
||||
plain = platform.spawn("by-exe-plain", exe="e2e-exe-other")
|
||||
checks.check(
|
||||
"a window of another program stays on the first workspace",
|
||||
platform.wait_for(lambda: platform.state().workspace_of(plain.title) == 0, timeout=20),
|
||||
)
|
||||
|
||||
platform.komorebic("clear-all-workspace-rules")
|
||||
for client in (sent, left, plain):
|
||||
platform.close(client)
|
||||
checks.check(
|
||||
"the three windows are closed",
|
||||
platform.wait_for(lambda: platform.state().managed() == 0, timeout=20),
|
||||
)
|
||||
@@ -0,0 +1,33 @@
|
||||
"""In the scrolling layout the window that has the focus is in view, wherever the others are."""
|
||||
|
||||
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:
|
||||
"""Changes the layout of the first workspace, which has `clients` tiled in a container each,
|
||||
to scrolling, gives each of them the focus in turn, and changes it back to bsp."""
|
||||
area = platform.work_area()
|
||||
|
||||
def in_view(client: Client) -> bool:
|
||||
window = platform.os_window(client)
|
||||
return window is not None and window.frame.inside(area)
|
||||
|
||||
platform.komorebic("change-layout", "scrolling")
|
||||
for client in clients:
|
||||
platform.activate(client)
|
||||
checks.check(
|
||||
f"in scrolling, {client.title} has the focus and is inside the work area",
|
||||
platform.wait_for(
|
||||
lambda c=client: focus_agrees(platform, clients, c.title) and in_view(c),
|
||||
timeout=20,
|
||||
),
|
||||
)
|
||||
|
||||
platform.komorebic("change-layout", "bsp")
|
||||
checks.check(
|
||||
"back in bsp every window is where the layout says",
|
||||
platform.wait_for(lambda: tiled(platform, clients), timeout=20),
|
||||
)
|
||||
@@ -0,0 +1,39 @@
|
||||
"""A workspace with tiling off leaves its windows where they are, and tiling it again tiles them."""
|
||||
|
||||
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 positions
|
||||
|
||||
|
||||
def run(platform: Platform, checks: Checks, clients: list[Client]) -> None:
|
||||
"""Toggles tiling off on the first workspace, which has `clients` tiled in a container each,
|
||||
and on again, with a layout change in between that must not move anything."""
|
||||
before = positions(platform, clients)
|
||||
|
||||
platform.komorebic("toggle-tiling")
|
||||
checks.check(
|
||||
"after 'toggle-tiling' the daemon has the workspace untiled",
|
||||
platform.wait_for(lambda: not platform.state().workspace().tile, timeout=20),
|
||||
)
|
||||
checks.check("... and no window moved", positions(platform, clients) == before)
|
||||
platform.komorebic("change-layout", "columns")
|
||||
checks.check(
|
||||
"... a layout change does not move them either",
|
||||
not platform.wait_for(lambda: positions(platform, clients) != before, timeout=3),
|
||||
)
|
||||
|
||||
platform.komorebic("toggle-tiling")
|
||||
checks.check(
|
||||
"'toggle-tiling' again has the workspace tiled",
|
||||
platform.wait_for(lambda: platform.state().workspace().tile, timeout=20),
|
||||
)
|
||||
checks.check(
|
||||
"... and every window is where the layout says",
|
||||
platform.wait_for(lambda: tiled(platform, clients), timeout=20),
|
||||
)
|
||||
platform.komorebic("change-layout", "bsp")
|
||||
checks.check(
|
||||
"... and in bsp again",
|
||||
platform.wait_for(lambda: tiled(platform, clients), timeout=20),
|
||||
)
|
||||
@@ -0,0 +1,61 @@
|
||||
"""A window moved to a workspace takes the focus there, and the last workspace is one command
|
||||
away."""
|
||||
|
||||
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 _in_view(platform: Platform, clients: list[Client]) -> list[str]:
|
||||
return sorted(c.title for c in clients if not platform.hidden(c))
|
||||
|
||||
|
||||
def run(platform: Platform, checks: Checks, clients: list[Client]) -> None:
|
||||
"""Moves the last of `clients`, which are tiled windows of workspace 0 in a container each,
|
||||
to workspace 1 with `move-to-workspace`, goes back and forth with `focus-last-workspace`, and
|
||||
moves it home. Workspace 1 is empty."""
|
||||
target = clients[-1]
|
||||
rest = sorted(c.title for c in clients if c != target)
|
||||
everyone = sorted(c.title for c in clients)
|
||||
platform.activate(target)
|
||||
platform.wait_for(lambda: focus_agrees(platform, clients, target.title))
|
||||
|
||||
platform.komorebic("move-to-workspace", "1")
|
||||
checks.check(
|
||||
"after 'move-to-workspace 1' the window is there, in view, and the others are put away",
|
||||
platform.wait_for(lambda: _in_view(platform, clients) == [target.title], timeout=20),
|
||||
)
|
||||
checks.check(
|
||||
"... the daemon has it on workspace 1",
|
||||
platform.wait_for(lambda: platform.state().containers(1) == [[target.title]]),
|
||||
)
|
||||
checks.check(
|
||||
"... and it has the focus",
|
||||
platform.wait_for(lambda: focus_agrees(platform, clients, target.title)),
|
||||
)
|
||||
|
||||
platform.komorebic("focus-last-workspace")
|
||||
checks.check(
|
||||
"'focus-last-workspace' brings the others back and puts the window away",
|
||||
platform.wait_for(lambda: _in_view(platform, clients) == rest, timeout=20),
|
||||
)
|
||||
platform.komorebic("focus-last-workspace")
|
||||
checks.check(
|
||||
"... and again, it goes back to the window",
|
||||
platform.wait_for(lambda: _in_view(platform, clients) == [target.title], timeout=20),
|
||||
)
|
||||
|
||||
platform.komorebic("move-to-workspace", "0")
|
||||
checks.check(
|
||||
"'move-to-workspace 0' has every window in view again",
|
||||
platform.wait_for(lambda: _in_view(platform, clients) == everyone, timeout=20),
|
||||
)
|
||||
checks.check(
|
||||
"... tiled where the layout says",
|
||||
platform.wait_for(lambda: tiled(platform, clients), timeout=20),
|
||||
)
|
||||
checks.check(
|
||||
"... and workspace 1 is empty",
|
||||
platform.wait_for(lambda: platform.state().containers(1) == []),
|
||||
)
|
||||
@@ -49,6 +49,10 @@ class Workspace:
|
||||
floating: list[Window]
|
||||
latest_layout: list[Rect]
|
||||
"""The rectangles the layout last computed, one for each container."""
|
||||
workspace_padding: int | None = None
|
||||
"""The padding of the workspace, when the daemon says."""
|
||||
container_padding: int | None = None
|
||||
"""The padding of each of its containers, when the daemon says."""
|
||||
|
||||
def windows(self) -> list[Window]:
|
||||
"""Every window of the workspace: the tiled ones, the monocle ones, the maximized one and
|
||||
@@ -162,6 +166,8 @@ def _workspace(value: dict[str, Any]) -> Workspace:
|
||||
maximized=_window(maximized) if maximized else None,
|
||||
floating=[_window(w) for w in _ring(value["floating_windows"])],
|
||||
latest_layout=[r for r in map(_rect, value.get("latest_layout", [])) if r is not None],
|
||||
workspace_padding=value.get("workspace_padding"),
|
||||
container_padding=value.get("container_padding"),
|
||||
)
|
||||
|
||||
|
||||
|
||||
+179
-18
@@ -58,6 +58,8 @@ class FakePlatform:
|
||||
focus_follows_move: bool = True,
|
||||
pointer: bool = True,
|
||||
follows_pointer: bool = True,
|
||||
reloads: bool = True,
|
||||
retiles_on_unlock: bool = True,
|
||||
) -> None:
|
||||
self.tiles = list(TILES)
|
||||
self.has_pointer = pointer
|
||||
@@ -79,13 +81,46 @@ class FakePlatform:
|
||||
self.display_count = 2
|
||||
self.display_of: dict[str, int] = {}
|
||||
self.forgets_displays = False
|
||||
self.floats: list[str] = []
|
||||
self.class_rules: dict[str, int] = {}
|
||||
self.ignored_classes: set[str] = set()
|
||||
self.exe_rules: dict[str, int] = {}
|
||||
self.ignored_exes: set[str] = set()
|
||||
self.exes: dict[str, str] = {}
|
||||
self.names: list[str | None] = [None, None, None]
|
||||
self.layout_name = "Columns"
|
||||
self.reloads = reloads
|
||||
self.locked = False
|
||||
self.moved: dict[str, Rect] = {}
|
||||
self.retiles_on_unlock = retiles_on_unlock
|
||||
self.tiling = True
|
||||
self.paused = False
|
||||
self.flipped = False
|
||||
self.last = 0
|
||||
self.maximized: str | None = None
|
||||
self.workspace_padding = 0
|
||||
self.container_padding = 0
|
||||
self.minimized: list[str] = []
|
||||
self.running = True
|
||||
self.placement: Any = None
|
||||
self.moves = moves
|
||||
self.focus_follows_move = focus_follows_move
|
||||
|
||||
def has(self, feature: str) -> bool:
|
||||
return feature == "pointer" and self.has_pointer
|
||||
return feature == "lock" or (feature == "pointer" and self.has_pointer)
|
||||
|
||||
def lock(self) -> None:
|
||||
self.locked = True
|
||||
|
||||
def unlock(self) -> None:
|
||||
self.locked = False
|
||||
if self.retiles_on_unlock:
|
||||
self.moved.clear()
|
||||
|
||||
def move_window(self, client: Client, x: int, y: int) -> None:
|
||||
here = self.os_window(client)
|
||||
assert here is not None
|
||||
self.moved[client.title] = Rect(x, y, here.frame.w, here.frame.h)
|
||||
|
||||
@property
|
||||
def pointer(self) -> FakePointer:
|
||||
@@ -109,6 +144,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
|
||||
@@ -133,7 +170,23 @@ class FakePlatform:
|
||||
"""The titles in view, in the order of the tiles."""
|
||||
return [stack[0] for stack in self.containers]
|
||||
|
||||
def spawn(self, title: str) -> Client:
|
||||
def spawn(self, title: str, app_id: str | None = None, exe: str | None = None) -> Client:
|
||||
self.exes[title] = exe or ""
|
||||
if exe in self.ignored_exes:
|
||||
self.unmanaged.append(title)
|
||||
return Client(title)
|
||||
if exe in self.exe_rules:
|
||||
self.spaces[self.exe_rules[exe]].append([title])
|
||||
return Client(title)
|
||||
if app_id in self.ignored_classes:
|
||||
self.unmanaged.append(title)
|
||||
return Client(title)
|
||||
if app_id in self.class_rules:
|
||||
self.spaces[self.class_rules[app_id]].append([title])
|
||||
return Client(title)
|
||||
if self.paused:
|
||||
self.unmanaged.append(title)
|
||||
return Client(title)
|
||||
if title in self.ignored:
|
||||
self.unmanaged.append(title)
|
||||
elif title in self.initial_rules:
|
||||
@@ -174,16 +227,26 @@ class FakePlatform:
|
||||
return space
|
||||
return None
|
||||
|
||||
def restart_with(self, config: dict[str, Any]) -> None:
|
||||
self.start_komorebi()
|
||||
def rewrite_config(self, config: dict[str, Any]) -> None:
|
||||
if self.reloads:
|
||||
self._load(config)
|
||||
|
||||
def _load(self, config: dict[str, Any]) -> None:
|
||||
workspaces = config["monitors"][0]["workspaces"]
|
||||
self.placement = workspaces[0].get("initial_window_placement_rules")
|
||||
self.names = [w.get("name") for w in workspaces] + [None] * (3 - len(workspaces))
|
||||
self.layout_name = workspaces[0]["layout"].title()
|
||||
self.prefix_rules = [
|
||||
(rule["id"], index)
|
||||
for index, workspace in enumerate(workspaces)
|
||||
for rule in workspace.get("workspace_rules", [])
|
||||
if rule["matching_strategy"] == "StartsWith"
|
||||
]
|
||||
|
||||
def restart_with(self, config: dict[str, Any]) -> None:
|
||||
self.start_komorebi()
|
||||
self._load(config)
|
||||
workspaces = config["monitors"][0]["workspaces"]
|
||||
self.placement = workspaces[0].get("initial_window_placement_rules")
|
||||
for title in [t for stack in self.spaces[0] for t in stack]:
|
||||
target = self._by_prefix(title)
|
||||
if target not in (None, 0):
|
||||
@@ -216,6 +279,12 @@ 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.minimized:
|
||||
self.minimized.remove(client.title)
|
||||
return
|
||||
if client.title in self.unmanaged:
|
||||
self.unmanaged.remove(client.title)
|
||||
return
|
||||
@@ -234,13 +303,23 @@ class FakePlatform:
|
||||
self.tiles = list(TILES)
|
||||
n = len(self.containers)
|
||||
if n:
|
||||
width = 1920 // n
|
||||
self.tiles = [Rect(i * width, 0, width, 1080) for i in range(n)] + list(TILES[n:])
|
||||
w, c = self.workspace_padding, self.container_padding
|
||||
width = (1920 - 2 * w) // n
|
||||
self.tiles = [
|
||||
Rect(w + i * width + c, w + c, width - 2 * c, 1080 - 2 * w - 2 * c)
|
||||
for i in range(n)
|
||||
] + list(TILES[n:])
|
||||
if self.flipped:
|
||||
self.tiles = [Rect(1920 - t.x - t.w, t.y, t.w, t.h) for t in self.tiles[:n]] + list(
|
||||
TILES[n:]
|
||||
)
|
||||
|
||||
def _container(self, title: str) -> int:
|
||||
return self._find(title)[1]
|
||||
|
||||
def hidden(self, client: Client) -> bool:
|
||||
if client.title in self.floats or client.title in self.minimized:
|
||||
return False
|
||||
if client.title in self.unmanaged:
|
||||
return False
|
||||
s, i = self._find(client.title)
|
||||
@@ -250,7 +329,17 @@ class FakePlatform:
|
||||
def work_area(self) -> Rect:
|
||||
return Rect(0, 0, 1920, 1080)
|
||||
|
||||
def minimize(self, client: Client) -> None:
|
||||
self._find_remove(client.title)
|
||||
self.minimized.append(client.title)
|
||||
self.focuses[self.current] = max(0, min(self.focus, len(self.containers) - 1))
|
||||
self._relayout()
|
||||
|
||||
def activate(self, client: Client) -> None:
|
||||
if client.title in self.minimized:
|
||||
self.minimized.remove(client.title)
|
||||
self.containers.append([client.title])
|
||||
self._relayout()
|
||||
self.current, self.focus = self._find(client.title)
|
||||
stack = self.containers[self.focus]
|
||||
stack.insert(0, stack.pop(stack.index(client.title)))
|
||||
@@ -259,6 +348,12 @@ class FakePlatform:
|
||||
return Image.new("RGB", (4, 4))
|
||||
|
||||
def os_window(self, client: Client) -> OsWindow | None:
|
||||
if client.title == self.maximized:
|
||||
return OsWindow(client.title, Rect(0, 0, 1920, 1080), focused=True)
|
||||
if client.title in self.minimized:
|
||||
return OsWindow(client.title, Rect(0, 0, 0, 0), focused=False)
|
||||
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:
|
||||
@@ -272,6 +367,8 @@ class FakePlatform:
|
||||
)
|
||||
tile = self.tiles[i]
|
||||
shift = 1920 * self.display_of.get(client.title, 0)
|
||||
if client.title in self.moved:
|
||||
return OsWindow(client.title, self.moved[client.title], focused=focused)
|
||||
return OsWindow(client.title, Rect(tile.x + shift, tile.y, tile.w, tile.h), focused=focused)
|
||||
|
||||
def komorebic_status(self, *args: str) -> tuple[int, str]:
|
||||
@@ -333,17 +430,28 @@ class FakePlatform:
|
||||
self.monocle = None if self.monocle else top
|
||||
case ("ensure-workspaces", _, _) | ("clear-all-workspace-rules",):
|
||||
if args[0] == "clear-all-workspace-rules":
|
||||
self.class_rules.clear()
|
||||
self.exe_rules.clear()
|
||||
self.rules.clear()
|
||||
self.initial_rules.clear()
|
||||
case ("initial-workspace-rule", "title", title, _, number):
|
||||
self.initial_rules[title] = int(number)
|
||||
case ("workspace-rule", "title", title, _, number):
|
||||
self.rules[title] = int(number)
|
||||
case ("workspace-rule", "class", name, _, number):
|
||||
self.class_rules[name] = int(number)
|
||||
case ("workspace-rule", "exe", name, _, number):
|
||||
self.exe_rules[name] = int(number)
|
||||
case ("ignore-rule", "exe", name):
|
||||
self.ignored_exes.add(name)
|
||||
case ("ignore-rule", "class", name):
|
||||
self.ignored_classes.add(name)
|
||||
case ("ignore-rule", "title", title):
|
||||
self.ignored.add(title)
|
||||
case ("move-to-workspace", number):
|
||||
self.komorebic("send-to-workspace", number)
|
||||
self.current = int(number)
|
||||
self.last, self.current = self.current, int(number)
|
||||
self.focus = len(self.containers) - 1
|
||||
case ("enforce-workspace-rules",):
|
||||
for title, number in self.rules.items():
|
||||
for s, containers in enumerate(self.spaces):
|
||||
@@ -355,7 +463,43 @@ class FakePlatform:
|
||||
self.spaces[number].append([title])
|
||||
break
|
||||
case ("focus-workspace", number):
|
||||
self.current = int(number)
|
||||
self.last, self.current = self.current, int(number)
|
||||
case ("focus-last-workspace",):
|
||||
self.last, self.current = self.current, self.last
|
||||
case ("focused-workspace-padding", size):
|
||||
self.workspace_padding = int(size)
|
||||
self._relayout()
|
||||
case ("focused-workspace-container-padding", size):
|
||||
self.container_padding = int(size)
|
||||
self._relayout()
|
||||
case ("toggle-maximize",):
|
||||
self.maximized = None if self.maximized else self.containers[self.focus][0]
|
||||
case ("resize-axis", "horizontal", way):
|
||||
d = 50 if way == "increase" else -50
|
||||
i = self.focus
|
||||
if n > 1 and i < n - 1:
|
||||
a, b = self.tiles[i], self.tiles[i + 1]
|
||||
self.tiles[i] = Rect(a.x, a.y, a.w + d, a.h)
|
||||
self.tiles[i + 1] = Rect(b.x + d, b.y, b.w - d, b.h)
|
||||
case ("promote",):
|
||||
self.containers.insert(0, self.containers.pop(self.focus))
|
||||
self.focus = 0
|
||||
case ("flip-layout", "horizontal"):
|
||||
self.flipped = not self.flipped
|
||||
self._relayout()
|
||||
case ("toggle-pause",):
|
||||
self.paused = not self.paused
|
||||
case ("toggle-tiling",):
|
||||
self.tiling = not self.tiling
|
||||
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]
|
||||
@@ -378,20 +522,28 @@ class FakePlatform:
|
||||
return {
|
||||
"id": hash(title) % 1000,
|
||||
"rect": {"left": tile.x, "top": tile.y, "right": tile.w, "bottom": tile.h},
|
||||
"details": {"title": title, "exe": "", "class": "", "path": ""},
|
||||
"details": {
|
||||
"title": title,
|
||||
"exe": self.exes.get(title, ""),
|
||||
"class": "",
|
||||
"path": "",
|
||||
},
|
||||
}
|
||||
|
||||
def rect(r: Rect) -> dict[str, int]:
|
||||
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]:
|
||||
def workspace(
|
||||
index: int, 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)
|
||||
windows = {"elements": [window(self.monocle, whole)], "focused": 0}
|
||||
monocle = {"id": "m", "locked": False, "windows": windows}
|
||||
return {
|
||||
"name": None,
|
||||
"name": self.names[index],
|
||||
"containers": {
|
||||
"elements": [
|
||||
{
|
||||
@@ -407,10 +559,19 @@ class FakePlatform:
|
||||
"focused": focus,
|
||||
},
|
||||
"monocle_container": monocle,
|
||||
"maximized_window": None,
|
||||
"floating_windows": {"elements": [], "focused": 0},
|
||||
"layout": {"Default": "Columns"},
|
||||
"tile": True,
|
||||
"maximized_window": (
|
||||
window(self.maximized, Rect(0, 0, 1920, 1080))
|
||||
if current and self.maximized
|
||||
else None
|
||||
),
|
||||
"floating_windows": {
|
||||
"elements": [window(t, Rect(300, 300, 600, 400)) for t in floats],
|
||||
"focused": 0,
|
||||
},
|
||||
"layout": {"Default": self.layout_name},
|
||||
"tile": self.tiling,
|
||||
"workspace_padding": self.workspace_padding,
|
||||
"container_padding": self.container_padding,
|
||||
"latest_layout": [rect(r) for r in self.tiles[: len(containers)]],
|
||||
}
|
||||
|
||||
@@ -419,7 +580,7 @@ class FakePlatform:
|
||||
"size": rect(Rect(0, 0, 1920, 1080)),
|
||||
"workspaces": {
|
||||
"elements": [
|
||||
workspace(c, f, i == self.current)
|
||||
workspace(i, c, f, i == self.current)
|
||||
for i, (c, f) in enumerate(zip(self.spaces, self.focuses, strict=True))
|
||||
],
|
||||
"focused": self.current,
|
||||
@@ -429,7 +590,7 @@ class FakePlatform:
|
||||
{
|
||||
"id": n + 1,
|
||||
"size": rect(Rect(n * 1920, 0, 1920, 1080)),
|
||||
"workspaces": {"elements": [workspace([], 0, False)], "focused": 0},
|
||||
"workspaces": {"elements": [workspace(0, [], 0, False)], "focused": 0},
|
||||
}
|
||||
for n in range(1, 1 if self.forgets_displays else self.display_count)
|
||||
]
|
||||
|
||||
@@ -1,21 +1,40 @@
|
||||
"""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.platform import OsWindow
|
||||
from komorebi_vm.core.scenarios import (
|
||||
closing,
|
||||
commands,
|
||||
config_reload,
|
||||
flipping,
|
||||
floating,
|
||||
focus,
|
||||
focus_follows_mouse,
|
||||
hotplug,
|
||||
layouts,
|
||||
lifecycle,
|
||||
lifecycle_hidden,
|
||||
locking,
|
||||
maximizing,
|
||||
minimizing,
|
||||
monocle,
|
||||
moving,
|
||||
padding,
|
||||
pausing,
|
||||
placement,
|
||||
promoting,
|
||||
resize,
|
||||
resize_commands,
|
||||
rules,
|
||||
rules_class,
|
||||
rules_exe,
|
||||
scrolling,
|
||||
stacks,
|
||||
startup_rules,
|
||||
tiling,
|
||||
tiling_off,
|
||||
workspace_moves,
|
||||
workspaces,
|
||||
)
|
||||
from tests.fake_platform import FakePlatform
|
||||
@@ -135,6 +154,359 @@ 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_daemon_that_is_right_passes_minimizing() -> None:
|
||||
platform = FakePlatform()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
minimizing.run(platform, checks, clients)
|
||||
assert checks.failed == 0, checks.failures
|
||||
assert checks.passed > 3
|
||||
|
||||
|
||||
def test_a_daemon_that_keeps_the_room_of_a_minimized_window_fails_minimizing() -> None:
|
||||
class Keeping(FakePlatform):
|
||||
def _relayout(self) -> None:
|
||||
pass
|
||||
|
||||
platform = Keeping()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
minimizing.run(platform, checks, clients)
|
||||
assert checks.failed > 0
|
||||
|
||||
|
||||
def test_a_daemon_that_is_right_passes_padding() -> None:
|
||||
platform = FakePlatform()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
padding.run(platform, checks, clients)
|
||||
assert checks.failed == 0, checks.failures
|
||||
assert checks.passed > 5
|
||||
|
||||
|
||||
def test_a_daemon_that_ignores_the_padding_fails_padding() -> None:
|
||||
class Ignoring(FakePlatform):
|
||||
def komorebic(self, *args: str) -> str:
|
||||
return "" if args[0].endswith("padding") else super().komorebic(*args)
|
||||
|
||||
platform = Ignoring()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
padding.run(platform, checks, clients)
|
||||
assert checks.failed > 0
|
||||
|
||||
|
||||
def test_a_daemon_that_is_right_passes_maximizing() -> None:
|
||||
platform = FakePlatform()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
maximizing.run(platform, checks, clients)
|
||||
assert checks.failed == 0, checks.failures
|
||||
assert checks.passed > 4
|
||||
|
||||
|
||||
def test_a_daemon_that_does_not_maximize_fails_maximizing() -> None:
|
||||
class Stubborn(FakePlatform):
|
||||
def komorebic(self, *args: str) -> str:
|
||||
return "" if args == ("toggle-maximize",) else super().komorebic(*args)
|
||||
|
||||
platform = Stubborn()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
maximizing.run(platform, checks, clients)
|
||||
assert checks.failed > 0
|
||||
|
||||
|
||||
def test_a_daemon_that_is_right_passes_workspace_moves() -> None:
|
||||
platform = FakePlatform()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
workspace_moves.run(platform, checks, clients)
|
||||
assert checks.failed == 0, checks.failures
|
||||
assert checks.passed > 6
|
||||
|
||||
|
||||
def test_a_daemon_that_does_not_follow_the_window_fails_workspace_moves() -> None:
|
||||
class Staying(FakePlatform):
|
||||
def komorebic(self, *args: str) -> str:
|
||||
if args[0] == "move-to-workspace":
|
||||
return super().komorebic("send-to-workspace", args[1])
|
||||
return super().komorebic(*args)
|
||||
|
||||
platform = Staying()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
workspace_moves.run(platform, checks, clients)
|
||||
assert checks.failed > 0
|
||||
|
||||
|
||||
def test_a_daemon_that_is_right_passes_resize_commands() -> None:
|
||||
platform = FakePlatform()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
resize_commands.run(platform, checks, clients)
|
||||
assert checks.failed == 0, checks.failures
|
||||
assert checks.passed > 3
|
||||
|
||||
|
||||
def test_a_daemon_that_does_not_resize_fails_resize_commands() -> None:
|
||||
class Stubborn(FakePlatform):
|
||||
def komorebic(self, *args: str) -> str:
|
||||
return "" if args[0] == "resize-axis" else super().komorebic(*args)
|
||||
|
||||
platform = Stubborn()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
resize_commands.run(platform, checks, clients)
|
||||
assert checks.failed > 0
|
||||
|
||||
|
||||
def test_a_daemon_that_is_right_passes_promoting() -> None:
|
||||
platform = FakePlatform()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
promoting.run(platform, checks, clients)
|
||||
assert checks.failed == 0, checks.failures
|
||||
assert checks.passed > 3
|
||||
|
||||
|
||||
def test_a_daemon_that_does_not_promote_fails_promoting() -> None:
|
||||
class Stubborn(FakePlatform):
|
||||
def komorebic(self, *args: str) -> str:
|
||||
return "" if args == ("promote",) else super().komorebic(*args)
|
||||
|
||||
platform = Stubborn()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
promoting.run(platform, checks, clients)
|
||||
assert checks.failed > 0
|
||||
|
||||
|
||||
def test_a_daemon_that_is_right_passes_flipping() -> None:
|
||||
platform = FakePlatform()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
flipping.run(platform, checks, clients)
|
||||
assert checks.failed == 0, checks.failures
|
||||
assert checks.passed > 3
|
||||
|
||||
|
||||
def test_a_daemon_that_does_not_flip_fails_flipping() -> None:
|
||||
class Stubborn(FakePlatform):
|
||||
def komorebic(self, *args: str) -> str:
|
||||
return "" if args[0] == "flip-layout" else super().komorebic(*args)
|
||||
|
||||
platform = Stubborn()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
flipping.run(platform, checks, clients)
|
||||
assert checks.failed > 0
|
||||
|
||||
|
||||
def test_a_daemon_that_is_right_passes_pausing() -> None:
|
||||
platform = FakePlatform()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
pausing.run(platform, checks, clients)
|
||||
assert checks.failed == 0, checks.failures
|
||||
assert checks.passed > 3
|
||||
|
||||
|
||||
def test_a_daemon_that_manages_while_paused_fails_pausing() -> None:
|
||||
class Stubborn(FakePlatform):
|
||||
def komorebic(self, *args: str) -> str:
|
||||
return "" if args == ("toggle-pause",) else super().komorebic(*args)
|
||||
|
||||
platform = Stubborn()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
pausing.run(platform, checks, clients)
|
||||
assert checks.failed > 0
|
||||
|
||||
|
||||
def test_a_daemon_that_is_right_passes_tiling_off() -> None:
|
||||
platform = FakePlatform()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
tiling_off.run(platform, checks, clients)
|
||||
assert checks.failed == 0, checks.failures
|
||||
assert checks.passed > 4
|
||||
|
||||
|
||||
def test_a_daemon_that_ignores_toggle_tiling_fails_tiling_off() -> None:
|
||||
class Stubborn(FakePlatform):
|
||||
def komorebic(self, *args: str) -> str:
|
||||
return "" if args == ("toggle-tiling",) else super().komorebic(*args)
|
||||
|
||||
platform = Stubborn()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
tiling_off.run(platform, checks, clients)
|
||||
assert checks.failed > 0
|
||||
|
||||
|
||||
def test_a_daemon_that_is_right_passes_lifecycle_hidden() -> None:
|
||||
platform = FakePlatform()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
lifecycle_hidden.run(platform, checks, clients)
|
||||
assert checks.failed == 0, checks.failures
|
||||
assert checks.passed > 4
|
||||
|
||||
|
||||
def test_a_daemon_that_loses_the_put_away_window_fails_lifecycle_hidden() -> None:
|
||||
class Forgetful(FakePlatform):
|
||||
def start_komorebi(self) -> None:
|
||||
super().start_komorebi()
|
||||
self.spaces = [[c for c in self.spaces[0] if c != ["win3"]], [], []]
|
||||
self.unmanaged.append("win3")
|
||||
|
||||
platform = Forgetful()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
lifecycle_hidden.run(platform, checks, clients)
|
||||
assert checks.failed > 0
|
||||
|
||||
|
||||
def test_a_daemon_that_is_right_passes_scrolling() -> None:
|
||||
platform = FakePlatform()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
scrolling.run(platform, checks, clients)
|
||||
assert checks.failed == 0, checks.failures
|
||||
assert checks.passed > 3
|
||||
|
||||
|
||||
def test_a_daemon_that_loses_the_focused_window_off_screen_fails_scrolling() -> None:
|
||||
class Off(FakePlatform):
|
||||
def os_window(self, client): # noqa: ANN001, ANN201
|
||||
window = super().os_window(client)
|
||||
if window is not None and window.focused:
|
||||
return OsWindow(window.title, Rect(5000, 0, 100, 100), focused=True)
|
||||
return window
|
||||
|
||||
platform = Off()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
scrolling.run(platform, checks, clients)
|
||||
assert checks.failed > 0
|
||||
|
||||
|
||||
def test_a_daemon_that_is_right_passes_rules_class() -> None:
|
||||
platform = FakePlatform()
|
||||
checks = Checks()
|
||||
rules_class.run(platform, checks)
|
||||
assert checks.failed == 0, checks.failures
|
||||
assert checks.passed > 4
|
||||
|
||||
|
||||
def test_a_daemon_that_ignores_class_rules_fails_rules_class() -> None:
|
||||
class Deaf(FakePlatform):
|
||||
def komorebic(self, *args: str) -> str:
|
||||
return "" if "class" in args else super().komorebic(*args)
|
||||
|
||||
platform = Deaf()
|
||||
checks = Checks()
|
||||
rules_class.run(platform, checks)
|
||||
assert checks.failed > 0
|
||||
|
||||
|
||||
def test_a_daemon_that_is_right_passes_rules_exe() -> None:
|
||||
platform = FakePlatform()
|
||||
checks = Checks()
|
||||
rules_exe.run(platform, checks)
|
||||
assert checks.failed == 0, checks.failures
|
||||
assert checks.passed > 4
|
||||
|
||||
|
||||
def test_a_daemon_that_ignores_exe_rules_fails_rules_exe() -> None:
|
||||
class Deaf(FakePlatform):
|
||||
def komorebic(self, *args: str) -> str:
|
||||
return "" if "exe" in args else super().komorebic(*args)
|
||||
|
||||
platform = Deaf()
|
||||
checks = Checks()
|
||||
rules_exe.run(platform, checks)
|
||||
assert checks.failed > 0
|
||||
|
||||
|
||||
def test_a_daemon_that_reloads_the_file_passes_config_reload() -> None:
|
||||
platform = FakePlatform()
|
||||
checks = Checks()
|
||||
config_reload.run(platform, checks)
|
||||
assert checks.failed == 0, checks.failures
|
||||
assert checks.passed > 6
|
||||
|
||||
|
||||
def test_a_daemon_that_does_not_reload_the_file_fails_config_reload() -> None:
|
||||
platform = FakePlatform(reloads=False)
|
||||
checks = Checks()
|
||||
config_reload.run(platform, checks)
|
||||
assert checks.failed > 0
|
||||
|
||||
|
||||
def test_a_daemon_that_tiles_again_on_unlock_passes_locking() -> None:
|
||||
platform = FakePlatform()
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
locking.run(platform, checks, clients)
|
||||
assert checks.failed == 0, checks.failures
|
||||
assert checks.passed > 4
|
||||
|
||||
|
||||
def test_a_daemon_that_does_not_tile_again_on_unlock_fails_locking() -> None:
|
||||
platform = FakePlatform(retiles_on_unlock=False)
|
||||
checks = Checks()
|
||||
clients = opened(platform, checks)
|
||||
locking.run(platform, checks, clients)
|
||||
assert checks.failed > 0
|
||||
|
||||
|
||||
def test_a_command_the_port_lacks_is_skipped_by_name() -> None:
|
||||
platform = FakePlatform()
|
||||
checks = Checks()
|
||||
|
||||
@@ -21,7 +21,7 @@ class FakePlatform:
|
||||
def wait_for(self, predicate, timeout: float = 10) -> bool: # noqa: ANN001
|
||||
return predicate()
|
||||
|
||||
def spawn(self, title: str) -> Client:
|
||||
def spawn(self, title: str, app_id: str | None = None, exe: str | None = None) -> Client:
|
||||
self.opened.append(title)
|
||||
return Client(title)
|
||||
|
||||
@@ -69,6 +69,21 @@ class FakePlatform:
|
||||
def komorebic(self, *args: str) -> str:
|
||||
return ""
|
||||
|
||||
def minimize(self, client: Client) -> None:
|
||||
pass
|
||||
|
||||
def rewrite_config(self, config: dict) -> None:
|
||||
pass
|
||||
|
||||
def lock(self) -> None:
|
||||
pass
|
||||
|
||||
def unlock(self) -> None:
|
||||
pass
|
||||
|
||||
def move_window(self, client: Client, x: int, y: int) -> None:
|
||||
pass
|
||||
|
||||
def activate(self, client: Client) -> None:
|
||||
pass
|
||||
|
||||
|
||||
Reference in new issue
Block a user