Skip to content

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

11.9 KB
Raw Blame
"""Same on all machines past the per-key suite (rc16 bug hunt, 11-10-2026): a group holding a 1.5.1
machine, two edits whose messages cross in flight, four desks, and a machine paired again, each
through the apps' own arrival code (settings_behaviour's fixtures) and recipients()' routing."""

import time
import unittest

from core import settings_sync
from core.tests.settings_behaviour import IDS, fixture
from core.tests.test_settings_per_key_desks import CHOICES
from core.tests.test_settings_per_key_review import FOURTH, RoutedDesks

# Beamer 1.5.1's shared keys (release/1.5.1 a4d36dfa, core/settings_sync.py): it reads nothing else.
OLD_CROSSING = ("resistance_px", "block_while_dragging", "shortcut", "trigger_key", "trigger_style", "double_tap_ms")
OLD_DESIGN = ("glow_style", "glow_colour", "effect_length", "effect_size", "shortcut_arrival",
              "shortcut_arrival_style")
OLD_KEYS = OLD_CROSSING + OLD_DESIGN
TRIGGER_KEYS = {"cmd_r", "f13"}


class OldPeer:
    """A 1.5.1 desk, as its settings_sync.arrived and each app's apply_same behave: one stamp for the
    whole state; a newer whole state is taken outright, its values only while on, and sent on
    unchanged; groups and per-value stamps are unknown and ignored."""

    def __init__(self, ident, values):
        self.ident = ident
        self.on, self.set_at, self.by = False, 0, ""
        self.shared = {key: values[key] for key in OLD_KEYS if key in values}
        self.routed = []

    def state(self):
        data = {"on": self.on, "set_at": self.set_at, "by": self.by}
        if self.on:
            data["crossing"] = {key: self.shared[key] for key in OLD_CROSSING}
            data["design"] = {key: self.shared[key] for key in OLD_DESIGN}
        return data

    def receive(self, source, data):
        if not settings_sync._valid_envelope(data):
            return
        by = settings_sync._id(data.get("by", ""))
        mine = settings_sync._id(self.by) or b""
        if not (data["set_at"] > self.set_at or (data["set_at"] == self.set_at and by > mine)):
            return
        self.on, self.set_at, self.by = data["on"], data["set_at"], data.get("by", "")
        if self.on:
            for section, keys in (("crossing", OLD_CROSSING), ("design", OLD_DESIGN)):
                given = data.get(section) if isinstance(data.get(section), dict) else {}
                self.shared.update({key: given[key] for key in keys
                                    if key in given and settings_sync._valid(key, given[key], TRIGGER_KEYS)})
        self.routed.append((dict(data), source))

    def edit(self, **values):
        self.shared.update(values)
        self.set_at = settings_sync.next_stamp(self.set_at, time.time())
        self.by = self.ident
        self.routed.append((self.state(), None))

    def values(self):
        return dict(self.shared)


class Group(RoutedDesks):
    def __init__(self, test, platforms, old=()):
        super().__init__(test, platforms)
        for index in old:
            self.apps[index] = OldPeer(IDS[index], self.apps[index].values())

    def link_all(self):
        for one in range(len(self.apps)):
            for other in range(one + 1, len(self.apps)):
                self.link(one, other)

    def unlink(self, index):
        self.links = {pair for pair in self.links if index not in pair}

    def old_edit(self, index, **values):
        app = self.apps[index]
        app.edit(**values)
        message, _source = app.routed.pop()
        self.run([(index, message, set(range(len(self.apps))) - {index})])

    def deliver_crossed(self, *indices):
        """Each of `indices` announces its state to every other at once, as messages in flight cross."""
        everyone = set(range(len(self.apps)))
        self.run([(index, self.apps[index].state(), everyone - {index}) for index in indices])

    def agree(self, keys, indices=None):
        indices = range(len(self.apps)) if indices is None else indices
        seen = [{key: self.apps[index].values().get(key) for key in keys} for index in indices]
        self.test.assertTrue(all(item == seen[0] for item in seen), f"the desks disagree: {seen}")
        return seen[0]


