Skip to content

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

15.1 KB
Raw Blame
import copy
import unittest

from core import crossing_state, profiles, protocol, ways


OWN, PEER, OTHER = (protocol.id_text(bytes([n]) * 16) for n in (1, 2, 3))
ALL = ["start", "middle", "end"]


def tile(x=0, y=0, w=160, h=100, **extra):
    return {"x": x, "y": y, "w": w, "h": h, **extra}


def base():
    default = {"edge": True, "thirds": ALL[:], "edges": [], "corner": False,
               "corner_at": "top_left", "corners": [], "notch": False}
    row = {PEER: {"ways": copy.deepcopy(default), "notch_return": False}}
    own_profile = {
        "name": {"value": "Desk", "set_at": 0, "by": ""}, "removed": None,
        "home": {"shake": {"value": True, "set_at": 0, "by": ""}},
        "rows": {OWN: {"set_at": 10, "by": OWN, "value": copy.deepcopy(row)}},
    }
    return {
        "machine_id": OWN,
        "peers": [{"id": PEER, "port": 24820, "side": "right", "send": True,
                   "ways": copy.deepcopy(row[PEER]["ways"]), "notch_return": False}],
        "zones": [], "layout": {OWN: tile(), PEER: tile(160)},
        "layout_set_at": 10, "layout_by": OWN,
        "crossing_desk": {"format": 1, "on": {"value": True, "set_at": 20, "by": OWN},
                           "active": {"value": profiles.DESK_ID, "set_at": 0, "by": ""},
                           "profiles": {profiles.DESK_ID: own_profile}, "status": {}},
        "crossing_own": {"format": 1, "use_own": False, "row": copy.deepcopy(row),
                         "shake": True, "applied": copy.deepcopy(row), "saved": []},
    }


