Skip to content

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

24.8 KB
Raw Blame
"""Synthetic settings fixtures exercising the actual app decisions without constructing UI."""

import ast
import copy
import importlib
import logging
import platform as system_platform
from pathlib import Path
import sys
import tempfile
import time
from dataclasses import replace
from types import SimpleNamespace
from typing import Optional
from unittest import TestCase

from core import protocol, settings_sync, ways, peerlist
from core.i18n import tr
from core.tests.app_methods import load_methods

ROOT = Path(__file__).resolve().parents[2]
IDS = [protocol.id_text(bytes([value]) * 16) for value in (1, 2, 3)]
SETTINGS_ROOT = tempfile.TemporaryDirectory()
VALUES = dict(glow_style="beam", glow_colour="ocean", effect_length="long",
              effect_size="large", frame_rate="half", shortcut_arrival=False, shortcut_arrival_style="locator")


def mac_adapter():
    sys.path.insert(0, str(ROOT / "mac_app"))
    config = importlib.import_module("config")
    tree = ast.parse((ROOT / "mac_app/settings_store.py").read_text())
    node = next(item for item in tree.body if isinstance(item, ast.FunctionDef) and item.name == "config_to_raw")
    namespace = {"config_module": config}
    exec(compile(ast.Module(body=[node], type_ignores=[]), "settings_store.py", "exec"), namespace)
    return config, namespace["config_to_raw"]


def fixture(platform, ident):
    namespace = dict(settings_sync=settings_sync, protocol=protocol, peerlist=peerlist, time=time, copy=copy,
                     Optional=Optional, replace=replace, LOGGER=logging.getLogger("settings-behaviour"),
                     core_ways=ways, ways=ways)
    if platform == "mac":
        config, to_raw = mac_adapter()
        namespace.update(config_to_raw=to_raw, KEY_NAME_TO_CODE={"cmd_r", "f13"}, SettingsError=ValueError,
                         desktop_mac=SimpleNamespace(display_map=lambda: {}))
        names = ("same_state", "_apply_followed_design", "_receive_design", "apply_same", "_set_design_follow", "_set_same",
                 "_show_trigger_conflict", "_trigger_chosen")
        cls = load_methods("mac_app/kvm_bridge_app.py", "ControlWindow", names, namespace)
        app = cls()
        cfg = config.parse_config(dict(host="", port=24800, auth_token="", design_set_at=1000, design_by=ident))
        app.controller = SimpleNamespace(cfg=cfg)
        app.controller.apply_settings = lambda value: setattr(app.controller, "cfg", value)
        app.settings_store = SimpleNamespace(save=lambda raw, **kwargs: config.parse_config(copy.deepcopy(raw)))
        app._receive_layout = lambda data, peer: False
        app.own_id = lambda: ident
        app.previews = None
        app._load_shared = lambda raw: None
        app.refresh = lambda: None
        app.values = lambda: settings_sync.mac_values(to_raw(app.controller.cfg))
        app.cfg = lambda: app.controller.cfg
        app.select = app._set_design_follow
        app.receive = lambda source, data: app.apply_same(data, peer=source)
        app.state = app.same_state
        app.style_hint = Label()
        app.conflict_note = app.style_hint
        app._changed = lambda: None
        app.key_recorder = SimpleNamespace(value=cfg.trigger_key)
        app.key_recorder.set_value = lambda value: setattr(app.key_recorder, "value", value)
        def record(key):
            app.key_recorder.value = key
            app._trigger_chosen(key)
        app.record = record
    else:
        sys.path.insert(0, str(ROOT / "win_app"))
        config = importlib.import_module("app_config")
        namespace.update(app_config=config, ConfigError=config.ConfigError, TRIGGER_KEYS={"cmd_r", "f13"})
        namespace["platform"] = system_platform
        names = ("_same_state", "_apply_followed_design", "_on_settings", "_design_follow_chosen", "_set_same",
                 "_show_trigger_conflict", "_record_trigger")
        namespace.update(TRIGGER_KEYS=config.TRIGGER_KEYS, TRIGGER_VKS=config.TRIGGER_VKS,
                         UNRECORDABLE_TRIGGER_VKS=config.UNRECORDABLE_TRIGGER_VKS)
        cls = load_methods("win_app/kvm_bridge_win.py", "WindowsApplication", names, namespace)
        app = cls()
        app._config = config.Config(host="", port=24800, auth_token="", machine_id=ident,
                                    design_set_at=1000, design_by=ident)
        app._persist = lambda: True
        app._reflect_config = lambda cfg: None
        app.sender = SimpleNamespace(update_config=lambda cfg: None)
        app._configure_trigger = lambda cfg: None
        app._same_fields = lambda: ()
        app._design_fields = lambda: ()
        app.design_follow_choice = SimpleNamespace(currentData=lambda role: app.chosen)
        namespace["Qt"] = SimpleNamespace(ItemDataRole=SimpleNamespace(UserRole=0))
        app.values = lambda: settings_sync.pc_values(app._config)
        app.cfg = lambda: app._config
        def select(peer):
            app.chosen = peer
            app._design_follow_chosen(0)
        app.select = select
        app.receive = app._on_settings
        app.state = app._same_state
        app.trigger_note = Label()
        app.conflict_note = app.trigger_note
        app.trigger_recorder = SimpleNamespace(set_title=lambda title: None)
        app.record = lambda key: app._record_trigger("key", config.TRIGGER_VKS[key])
    app.logger = logging.getLogger("settings-behaviour")
    app.peers = [{"id": peer, "port": 24820} for peer in IDS if peer != ident]
    if platform == "mac":
        app.settings_store.current = lambda: {"peers": app.peers}
        app.controller.book = SimpleNamespace(peers=lambda: app.peers)
    else:
        app.book = SimpleNamespace(peers=lambda: app.peers)
        app._peer_caps = lambda: {}
        app.config_path = Path(tempfile.mkdtemp(dir=SETTINGS_ROOT.name)) / "settings.json"
        config.write_settings(app.config_path, {"schema": config.SCHEMA, "machine_id": ident,
                                                "peers": copy.deepcopy(app.peers), "zones": []})
    app._design_states = {}
    app._followed_version = None
    app._design_path = [ident]
    app._refresh_design_follow = lambda: None
    app._show_same = lambda: None
    app.sent = []
    app._send_same = lambda data=None, source=None: app.sent.append(copy.deepcopy(data if data is not None else app.state()))
    return app