class MixedWithOnePointFiveOne(unittest.TestCase):
    """A Mac and a PC on 1.5.2 and a PC still on 1.5.1, every pair linked, Same on everywhere."""

    def setUp(self):
        self.group = Group(self, ("mac", "win", "win"), old=(2,))
        self.mac, self.pc, self.old = self.group.apps
        self.mac._set_same(True)
        self.mac.routed.clear()
        self.group.link_all()
        self.assertTrue(self.old.on, "the 1.5.1 machine follows Same on")
        self.group.edit(0, **CHOICES)

    def test_a_new_machines_edit_reaches_the_old_one(self):
        old_choices = {key: value for key, value in CHOICES.items() if key in OLD_KEYS}
        self.assertEqual({key: self.old.values()[key] for key in old_choices}, old_choices)
        self.group.agree(CHOICES, (0, 1))

    def test_an_old_machines_edit_reaches_both_and_moves_nothing_else(self):
        time.sleep(1.1)
        self.group.old_edit(2, glow_colour="mono")
        expected = dict(CHOICES, glow_colour="mono")
        for index in (0, 1):
            self.assertEqual(self.group.shared(index), expected, f"desk {index}")

    def test_a_value_only_1_5_2_has_survives_an_old_machines_edit(self):
        self.group.edit(1, shortcut_goes_to="ticked")
        time.sleep(1.1)
        self.group.old_edit(2, trigger_style="double_tap")
        for index in (0, 1):
            values = self.group.apps[index].values()
            self.assertEqual(values["shortcut_goes_to"], "ticked", f"desk {index}")
            self.assertEqual(values["trigger_style"], "double_tap", f"desk {index}")

    def test_the_old_machine_away_for_an_edit_learns_it_when_its_links_come_back(self):
        self.group.online.discard(2)
        self.group.edit(0, glow_colour="aurora")
        self.group.online.add(2)
        self.group.link(2, 0)
        self.group.link(2, 1)
        self.assertEqual(self.old.values()["glow_colour"], "aurora")
        self.group.agree(OLD_KEYS)

    def test_a_new_machine_away_for_an_old_machines_edit_learns_it_when_back(self):
        self.group.online.discard(1)
        time.sleep(1.1)
        self.group.old_edit(2, effect_length="short")
        self.group.online.add(1)
        self.group.link(1, 0)
        self.group.link(1, 2)
        self.assertEqual(self.pc.values()["effect_length"], "short")
        self.group.agree(OLD_KEYS)


class OldMachineTurnsItOn(unittest.TestCase):
    """Same off everywhere; a person turns it on on the 1.5.1 machine, which sends no groups."""

    def setUp(self):
        self.group = Group(self, ("mac", "win", "win"), old=(2,))
        self.mac, self.pc, self.old = self.group.apps
        self.group.link_all()
        self.assertFalse(any(app.cfg().same_on_both for app in (self.mac, self.pc)))

    def test_both_new_machines_share_every_group_and_take_its_values(self):
        time.sleep(1.1)
        self.group.old_edit(2, glow_colour="mono", trigger_style="hold")
        self.old.on = True
        self.group.old_edit(2)
        for index, app in ((0, self.mac), (1, self.pc)):
            with self.subTest(desk=index):
                self.assertTrue(app.cfg().same_on_both)
                self.assertEqual(tuple(app.cfg().same_groups), settings_sync.ALL_GROUPS,
                                 "on from a peer that sends no groups shares every group, as turning it on here does")
                self.assertEqual(self.group.shared(index, ("glow_colour", "trigger_style")),
                                 {"glow_colour": "mono", "trigger_style": "hold"})


