Skip to content

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

41.7 KB
Raw Blame
"""Same on all machines in the real window: the Overview switch, a Mac's settings arriving, and a
change here going out. Built offscreen from a synthetic config as test_style_for builds it, which
starts no receiver, hooks or announcer; the two links' sends are recorded instead."""

import json
import os
import tempfile
import time
import unittest
from pathlib import Path
from unittest import mock

try:
    from PySide6.QtTest import QTest
    from PySide6.QtCore import Qt
    from PySide6.QtWidgets import QApplication

    import kvm_bridge_win
    import pages_win
    from core import settings_sync
    import theme
    import app_config
    from app_config import load_config
    from core import protocol
    from core.tests import responder_harness as harness
except ImportError:  # PySide6 is only in the Windows venv
    kvm_bridge_win = None


def mac_message(on, set_at, by=None, **values):
    base = dict(shortcut=False, resistance_px=60,
                block_while_dragging=False, trigger_key="alt_r", trigger_style="hold", double_tap_ms=400,
                glow_style="beam", glow_colour="ocean", effect_length="long", shortcut_arrival=False,
                shortcut_arrival_style="locator")
    base.update(values)
    return settings_sync.message_data(on, set_at, base, by=by or protocol.id_text(harness.B),
                                      groups=settings_sync.ALL_GROUPS if on else [])