class Label:
    def __init__(self):
        self.text = ""
        self.visible = True
        self.view = SimpleNamespace(setHidden_=lambda hidden: self.setVisible(not hidden))

    def set(self, text, **kwargs):
        self.text = text

    def setText(self, text):
        self.text = text

    def setVisible(self, visible):
        self.visible = visible


def reflect_shortcut_visibility(app, platform):
    """Stop at the next unrelated UI dependency, after the actual module visibility decision."""
    class UnrelatedUI(Exception):
        pass
    def stop(*args):
        raise UnrelatedUI
    def visibility(view, visible):
        view.visible = visible
    motion = SimpleNamespace(set_hidden=lambda view, hidden: visibility(view, not hidden),
                             set_shown=lambda view, visible, **_options: visibility(view, visible))
    if platform == "mac":
        pages = importlib.import_module("pages")
        namespace = dict(pages=SimpleNamespace(crossing_rows=pages.crossing_rows, part_names=stop), motion=motion)
        cls = load_methods("mac_app/kvm_bridge_app.py", "ControlWindow", ["_reflect"], namespace)
        app.method_boxes = {name: SimpleNamespace(value=name in app.cfg().crossing["methods"])
                            for name in ("shortcut", "edge", "corner", "part", "notch")}
        app.edge_row = app.parts_row = app.corner_row = SimpleNamespace()
        app.corner_select = SimpleNamespace(set_enabled=lambda enabled: None)
        app.resistance_module = SimpleNamespace(view=SimpleNamespace())
        app.dragging_box = SimpleNamespace(view=SimpleNamespace(), set_enabled=lambda enabled: None)
        app.shortcut_module = SimpleNamespace(view=SimpleNamespace(visible=False))
        app.key_recorder.cancel = lambda: None
        app.edge_select = SimpleNamespace(value="right")
        method = lambda: cls._reflect(app)
        view = app.shortcut_module.view
    else:
        pages = importlib.import_module("pages_win")
        namespace = dict(pages_win=pages, ways=ways, motion=motion, peerlist=peerlist,
                         widgets=SimpleNamespace(set_role=lambda *args: None),
                         platform=system_platform,
                         OWN_PLATFORM="windows",
                         TRIGGER_KEYS=SimpleNamespace(get=stop))
        namespace["profiles"] = importlib.import_module("core.profiles")
        namespace["tr"] = importlib.import_module("core.i18n").tr
        cls = load_methods("win_app/kvm_bridge_win.py", "WindowsApplication", ["_reflect_ways"], namespace)
        app._crossing_settings = lambda: {"machine_id": app._config.machine_id, "peers": [], "zones": []}
        # Crossing profiles (1.5.5): Same ways off, so the page shows this machine's own settings.
        app._profile_settings = app._crossing_settings
        app._crossing_view_settings = app._crossing_settings
        app._reflect_profiles = lambda _settings: None
        app._profile_remote = lambda: False
        app._profile_machine_name = lambda _settings, peer: peer
        app._profile_live = lambda _peer: False
        app._profile_caps = lambda _peer, _settings: set()
        app._profile_read_only = lambda: False
        app._crossing_machines = lambda: []
        app._chosen_machine = lambda: None
        app._rebuild_machine_choice = lambda values: None
        app._ways_in = lambda: set()

        class UI:
            def __init__(self):
                self.visible = True
                self.view = self
                self._buttons = {"next": self, "ticked": self}

            def set_value(self, *args): pass
            def set_names(self, *args): pass
            def setText(self, *args): pass
            def setVisible(self, visible): self.visible = visible
            def setToolTip(self, *args): pass
            def setAccessibleName(self, *args): pass
            def setAccessibleDescription(self, *args): pass
            def setText(self, *args): pass
            def setChecked(self, *args): pass
            def isChecked(self): return False
            def blockSignals(self, *args): pass
            def set_edge(self, *args): pass
            def text(self): return ""
            def toolTip(self): return ""
            def accessibleName(self): return ""
            def accessibleDescription(self): return ""
            def isEnabled(self): return True
            def setEnabled(self, *args): pass
            def isVisible(self): return self.visible
            def isHidden(self): return not self.visible
            def hide(self): pass
            def deleteLater(self): pass

            def __getattr__(self, name):
                # Any other widget call the refresh makes is not what these tests measure.
                return lambda *args, **kwargs: None

        ui = UI()
        app._peer_entries = []
        app._design_peer_caps = lambda: {}
        app._live = lambda _peer: False
        app._gone = lambda _peer: False
        app._shown = lambda value: value
        app.atlas_note = UI()
        app.atlas_canvas = SimpleNamespace(set_tiles=lambda *args, **kwargs: None,
                                           set_left_out=lambda *args: None,
                                           shelf_ids=[], cycle={})
        app.left_out_layout = SimpleNamespace(count=lambda: 0, takeAt=lambda _index: None)
        app.left_out_shelf = app.left_out_heading = app.left_out_note = UI()
        app.selected_machine_name = app.dormant_note = app.selected_machine_status = UI()
        app.selected_machine_header = app.ways_heading = app.ways_summary = UI()
        app.canvas_rename = app.canvas_leave_out = UI()
        app.blocked_note = app.missing_note = app.no_way_back_note = UI()
        app.shortcut_target_choice = app.shortcut_target_note = UI()
        app.resistance_strip = UI()
        app._reflect_jump_key = stop
        for name in ("machine_choice", "edge_choice", "edge_heading", "edge_note", "edge_unlearned", "corner_choice", "parts_note"):
            setattr(app, name, ui)
        app.machine_row = app.resistance_module = SimpleNamespace()
        app.ways_module = SimpleNamespace(eyebrow=SimpleNamespace(setText=lambda text: None))
        app.shortcut_module = UI()
        app.way_boxes = {name: UI() for name in ("edge", "corner", "parts", "shortcut")}
        app.edge_way_detail = UI()
        app.part_buttons = {}
        app.third_boxes = {name: UI() for name in ("start", "middle", "end")}
        app.crossing_rows = {name: UI() for name in ("edge", "corner", "parts", "thirds", "shortcut", "dragging", "resistance")}
        app._crossing_text = lambda widget, text: widget.setText(text)
        app._left_out_rows = {}
        method = lambda: cls._reflect_ways(app)
        view = app.shortcut_module
    try:
        method()
    except UnrelatedUI:
        pass
    return view.visible