class TwoAtOnce(unittest.TestCase):
    """A person on each of two machines changes a shared value in the same moment: both messages are
    in flight before either lands."""

    def setUp(self):
        self.group = Group(self, ("mac", "win"))
        self.group.apps[0]._set_same(True)
        self.group.apps[0].routed.clear()
        self.group.link_all()
        self.group.edit(0, **CHOICES)

    def edit_unheard(self, index, **values):
        online = set(self.group.online)
        self.group.online.clear()
        self.group.edit(index, **values)
        self.group.online |= online

    def test_different_values_both_stand(self):
        time.sleep(1.1)
        self.edit_unheard(0, glow_colour="sunset")
        self.edit_unheard(1, trigger_style="double_tap")
        self.group.deliver_crossed(0, 1)
        expected = dict(CHOICES, glow_colour="sunset", trigger_style="double_tap")
        for index in (0, 1):
            self.assertEqual(self.group.shared(index), expected, f"desk {index}")

    def test_the_same_value_settles_on_one_choice_on_both(self):
        time.sleep(1.1)
        self.edit_unheard(0, glow_colour="sunset")
        self.edit_unheard(1, glow_colour="mono")
        self.group.deliver_crossed(0, 1)
        settled = self.group.agree(("glow_colour",))
        self.assertIn(settled["glow_colour"], ("sunset", "mono"))
        self.assertEqual(self.group.shared(0, ("trigger_style",)), {"trigger_style": "hold"})


class FourDesks(unittest.TestCase):
    def setUp(self):
        # A fourth desk for this case only: IDS is shared, and other suites assert on its length.
        IDS.append(FOURTH)
        self.addCleanup(IDS.remove, FOURTH)
        self.group = Group(self, ("mac", "win", "win", "win"))
        self.group.apps[0]._set_same(True)
        self.group.apps[0].routed.clear()
        self.group.link_all()

    def test_edits_on_three_machines_while_one_is_away_all_land_everywhere(self):
        self.group.edit(0, **CHOICES)
        self.group.agree(CHOICES)
        self.group.online.discard(3)
        time.sleep(1.1)
        self.group.edit(1, glow_colour="sunset")
        self.group.edit(2, trigger_style="double_tap")
        self.group.online.add(3)
        for other in range(3):
            self.group.link(3, other)
        expected = dict(CHOICES, glow_colour="sunset", trigger_style="double_tap")
        for index in range(4):
            self.assertEqual(self.group.shared(index), expected, f"desk {index}")

    def test_the_away_machines_own_edit_is_kept_and_it_takes_the_rest(self):
        self.group.edit(0, **CHOICES)
        self.group.online.discard(3)
        time.sleep(1.1)
        self.group.edit(1, glow_colour="sunset")
        time.sleep(1.1)
        online = set(self.group.online)
        self.group.online.clear()
        self.group.edit(3, effect_length="short")
        self.group.online |= online | {3}
        for other in range(3):
            self.group.link(3, other)
        expected = dict(CHOICES, glow_colour="sunset", effect_length="short")
        for index in range(4):
            self.assertEqual(self.group.shared(index), expected, f"desk {index}")


class PairedAgain(unittest.TestCase):
    def setUp(self):
        self.group = Group(self, ("mac", "win", "win"))
        self.group.apps[0]._set_same(True)
        self.group.apps[0].routed.clear()
        self.group.link_all()
        self.group.edit(0, **CHOICES)

    def test_a_machine_forgotten_and_paired_again_takes_what_changed_meanwhile(self):
        self.group.unlink(2)
        time.sleep(1.1)
        self.group.edit(1, glow_colour="sunset")
        self.group.link(2, 0)
        self.group.link(2, 1)
        for index in range(3):
            self.assertEqual(self.group.shared(index), dict(CHOICES, glow_colour="sunset"), f"desk {index}")

    def test_a_reinstalled_machine_adopts_the_group_and_changes_nobody(self):
        self.group.unlink(2)
        fresh = fixture("win", IDS[2])
        self.group.apps[2] = fresh
        fresh.routed = []
        fresh._send_same = lambda data=None, source=None: fresh.routed.append(
            (data if data is not None else fresh.state(), source))
        self.group.link(2, 0)
        self.group.link(2, 1)
        for index in range(3):
            self.assertEqual(self.group.shared(index), CHOICES, f"desk {index}")
        self.assertTrue(fresh.cfg().same_on_both)


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