class ProfileEventTests(unittest.TestCase):
    def test_existing_crossing_events_reconcile_and_report_desk_paths(self):
        held = base()
        out = crossing_state.edit_ways(held, PEER, thirds=["start"], platform="mac",
                                       live=lambda _: True, gone=lambda _: False, now=40)
        row = out["settings"]["crossing_desk"]["profiles"][profiles.DESK_ID]["rows"][OWN]
        self.assertEqual(row["value"][PEER]["ways"]["thirds"], ["start"])
        self.assertIn(("row", profiles.DESK_ID, OWN), out["send_desk"])
        self.assertEqual(out["settings"]["crossing_own"]["applied"],
                         profiles.live_row(out["settings"]))

    def test_turning_same_on_seeds_without_changing_live_crossings(self):
        held = base()
        held["crossing_desk"]["on"] = {"value": False, "set_at": 30, "by": OWN}
        held["crossing_desk"]["profiles"][profiles.DESK_ID]["rows"].pop(OWN)
        before = profiles.live_row(held)
        out = crossing_state.set_same_ways(held, True, platform="mac", now=40)
        self.assertTrue(out["accepted"])
        self.assertEqual(profiles.live_row(out["settings"]), before)
        row = out["settings"]["crossing_desk"]["profiles"][profiles.DESK_ID]["rows"][OWN]
        self.assertEqual(row["value"], before)
        self.assertEqual(row["set_at"], 40)

    def test_own_override_is_local_and_share_mine_writes_the_active_desk_row(self):
        held = base()
        enabled = crossing_state.set_own_ways(held, True, platform="mac", now=41)
        self.assertTrue(enabled["settings"]["crossing_own"]["use_own"])
        edited = crossing_state.edit_ways(enabled["settings"], PEER, edge=False, platform="mac",
                                          live=lambda _: True, gone=lambda _: False, now=42)
        changed = edited["settings"]["crossing_own"]["row"]
        shared = crossing_state.share_mine(edited["settings"], platform="mac", now=43)
        row = shared["settings"]["crossing_desk"]["profiles"][profiles.DESK_ID]["rows"][OWN]
        self.assertEqual(row["value"], changed)
        self.assertTrue(any(path[0] == "row" for path in shared["send_desk"]))

    def test_edit_other_changes_only_the_target_machine_row(self):
        held = base()
        target_row = {OWN: {"ways": {"edge": True, "thirds": ALL[:], "edges": [],
                                     "corner": False, "corner_at": "top_left",
                                     "corners": [], "notch": False}, "notch_return": False}}
        held["crossing_desk"]["profiles"][profiles.DESK_ID]["rows"][OTHER] = {
            "set_at": 5, "by": OWN, "value": target_row}
        out = crossing_state.edit_other(held, OTHER, OWN, thirds=["end"], platform="mac", now=50)
        row = out["settings"]["crossing_desk"]["profiles"][profiles.DESK_ID]["rows"][OTHER]
        self.assertEqual(row["value"][OWN]["ways"]["thirds"], ["end"])
        self.assertEqual(profiles.live_row(out["settings"]), profiles.live_row(held))

    def test_edit_other_keeps_the_last_thirds_choice_and_refuses_a_held_corner(self):
        held = base()
        row = {OWN: {"ways": {"edge": True, "thirds": ["middle"], "edges": [],
                              "corner": False, "corner_at": "top_left", "corners": [],
                              "notch": False}, "notch_return": False},
               PEER: {"ways": {"edge": True, "thirds": ALL[:], "edges": [],
                               "corner": True, "corner_at": "top_left",
                               "corners": ["top_left"], "notch": False},
                      "notch_return": False}}
        held["crossing_desk"]["profiles"][profiles.DESK_ID]["rows"][OTHER] = {
            "set_at": 5, "by": OWN, "value": row}
        kept = crossing_state.edit_other(held, OTHER, OWN, thirds=[], platform="mac", now=50)
        self.assertEqual(kept["settings"]["crossing_desk"]["profiles"][profiles.DESK_ID]
                         ["rows"][OTHER]["value"][OWN]["ways"]["thirds"], ["middle"])
        refused = crossing_state.edit_other(held, OTHER, OWN, corner=True,
                                            corner_at="top_left", platform="mac", now=51)
        self.assertFalse(refused["accepted"])
        self.assertEqual(refused["settings"], held)

    def test_edit_other_ignores_notch_controls_for_a_non_mac_target(self):
        held = base()
        held["crossing_desk"]["status"][OTHER] = {"set_at": 1, "by": OTHER,
            "value": {"app": "1.5.4", "platform": "windows", "in_force": "desk",
                      "profile": profiles.DESK_ID, "row": None, "waiting": []}}
        held["crossing_desk"]["profiles"][profiles.DESK_ID]["rows"][OTHER] = {
            "set_at": 5, "by": OWN,
            "value": {OWN: {"ways": {"edge": True, "thirds": ALL[:], "edges": [],
                                      "corner": False, "corner_at": "top_left", "corners": [],
                                      "notch": False}, "notch_return": False}}}
        out = crossing_state.edit_other(held, OTHER, OWN, notch=True, notch_return=True,
                                        platform="mac", now=50)
        intent = (out["settings"]["crossing_desk"]["profiles"][profiles.DESK_ID]
                  ["rows"][OTHER]["value"][OWN])
        self.assertFalse(intent["ways"]["notch"])
        self.assertFalse(intent["notch_return"])

    def test_other_row_edits_and_share_mine_are_refused_while_sync_is_off(self):
        held = base()
        held["crossing_desk"]["on"] = {"value": False, "set_at": 30, "by": OWN}
        edited = crossing_state.edit_other(held, OTHER, OWN, edge=False, now=40)
        shared = crossing_state.share_mine(held, now=41)
        self.assertFalse(edited["accepted"])
        self.assertFalse(shared["accepted"])
        self.assertEqual(edited["settings"], held)
        self.assertEqual(shared["settings"], held)

    def test_profile_switch_snapshots_old_picture_and_activates_new_picture(self):
        held = base()
        held["layout"][OWN]["display_offsets"] = {"0": {"x": 50, "y": 0}}
        held["layout"][OWN]["displays"] = {"0": tile()}
        held["peers"].append({"id": OTHER, "port": 24820, "side": "right", "send": True,
                              "ways": copy.deepcopy(held["peers"][0]["ways"])})
        held["layout"][OTHER] = tile(320)
        held["crossing_desk"]["profiles"][profiles.DESK_ID]["picture"] = None
        created = crossing_state.new_profile(held, "Sofa", now=50)
        sofa = next(pid for pid in created["settings"]["crossing_desk"]["profiles"]
                    if pid != profiles.DESK_ID)
        created["settings"]["crossing_desk"]["profiles"][sofa]["picture"] = {
            "set_at": 50, "by": OWN,
            "tiles": {OWN: {**tile(), "display_offsets": {"unplugged": {"x": 5, "y": 0}}},
                      PEER: tile(160)}}
        switched = crossing_state.switch_profile(created["settings"], sofa, platform="mac", now=60)
        desk = switched["settings"]["crossing_desk"]["profiles"][profiles.DESK_ID]
        self.assertEqual(desk["picture"]["tiles"][OWN]["x"], 0)
        self.assertEqual(desk["picture"]["tiles"][OWN]["display_offsets"], {"0": {"x": 50, "y": 0}})
        self.assertEqual(switched["settings"]["crossing_desk"]["active"]["value"], sofa)
        # Kept while active so every machine's desk is the same; not read until it is left again.
        self.assertIn("picture", switched["settings"]["crossing_desk"]["profiles"][sofa])
        self.assertTrue(switched["send_picture"])
        self.assertNotIn("display_offsets", switched["settings"]["layout"][OWN])
        self.assertIn("displays", switched["settings"]["layout"][OWN])
        self.assertEqual(switched["settings"]["layout"][OTHER]["x"], 320)

    def test_shake_setting_changes_the_in_force_register(self):
        held = base()
        held["crossing_own"]["use_own"] = True
        out = crossing_state.set_shake(held, False, now=70)
        self.assertFalse(profiles.shake_on(out["settings"]))
        self.assertIn(("home", profiles.DESK_ID, "shake"), out["send_desk"])

    def test_shake_sensitivity_is_profile_synced_and_local_when_same_ways_is_off(self):
        held = base()
        out = crossing_state.set_shake_sensitivity(held, 150, now=70)
        self.assertTrue(out["accepted"])
        self.assertEqual(profiles.shake_sensitivity(out["settings"]), 150)
        self.assertIn(("home", profiles.DESK_ID, "sensitivity"), out["send_desk"])

        held["crossing_desk"]["on"]["value"] = False
        local = crossing_state.set_shake_sensitivity(held, 75, now=71)
        self.assertEqual(profiles.shake_sensitivity(local["settings"]), 75)
        self.assertNotIn(("home", profiles.DESK_ID, "sensitivity"), local["send_desk"])

    def test_shake_sensitivity_rejects_values_outside_the_control_range(self):
        for value in (49, 201, True):
            with self.subTest(value=value):
                self.assertFalse(crossing_state.set_shake_sensitivity(base(), value, now=70)["accepted"])

    def test_shake_sensitivity_delta_reaches_peer_without_overwriting_local_preference(self):
        edited = crossing_state.set_shake_sensitivity(base(), 150, now=70)
        target = base()
        target["crossing_own"]["shake_sensitivity"] = 80
        target["peers"][0].update(allow_drive=True, linked=True)
        packet = profiles.desk_message(edited["settings"], edited["send_desk"])
        received, *_ = profiles.merge_desk(target, packet, source=PEER, now=71)
        self.assertEqual(profiles.shake_sensitivity(received), 150)
        loaded, _ = profiles.before_load(received, now=72)
        self.assertEqual(profiles.shake_sensitivity(loaded), 150)
        local = crossing_state.set_same_ways(loaded, False, now=73)["settings"]
        self.assertEqual(profiles.shake_sensitivity(local), 80)

    def test_new_profile_carries_the_active_shake_sensitivity(self):
        held = crossing_state.set_shake_sensitivity(base(), 150, now=70)["settings"]
        created = crossing_state.new_profile(held, "Studio", now=71)
        profile_id = next(pid for pid in created["settings"]["crossing_desk"]["profiles"]
                          if pid != profiles.DESK_ID)
        self.assertEqual(profiles.shake_sensitivity(created["settings"]), 150)
        self.assertEqual(created["settings"]["crossing_desk"]["profiles"][profile_id]
                         ["home"]["sensitivity"]["value"], 150)
        self.assertIn(("home", profile_id, "sensitivity"), created["send_desk"])

    def test_same_ways_toggle_sends_the_register_even_when_a_seed_is_also_written(self):
        held = base()
        held["crossing_desk"]["on"] = {"value": False, "set_at": 30, "by": OWN}
        out = crossing_state.set_same_ways(held, True, platform="mac", now=40)
        self.assertIn(("on",), out["send_desk"])

    def test_event_rolls_back_when_the_mutation_exceeds_the_desk_size_cap(self):
        created = crossing_state.new_profile(base(), "Sofa", now=70)
        held = created["settings"]
        sofa = next(pid for pid in held["crossing_desk"]["profiles"] if pid != profiles.DESK_ID)
        held["crossing_desk"]["status"][OTHER] = {
            "set_at": 1, "by": OTHER,
            "value": {"app": "x" * profiles.MAX_DESK_BYTES, "platform": "mac",
                      "in_force": "desk", "profile": profiles.DESK_ID,
                      "row": None, "waiting": []}}
        out = crossing_state.switch_profile(held, sofa, platform="mac", now=71)
        self.assertFalse(out["accepted"])
        self.assertEqual(out["reason"], "desk_full")
        self.assertEqual(out["settings"], held)
        self.assertFalse(out["send_picture"])
        self.assertFalse(out["forward_picture"])
        self.assertEqual(out["forward"], {})
        self.assertEqual(out["answer"], {})
        self.assertEqual(out["tell"], [])

    def test_forward_contains_only_registers_taken_from_the_peer(self):
        held = base()
        held["crossing_desk"]["on"] = {"value": False, "set_at": 30, "by": OWN}
        held["peers"][0].update(allow_drive=True, linked=True)
        received_on = {"value": True, "set_at": 90, "by": PEER}
        out = crossing_state.desk_arrived(held, {"on": received_on}, source=PEER,
                                          platform="mac", now=100)
        self.assertTrue(out["accepted"])
        self.assertEqual(out["forward"], {"on": received_on})
        self.assertIn(("row", profiles.DESK_ID, OWN), out["send_desk"])

    def test_desk_arrival_is_refused_from_a_peer_that_cannot_drive(self):
        held = base()
        held["peers"][0]["allow_drive"] = False
        state = profiles.desk_message(held)
        out = crossing_state.desk_arrived(held, state, source=PEER, platform="mac", now=80)
        self.assertFalse(out["accepted"])
        self.assertEqual(out["reason"], "untrusted")
        self.assertEqual(out["settings"], held)

    def test_saved_row_restore_archives_the_row_it_replaces(self):
        held = base()
        old = copy.deepcopy(held["crossing_own"]["row"])
        old[PEER]["ways"]["edge"] = False
        profiles.archive(held, old, "edited", 11)
        saved_id = held["crossing_own"]["saved"][0]["id"]
        out = crossing_state.restore_saved(held, saved_id, platform="mac", now=90)
        self.assertFalse(out["settings"]["crossing_own"]["row"][PEER]["ways"]["edge"])
        self.assertGreaterEqual(len(out["settings"]["crossing_own"]["saved"]), 2)

    def test_deleting_saved_row_does_not_change_live_or_desk_state(self):
        held = base()
        profiles.archive(held, held["crossing_own"]["row"], "edited", 11)
        saved_id = held["crossing_own"]["saved"][0]["id"]
        out = crossing_state.delete_saved(held, saved_id)
        self.assertEqual(out["settings"]["crossing_own"]["saved"], [])
        self.assertEqual(profiles.live_row(out["settings"]), profiles.live_row(held))


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