def status_fixture(platform, caps, cached=False, following=False, offline=()):
    app = fixture(platform, IDS[1])
    app.peers = [{"id": IDS[0], "name": "Leader", "token": "synthetic"}]
    app.peers += [{"id": ident, "name": f"Offline {n}", "token": f"offline-{n}"} for n, ident in enumerate(offline)]
    if cached:
        app._design_states[IDS[0]] = {"set_at": 10, "by": IDS[0], "values": VALUES}
    app.cfg().design_follow_peer = IDS[0] if following else ""
    app._design_peer_caps = lambda: caps
    app._lock_followed_design = lambda entry, name: setattr(app, "locked_to", entry)
    namespace = dict(settings_sync=settings_sync, peerlist=peerlist, protocol=protocol, tr=tr)
    if platform == "mac":
        class MenuChoice:
            def __init__(self, choices, **kwargs):
                self.choices = choices
                self.items = []
                for value, title in choices:
                    cell = SimpleNamespace(enabled=True, tooltip="", setAlphaValue_=lambda alpha: None)
                    cell.title = lambda title=title: title
                    cell.setToolTip_ = lambda text, cell=cell: setattr(cell, "tooltip", text)
                    cell.setEnabled_ = lambda enabled, cell=cell: setattr(cell, "enabled", enabled)
                    self.items.append((value, cell))
                self.view = None
        namespace["widgets"] = SimpleNamespace(MenuChoice=MenuChoice, add=lambda *args, **kwargs: None)
        app.follow_host = SimpleNamespace(arrangedSubviews=lambda: [])
        app.follow_note = Label()
        app._set_design_follow = lambda peer: None
        method = load_methods("mac_app/kvm_bridge_app.py", "ControlWindow", ["_refresh_design_follow"], namespace)
        method._refresh_design_follow(app)
        app.status_titles = [title for value, title in app.follow_select.choices]
        app.status_tooltip = app.follow_select.items[1][1].tooltip if len(app.follow_select.items) > 1 else ""
        app.status_note = app.follow_note.text
    else:
        class Item:
            def __init__(self, title):
                self.title = title
            def setData(self, value, role):
                self.value = value
            def setEnabled(self, enabled):
                self.enabled = enabled
            def setToolTip(self, text):
                self.tooltip = text
        class Model:
            def __init__(self, choice):
                self.rows = []
            def clear(self):
                self.rows.clear()
            def appendRow(self, item):
                self.rows.append(item)
        namespace.update(QStandardItemModel=Model, QStandardItem=Item,
                         Qt=SimpleNamespace(ItemDataRole=SimpleNamespace(UserRole=0)))
        app._peer_entries = app.peers
        app._shown = lambda text: text
        app._hide_addresses = lambda: False
        app._design_follow_signature = object()
        choice = SimpleNamespace(blockSignals=lambda on: None, findData=lambda *args: 0,
                                 setCurrentIndex=lambda index: None)
        choice.setModel = lambda model: setattr(choice, "model", model)
        app.design_follow_choice = choice
        app.design_follow_note = Label()
        method = load_methods("win_app/kvm_bridge_win.py", "WindowsApplication", ["_refresh_design_follow"], namespace)
        method._refresh_design_follow(app)
        app.status_titles = [item.title for item in choice.model.rows]
        app.status_tooltip = getattr(choice.model.rows[1], "tooltip", "") if len(choice.model.rows) > 1 else ""
        app.status_note = app.design_follow_note.text
    return app


