Skip to content

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

11.3 KB
Raw Blame
"""Sender-only phone decisions without creating a window or installing input hooks."""

import sys
import unittest
from contextlib import nullcontext
from pathlib import Path
from types import SimpleNamespace
from typing import Optional

sys.path.append(str(Path(__file__).resolve().parents[2]))
sys.path.append(str(Path(__file__).resolve().parents[1]))

from core import peerlist, protocol, settings_sync
from core.tests.app_methods import load_methods
import pages_win
import peers_view
import sender

PHONE = protocol.id_text(bytes(range(16)))
DESKTOP = protocol.id_text(bytes(range(16, 32)))


def entries():
    return [dict(id=PHONE, token=protocol.id_text(bytes(range(32))), name="My phone", platform="ios", port=0,
                 send=True, allow_drive=True, in_use=True),
            dict(id=DESKTOP, token=protocol.id_text(bytes(range(32, 64))), name="Desktop", platform="windows", port=24820,
                 send=True, allow_drive=True, in_use=True)]


def application(*methods, **extra):
    namespace = dict(Optional=Optional, Config=SimpleNamespace, peerlist=peerlist,
                     protocol=protocol, settings_sync=settings_sync, pages_win=pages_win,
                     platform_parts=SimpleNamespace(WAYLAND=False),
                     Qt=SimpleNamespace(ItemDataRole=SimpleNamespace(UserRole=1)), **extra)
    namespace["TRIGGER_KEYS"] = ()
    return load_methods("win_app/kvm_bridge_win.py", "WindowsApplication", methods, namespace)()


class Control:
    def __init__(self, text=""):
        self.value = text
        self.checked = False
        self.visible = True
        self.enabled = True

    def text(self): return self.value
    def setText(self, text): self.value = text
    def isChecked(self): return self.checked
    def setChecked(self, value): self.checked = value
    def blockSignals(self, value): pass
    def setVisible(self, value): self.visible = value
    def setEnabled(self, value): self.enabled = value
    def setToolTip(self, value): self.tooltip = value
    def setAccessibleName(self, value): self.accessible = value
    def isVisibleTo(self, parent): return self.visible


