Skip to content

One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.

16.5 KB
Raw Blame
import os
import sys
import unittest
from types import SimpleNamespace

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

import pages_win
import capture_portal
import inject_portal
import portal
from portal_fakes import FakeBus, FakeEi, vardict, wait_for
from core.tests.app_methods import load_methods
from PySide6.QtWidgets import QApplication, QHBoxLayout, QVBoxLayout, QWidget
import widgets


class MemoryTokens:
    def read(self):
        return ""

    def write(self, _token):
        pass


class LinuxPermissionsTest(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.app = QApplication.instance() or QApplication([])

    def test_card_is_only_visible_on_linux_wayland(self):
        visible = pages_win.linux_permissions_visible
        self.assertTrue(visible("linux", True))
        self.assertFalse(visible("linux", False))
        self.assertFalse(visible("win32", True))
        self.assertFalse(visible("darwin", True))

    def test_portal_reports_each_row_state(self):
        state = pages_win.LinuxPermissionState()
        self.assertEqual(state.status("capture"), ("not_requested", ""))
        self.assertEqual(state.status("remote"), ("not_requested", ""))

        state.report("capture", "ready")
        state.report("remote", "refused", "The desktop refused remote control.")
        self.assertEqual(state.status("capture"), ("ready", ""))
        self.assertEqual(state.status("remote"), ("refused", "The desktop refused remote control."))

        state.report("capture", "unavailable", "InputCapture is missing.")
        self.assertEqual(state.status("capture"), ("unavailable", "InputCapture is missing."))

        state.report("remote", "unavailable", "The session closed.", retryable=True)
        self.assertTrue(state.can_ask_again("remote"))

    def test_ask_again_resets_the_row_and_starts_a_fresh_request(self):
        requests = []
        state = pages_win.LinuxPermissionState()
        for direction in ("capture", "remote"):
            state.bind_requester(direction, lambda key=direction: requests.append(key))
            state.report(direction, "refused", "The desktop refused the request.")
            self.assertTrue(state.ask_again(direction))
            self.assertEqual(state.status(direction), ("not_requested", ""))
        self.assertEqual(requests, ["capture", "remote"])

    def test_input_capture_requires_both_granted_capabilities(self):
        for version in (1, 2):
            with self.subTest(version=version):
                bus = FakeBus(versions={capture_portal.INTERFACE: version})
                if version == 2:
                    bus.returns["CreateSession2"] = (vardict({"session_handle": "/session/1"}),)
                    bus.answers["Start"] = (0, {"capabilities": capture_portal.CAP_KEYBOARD})
                else:
                    bus.answers["CreateSession"] = (0, {
                        "session_handle": "/session/1", "capabilities": capture_portal.CAP_KEYBOARD,
                    })
                bus.returns["ConnectToEIS"] = (99,)
                session = capture_portal._Session(lambda: bus, lambda _fd: object(), MemoryTokens(), lambda: False)
                session.check()

                with self.assertRaises(capture_portal.CaptureUnavailable):
                    session.open()

                self.assertEqual(bus.made("ConnectToEIS"), [])

    @unittest.skipIf(sys.platform == "win32", "the Wayland back ends select on pipes, which Windows cannot; they run only on Linux")
    def test_remote_desktop_refuses_partial_device_grants(self):
        state = pages_win.LinuxPermissionState()
        bus = FakeBus(versions={inject_portal.INTERFACE: 2, inject_portal.CLIPBOARD: 1})
        bus.answers["CreateSession"] = (0, {"session_handle": "/session/1"})
        bus.answers["Start"] = (0, {"devices": inject_portal.DEVICE_KEYBOARD})
        bus.returns["ConnectToEIS"] = (99,)
        remote = inject_portal.Remote(connect=lambda: bus, ei=lambda _fd: FakeEi(), tokens=MemoryTokens())
        inject_portal.on_permission = lambda status, detail, retryable=False: state.report(
            "remote", status, detail, retryable,
        )
        try:
            remote.start()
            wait_for(lambda: state.status("remote")[0] != "not_requested", what="the permission state")
            self.assertEqual(state.status("remote")[0], "refused")
            self.assertTrue(state.can_ask_again("remote"))
            self.assertEqual(bus.made("ConnectToEIS"), [])
        finally:
            remote.stop()
            inject_portal.on_permission = None

    @unittest.skipIf(sys.platform == "win32", "the Wayland back ends select on pipes, which Windows cannot; they run only on Linux")
    def test_capture_partial_grant_is_refused_and_retryable(self):
        state = pages_win.LinuxPermissionState()
        bus = FakeBus(versions={capture_portal.INTERFACE: 2})
        bus.returns["CreateSession2"] = (vardict({"session_handle": "/session/1"}),)
        bus.answers["Start"] = (0, {"capabilities": capture_portal.CAP_KEYBOARD})
        hooks = capture_portal.Hooks(lambda *_args: False, lambda *_args: False, lambda *_args: None,
                                     connect=lambda: bus, ei=lambda _fd: FakeEi(), tokens=MemoryTokens())
        hooks.on_permission = lambda status, detail, retryable=False: state.report(
            "capture", status, detail, retryable,
        )
        try:
            hooks.start()
            wait_for(lambda: state.status("capture")[0] != "not_requested", what="the partial InputCapture grant")
            self.assertEqual(state.status("capture")[0], "refused")
            self.assertTrue(state.can_ask_again("capture"))
        finally:
            hooks.stop()

    @unittest.skipIf(sys.platform == "win32", "the Wayland back ends select on pipes, which Windows cannot; they run only on Linux")
    def test_remote_ask_again_opens_a_fresh_portal_request(self):
        state = pages_win.LinuxPermissionState()
        buses = []
        def connect():
            bus = FakeBus(versions={inject_portal.INTERFACE: 2, inject_portal.CLIPBOARD: 1})
            bus.answers["CreateSession"] = (0, {"session_handle": f"/session/{len(buses) + 1}"})
            bus.answers["Start"] = (1, {}) if not buses else (
                0, {"devices": inject_portal.DEVICE_KEYBOARD | inject_portal.DEVICE_POINTER},
            )
            bus.returns["ConnectToEIS"] = (99,)
            buses.append(bus)
            return bus
        remote = inject_portal.Remote(connect=connect, ei=lambda _fd: FakeEi(), tokens=MemoryTokens())
        inject_portal.on_permission = lambda status, detail, retryable=False: state.report(
            "remote", status, detail, retryable,
        )
        state.bind_requester("remote", remote.request_again)
        try:
            remote.start()
            wait_for(lambda: state.status("remote")[0] == "refused", what="the permission refusal")
            self.assertTrue(state.ask_again("remote"))
            wait_for(lambda: state.status("remote")[0] == "ready", what="the fresh RemoteDesktop request")
            self.assertEqual([len(bus.made("Start")) for bus in buses], [1, 1])
        finally:
            remote.stop()
            inject_portal.on_permission = None

    @unittest.skipIf(sys.platform == "win32", "the Wayland back ends select on pipes, which Windows cannot; they run only on Linux")
    def test_capture_ask_again_opens_a_fresh_portal_request(self):
        state = pages_win.LinuxPermissionState()
        buses = []
        def connect():
            bus = FakeBus(versions={capture_portal.INTERFACE: 2})
            bus.returns["CreateSession2"] = (vardict({"session_handle": f"/session/{len(buses) + 1}"}),)
            bus.answers["Start"] = (1, {}) if not buses else (
                0, {"capabilities": capture_portal.CAP_KEYBOARD | capture_portal.CAP_POINTER},
            )
            bus.returns["ConnectToEIS"] = (99,)
            bus.answers["GetZones"] = (0, {"zones": []})
            buses.append(bus)
            return bus
        hooks = capture_portal.Hooks(lambda *_args: False, lambda *_args: False, lambda *_args: None,
                                     connect=connect, ei=lambda _fd: FakeEi(), tokens=MemoryTokens())
        hooks.on_permission = lambda status, detail, retryable=False: state.report(
            "capture", status, detail, retryable,
        )
        state.bind_requester("capture", hooks.request_again)
        try:
            hooks.start()
            wait_for(lambda: state.status("capture")[0] == "refused", what="the capture refusal")
            self.assertEqual(state.status("capture")[0], "refused")
            self.assertTrue(state.ask_again("capture"))
            wait_for(lambda: state.status("capture")[0] == "ready", what="the fresh InputCapture request")
            self.assertEqual([len(bus.made("Start")) for bus in buses], [1, 1])
        finally:
            hooks.stop()

    def test_permissions_widget_shows_states_and_retry_visibility(self):
        surface = self.permissions_surface("linux", True)
        surface._overview_page(QVBoxLayout(), None)
        module = surface.permissions_module
        self.assertIsNotNone(surface.permissions_module)
        for direction in ("capture", "remote"):
            status, detail, retry = surface.permission_rows[direction]
            self.assertEqual(status.text(), "Not requested")
            self.assertTrue(retry.isHidden())
            surface.permission_state.report(direction, "refused", "Access was refused.")
            self.assertEqual(status.text(), "Refused")
            self.assertEqual(detail.text(), "Access was refused.")
            self.assertFalse(retry.isHidden())
            surface.permission_state.report(direction, "unavailable", "Portal is unavailable.")
            self.assertEqual(status.text(), "Unavailable")
            self.assertTrue(retry.isHidden())
            surface.permission_state.report(direction, "unavailable", "Session closed.", retryable=True)
            self.assertFalse(retry.isHidden())
            surface.permission_state.report(direction, "ready")
            self.assertEqual(status.text(), "Ready")
            self.assertTrue(retry.isHidden())
            requests = []
            surface.permission_state.bind_requester(direction, lambda: requests.append(direction))
            surface.permission_state.report(direction, "refused", "Access was refused.")
            retry.click()
            self.assertEqual(requests, [direction])
            self.assertEqual(status.text(), "Not requested")
        module.deleteLater()

    def test_overview_omits_permissions_card_on_x11_and_windows(self):
        for platform_name, wayland in (("linux", False), ("win32", True)):
            surface = self.permissions_surface(platform_name, wayland)
            layout = QVBoxLayout()
            surface._overview_page(layout, None)
            self.assertIsNone(surface.permissions_module)

    def permissions_surface(self, platform_name, wayland):
        namespace = {
            "pages_win": pages_win,
            "widgets": widgets,
            "QVBoxLayout": QVBoxLayout,
            "QHBoxLayout": QHBoxLayout,
            "QPushButton": widgets.ActionButton,
            "QWidget": QWidget,
            "sys": SimpleNamespace(platform=platform_name),
            "platform_parts": SimpleNamespace(WAYLAND=wayland),
            "machines_win": SimpleNamespace(MachinesModule=lambda *_args, **_kwargs: QWidget(),
                                             PairingSheet=lambda *_args: QWidget()),
        }
        methods = ["_overview_page", "_permissions_module", "_on_permission", "_ask_permission_again"]
        klass = load_methods("win_app/kvm_bridge_win.py", "WindowsApplication", methods, namespace)
        surface = klass()
        surface.permission_state = pages_win.LinuxPermissionState() if pages_win.linux_permissions_visible(
            platform_name, wayland,
        ) else None
        if surface.permission_state is not None:
            surface.permission_state.on_change = surface._on_permission
        surface._set_peer_send = surface._set_peer_allow = surface._set_peer_in_use = lambda *_args: None
        surface._set_peer_pin = lambda *_args: None
        surface._set_shortcut_cycle = lambda *_args: None
        surface._re_pair = lambda *_args: None
        surface._set_peer_left_out = surface._rename_peer = lambda *_args: None
        surface._remove_peer = surface._toggle_pairing_sheet = lambda *_args: None
        surface._show_code = surface._cancel_code = surface._pair_clicked = surface._pick_machine = lambda *_args: None
        surface._pair_phone = surface._start_nearby = surface._choose_nearby = lambda *_args: None
        surface._confirm_nearby = surface._cancel_nearby = lambda *_args: None
        surface._link_module = surface._input_module = surface._same_module = surface._name_module = lambda *_args: QWidget()
        surface._sign_in_module = surface._tray_module = surface._updates_module = lambda *_args: QWidget()
        surface._refresh_peers = lambda: None
        return surface

    def test_refusal_during_select_devices_is_retryable(self):
        state = pages_win.LinuxPermissionState()
        bus = FakeBus(versions={inject_portal.INTERFACE: 2, inject_portal.CLIPBOARD: 1})
        bus.answers["CreateSession"] = (0, {"session_handle": "/session/1"})
        bus.answers["SelectDevices"] = (1, {})
        remote = inject_portal.Remote(connect=lambda: bus, ei=lambda _fd: FakeEi(), tokens=MemoryTokens())
        inject_portal.on_permission = lambda status, detail, retryable=False: state.report(
            "remote", status, detail, retryable,
        )
        try:
            remote.start()
            wait_for(lambda: state.status("remote")[0] != "not_requested", what="the permission refusal")
            self.assertEqual(state.status("remote")[0], "refused")
            self.assertTrue(state.can_ask_again("remote"))
        finally:
            remote.stop()
            inject_portal.on_permission = None

    @unittest.skipIf(sys.platform == "win32", "the Wayland back ends select on pipes, which Windows cannot; they run only on Linux")
    def test_remote_desktop_closed_signal_can_be_asked_again(self):
        state = pages_win.LinuxPermissionState()
        bus = FakeBus(versions={inject_portal.INTERFACE: 2, inject_portal.CLIPBOARD: 1})
        bus.answers["CreateSession"] = (0, {"session_handle": "/session/1"})
        bus.answers["Start"] = (0, {"devices": inject_portal.DEVICE_KEYBOARD | inject_portal.DEVICE_POINTER})
        bus.returns["ConnectToEIS"] = (99,)
        remote = inject_portal.Remote(connect=lambda: bus, ei=lambda _fd: FakeEi(), tokens=MemoryTokens())
        inject_portal.on_permission = lambda status, detail, retryable=False: state.report(
            "remote", status, detail, retryable,
        )
        try:
            remote.start()
            wait_for(remote.ready.is_set, what="RemoteDesktop readiness")
            bus.emit("/session/1", portal.SESSION, "Closed", ())
            wait_for(lambda: state.status("remote")[0] == "unavailable", what="the closed session")
            self.assertTrue(state.can_ask_again("remote"))
        finally:
            remote.stop()
            inject_portal.on_permission = None

    @unittest.skipIf(sys.platform == "win32", "the Wayland back ends select on pipes, which Windows cannot; they run only on Linux")
    def test_input_capture_closed_signal_can_be_asked_again(self):
        state = pages_win.LinuxPermissionState()
        bus = FakeBus(versions={capture_portal.INTERFACE: 2})
        bus.returns["CreateSession2"] = (vardict({"session_handle": "/session/1"}),)
        bus.returns["ConnectToEIS"] = (99,)
        bus.answers["Start"] = (0, {"capabilities": capture_portal.CAP_KEYBOARD | capture_portal.CAP_POINTER})
        bus.answers["GetZones"] = (0, {"zones": []})
        hooks = capture_portal.Hooks(lambda *_args: False, lambda *_args: False, lambda *_args: None,
                                     connect=lambda: bus, ei=lambda _fd: FakeEi(), tokens=MemoryTokens())
        hooks.on_permission = lambda status, detail, retryable=False: state.report(
            "capture", status, detail, retryable,
        )
        try:
            hooks.start()
            wait_for(lambda: state.status("capture")[0] == "ready", what="InputCapture readiness")
            bus.emit("/session/1", portal.SESSION, "Closed", ())
            wait_for(lambda: state.status("capture")[0] == "unavailable", what="the closed session")
            self.assertTrue(state.can_ask_again("capture"))
        finally:
            hooks.stop()


if __name__ == "__main__":
    unittest.main()