The contract bump added Monitor.id and nobody implemented it: slice B predates v2, so the integration slice had to join a client to its output through Workspace.monitor instead. Field added, parsed from `monitors -j`, and -1 when a reply omits it -- a missing id must not default to 0, which would silently bind every such client to the first output. Two tests: the id is parsed, and omitting it yields -1.
262 lines
8.9 KiB
Python
262 lines
8.9 KiB
Python
"""The request socket, against a real listener.
|
|
|
|
Every test here connects over ``AF_UNIX`` to a socket the fixture bound, so the
|
|
failures that matter — a path that is gone, a peer that refuses, a peer that
|
|
closes mid-reply, a peer that never answers — are produced rather than
|
|
simulated.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import socket
|
|
|
|
import pytest
|
|
|
|
from hhstreamd.ipc import CompositorUnavailable, CursorPos, HyprlandIPC
|
|
|
|
from conftest import HANG
|
|
|
|
|
|
@pytest.fixture
|
|
def ipc(instance):
|
|
client = HyprlandIPC(instance / ".socket.sock", instance / ".socket2.sock")
|
|
yield client
|
|
client.close()
|
|
|
|
|
|
def test_version_is_the_banner_verbatim(servers, good_handler, ipc):
|
|
request, _ = servers(good_handler)
|
|
assert ipc.version().startswith("Hyprland 0.41.2 built from branch")
|
|
assert "Tag: v0.41.2" in ipc.version()
|
|
# Text, not JSON, and the command carries a leading "/" so an argument
|
|
# containing a slash could never be read as output flags.
|
|
assert request.requests[0] == ("", "version")
|
|
|
|
|
|
def test_monitors(servers, good_handler, ipc):
|
|
request, _ = servers(good_handler)
|
|
monitors = ipc.monitors()
|
|
assert [m.name for m in monitors] == ["HEADLESS-2", "HEADLESS-3"]
|
|
# The id is what ties a client to the output it is on: `clients -j` reports
|
|
# a client's monitor as this same number, while workspaces report a name.
|
|
assert [m.id for m in monitors] == [0, 1]
|
|
first = monitors[0]
|
|
assert (first.x, first.y, first.width, first.height) == (0, 0, 1280, 720)
|
|
assert first.scale == 1.0
|
|
assert first.active_workspace_id == 1000
|
|
# The second monitor carries no activeWorkspace at all: a defined None.
|
|
assert monitors[1].active_workspace_id is None
|
|
assert monitors[1].scale == 1.5
|
|
assert request.requests == [("j", "monitors")]
|
|
|
|
|
|
def test_monitors_without_an_id_is_minus_one(servers, ipc):
|
|
"""A reply that omits the id must not join to a real output.
|
|
|
|
`Monitor.id` is the join key for a client's output, so a missing id has to be
|
|
a value no compositor can use -- `-1` -- rather than a plausible-looking `0`
|
|
that would silently bind every such client to the first output.
|
|
"""
|
|
|
|
def handler(flags, command):
|
|
return ('[{"name": "HEADLESS-9", "x": 0, "y": 0, "width": 100, '
|
|
'"height": 50, "scale": 1.0}]')
|
|
|
|
servers(handler)
|
|
monitors = ipc.monitors()
|
|
assert [m.id for m in monitors] == [-1]
|
|
assert monitors[0].name == "HEADLESS-9"
|
|
|
|
|
|
def test_workspaces(servers, good_handler, ipc):
|
|
servers(good_handler)
|
|
workspaces = ipc.workspaces()
|
|
assert [w.id for w in workspaces] == [1000, -99]
|
|
assert workspaces[0].monitor == "HEADLESS-2"
|
|
assert workspaces[0].windows == 1
|
|
assert workspaces[0].is_special is False
|
|
# No "special" key in this reply: the negative id and the name prefix are
|
|
# what every Hyprland has agreed on.
|
|
assert workspaces[1].is_special is True
|
|
|
|
|
|
def test_clients(servers, good_handler, ipc):
|
|
request, _ = servers(good_handler)
|
|
clients = ipc.clients()
|
|
assert len(clients) == 2
|
|
foot, chromium = clients
|
|
assert foot.address == "0x5d3d1c0"
|
|
assert foot.pid == 4242
|
|
assert foot.workspace_id == 1000
|
|
assert foot.class_ == "foot"
|
|
assert foot.initial_class == "hh-foot-v7r4li"
|
|
# A title with commas in it survives whole; the broker shows this to a user.
|
|
assert foot.title == "hermes: ~, build, and notes"
|
|
assert foot.stable_id == "hh-foot-v7r4li:4242"
|
|
assert foot.visible is True
|
|
# clients -j reports the monitor as an index, not a name; the field is text
|
|
# so that None keeps its one meaning of "the reply said nothing".
|
|
assert foot.monitor == "0"
|
|
|
|
assert chromium.visible is False
|
|
assert chromium.monitor is None
|
|
assert chromium.workspace_id is None
|
|
assert chromium.stable_id == "0x5d4aa10"
|
|
assert request.requests == [("j", "clients")]
|
|
|
|
|
|
def test_cursorpos(servers, good_handler, ipc):
|
|
servers(good_handler)
|
|
assert ipc.cursorpos() == CursorPos(x=640, y=360)
|
|
|
|
|
|
def test_query_passes_a_command_through_untouched(servers, ipc):
|
|
seen = []
|
|
|
|
def handler(flags, command):
|
|
seen.append((flags, command))
|
|
return "ok"
|
|
|
|
servers(handler)
|
|
assert ipc.query("dispatch exec /usr/bin/true") == "ok"
|
|
# The slash in the argument must not be read as a flag separator.
|
|
assert seen == [("", "dispatch exec /usr/bin/true")]
|
|
|
|
|
|
def test_query_keeps_an_explicit_flag_prefix(servers, ipc):
|
|
seen = []
|
|
|
|
def handler(flags, command):
|
|
seen.append((flags, command))
|
|
return "[]"
|
|
|
|
servers(handler)
|
|
assert ipc.query("j/devices") == "[]"
|
|
assert seen == [("j", "devices")]
|
|
|
|
|
|
def test_an_empty_request_is_refused_before_connecting(ipc):
|
|
with pytest.raises(CompositorUnavailable, match="empty request"):
|
|
ipc.query(" ")
|
|
|
|
|
|
@pytest.mark.parametrize("method", ["monitors", "workspaces", "clients", "cursorpos"])
|
|
def test_plain_text_where_json_was_promised(servers, ipc, method):
|
|
"""What Hyprland answers for a command it does not know."""
|
|
|
|
servers(lambda flags, command: "unknown request")
|
|
with pytest.raises(CompositorUnavailable, match="not JSON"):
|
|
getattr(ipc, method)()
|
|
|
|
|
|
def test_a_json_object_where_a_list_belongs(servers, ipc):
|
|
servers(lambda flags, command: '{"monitors": []}')
|
|
with pytest.raises(CompositorUnavailable, match="expected a JSON list"):
|
|
ipc.monitors()
|
|
|
|
|
|
def test_a_list_of_scalars(servers, ipc):
|
|
servers(lambda flags, command: '["HEADLESS-2"]')
|
|
with pytest.raises(CompositorUnavailable, match="expected objects"):
|
|
ipc.monitors()
|
|
|
|
|
|
def test_a_client_without_an_address_is_malformed(servers, ipc):
|
|
"""The one key whose absence makes the record meaningless."""
|
|
|
|
servers(lambda flags, command: '[{"class": "foot", "pid": 1}]')
|
|
with pytest.raises(CompositorUnavailable, match="no address"):
|
|
ipc.clients()
|
|
|
|
|
|
def test_a_monitor_without_a_name_is_malformed(servers, ipc):
|
|
servers(lambda flags, command: '[{"width": 1280}]')
|
|
with pytest.raises(CompositorUnavailable, match="no name"):
|
|
ipc.monitors()
|
|
|
|
|
|
def test_a_workspace_without_an_id_is_malformed(servers, ipc):
|
|
servers(lambda flags, command: '[{"name": "1000"}]')
|
|
with pytest.raises(CompositorUnavailable, match="no id"):
|
|
ipc.workspaces()
|
|
|
|
|
|
def test_missing_keys_degrade_rather_than_raise_keyerror(servers, ipc):
|
|
"""A reply from a Hyprland that reports less than this one expects."""
|
|
|
|
servers(lambda flags, command: '[{"address": "0x1"}]')
|
|
(client,) = ipc.clients()
|
|
assert client.pid == -1
|
|
assert client.workspace_id is None
|
|
assert client.monitor is None
|
|
assert (client.class_, client.initial_class, client.title) == ("", "", "")
|
|
assert client.stable_id == "0x1"
|
|
# Nothing said it was unmapped, so it is not reported as gone.
|
|
assert client.visible is True
|
|
|
|
|
|
def test_cursorpos_without_coordinates(servers, ipc):
|
|
servers(lambda flags, command: '{"ok": true}')
|
|
with pytest.raises(CompositorUnavailable, match="x and y"):
|
|
ipc.cursorpos()
|
|
|
|
|
|
def test_cursorpos_with_non_numeric_coordinates(servers, ipc):
|
|
servers(lambda flags, command: '{"x": "left", "y": null}')
|
|
with pytest.raises(CompositorUnavailable, match="not numbers"):
|
|
ipc.cursorpos()
|
|
|
|
|
|
def test_connection_closed_mid_reply(servers, ipc):
|
|
"""The compositor dies while writing: a truncated reply, never a guess."""
|
|
|
|
servers(lambda flags, command: '[{"address": "0x5d3d1c0", "pid": 4242, "cla')
|
|
with pytest.raises(CompositorUnavailable, match="not JSON"):
|
|
ipc.clients()
|
|
|
|
|
|
def test_connection_closed_with_no_reply_at_all(servers, ipc):
|
|
servers(lambda flags, command: None)
|
|
with pytest.raises(CompositorUnavailable, match="empty reply"):
|
|
ipc.workspaces()
|
|
with pytest.raises(CompositorUnavailable, match="empty reply"):
|
|
ipc.version()
|
|
|
|
|
|
def test_missing_socket(instance):
|
|
ipc = HyprlandIPC(instance / ".socket.sock")
|
|
with pytest.raises(CompositorUnavailable) as caught:
|
|
ipc.clients()
|
|
assert str(instance / ".socket.sock") in str(caught.value)
|
|
|
|
|
|
def test_nothing_listening(instance, ipc):
|
|
"""A socket left behind by a compositor that is gone: ECONNREFUSED."""
|
|
|
|
stale = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
|
|
stale.bind(str(instance / ".socket.sock"))
|
|
try:
|
|
with pytest.raises(CompositorUnavailable, match="request socket"):
|
|
ipc.monitors()
|
|
finally:
|
|
stale.close()
|
|
|
|
|
|
def test_a_compositor_that_never_answers(servers, ipc):
|
|
"""Accepted, then silence: the read timeout, exercised for real."""
|
|
|
|
servers(lambda flags, command: HANG)
|
|
ipc.request_timeout_s = 0.3
|
|
with pytest.raises(CompositorUnavailable, match="did not answer"):
|
|
ipc.clients()
|
|
|
|
|
|
def test_each_request_is_its_own_connection(servers, good_handler, ipc):
|
|
"""What hyprctl does, and what the compositor expects: no session state."""
|
|
|
|
request, _ = servers(good_handler)
|
|
ipc.monitors()
|
|
ipc.clients()
|
|
ipc.clients()
|
|
assert request.requests == [("j", "monitors"), ("j", "clients"), ("j", "clients")]
|