One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
import os
import subprocess
import sys
import unittest
from pathlib import Path
from types import SimpleNamespace
from unittest import mock
sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
import desktop_x11
from core.return_edge import Rect
WIN_APP = Path(__file__).resolve().parent.parent
class FakeXError(Exception):
pass
class FakeClosed(Exception):
pass
class FakeProperty:
def __init__(self, value):
self.value = value
class FakeWindow:
def __init__(self, wid, state=(), wm_class=("kate", "Kate"), error=None):
self.wid, self.state, self.wm_class, self.error = wid, state, wm_class, error
def get_full_property(self, atom, kind):
if self.error:
raise self.error
return FakeProperty(list(self.state)) if self.state is not None else None
def get_wm_class(self):
if self.error:
raise self.error
return self.wm_class
class FakeRoot:
def __init__(self, display):
self.display = display
self.pointer = SimpleNamespace(root_x=0, root_y=0, mask=0)
self.geometry = SimpleNamespace(width=1600, height=900)
self.monitor_list = []
self.monitor_error = None
self.warps = []
self.active = None
self.calls = []
def xrandr_get_monitors(self, is_active=True):
self.calls.append(("xrandr_get_monitors", is_active))
if self.monitor_error:
raise self.monitor_error
return SimpleNamespace(monitors=self.monitor_list)
def get_geometry(self):
return self.geometry
def query_pointer(self):
if self.display.dead:
raise FakeClosed()
return self.pointer
def warp_pointer(self, x, y):
self.warps.append((x, y))
def get_full_property(self, atom, kind):
assert atom == self.display.intern_atom("_NET_ACTIVE_WINDOW")
return None if self.active is None else FakeProperty([self.active])
class FakeDisplay:
ATOMS = {"_NET_ACTIVE_WINDOW": 11, "_NET_WM_STATE": 12, "_NET_WM_STATE_FULLSCREEN": 13, "_NET_WM_STATE_ABOVE": 14}
def __init__(self, randr=(1, 5)):
self.randr = randr
self.root = FakeRoot(self)
self.windows = {}
self.flushes = 0
self.closed = False
self.dead = False
def has_extension(self, name):
return name == "RANDR" and self.randr is not None
def xrandr_query_version(self):
return SimpleNamespace(major_version=self.randr[0], minor_version=self.randr[1])
def intern_atom(self, name):
return self.ATOMS[name]
def create_resource_object(self, kind, wid):
assert kind == "window"
return self.windows[wid]
def flush(self):
self.flushes += 1
def close(self):
self.closed = True
def connection(display):
return SimpleNamespace(display=display, root=display.root, x_error=FakeXError, closed=(FakeClosed, OSError))
class DesktopX11Test(unittest.TestCase):
def setUp(self):
self.display = FakeDisplay()
self.root = self.display.root
self.connects = mock.Mock(side_effect=lambda: connection(self.display))
patch = mock.patch.object(desktop_x11, "_connect", self.connects)
patch.start()
self.addCleanup(patch.stop)
desktop_x11._reset()
self.addCleanup(desktop_x11._reset)
def two_monitors(self):
self.root.monitor_list = [
SimpleNamespace(x=-1280, y=100, width_in_pixels=1280, height_in_pixels=1024),
SimpleNamespace(x=0, y=0, width_in_pixels=1920, height_in_pixels=1080),
]
def test_monitors_from_randr_one_five(self):
self.two_monitors()
self.assertEqual(desktop_x11.monitors(), [Rect(-1280, 100, 1280, 1024), Rect(0, 0, 1920, 1080)])
self.assertEqual(self.root.calls, [("xrandr_get_monitors", True)])
def test_monitors_falls_back_to_the_root_without_randr(self):
self.display.randr = None
self.two_monitors()
self.assertEqual(desktop_x11.monitors(), [Rect(0, 0, 1600, 900)])
self.assertEqual(self.root.calls, [])
def test_monitors_falls_back_to_the_root_on_randr_one_four(self):
self.display.randr = (1, 4)
self.two_monitors()
self.assertEqual(desktop_x11.monitors(), [Rect(0, 0, 1600, 900)])
self.assertEqual(self.root.calls, [])
def test_monitors_accepts_a_later_major_version(self):
self.display.randr = (2, 0)
self.two_monitors()
self.assertEqual(len(desktop_x11.monitors()), 2)
def test_monitors_falls_back_to_the_root_when_the_request_fails(self):
self.root.monitor_error = FakeXError()
self.assertEqual(desktop_x11.monitors(), [Rect(0, 0, 1600, 900)])
def test_monitors_falls_back_to_the_root_when_randr_lists_none(self):
self.assertEqual(desktop_x11.monitors(), [Rect(0, 0, 1600, 900)])
def test_cursor_position(self):
self.root.pointer = SimpleNamespace(root_x=-40, root_y=612, mask=0)
self.assertEqual(desktop_x11.cursor_position(), (-40, 612))
def test_set_cursor_position_warps_with_ints_and_flushes_once(self):
desktop_x11.set_cursor_position(321.0, 123.9)
self.assertEqual(self.root.warps, [(321, 123)])
for value in self.root.warps[0]:
self.assertIs(type(value), int)
self.assertEqual(self.display.flushes, 1)
def test_button_down_reads_the_pointer_mask(self):
cases = {"left": 1 << 8, "middle": 1 << 9, "right": 1 << 10}
for name, bit in cases.items():
for other in cases:
with self.subTest(name=name, mask=other):
self.root.pointer = SimpleNamespace(root_x=0, root_y=0, mask=cases[other] | 1)
self.assertEqual(desktop_x11.button_down(name), other == name)
self.root.pointer = SimpleNamespace(root_x=0, root_y=0, mask=0)
self.assertFalse(desktop_x11.button_down(name))
def test_button_down_is_false_for_back_forward_and_unknown(self):
self.root.pointer = SimpleNamespace(root_x=0, root_y=0, mask=0x1F00)
for name in ("back", "forward", "wheel", ""):
with self.subTest(name=name):
self.assertFalse(desktop_x11.button_down(name))
def fullscreen(self, **kwargs):
window = FakeWindow(77, state=kwargs.pop("state", (13,)), **kwargs)
self.display.windows[77] = window
self.root.active = 77
return window
def test_full_screen_app_names_the_window_class(self):
self.fullscreen()
self.assertEqual(desktop_x11.full_screen_app(), "Kate")
def test_full_screen_app_is_none_when_not_full_screen(self):
self.fullscreen(state=(14,))
self.assertIsNone(desktop_x11.full_screen_app())
def test_full_screen_app_is_none_without_a_state_property(self):
self.fullscreen(state=None)
self.assertIsNone(desktop_x11.full_screen_app())
def test_full_screen_app_is_none_without_an_active_window(self):
self.assertIsNone(desktop_x11.full_screen_app())
self.root.active = 0
self.assertIsNone(desktop_x11.full_screen_app())
def test_full_screen_app_without_a_wm_class_is_an_app(self):
self.fullscreen(wm_class=None)
self.assertEqual(desktop_x11.full_screen_app(), "An app")
self.fullscreen(wm_class=("kate", ""))
self.assertEqual(desktop_x11.full_screen_app(), "An app")
def test_full_screen_app_is_none_when_the_window_vanishes(self):
self.fullscreen(error=FakeXError())
self.assertIsNone(desktop_x11.full_screen_app())
def test_one_connection_is_shared_across_calls(self):
desktop_x11.cursor_position()
desktop_x11.button_down("left")
desktop_x11.set_cursor_position(1, 2)
self.assertEqual(self.connects.call_count, 1)
def test_a_dropped_connection_reconnects_on_the_next_call(self):
first = self.display
desktop_x11.cursor_position()
first.dead = True
with self.assertRaises(FakeClosed):
desktop_x11.cursor_position()
self.assertTrue(first.closed)
self.display = FakeDisplay()
self.display.root.pointer = SimpleNamespace(root_x=5, root_y=6, mask=0)
self.assertEqual(desktop_x11.cursor_position(), (5, 6))
self.assertEqual(self.connects.call_count, 2)
def test_an_oserror_also_drops_the_connection(self):
desktop_x11.cursor_position()
with mock.patch.object(self.root, "query_pointer", side_effect=BrokenPipeError()):
with self.assertRaises(OSError):
desktop_x11.cursor_position()
desktop_x11.cursor_position()
self.assertEqual(self.connects.call_count, 2)
def test_an_x_error_keeps_the_connection(self):
with mock.patch.object(self.root, "query_pointer", side_effect=FakeXError()):
with self.assertRaises(FakeXError):
desktop_x11.cursor_position()
desktop_x11.cursor_position()
self.assertEqual(self.connects.call_count, 1)
def test_a_failed_connect_is_retried(self):
self.connects.side_effect = [OSError("no display"), connection(self.display)]
with self.assertRaises(OSError):
desktop_x11.cursor_position()
desktop_x11.cursor_position()
self.assertEqual(self.connects.call_count, 2)
class ImportTest(unittest.TestCase):
def test_imports_without_loading_xlib(self):
code = (
"import sys; sys.path.append('..'); import desktop_x11; "
"sys.exit(1 if any(m == 'Xlib' or m.startswith('Xlib.') for m in sys.modules) else 0)"
)
done = subprocess.run([sys.executable, "-c", code], cwd=WIN_APP, capture_output=True, text=True)
self.assertEqual(done.returncode, 0, done.stderr)
if __name__ == "__main__":
unittest.main()