@unittest.skipIf(kvm_bridge_win is None, "needs PySide6")
class SameOnBothTest(unittest.TestCase):
    def setUp(self):
        os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
        self.app = QApplication.instance() or QApplication([])
        theme.init_fonts()
        folder = Path(tempfile.mkdtemp())
        self.path = folder / "settings.json"
        (folder / "config.json").write_text(json.dumps({
            "host": "192.168.1.20", "port": harness.free_port(), "auth_token": "synthetic", "paired_with": "MacBook Pro",
            "mac_host": "192.168.1.10", "mac_return_edge": "left", "edge_glow": True,
        }))
        self.window = kvm_bridge_win.WindowsApplication(self.path)
        self.sent = []
        self.peers = {harness.B: {"settings"}, harness.C: {"settings"}}
        self.window._peer_caps = lambda: dict(self.peers)
        self.window._send_to = lambda peer, message: self.sent.append((peer, message["data"])) or True
        self.window._refresh_window()

    def tearDown(self):
        self.window.server.stop()
        self.window.deleteLater()

    def pair_peer(self, peer: str) -> None:
        settings = app_config.load_settings(self.path)
        settings["peers"][0]["id"] = peer
        app_config.write_settings(self.path, settings)
        self.window._refresh_peers()

    def test_off_by_default_with_each_page_its_own(self):
        self.assertFalse(self.window.same_checks["everything"].isChecked())
        self.assertEqual(set(self.window.same_checks), {"crossing", "design", "shortcut", "names", "everything"})
        self.assertEqual(self.window.scope_labels["design"].text(), pages_win.SCOPE["design"])

    def test_unchanged_refresh_does_not_reload_settings_for_same_on_all(self):
        self.window._show_same()
        with mock.patch.object(app_config, "load_settings", wraps=app_config.load_settings) as load:
            self.window._show_same()
            self.window._show_same()
        load.assert_not_called()

    def test_same_on_all_reloads_a_changed_settings_file(self):
        self.window._show_same()
        settings = app_config.load_settings(self.path)
        settings["same_before_sync"] = {"saved_at": int(time.time()), "groups": [],
                                         "values": {"shortcut": False}, "names": {}}
        app_config.write_settings(self.path, settings)

        with mock.patch.object(app_config, "load_settings", wraps=app_config.load_settings) as load:
            self.window._show_same()

        load.assert_called_once_with(self.path)
        self.assertFalse(self.window.same_revert.isHidden())

    def test_same_on_all_rechecks_a_write_that_lands_during_the_read(self):
        original_load = app_config.load_settings
        saved = {"saved_at": int(time.time()), "groups": [], "values": {"shortcut": False}, "names": {}}
        calls = 0

        def load_then_write(path):
            nonlocal calls
            settings = original_load(path)
            if calls == 0:
                changed = original_load(path)
                changed["same_before_sync"] = saved
                app_config.write_settings(path, changed)
            calls += 1
            return settings

        self.window._same_settings_signature = object()
        with mock.patch.object(app_config, "load_settings", side_effect=load_then_write):
            self.window._show_same()
            self.window._show_same()

        self.assertEqual(calls, 2)
        self.assertFalse(self.window.same_revert.isHidden())

    def test_display_reconciliation_skips_unchanged_inputs_and_runs_for_changes(self):
        self.window._refresh_own_displays = lambda: None
        self.window._own_display_map = {"screen": {"x": 0, "y": 0, "width": 1920, "height": 1080}}
        self.window._carry_crossing = mock.Mock()
        with mock.patch.object(kvm_bridge_win.crossing_state, "displays_changed",
                               wraps=kvm_bridge_win.crossing_state.displays_changed) as reconcile:
            self.window._displays_changed()
            self.window._displays_changed()
            self.assertEqual(reconcile.call_count, 1)
            self.window._own_display_map = {"screen": {"x": 0, "y": 0, "width": 1600, "height": 900}}
            self.window._displays_changed()
            self.assertEqual(reconcile.call_count, 2)
            settings = app_config.load_settings(self.path)
            settings["name"] = "Changed from another process"
            app_config.write_settings(self.path, settings)
            self.window._displays_changed()
            self.assertEqual(reconcile.call_count, 3)

    def test_display_reconciliation_rechecks_a_write_that_lands_during_the_read(self):
        self.window._refresh_own_displays = lambda: None
        self.window._own_display_map = {"screen": {"x": 0, "y": 0, "width": 1920, "height": 1080}}
        self.window._carry_crossing = mock.Mock()
        original = kvm_bridge_win.crossing_state.displays_changed
        calls = 0

        def reconcile_then_write(*args, **kwargs):
            nonlocal calls
            outcome = original(*args, **kwargs)
            if calls == 0:
                settings = app_config.load_settings(self.path)
                settings["name"] = "Changed during reconciliation"
                app_config.write_settings(self.path, settings)
            calls += 1
            return outcome

        with mock.patch.object(kvm_bridge_win.crossing_state, "displays_changed",
                               side_effect=reconcile_then_write):
            self.window._displays_changed()
            self.window._displays_changed()

        self.assertEqual(calls, 2)

    def test_display_reconciliation_retries_after_a_settings_read_recovers(self):
        self.window._refresh_own_displays = lambda: None
        self.window._own_display_map = {"screen": {"x": 0, "y": 0, "width": 1920, "height": 1080}}
        self.window._carry_crossing = mock.Mock()
        self.window._window_settings_version = None
        self.window._displays_signature = None
        original_load = app_config.load_settings

        with mock.patch.object(app_config, "load_settings",
                               side_effect=[OSError("temporary read failure"), original_load(self.path)]), \
             mock.patch.object(kvm_bridge_win.crossing_state, "displays_changed",
                               wraps=kvm_bridge_win.crossing_state.displays_changed) as reconcile:
            self.window._displays_changed()
            self.assertTrue(self.window._window_settings_stale)
            self.window._displays_changed()

        self.assertFalse(self.window._window_settings_stale)
        self.assertEqual(reconcile.call_count, 1)

    def test_display_reconciliation_tracks_legacy_settings_changes(self):
        self.window._refresh_own_displays = lambda: None
        self.window._own_display_map = {"screen": {"x": 0, "y": 0, "width": 1920, "height": 1080}}
        self.window._carry_crossing = mock.Mock()
        legacy_path = app_config.legacy_config_path(self.path)

        with mock.patch.object(kvm_bridge_win.crossing_state, "displays_changed",
                               wraps=kvm_bridge_win.crossing_state.displays_changed) as reconcile:
            self.window._displays_changed()
            legacy_path.write_text(legacy_path.read_text() + "\n")
            self.window._displays_changed()

        self.assertEqual(reconcile.call_count, 2)

    def test_everything_can_be_turned_off(self):
        self.window._set_same_groups(settings_sync.ALL_GROUPS)
        self.window.same_checks["everything"].setChecked(False)

        self.assertEqual(self.window._config.same_groups, [])

    def test_an_old_peer_does_not_change_this_pcs_group_selection(self):
        self.window._config.same_groups = ["design"]
        message = mac_message(True, 100, resistance_px=60)
        message.pop("groups")
        self.window._on_settings(protocol.id_text(harness.B), message)

        self.assertEqual(self.window._config.same_groups, ["design"])
        self.assertEqual(self.window._config.crossing_resistance_px, 120)

    def test_revert_restores_the_saved_values_and_announces_them(self):
        peer = protocol.id_text(harness.B)
        self.pair_peer(peer)
        data = settings_sync.message_data(True, 100, {"resistance_px": 60}, by=peer,
                                          groups=["crossing"])
        self.window._on_settings(peer, data)
        self.assertTrue(settings_sync.snapshot_available(
            app_config.load_settings(self.path).get("same_before_sync")))

        self.window._revert_same()

        self.assertEqual(self.window._config.crossing_resistance_px, 120)
        self.assertEqual(self.window._config.same_groups, ["crossing"])
        self.assertEqual(self.sent[-1][1]["crossing"]["resistance_px"], 120)

    def test_revert_clears_a_first_remote_label_with_a_new_stamp(self):
        peer = protocol.id_text(harness.B)
        self.pair_peer(peer)
        data = settings_sync.message_data(True, 100, by=peer, groups=["names"], names={
            peer: {"label": "Named here", "set_at": 100, "by": peer},
        })
        self.window._on_settings(peer, data)
        self.assertEqual(app_config.load_settings(self.path)["peers"][0]["label"], "Named here")

        self.window._revert_same()

        restored = app_config.load_settings(self.path)["peers"][0]
        self.assertEqual(restored["label"], "")
        self.assertGreater(restored["label_set_at"], 100)

    def test_legacy_off_state_stays_off_when_announced_to_a_group_peer(self):
        self.window._config.same_groups = ["design"]
        self.window._on_settings(protocol.id_text(harness.B), {"on": False, "set_at": 100,
                                                                 "by": protocol.id_text(harness.B)})

        self.assertFalse(self.window._same_state()["on"])
        self.assertEqual(self.window._same_state()["groups"], ["design"])

    def test_revert_keeps_the_current_trigger_when_a_jump_chord_now_uses_it(self):
        peer = protocol.id_text(harness.B)
        self.pair_peer(peer)
        original_groups = list(self.window._config.same_groups)
        self.window._config.trigger_key = "alt_r"
        self.window._persist()
        # The key changed here holds its own stamp now: only a newer choice from the peer replaces it.
        newer = self.window._config.same_stamps["trigger_key"][0] + 1
        data = settings_sync.message_data(True, newer, {"trigger_key": "f13"}, by=peer,
                                          groups=["shortcut"])
        self.window._on_settings(peer, data)
        settings = app_config.load_settings(self.path)
        settings["peers"][0]["jump_key"] = "alt+cmd+3"
        app_config.write_settings(self.path, settings)
        self.window._peer_entries = settings["peers"]

        self.window._revert_same()

        self.assertEqual(self.window._config.trigger_key, "f13")
        self.assertEqual(self.window._config.same_groups, ["shortcut"])

    def test_names_only_keeps_design_following_and_local_scope(self):
        peer = protocol.id_text(harness.B)
        self.pair_peer(peer)
        self.window._config.same_on_both = True
        self.window._config.same_groups = ["names"]
        self.window._config.design_follow_peer = peer
        self.window._design_states[peer] = {"set_at": 100, "by": peer, "values": {"effect_length": "long"}}
        self.window._apply_followed_design(force=True)
        self.window._show_same()
        self.assertEqual(self.window._config.effect_length, "long")
        self.assertNotIn("crossing", self.window.scope_labels)
        row = self.window.crossing_ledger.rows[peer]
        row.begin_rename()
        self.assertIn("Only on this PC", row.rename_hint.text())
        self.assertEqual(self.window.scope_labels["design"].text(), pages_win.SCOPE["design"])
        self.assertIn("Names", self.window.same_note.text())

    def test_stale_names_policy_cannot_rename_after_names_was_deselected(self):
        peer = protocol.id_text(harness.B)
        self.pair_peer(peer)
        self.window._on_settings(peer, settings_sync.message_data(True, 200, by=peer, groups=["crossing"]))
        self.window._on_settings(peer, settings_sync.message_data(True, 100, by=peer, groups=["names"],
            names={peer: {"label": "Delayed", "set_at": 300, "by": peer}}))
        self.assertNotEqual(app_config.load_settings(self.path)["peers"][0].get("label"), "Delayed")

    def test_local_design_change_does_not_stamp_a_names_only_policy(self):
        self.window._config.same_groups = ["names"]
        self.window._config.same_on_both = True
        self.window._config.same_set_at = 100
        self.window._same_seen = self.window._same_fields()
        self.window._config.glow_colour = "ocean"
        self.window._persist()
        self.assertEqual(self.window._config.same_set_at, 100)

    def test_a_remote_selection_that_drops_design_resumes_the_cached_leader(self):
        peer = protocol.id_text(harness.B)
        self.pair_peer(peer)
        config = self.window._config
        config.same_on_both, config.same_groups, config.same_set_at = True, ["design"], 10
        config.design_follow_peer = peer
        self.window._design_states[peer] = {"set_at": 100, "by": peer, "values": {"effect_length": "long"}}
        self.window._followed_version = (peer, 100, peer)
        self.window._on_settings(protocol.id_text(harness.C), settings_sync.message_data(
            True, 11, by=protocol.id_text(harness.C), groups=["names"]))
        self.assertEqual(self.window._config.effect_length, "long")

    def test_selection_only_revert_keeps_a_later_local_design_edit(self):
        peer = protocol.id_text(harness.B)
        self.pair_peer(peer)
        config = self.window._config
        config.same_on_both, config.same_groups, config.same_set_at = True, ["crossing"], 10
        self.window._on_settings(peer, settings_sync.message_data(True, 11, by=peer, groups=["design"]))
        self.window._config.glow_colour = "ocean"
        self.window._revert_same()
        self.assertEqual(self.window._config.same_groups, ["crossing"])
        self.assertEqual(self.window._config.glow_colour, "ocean")
        self.assertEqual(self.window.glow_colour_choice.value, "ocean")

    def test_older_settings_peer_without_layout_capability_shows_group_note(self):
        self.window._peer_caps = lambda: {harness.B: {"settings"}}

        self.window._show_same()

        self.assertFalse(self.window.same_old_note.isHidden())
        self.assertTrue(self.window.same_checks["crossing"].isEnabled())

    def test_full_screen_hold_switch_names_this_pcs_edges(self):
        self.assertEqual(self.window.hold_switch.text(), "Hold this PC's edges while an app on it is full screen")
    def test_this_pcs_design_state_is_announced_when_same_is_off(self):
        data = self.window._same_state()

        self.assertFalse(data["on"])
        self.assertEqual(data["design_sync"]["values"]["effect_size"], "medium")
        self.assertEqual(set(data["design_sync"]["values"]), set(settings_sync.DESIGN_KEYS))

    def test_a_followed_design_is_applied_and_renamed_as_this_pcs_state(self):
        peer = protocol.id_text(harness.B)
        self.pair_peer(peer)
        self.window._config.design_follow_peer = peer
        received = settings_sync.message_data(
            False, 100, by=peer,
            design_state={"set_at": 200, "by": peer,
                          "values": {"effect_length": "long"}},
        )

        self.window._on_settings(peer, received)

        self.assertEqual(self.window._config.effect_length, "long")
        self.assertGreater(self.window._config.design_set_at, 200)
        self.assertEqual(self.window._config.design_by, self.window._config.machine_id)
        self.assertEqual(self.sent[-1][1]["design_sync"]["values"]["effect_length"], "long")

    def test_a_design_state_in_a_malformed_settings_envelope_is_dropped_whole(self):
        peer = protocol.id_text(harness.B)
        self.pair_peer(peer)
        self.window._config.design_follow_peer = peer
        state = {"set_at": 200, "by": peer, "values": {"effect_length": "long"}}

        for outer in ({"on": "no"}, {"set_at": True}, {"by": "not an id"}):
            received = settings_sync.message_data(False, 100, by=peer, design_state=state)
            received.update(outer)
            self.window._on_settings(peer, received)

        self.assertEqual(self.window._config.effect_length, "normal")
        self.assertNotIn(peer, self.window._design_states)
        self.assertEqual(self.sent, [])

    def test_follow_accepts_the_leaders_next_change_after_this_pc_reannounces(self):
        peer = protocol.id_text(harness.B)
        self.pair_peer(peer)
        config = self.window._config
        config.design_follow_peer = peer
        config.design_set_at = 50
        config.design_by = peer

        for stamp, length in ((100, "long"), (101, "short")):
            received = settings_sync.message_data(
                False, stamp - 50, by=peer,
                design_state={"set_at": stamp, "by": peer, "values": {"effect_length": length}},
            )
            self.window._on_settings(peer, received)

        self.assertEqual(self.window._config.effect_length, "short")
        self.assertGreater(self.window._config.design_set_at, 101)
        self.assertEqual(self.window._config.design_by, self.window._config.machine_id)
        self.assertEqual(self.sent[-1][1]["design_sync"]["values"]["effect_length"], "short")
        self.assertEqual((self.sent[-1][1]["design_sync"]["set_at"], self.sent[-1][1]["design_sync"]["by"]),
                         (self.window._config.design_set_at, self.window._config.machine_id))

    def test_followed_size_updates_the_control_without_saving_a_local_edit(self):
        peer = protocol.id_text(harness.B)
        self.pair_peer(peer)
        self.window._config.design_follow_peer = peer
        received = settings_sync.message_data(
            False, 100, by=peer,
            design_state={"set_at": 200, "by": peer, "values": {"effect_size": "large"}},
        )

        self.window._on_settings(peer, received)

        self.assertEqual(self.window.size_choice.value, "large")
        self.assertEqual(self.window._config.effect_size, "large")
        self.assertEqual(self.sent[-1][1]["design_sync"]["values"]["effect_size"], "large")

    def test_same_on_design_change_is_announced_with_a_new_local_design_stamp(self):
        source = protocol.id_text(harness.C)
        config = self.window._config
        config.same_on_both = True
        config.same_set_at = 10
        config.same_by = source
        config.design_set_at = 20
        config.design_by = config.machine_id
        config.effect_length = "short"
        received = mac_message(True, 11, by=source, effect_length="long")
        received["design_sync"] = {
            "set_at": 100, "by": source, "values": {"effect_length": "long"},
        }

        self.window._on_settings(source, received)

        self.assertEqual(self.window._config.effect_length, "long")
        self.assertGreater(self.window._config.design_set_at, 100)
        self.assertEqual(self.window._config.design_by, self.window._config.machine_id)
        self.assertEqual(self.sent[-1][1]["design_sync"]["set_at"], self.window._config.design_set_at)
        self.assertNotEqual(self.sent[-1][1]["design_sync"]["by"], source)

    def test_same_off_from_another_machine_resumes_the_cached_followed_design(self):
        leader = protocol.id_text(harness.B)
        other = protocol.id_text(harness.C)
        self.pair_peer(leader)
        config = self.window._config
        config.same_on_both = True
        config.same_groups = list(settings_sync.ALL_GROUPS)
        config.same_set_at = 10
        config.same_by = other
        config.design_follow_peer = leader
        config.effect_length = "short"
        self.window._design_states[leader] = {
            "set_at": 100, "by": leader, "values": {"effect_length": "long"},
        }
        apply_followed = mock.Mock(wraps=self.window._apply_followed_design)
        self.window._apply_followed_design = apply_followed

        self.window._on_settings(other, settings_sync.message_data(False, 11, by=other))

        apply_followed.assert_called_once()
        self.assertEqual(self.window._config.effect_length, "long")
        self.assertEqual(self.sent[-1][1]["design_sync"]["values"]["effect_length"], "long")
        self.assertEqual((self.sent[-1][1]["design_sync"]["set_at"], self.sent[-1][1]["design_sync"]["by"]),
                         (self.window._config.design_set_at, self.window._config.machine_id))

    def follow(self, **values):
        peer = protocol.id_text(harness.B)
        self.pair_peer(peer)
        # A preset set alone would lose to the held slider value when the config resolves them.
        for key, value in settings_sync._with_continuous(values).items():
            setattr(self.window._config, key, value)
        self.window._config.design_follow_peer = peer
        self.window._reflect_config(self.window._config)
        self.window._design_seen = self.window._design_fields()
        self.window._refresh_design_follow()
        return peer

    def followed_controls(self):
        w = self.window
        return [w.length_choice.view, w.size_choice.view, w.landing_toggle,
                *(w.glow_style_choice.tile(value) for value in self.window.effect_stills),
                *(w.switch_style_choice.tile(value) for value in self.window.switch_stills),
                *w.glow_colour_choice._swatches.values()]

    def test_following_locks_the_followed_design_controls_under_a_banner(self):
        self.follow()

        self.assertFalse(any(control.isEnabled() for control in self.followed_controls()))
        for control in (self.window.length_choice.view, self.window.size_choice.view,
                        self.window.glow_colour_choice.view, self.window.landing_toggle):
            self.assertAlmostEqual(control.graphicsEffect().opacity(), 0.45)
        for choice in (self.window.glow_style_choice, self.window.switch_style_choice):
            for tiles in choice.groups.values():
                self.assertAlmostEqual(tiles.view.graphicsEffect().opacity(), 0.45)
        self.assertTrue(self.window.glow_toggle.isEnabled())
        self.assertFalse(self.window.follow_banner.isHidden())
        self.assertEqual(self.window.follow_banner_label.text(), "Following MacBook Pro's design")

    def test_a_click_on_a_locked_control_changes_nothing_and_keeps_following(self):
        peer = self.follow(effect_length="long")
        self.sent.clear()

        QTest.mouseClick(self.window.length_choice.view, Qt.MouseButton.LeftButton)
        QTest.keyClick(self.window.length_choice.view, Qt.Key.Key_Left)
        self.window.landing_toggle.click()

        self.assertEqual(self.window.length_choice.value, "long")
        self.assertEqual(self.window._config.effect_length, "long")
        self.assertEqual(self.window._config.design_follow_peer, peer)
        self.assertEqual(self.sent, [])

    def test_stop_following_unlocks_the_controls_and_keeps_the_shown_design(self):
        self.follow(effect_length="long", glow_colour="ocean")

        self.window.stop_follow_button.click()

        self.assertEqual(self.window._config.design_follow_peer, "")
        self.assertTrue(all(control.isEnabled() for control in self.followed_controls()))
        self.assertTrue(self.window.follow_banner.isHidden())
        self.assertEqual((self.window.length_choice.value, self.window._config.effect_length), ("long", "long"))
        self.assertEqual((self.window.glow_colour_choice.value, self.window._config.glow_colour), ("ocean", "ocean"))
        self.assertEqual(self.sent[-1][1]["design_sync"]["values"]["effect_length"], "long")

    def test_unpairing_the_followed_machine_resets_the_selection(self):
        peer = protocol.id_text(harness.B)
        self.window._config.design_follow_peer = peer
        with mock.patch.object(self.window.book, "peers", return_value=[]), \
                mock.patch.object(self.window.book, "zones", return_value=[]):
            self.window._refresh_peers()

        self.assertEqual(self.window._config.design_follow_peer, "")

    def test_same_on_all_machines_keeps_precedence_over_a_followed_design(self):
        peer = protocol.id_text(harness.B)
        self.pair_peer(peer)
        self.window._config.design_follow_peer = peer
        self.window._config.same_on_both = True
        self.window._config.same_set_at = 100
        self.window._config.same_groups = list(settings_sync.ALL_GROUPS)
        received = settings_sync.message_data(
            True, 101, settings_sync.pc_values(self.window._config), by=peer,
            design_state={"set_at": 202, "by": peer,
                          "values": {"effect_length": "long"}},
        )

        self.window._on_settings(peer, received)

        self.assertEqual(self.window._config.effect_length, "normal")
        self.assertEqual(self.window._config.design_follow_peer, protocol.id_text(harness.B))

    def test_an_older_peer_is_disabled_in_match_design_with(self):
        self.window._peer_entries = [harness.entry(harness.B, "Old PC")]
        self.peers = {harness.B: {"settings"}}
        self.window._design_peer_caps = lambda: {protocol.id_text(harness.B): {"settings"}}

        self.window._refresh_design_follow()

        self.assertFalse(self.window.design_follow_choice.model().item(1).isEnabled())
        self.assertIn("Needs beta.6 or later", self.window.design_follow_choice.itemText(1))

    def test_design_follow_keeps_its_model_until_inputs_change(self):
        self.window._design_peer_caps = lambda: {}
        self.window._refresh_design_follow()
        model = self.window.design_follow_choice.model()

        self.window._refresh_design_follow()

        self.assertIs(self.window.design_follow_choice.model(), model)

    def test_design_follow_refreshes_rows_when_peer_capabilities_change(self):
        peer = harness.entry(harness.B, "MacBook Pro")
        self.window._peer_entries = [peer]
        caps = {}
        self.window._design_peer_caps = lambda: caps
        self.window._refresh_design_follow()
        model = self.window.design_follow_choice.model()
        self.assertEqual(model.rowCount(), 1)

        caps[peer["id"]] = {"settings"}
        self.window._refresh_design_follow()

        self.assertIs(self.window.design_follow_choice.model(), model)
        self.assertEqual(model.rowCount(), 2)

    def test_design_follow_updates_lock_when_same_on_design_changes(self):
        peer = harness.entry(harness.B, "MacBook Pro")
        self.window._peer_entries = [peer]
        self.window._design_peer_caps = lambda: {peer["id"]: {"settings", "layout", "design_sync"}}
        self.window._config.design_follow_peer = peer["id"]
        self.window._config.same_on_both = False
        self.window._config.same_groups = []
        self.window._design_states[peer["id"]] = {"set_at": 1, "by": peer["id"], "values": {}}
        self.window._refresh_design_follow()
        self.assertFalse(self.window.follow_banner.isHidden())

        self.window._config.same_on_both = True
        self.window._config.same_groups = ["design"]
        self.window._refresh_design_follow()

        self.assertTrue(self.window.follow_banner.isHidden())

    def test_design_follow_label_refreshes_when_hide_addresses_changes(self):
        peer = harness.entry(harness.B, "192.168.1.10")
        self.window._peer_entries = [peer]
        self.window._design_peer_caps = lambda: {peer["id"]: {"settings", "layout", "design_sync"}}
        self.window._config.design_follow_peer = peer["id"]
        self.window._design_states[peer["id"]] = {"set_at": 1, "by": peer["id"], "values": {}}
        self.window._config.hide_addresses = False
        self.window._refresh_design_follow()
        model = self.window.design_follow_choice.model()
        self.assertEqual(model.item(1).text(), "192.168.1.10")

        self.window._config.hide_addresses = True
        self.window._refresh_design_follow()

        self.assertEqual(model.item(1).text(), pages_win.HIDDEN)

    def test_peer_refresh_reads_peers_and_zones_from_one_snapshot(self):
        peer = harness.entry(harness.B, "MacBook Pro")
        zone = {"peer": peer["id"], "side": "left"}
        snapshot = mock.Mock(return_value=([peer], [zone]))
        self.window.book.snapshot = snapshot
        peers = mock.Mock(side_effect=AssertionError("peers() must not read a second snapshot"))
        zones = mock.Mock(side_effect=AssertionError("zones() must not read a second snapshot"))
        self.window.book.peers = peers
        self.window.book.zones = zones

        self.window._refresh_peers()

        snapshot.assert_called_once_with()
        peers.assert_not_called()
        zones.assert_not_called()
        self.assertEqual(self.window._peer_entries, [peer])
        self.assertEqual(self.window._zone_entries, [zone])
        snapshot.return_value = ([], [])
        self.window._refresh_peers()
        self.assertEqual(snapshot.call_count, 2)
        self.assertEqual(self.window._peer_entries, [])

    def test_unchanged_refreshes_have_bounded_retained_python_memory(self):
        import gc
        import tracemalloc

        self.window._show_same()
        gc.collect()
        tracemalloc.start()
        before = tracemalloc.take_snapshot()
        for _ in range(400):
            self.window._refresh_window()
        gc.collect()
        after = tracemalloc.take_snapshot()
        tracemalloc.stop()
        retained = sum(stat.size_diff for stat in after.compare_to(before, "filename")
                       if "/win_app/" in str(stat.traceback))

        self.assertLess(retained, 64 * 1024, f"retained Qt refresh allocations: {retained} bytes")

    def test_the_macs_settings_arrive_on_this_pcs_fields_and_controls(self):
        self.window._on_settings(protocol.id_text(harness.B), mac_message(True, 100))
        config = self.window._config
        self.assertTrue(config.same_on_both)
        self.assertNotIn("shortcut", config.crossing_methods)
        self.assertEqual((config.glow_style, config.glow_colour, config.effect_length), ("beam", "ocean", "long"))
        self.assertEqual((config.trigger_style, config.double_tap_ms, config.shortcut_arrival), ("hold", 400, False))
        self.assertTrue(config.edge_glow)
        self.assertEqual(load_config(self.path).glow_style, "beam")
        self.assertEqual(self.window.resistance_slider.value(), 60)
        self.assertFalse(self.window.landing_toggle.isChecked())
        self.window._refresh_window()
        self.assertTrue(self.window.same_checks["crossing"].isChecked())
        self.assertNotIn("crossing", self.window.scope_labels)
        self.assertFalse(self.window.dragging_switch.isChecked())
        # Applying what arrived is not a change made here: it goes on to the other peer and never back.
        self.assertEqual([peer for peer, _data in self.sent], [harness.C])

    def test_an_older_message_changes_nothing(self):
        self.window._on_settings(protocol.id_text(harness.B), mac_message(True, 100))
        self.window._on_settings(protocol.id_text(harness.B), mac_message(True, 90, glow_style="glow"))
        self.assertEqual(self.window._config.glow_style, "beam")

    def test_a_state_a_peer_already_holds_is_not_sent_on_again(self):
        self.window._on_settings(protocol.id_text(harness.B), mac_message(True, 100))
        self.sent.clear()
        self.window._on_settings(protocol.id_text(harness.C), mac_message(True, 100))
        self.assertEqual(self.sent, [])

    def test_a_peer_without_the_settings_capability_is_sent_none(self):
        self.peers[harness.C] = set()
        self.window.same_checks["everything"].setChecked(True)
        self.assertEqual([peer for peer, _data in self.sent], [harness.B])

    def test_turning_it_on_here_sends_this_pcs_values_to_every_peer_that_takes_them(self):
        self.window.same_checks["everything"].setChecked(True)
        self.assertEqual([peer for peer, _data in self.sent], [harness.B, harness.C])
        data = self.sent[0][1]
        self.assertTrue(data["on"])
        self.assertIs(data["crossing"]["shortcut"], True)

    def test_a_change_here_while_on_is_stamped_and_sent_and_one_to_this_pcs_own_is_not(self):
        self.window.same_checks["everything"].setChecked(True)
        stamp = self.window._config.same_set_at
        self.sent.clear()
        self.window._config.same_set_at = stamp - 10
        self.window._config.edge_glow = False
        self.window._persist()
        self.assertEqual(self.sent, [])
        self.window._config.effect_length = "short"
        self.window._config.effect_pace = 0.5
        self.window._persist()
        self.assertEqual(len(self.sent), 2)
        self.assertGreaterEqual(self.window._config.same_set_at, stamp)
        self.assertEqual(self.window._config.same_by, self.window._config.machine_id)
        self.assertEqual(self.sent[0][1]["design"]["effect_length"], "short")

    # Per-key stamps (rc14, 10-10-2026): an edit carries only what a person changed.
    def test_a_change_here_stamps_only_that_value_and_the_state_carries_each_stamp(self):
        config = self.window._config
        seed = [config.same_set_at, config.same_by]
        self.window.same_checks["everything"].setChecked(True)
        self.sent.clear()
        self.window._config.crossing_resistance_px = 60
        self.window._persist()
        config = self.window._config
        stamps = config.same_stamps
        self.assertEqual(stamps["resistance_px"][1], config.machine_id)
        self.assertEqual({key for key, stamp in stamps.items() if list(stamp) != seed}, {"resistance_px"},
                         "turning it on froze every other value at the stamp it held")
        self.assertEqual(app_config.load_settings(self.path)["same_stamps"]["resistance_px"],
                         list(stamps["resistance_px"]))
        sent = self.sent[0][1]
        self.assertEqual(sent["stamps"]["resistance_px"], list(stamps["resistance_px"]))
        self.assertEqual(sent["stamps"]["glow_colour"], seed)
        self.assertGreaterEqual(sent["set_at"], stamps["resistance_px"][0])
        self.assertEqual(self.window._same_state()["stamps"], sent["stamps"])

    def test_a_newer_value_in_an_older_state_is_taken_alone_and_a_newer_one_here_is_answered(self):
        self.window.same_checks["everything"].setChecked(True)
        self.window._config.crossing_resistance_px = 60
        self.window._persist()
        config = self.window._config
        policy = (config.same_set_at, config.same_by)
        mine = config.same_stamps["resistance_px"][0]
        self.sent.clear()
        peer = protocol.id_text(harness.B)
        stamps = settings_sync.held_stamps({"glow_colour": [5, peer], "resistance_px": [4, peer]}, 0, "")
        data = settings_sync.message_data(True, policy[0] - 1, dict(
            resistance_px=30, glow_colour="ocean", trigger_key="alt_r"), by=peer,
            groups=settings_sync.ALL_GROUPS, stamps=stamps)
        self.window._on_settings(peer, data)
        config = self.window._config
        self.assertEqual((config.glow_colour, config.crossing_resistance_px), ("ocean", 60))
        self.assertNotEqual(config.trigger_key, "alt_r")
        self.assertEqual((config.same_set_at, config.same_by), policy)
        self.assertEqual(config.same_stamps["glow_colour"], [5, peer])
        forwarded = [sent for to, sent in self.sent if to == harness.C and sent["by"] == peer]
        self.assertEqual([sent["stamps"] for sent in forwarded], [data["stamps"]], "what it took goes on as it came")
        answers = [sent for to, sent in self.sent if to == harness.B]
        self.assertEqual(len(answers), 1)
        self.assertEqual(answers[0]["stamps"]["resistance_px"], [mine, config.machine_id])

    def test_a_value_changed_here_while_off_outlives_an_older_state_turning_it_on(self):
        self.window._config.crossing_resistance_px = 60
        self.window._persist()
        self.assertEqual(self.sent, [])
        config = self.window._config
        mine = config.same_stamps["resistance_px"]
        self.assertEqual(mine[1], config.machine_id)
        peer = protocol.id_text(harness.B)
        self.window._on_settings(peer, mac_message(True, mine[0] - 1, resistance_px=30))
        config = self.window._config
        self.assertTrue(config.same_on_both)
        self.assertEqual((config.crossing_resistance_px, config.glow_colour), (60, "ocean"))
        answer = [sent for to, sent in self.sent if to == harness.B][-1]
        # The value travels with its own stamp, newer than the state it comes in.
        self.assertEqual(answer["stamps"]["resistance_px"], mine)
        held = settings_sync.held_stamps({}, mine[0] - 1, peer)
        back = settings_sync.merge(answer, held, mine[0] - 1, kvm_bridge_win.TRIGGER_KEYS, by_here=peer,
                                   on_here=True, current_groups=settings_sync.ALL_GROUPS)
        self.assertEqual(back["values"], {"resistance_px": 60})

    def test_a_save_after_a_link_replaced_the_first_peer_does_not_bring_the_old_pairing_back(self):
        # A fold removed the entry migrated from 1.4.x; the window still holds its token.
        settings = app_config.load_settings(self.path)
        settings["peers"] = [harness.entry(harness.B, "Mac", linked=True, token=harness.TOKENS[harness.B])]
        settings["zones"] = []
        app_config.write_settings(self.path, settings)
        self.window._config.effect_length = "short"
        self.window._config.effect_pace = 0.5
        self.assertTrue(self.window._persist())
        saved = app_config.load_settings(self.path)
        self.assertEqual([peer["token"] for peer in saved["peers"]], [harness.TOKENS[harness.B]])
        self.assertEqual(self.window._config.auth_token, harness.TOKENS[harness.B])

    def test_a_state_that_goes_on_is_forwarded_with_this_pcs_direct_design_state(self):
        self.peers = {harness.B: {"settings"}, harness.C: {"settings"}}
        message = mac_message(True, 100)
        self.window._on_settings(protocol.id_text(harness.B), message)
        self.assertEqual(len(self.sent), 1)
        self.assertEqual(self.sent[0][0], harness.C)
        forwarded = self.sent[0][1]
        self.assertEqual({key: value for key, value in forwarded.items() if key != "design_sync"},
                         {key: value for key, value in message.items() if key != "design_sync"})
        self.assertEqual(forwarded["design_sync"]["by"], self.window._config.machine_id)

    def test_a_design_change_here_while_off_announces_its_local_state(self):
        self.window._config.effect_length = "short"
        self.window._config.effect_pace = 0.5
        self.window._persist()
        self.assertEqual(len(self.sent), 2)
        self.assertTrue(all(message["design_sync"]["values"]["effect_length"] == "short"
                            for _peer, message in self.sent))

    def test_announcing_carries_a_chosen_arrangement_the_peers_it_may_send_to_and_the_settings(self):
        settings = app_config.load_settings(self.path)
        settings["peers"][0]["id"] = protocol.id_text(harness.B)
        inactive = dict(settings["peers"][0], id=protocol.id_text(harness.C), token="inactive", in_use=False)
        settings["peers"].append(inactive)
        app_config.write_settings(self.path, settings)
        self.peers = {harness.B: {"settings"}}
        messages = self.window._announce(harness.B)
        self.assertEqual([m["type"] for m in messages], ["arrangement", "paired", "settings"])
        self.assertEqual(messages[1]["data"]["ids"], [])
        settings["peers"][0].update(side="left", side_set_at=500, side_by=self.window._config.machine_id)
        app_config.write_settings(self.path, settings)
        messages = self.window._announce(harness.B)
        self.assertEqual(messages[0]["type"], "arrangement")
        self.assertEqual(messages[0]["data"]["edge"], "left")
        self.assertEqual(messages[0]["data"]["set_at"], 500)

    def test_a_followed_design_is_not_stamped_as_this_pcs_choice(self):
        # The Mac's follow path stamps nothing; stamped here, a copied design beat a real choice.
        peer = protocol.id_text(harness.B)
        self.pair_peer(peer)
        config = self.window._config
        config.same_on_both, config.same_groups, config.same_set_at = True, ["crossing"], 10
        self.window._same_seen = self.window._same_fields()
        config.design_follow_peer = peer
        self.window._design_states[peer] = {"set_at": 100, "by": peer, "values": {"glow_colour": "ocean"}}
        self.window._apply_followed_design(force=True)
        self.assertEqual(self.window._config.glow_colour, "ocean")
        stamp = settings_sync.held_stamps(config.same_stamps, config.same_set_at, config.same_by)["glow_colour"]
        self.assertNotEqual(stamp[1], config.machine_id, "the followed colour was stamped as chosen here")


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