115 lines
5.7 KiB
Python
115 lines
5.7 KiB
Python
"""Focus history against real windows on a disposable nested compositor.
|
|
|
|
FERESE_TEST_FOCUS_HISTORY=1 python3 scripts/tests/test_focus_history_isolated.py
|
|
Requires built debug ferese/feresectl, foot, dbus-daemon, and a Wayland host.
|
|
"""
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import signal
|
|
import subprocess
|
|
import tempfile
|
|
import time
|
|
import unittest
|
|
|
|
|
|
@unittest.skipUnless(os.environ.get("FERESE_TEST_FOCUS_HISTORY") == "1", "nested focus test is opt-in")
|
|
class FocusHistoryTest(unittest.TestCase):
|
|
def test_last_focus_crosses_workspaces_and_skips_closed_windows(self):
|
|
repo = Path(__file__).resolve().parents[2]
|
|
with tempfile.TemporaryDirectory(prefix="ferese-focus-test-") as temporary:
|
|
root = Path(temporary)
|
|
runtime = root / "runtime"
|
|
runtime.mkdir(mode=0o700)
|
|
config = root / "config/ferese"
|
|
config.mkdir(parents=True)
|
|
(config / "config.kdl").write_text("animations { enabled #false; }\n")
|
|
display = Path(os.environ["WAYLAND_DISPLAY"])
|
|
if not display.is_absolute():
|
|
display = Path(os.environ["XDG_RUNTIME_DIR"]) / display
|
|
env = dict(os.environ, WAYLAND_DISPLAY=str(display), XDG_RUNTIME_DIR=str(runtime),
|
|
XDG_CONFIG_HOME=str(root / "config"), XDG_STATE_HOME=str(root / "state"))
|
|
env.pop("WAYLAND_SOCKET", None)
|
|
env.pop("FERESE_SHELL_CONTROL_SOCKET", None)
|
|
children = []
|
|
|
|
def launch(command, **kwargs):
|
|
child = subprocess.Popen(command, env=env, start_new_session=True, **kwargs)
|
|
children.append(child)
|
|
return child
|
|
|
|
def command(*args):
|
|
return json.loads(subprocess.check_output(
|
|
[str(repo / "target/debug/feresectl"), *args], env=env, timeout=5
|
|
))
|
|
|
|
def wait_for(predicate):
|
|
deadline = time.monotonic() + 10
|
|
while time.monotonic() < deadline:
|
|
result = predicate()
|
|
if result:
|
|
return result
|
|
time.sleep(.025)
|
|
self.fail("Timed out waiting for compositor state: " + (root / "compositor.log").read_text())
|
|
|
|
def focused():
|
|
result = command("get-focused-window")
|
|
return result["id"] if result else None
|
|
|
|
with (root / "compositor.log").open("w") as log:
|
|
try:
|
|
bus = launch(["dbus-daemon", "--session", "--nofork", "--print-address=1"],
|
|
stdout=subprocess.PIPE, text=True)
|
|
env["DBUS_SESSION_BUS_ADDRESS"] = bus.stdout.readline().strip()
|
|
launch([str(repo / "target/debug/ferese"), "--backend", "nested"], stdout=log, stderr=log)
|
|
wait_for(lambda: (runtime / "ferese/control.sock").is_socket())
|
|
command("focus-last-window")
|
|
self.assertIsNone(focused())
|
|
env["WAYLAND_DISPLAY"] = str(next(
|
|
path for path in runtime.glob("wayland-*") if not path.name.endswith(".lock")
|
|
))
|
|
windows = []
|
|
for index in range(3):
|
|
app = f"ferese.test.focus.{index}"
|
|
child = launch(["foot", "--app-id", app, "sleep", "120"], stdout=log, stderr=log)
|
|
window = wait_for(lambda: next((w for w in command("get-windows")
|
|
if w["app_id"] == app and w["width"] > 0), None))
|
|
wait_for(lambda: focused() == window["id"])
|
|
windows.append((child, window["id"]))
|
|
if index == 1:
|
|
command("workspace", "2")
|
|
first, second, third = [window for _, window in windows]
|
|
command("focus-last-window")
|
|
self.assertEqual(focused(), second)
|
|
self.assertEqual(next(w["name"] for w in command("get-workspaces") if w["active"]), "1")
|
|
command("focus-last-window")
|
|
self.assertEqual(focused(), third)
|
|
self.assertEqual(next(w["name"] for w in command("get-workspaces") if w["active"]), "2")
|
|
command("focus-mru-previous")
|
|
self.assertEqual(focused(), first, "reverse traversal reaches least recent window")
|
|
command("focus-mru-next")
|
|
self.assertEqual(focused(), third)
|
|
windows[1][0].terminate()
|
|
windows[1][0].wait(timeout=3)
|
|
wait_for(lambda: not any(w["id"] == second for w in command("get-windows")))
|
|
command("focus-last-window")
|
|
self.assertEqual(focused(), first, "closed windows must not consume a focus action")
|
|
command("reload-config")
|
|
command("focus-last-window")
|
|
self.assertEqual(focused(), third, "reload must preserve focus history")
|
|
finally:
|
|
for child in reversed(children):
|
|
if child.poll() is None:
|
|
os.killpg(child.pid, signal.SIGTERM)
|
|
try:
|
|
child.wait(timeout=3)
|
|
except subprocess.TimeoutExpired:
|
|
os.killpg(child.pid, signal.SIGKILL)
|
|
child.wait(timeout=3)
|
|
if child.stdout is not None:
|
|
child.stdout.close()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|