Skip to content

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

9.1 KB
Raw Blame
"""Profiles over fake links and a synthetic book; no application or real input."""

import copy
import json
import sys
import threading
import unittest
from pathlib import Path
from types import SimpleNamespace
from unittest import mock

sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
sys.path.insert(0, str(Path(__file__).resolve().parent))

import bridge
import settings_store
from bridge_fakes import FakeClipboard, FakeQuartz, make_config, quiet_logger
from fake_link import FakeLink
from core import crossing_state, profiles, protocol, receiver
from core.tests.test_profiles import A, B, C, raw


class ProfileSyncTests(unittest.TestCase):
    def setUp(self):
        self.held, _ = profiles.before_load(raw(), now=100)
        self.held, _ = profiles.after_load(self.held, platform="mac", now=100)
        self.held["peers"].append(dict(id=C, port=24820, send=True, allow_drive=True))
        self.saved = []

        def save(settings):
            self.saved.append(copy.deepcopy(settings))
            self.held = copy.deepcopy(settings)

        self.controller = bridge.KVMController(make_config(), quartz=FakeQuartz,
            clipboard=FakeClipboard(), logger=quiet_logger(), link_factory=FakeLink)
        self.controller.book = receiver.PeerBook(lambda: self.held, save, threading.RLock())
        self.controller.announce = lambda: [protocol.settings_msg(dict(
            on=False, set_at=9, by=A, groups=[], layout={"tiles": {}}, design_sync={}))]
        self.sent = []
        self.controller._peers_up = {B: self.link(B), C: self.link(C)}
        self.controller.zones_changed = lambda: None
        # What linked peers were last told, as after the app's first publish at start.
        self.controller._desk_published = profiles.desk_message(self.held)

    def link(self, peer, caps=("settings", "profiles", "layout")):
        return SimpleNamespace(peer_id=peer, caps=frozenset(caps), live=lambda: True,
            post=lambda message: self.sent.append((peer, message)))

    def desks(self):
        return [(peer, message["data"]) for peer, message in self.sent
                if message["type"] == protocol.MSG_SETTINGS and "desk" in message["data"]]

    def test_local_register_edits_use_separate_frames_and_only_profile_peers(self):
        self.controller._peers_up[C] = self.link(C, ("settings", "layout"))
        outcome = crossing_state.set_same_ways(self.held, True, platform="mac", now=200)
        with mock.patch.object(profiles, "MAX_DESK_BYTES", 240):
            self.controller.carry_crossing(outcome)
        desks = self.desks()
        self.assertGreater(len(desks), 1)
        self.assertEqual({peer for peer, _ in desks}, {B})
        for _, data in desks:
            self.assertEqual(data["on"], False)
            self.assertEqual(data["set_at"], 9)
            self.assertEqual(data["by"], A)
            self.assertNotIn("layout", data)
            self.assertNotIn("design_sync", data)
        self.assertTrue(any("on" in data["desk"] for _, data in desks))

    def test_a_change_made_outside_a_crossing_event_still_reaches_linked_peers(self):
        # App review: pairing (and a load that reconciled) saved desk changes no event carried.
        changed = crossing_state.set_same_ways(self.held, True, platform="mac", now=200)["settings"]
        self.held = changed
        self.controller._peers_up[C] = self.link(C, ("settings", "layout"))
        self.controller.publish_desk()
        desks = self.desks()
        self.assertEqual({peer for peer, _ in desks}, {B}, "only peers with profiles")
        sent = [data["desk"] for _, data in desks]
        self.assertTrue(any("on" in desk for desk in sent))
        self.sent.clear()
        self.controller.publish_desk()
        self.assertEqual(self.desks(), [], "an unchanged desk is not sent again")

    def test_forward_goes_to_others_and_answer_only_to_source(self):
        forward = {"on": dict(value=True, set_at=202, by=B)}
        answer = {"active": dict(value=profiles.DESK_ID, set_at=203, by=A)}
        outcome = crossing_state._outcome(self.held, forward=forward, answer=answer)
        self.controller.carry_crossing(outcome, source=B)
        self.assertEqual([(peer, data["desk"]) for peer, data in self.desks()],
                         [(C, forward), (B, answer)])

    def test_inbound_link_gets_desk_without_duplicating_outbound(self):
        self.controller.responder = SimpleNamespace(links=lambda: [protocol.read_id(B), protocol.read_id(C)],
            caps_of=lambda ident: ("settings", "profiles"),
            send=lambda ident, message: self.sent.append((protocol.id_text(ident), message)))
        self.controller._peers_up.pop(C)
        self.controller._send_desk({"on": dict(value=False, set_at=0, by="")})
        self.assertEqual([peer for peer, _ in self.desks()], [B, C])

    def test_link_up_sends_whole_desk_only_to_that_peer(self):
        self.controller._announce_paired = lambda link: None
        self.controller.crossing_link_up = lambda peer: None
        self.controller._announce_to(self.controller._peers_up[B], {})
        desks = self.desks()
        self.assertEqual({peer for peer, _ in desks}, {B})
        self.assertEqual(desks[0][1]["desk"]["profiles"][profiles.DESK_ID]["name"]["value"], "Desk")

    def test_arrival_runs_crossing_event_and_saves_before_rearming(self):
        stages = []
        self.controller.zones_changed = lambda: stages.append("zones")
        self.controller.responder = SimpleNamespace(links=lambda: [],
            peers_changed=lambda: stages.append("peers"), rearm=lambda: stages.append("rearm"))
        data = dict(on=False, set_at=200, by=B,
                    desk={"on": dict(value=True, set_at=200, by=B)})
        outcome = self.controller.receive_desk(data, B, linked=True, now=201)
        self.assertTrue(outcome["accepted"])
        self.assertEqual(self.held["crossing_desk"]["on"]["value"], True)
        self.assertTrue(self.saved)
        self.assertEqual(stages, ["zones", "peers", "rearm"])
        self.assertTrue(self.controller.desk_last_heard[B])

    def test_unlinked_and_malformed_arrivals_do_not_change_settings(self):
        data = dict(on=False, set_at=200, by=B,
                    desk={"on": dict(value=True, set_at=200, by=B)})
        self.assertFalse(self.controller.receive_desk(data, B, linked=False, now=201)["accepted"])
        self.assertIsNone(self.controller.receive_desk({"desk": {}}, B, linked=True, now=201))
        self.assertFalse(self.saved)
        self.assertFalse(self.controller.desk_last_heard.get(B, False))

    def test_profile_capability_and_last_heard_reset_survive_reconnect(self):
        self.assertIn(B, self.controller.profiles_capable())
        self.controller.desk_last_heard[B] = True
        self.controller.reset_desk_peer(B)
        self.controller._peers_up.clear()
        self.assertIn(B, self.controller.profiles_capable())
        self.assertFalse(self.controller.desk_last_heard.get(B, False))

    def test_new_profile_event_does_not_inject_unsupported_capable_keyword(self):
        outcome = self.controller.crossing_event(crossing_state.new_profile, "Sofa", platform="mac", now=201)
        self.assertTrue(outcome["accepted"])
        self.assertIn("Sofa", [item["name"] for item in profiles.profile_list(self.held)])

    def test_inbound_announcement_sends_full_desk_and_caches_capability(self):
        from windows_input import WindowsInput
        inbound = WindowsInput.__new__(WindowsInput)
        inbound._controller = self.controller
        inbound.server = SimpleNamespace(links=lambda: [protocol.read_id(B)],
            caps_of=lambda ident: frozenset(("settings", "layout", "profiles")),
            send=lambda ident, message: self.sent.append((protocol.id_text(ident), message)))
        self.controller.responder = inbound.server
        self.controller._peers_up.clear()
        self.controller.crossing_link_up = lambda peer: None
        inbound._announce(protocol.read_id(B))
        self.assertEqual({peer for peer, _ in self.desks()}, {B})
        self.controller._peers_up.clear()
        inbound.server.links = lambda: []
        self.assertIn(B, self.controller.profiles_capable())


class LoadNoteTests(unittest.TestCase):
    def test_older_version_note_is_in_memory_and_consumed_once(self):
        import tempfile
        with tempfile.TemporaryDirectory(dir=Path(__file__).resolve().parents[2]) as directory:
            store = settings_store.SettingsStore(Path(directory) / "settings.json")
            held, _ = profiles.before_load(raw(), now=100)
            held, _ = profiles.after_load(held, platform="mac", now=100)
            held = store.save_settings(held)
            held["peers"][0]["ways"]["thirds"] = ["end"]
            store.path.write_text(json.dumps(held))
            loaded = store.load_settings()
            self.assertEqual(loaded["crossing_own"]["row"][B]["ways"]["thirds"], ["end"])
            self.assertTrue(store.take_profile_load_note("older_version"))
            self.assertFalse(store.take_profile_load_note("older_version"))
            self.assertNotIn("profile_load_notes", loaded)


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