def leader_message(ident, stamp=100, values=None, path=None):
    state = dict(set_at=stamp, by=ident, values=dict(VALUES if values is None else values))
    if path is not None:
        state["path"] = path
    return settings_sync.message_data(False, 0, by=ident, design_state=state)


class SettingsBehaviourTests(TestCase):
    platform = None

    def setUp(self):
        self.app = fixture(self.platform, IDS[1])

    def cache_and_select(self, stamp=100):
        self.app.receive(IDS[0], leader_message(IDS[0], stamp))
        self.app.select(IDS[0])

    def assert_design(self, app, values=VALUES):
        expected = settings_sync._with_continuous(values)
        self.assertEqual({key: app.values()[key] for key in settings_sync.DESIGN_KEYS}, expected)

    def test_selecting_older_leader_adopts_all_six_values_and_announces_local_version(self):
        self.cache_and_select()
        self.assert_design(self.app)
        state = self.app.state()["design_sync"]
        self.assertGreater(state["set_at"], 1000)
        self.assertEqual(state["by"], IDS[1])
        self.assertEqual(state["path"], [IDS[0], IDS[1]])

    def test_compatible_design_not_yet_received_is_not_labelled_old(self):
        waiting = "Design not available yet: connect to this machine with Beamer 1.5.0 beta.6 or later."
        app = status_fixture(self.platform, {IDS[0]: {"settings", "design_sync"}})
        self.assertNotIn("Needs beta.6 or later", app.status_titles[1])
        self.assertEqual(app.status_titles[1], "Leader")
        self.assertEqual(app.status_tooltip, waiting)
        self.assertEqual(app.status_note, waiting)

    def test_connected_machine_with_design_is_offered_whatever_offline_peers_say(self):
        # 05-10-2026, 1.5.0-rc.4: the PC was linked and its Design had arrived, but the Mac's other
        # paired machines were offline and their missing Design set the note to "not available".
        app = status_fixture(self.platform, {IDS[0]: {"settings", "design_sync"}}, cached=True, offline=(IDS[2],))
        self.assertEqual(app.status_titles, ["None", "Leader"])
        self.assertEqual(app.status_tooltip, "Leader" if self.platform == "mac" else "")
        self.assertTrue(app.status_note.startswith("None: this "), app.status_note)

    def test_no_connected_machine_lists_none_with_one_quiet_line(self):
        app = status_fixture(self.platform, {}, offline=(IDS[2],))
        self.assertEqual(app.status_titles, ["None"])
        self.assertEqual(app.status_note, settings_sync.NO_MACHINE_CONNECTED)

    def test_observed_missing_design_capability_is_labelled_old(self):
        app = status_fixture(self.platform, {IDS[0]: {"settings"}})
        self.assertIn("Needs beta.6 or later", app.status_titles[1])

    def test_following_offline_machine_keeps_last_design_and_says_so(self):
        app = status_fixture(self.platform, {}, cached=True, following=True)
        self.assertEqual(app.status_note, "Keeping the last design received from Leader until it reconnects.")

    def test_shared_trigger_clash_preserves_local_jump_and_trigger_and_reports_conflict(self):
        self.app.peers.append({"id": IDS[0], "jump_key": "ctrl+f13"})
        before = self.app.cfg().trigger_key
        data = settings_sync.message_data(True, 20, {"trigger_key": "f13", "resistance_px": 75}, by=IDS[0],
                                          groups=settings_sync.ALL_GROUPS)
        self.app.peers[0]["jump_key"] = "cmd+f13"
        self.app.receive(IDS[0], data)
        self.assertEqual(self.app.cfg().trigger_key, before)
        self.assertEqual(self.app.peers[0]["jump_key"], "cmd+f13")
        self.assertEqual(self.app.values()["resistance_px"], 75)
        self.assertIn("clashes", self.app.conflict_note.text)
        self.assertTrue(self.app.conflict_note.visible)

    def test_recording_a_trigger_clash_preserves_the_local_trigger_and_shows_a_note(self):
        self.app.peers.append({"id": IDS[0], "jump_key": "ctrl+f13"})
        before = self.app.cfg().trigger_key
        self.app.record("f13")
        self.assertEqual(self.app.cfg().trigger_key, before)
        self.assertIn("clashes", self.app.conflict_note.text)
        self.assertTrue(self.app.conflict_note.visible)
        if self.platform == "mac":
            self.assertEqual(self.app.key_recorder.value, before)

    def test_shared_clash_note_stays_visible_when_shortcut_is_switched_off(self):
        self.app.peers.append({"id": IDS[0], "jump_key": "ctrl+f13"})
        before = self.app.cfg().trigger_key
        self.app.receive(IDS[0], settings_sync.message_data(
            True, 20, {"trigger_key": "f13", "shortcut": False}, by=IDS[0], groups=settings_sync.ALL_GROUPS))
        self.assertEqual(self.app.cfg().trigger_key, before)
        self.assertIn("clashes", self.app.conflict_note.text)
        self.assertTrue(reflect_shortcut_visibility(self.app, self.platform))

    def test_next_leader_update_uses_leader_cursor_and_duplicates_do_not_resend(self):
        self.cache_and_select()
        changed = dict(VALUES, effect_length="short")
        message = leader_message(IDS[0], 101, changed)
        self.app.receive(IDS[0], message)
        self.assert_design(self.app, changed)
        count = len(self.app.sent)
        self.app.receive(IDS[0], message)
        self.app.receive(IDS[0], leader_message(IDS[0], 99))
        self.assertEqual(len(self.app.sent), count)
        self.assert_design(self.app, changed)

    def test_same_off_here_resumes_the_already_adopted_cached_version(self):
        self.cache_and_select()
        self.app.cfg().same_on_both = True
        self.app.cfg().same_groups = list(settings_sync.ALL_GROUPS)
        self._set_values(dict(VALUES, effect_length="short"))
        self.app._set_same(False)
        self.assert_design(self.app)

    def test_same_off_received_resumes_the_already_adopted_cached_version(self):
        self.cache_and_select()
        self.app.cfg().same_on_both = True
        self.app.cfg().same_groups = list(settings_sync.ALL_GROUPS)
        self._set_values(dict(VALUES, effect_length="short"))
        data = settings_sync.message_data(False, self.app.cfg().same_set_at + 1, by=IDS[2])
        self.app.receive(IDS[2], data)
        self.assert_design(self.app)

    def _set_values(self, values):
        self.set_values(self.app, values)

    def set_values(self, app, values):
        if self.platform == "mac":
            config, to_raw = mac_adapter()
            raw = settings_sync.apply_mac(to_raw(app.cfg()), values)
            app.controller.apply_settings(config.parse_config(raw))
        else:
            settings_sync.apply_pc(app.cfg(), values)

    def test_downstream_follower_adopts_when_its_leader_selects_older_design(self):
        downstream = fixture(self.platform, IDS[2])
        downstream.receive(IDS[1], self.app.state())
        downstream.select(IDS[1])
        self.cache_and_select()
        downstream.receive(IDS[1], self.app.state())
        self.assert_design(downstream)
        self.assertEqual(downstream.state()["design_sync"]["path"], IDS)

    def test_two_machine_cycle_has_bounded_announcements(self):
        self._cycle(2, False)

    def test_three_machine_cycle_has_bounded_announcements(self):
        self._cycle(3, False)

    def test_identical_values_cycle_has_bounded_announcements(self):
        self._cycle(3, True)

    def test_two_machine_identical_values_cycle_has_bounded_announcements(self):
        self._cycle(2, True)

    def _cycle(self, count, identical):
        apps = [fixture(self.platform, ident) for ident in IDS[:count]]
        if not identical:
            self.set_values(apps[0], VALUES)
        initial = [app.state() for app in apps]
        for index, app in enumerate(apps):
            leader = (index + 1) % count
            app.receive(IDS[leader], initial[leader])
            app.select(IDS[leader])
        queue = [(index, data) for index, app in enumerate(apps) for data in app.sent]
        for app in apps:
            app.sent.clear()
        processed = 0
        while queue:
            source, data = queue.pop(0)
            processed += 1
            self.assertLess(processed, 40, "follow cycle kept announcing")
            for index, app in enumerate(apps):
                if source != index:
                    app.receive(IDS[source], data)
                    queue.extend((index, message) for message in app.sent)
                    app.sent.clear()
        self.assertTrue(any(not app.cfg().design_follow_peer for app in apps))