class PhoneUiTests(unittest.TestCase):
    def test_phone_is_never_woken_even_with_stale_hardware(self):
        attempts = []
        threads = SimpleNamespace(Thread=lambda **fields: SimpleNamespace(start=lambda: attempts.append(fields)))
        link = load_methods("win_app/sender.py", "LinkSender", ["wake"],
                            dict(Optional=Optional, threading=threads))()
        peer = protocol.read_id(PHONE)
        link._peers = {peer: dict(entries()[0], hw="aa:bb:cc:dd:ee:ff")}
        link.links = SimpleNamespace(up=lambda peer: False, refused=lambda peer: False)
        link._wake_lock, link._waking = nullcontext(), set()
        link._wake_worker = lambda *args: None
        self.assertFalse(link.wake(peer))
        self.assertEqual(attempts, [])

    def test_phone_never_learns_hardware_even_with_a_stale_host(self):
        looked_up = []
        link = load_methods("win_app/sender.py", "LinkSender", ["_learn_hardware"], {})()
        peer = protocol.read_id(PHONE)
        link._peers = {peer: dict(entries()[0], host="192.0.2.1", hw="")}
        link._mac_lookup = lambda host: looked_up.append(host) or ""
        link._learn_hardware(peer)
        self.assertEqual(looked_up, [])

    def test_phone_is_never_dialled_even_with_a_saved_host(self):
        made = []
        class Link:
            def __init__(self, token, *args, **kwargs): made.append(token)
        links = sender.LinkSet(SimpleNamespace(_hardware=None, _book=None, _identity=None),
                               is_local=lambda host: False, link_class=Link)
        peers = entries()
        peers[0]["host"] = "192.0.2.1"
        peers[1]["host"] = "192.0.2.2"
        links.sync(peers)
        self.assertEqual(made, [peers[1]["token"]])

    def test_crossing_choice_and_settings_exclude_phone_even_with_stale_zone(self):
        app = application("_crossing_machines", "_crossing_settings")
        app._peer_entries = entries()
        app._zone_entries = [dict(peer=PHONE), dict(peer=DESKTOP)]
        app._config = SimpleNamespace(machine_id="own", layout={}, layout_set_at=0, layout_by="")
        app._shown = lambda text: text
        self.assertEqual(app._crossing_machines(), [(DESKTOP, "Desktop")])
        self.assertEqual(app._crossing_settings()["peers"], [entries()[1]])
        self.assertEqual(app._crossing_settings()["zones"], [dict(peer=DESKTOP)])

    def test_same_and_match_capabilities_ignore_phone_advertisements(self):
        app = application("_peer_caps", "_design_peer_caps")
        phone, desktop = protocol.read_id(PHONE), protocol.read_id(DESKTOP)
        app._peer_entries = entries()
        app.sender = SimpleNamespace(peers_up=lambda: [phone, desktop],
                                     links=SimpleNamespace(caps=lambda peer: {"settings", "design_sync"}))
        app.server = SimpleNamespace(links=lambda: [phone, desktop], caps_of=lambda peer: {"settings", "design_sync"})
        self.assertEqual(set(app._peer_caps()), {desktop})
        self.assertEqual(set(app._design_peer_caps()), {DESKTOP})

    def test_phone_settings_never_apply_even_when_advertised(self):
        app = application("_on_settings")
        app._peer_entries = entries()
        app.book = SimpleNamespace(peers=lambda: app._peer_entries)
        class Config:
            @property
            def same_on_both(self):
                raise AssertionError("phone settings must be ignored before reading local settings")
        app._config = Config()
        app._design_states = {}
        app._on_settings(PHONE, {"design_sync": {}})
        self.assertEqual(app._design_states, {})

    def test_match_choices_ignore_phone(self):
        class Model:
            def __init__(self, parent): self.items = []
            def clear(self): self.items.clear()
            def appendRow(self, item): self.items.append(item)

        class Item(Control):
            def setData(self, value, role): self.data = value

        app = application("_refresh_design_follow", "_lock_followed_design", QStandardItemModel=Model, QStandardItem=Item)
        app._peer_entries = entries()
        app._config = SimpleNamespace(design_follow_peer="", same_on_both=False, hide_addresses=False)
        app._design_states = {PHONE: {}, DESKTOP: {}}
        app._design_peer_caps = lambda: {PHONE: {"design_sync"}, DESKTOP: {"design_sync"}}
        app._shown = lambda text: text
        app._hide_addresses = lambda: False
        app._design_follow_signature = object()
        choice = app.design_follow_choice = Control()
        choice.setModel = lambda model: setattr(choice, "model", model)
        choice.findData = lambda value, role: 0
        choice.setCurrentIndex = lambda value: None
        app.design_follow_note = Control()
        app._refresh_design_follow()
        self.assertEqual([item.data for item in choice.model.items], ["", DESKTOP])

    def test_bulk_send_does_not_enable_phone_but_receive_can_be_toggled(self):
        settings = {"peers": entries()}
        settings["peers"][0]["send"] = False
        fake_config = SimpleNamespace(SETTINGS_LOCK=nullcontext(), load_settings=lambda path: settings,
                                      write_settings=lambda path, value: None)
        app = application("_set_every_peer", app_config=fake_config)
        app.config_path = "synthetic"
        app.sender = SimpleNamespace(owner=None)
        app._after_peers_edit = lambda: None
        app._set_every_peer("send", True)
        self.assertFalse(settings["peers"][0]["send"])
        app._set_every_peer("allow_drive", False)
        self.assertFalse(settings["peers"][0]["allow_drive"])

    def test_phone_only_tray_has_no_send_direction(self):
        app = application("_refresh_tray_directions")
        app._peer_entries = entries()[:1]
        app._shown = lambda text: text
        app.drive_action, app.send_action = Control(), Control()
        app._refresh_tray_directions()
        self.assertTrue(app.drive_action.enabled)
        self.assertFalse(app.send_action.enabled)
        self.assertFalse(app.send_action.checked)

    def test_tray_send_input_targets_never_offer_a_phone(self):
        class Action(Control):
            def __init__(self, text, parent):
                super().__init__(text)
                self.triggered = SimpleNamespace(connect=lambda callback: None)
        app = application("_refresh_tray_machines", QAction=Action)
        app._peer_entries = entries()
        other = dict(entries()[1], id=protocol.id_text(bytes(range(32, 48))),
                     token="another-desktop", name="Another desktop")
        app._peer_entries.append(other)
        app._shown = lambda text: text
        app.machine_actions = {}
        app.tray_menu = SimpleNamespace(insertAction=lambda before, action: None)
        app.pause_action = object()
        app.redirect_action = Control()
        app.sender = SimpleNamespace(owner=None, redirecting=False)
        app._live = lambda peer: True
        app._refresh_tray_machines()
        self.assertEqual(set(app.machine_actions), {DESKTOP, other["id"]})
        self.assertTrue(all("phone" not in action.text() for action in app.machine_actions.values()))

    def test_same_announcements_ignore_phone_even_with_advertised_capabilities_and_side(self):
        from core import return_edge
        app = application("_announce", return_edge=return_edge)
        phone = dict(entries()[0], send=False, side="left", side_set_at=10)
        app.book = SimpleNamespace(peers=lambda: [phone])
        app._config = SimpleNamespace(machine_id=DESKTOP)
        app._peer_caps = lambda: {protocol.read_id(PHONE): {"settings", "design_sync"}}
        self.assertEqual(app._announce(protocol.read_id(PHONE)), [])

    def test_phone_row_has_name_platform_remove_and_in_use_without_directions(self):
        row = load_methods("win_app/machines_win.py", "PeerRow", ["refresh", "_ask"],
                           dict(KEEP_NOTE="kept", peerlist=peerlist))()
        for name in ("name", "word", "where", "detail", "confirm_text", "in_use", "send", "allow",
                     "remove_button", "directions", "direction_group", "shortcut_cycle", "repair_button",
                     "confirm", "left_out", "left_out_note", "pin_address"):
            setattr(row, name, Control())
        row.led = SimpleNamespace(set_tone=lambda tone: None)
        row.confirm.visible = False
        row.refresh(entries()[0], "My phone", SimpleNamespace(tone="signal", word="Linked", detail="Connected"),
                    "iPhone", cycle_mode="last")
        self.assertEqual(row.name.text(), "My phone")
        self.assertEqual(row.where.text(), "iPhone")
        self.assertFalse(row.directions.visible)
        self.assertFalse(row.direction_group.visible)
        self.assertFalse(row.pin_address.visible)
        row._ask(False)
        self.assertFalse(row.directions.visible)
        self.assertTrue(row.in_use.visible)
        self.assertTrue(row.remove_button.visible)

    def test_phone_waits_and_links_instead_of_showing_pair_again(self):
        for up, word in ((False, "Waiting"), (True, "Linked")):
            state = peers_view.describe(entries()[0], "My phone", up=up, driving=False,
                                        input_there=False, kind="", status="", waking=False)
            self.assertEqual(state.word, word)


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