One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
"""Same on all machines, without AppKit or Qt: the message, the merge and the window's words."""
import base64
import unittest
from types import SimpleNamespace
from core import settings_sync
KEYS = {"alt_r", "cmd_r", "f13"}
NOW = 1790000000
def b64(raw):
return base64.b64encode(raw).decode()
def mac_raw(**crossing):
base = {
"methods": ["shortcut", "edge", "notch"], "edge": "right", "edge_parts": ["middle"],
"corner": "top_right", "resistance_px": 120, "block_while_dragging": True, "glow": True,
"glow_style": "glow", "glow_colour": "signal", "effect_length": "normal", "effect_size": "medium",
"frame_rate": "display",
"shortcut_arrival": True,
"shortcut_goes_to": "last",
"shortcut_arrival_style": "match", "notch_style": "beam", "notch_after_ms": 1200, "haptics": True,
"hold_full_screen": False,
}
base.update(crossing)
return {"trigger_key": "alt_r", "trigger_style": "double_tap", "double_tap_ms": 300,
"appearance": "dark", "crossing": base}
def pc_config(**fields):
base = dict(
crossing_methods=["edge", "shortcut"], crossing_edge_parts=["middle"], crossing_corner="top_left",
crossing_resistance_px=120, block_while_dragging=True, trigger_key="cmd_r", trigger_style="double_tap",
shortcut_goes_to="last",
double_tap_ms=300, glow_style="glow", glow_colour="signal", effect_length="normal", effect_size="medium",
shortcut_arrival=True, shortcut_arrival_style="match", mac_return_edge="left", edge_glow=True,
frame_rate="display",
appearance="light",
)
base.update(fields)
return SimpleNamespace(**base)
class MessageTests(unittest.TestCase):
def test_admin_mode_is_never_transmitted_or_applied(self):
config = pc_config(run_as_administrator=True)
self.assertNotIn("run_as_administrator", settings_sync.pc_values(config))
data = settings_sync.message_data(True, 1, {"run_as_administrator": True})
self.assertNotIn("run_as_administrator", data["crossing"])
self.assertNotIn("run_as_administrator", data["design"])
settings_sync.apply_pc(config, {"run_as_administrator": False})
self.assertTrue(config.run_as_administrator)
raw = mac_raw()
self.assertNotIn("run_as_administrator", settings_sync.apply_mac(raw, {"run_as_administrator": True}))
def test_pc_modifier_style_is_local_and_not_part_of_same_on_all_machines(self):
self.assertNotIn("modifier_style", settings_sync.CROSSING_KEYS + settings_sync.DESIGN_KEYS)
def test_left_out_peer_fields_are_not_carried_by_same_on_all_machines(self):
data = settings_sync.message_data(True, 7, {"left_out": True, "left_out_ways": ["edge"]})
self.assertEqual(data, {"on": True, "set_at": 7, "by": "", "crossing": {}, "design": {}})
def test_new_design_choices_survive_the_settings_message_round_trip(self):
from core import effects
styles = ("aperture", "crease", "pleat", "concertina", "thread", "weave", "jacquard")
colours = ("vellum", "carbon_copy", "marbled", "flax", "madder", "tide")
for style in styles:
for colour in colours:
with self.subTest(style=style, colour=colour):
values = settings_sync.mac_values(mac_raw(
glow_style=style, glow_colour=colour, shortcut_arrival_style=style,
))
data = settings_sync.message_data(True, 7, values)
_on, _stamp, received = settings_sync.read(data, KEYS)
self.assertEqual(received["glow_style"], style)
self.assertEqual(received["glow_colour"], colour)
self.assertEqual(received["shortcut_arrival_style"], style)
self.assertTrue(set(styles) <= set(effects.EFFECT_IDS))
self.assertTrue(set(colours) <= set(effects.PACK_IDS))
def test_names_keep_the_newest_stamp_per_machine(self):
first, second = b64(b"\x01" * 16), b64(b"\x02" * 16)
held = {first: {"label": "Old", "set_at": 20, "by": first}}
data = settings_sync.message_data(True, 10, names={
first: {"label": "Older", "set_at": 19, "by": second},
second: {"label": "New", "set_at": 21, "by": second},
})
self.assertEqual(settings_sync.names_arrived(data, held, now=NOW),
({second: {"label": "New", "set_at": 21, "by": second}}, None))
def test_names_from_settings_includes_unlabelled_peers_for_revert(self):
own, peer = b64(b"\x01" * 16), b64(b"\x02" * 16)
settings = {"machine_id": own, "name": "", "peers": [{"id": peer}]}
names = settings_sync.names_from_settings(settings)
self.assertEqual(names[peer], {"label": "", "set_at": 0, "by": own})
def test_an_untouched_empty_own_name_cannot_be_attributed_to_a_peer(self):
own, peer = b64(b"\x01" * 16), b64(b"\x02" * 16)
settings = {"machine_id": own, "name": "", "name_set_at": 0, "name_by": peer, "peers": []}
self.assertEqual(settings_sync.names_from_settings(settings)[own],
{"label": "", "set_at": 0, "by": own})
def test_a_name_for_this_machine_is_returned_as_its_own_name(self):
own = b64(b"\x01" * 16)
settings = {"machine_id": own, "name": "", "peers": []}
data = settings_sync.message_data(True, 10, names={
own: {"label": "This Mac", "set_at": 21, "by": own},
})
updates, own_name = settings_sync.names_arrived(data, {}, own_id=own, now=NOW)
self.assertEqual((updates, own_name),
({own: {"label": "This Mac", "set_at": 21, "by": own}}, "This Mac"))
self.assertTrue(settings_sync.apply_names(settings, updates))
self.assertEqual(settings["name"], "This Mac")
def test_names_are_ignored_when_same_is_off(self):
own = b64(b"\x01" * 16)
data = settings_sync.message_data(False, 10)
data["names"] = {
own: {"label": "Ignored", "set_at": 21, "by": own},
}
self.assertEqual(settings_sync.names_arrived(data, {}, own_id=own, now=NOW), ({}, None))
def test_names_follow_the_selected_group_and_legacy_peers_use_local_selection(self):
own = b64(b"\x01" * 16)
data = settings_sync.message_data(True, 10, names={
own: {"label": "Incoming", "set_at": 21, "by": own},
})
self.assertEqual(settings_sync.names_arrived(data, {}, own_id=own, now=NOW,
current_groups=["crossing"]), ({}, None))
legacy = {key: value for key, value in data.items() if key != "groups"}
self.assertEqual(settings_sync.names_arrived(legacy, {}, own_id=own, now=NOW,
current_groups=["names"])[1], "Incoming")
def test_name_entries_with_bad_stamps_or_authors_are_ignored(self):
ident = b64(b"\x01" * 16)
data = settings_sync.message_data(True, 10, names={
ident: {"label": "Too far", "set_at": NOW + 86401, "by": ident},
"bad-id": {"label": "Bad id", "set_at": 21, "by": ident},
b64(b"\x02" * 16): {"label": "Bad author", "set_at": 21, "by": "bad"},
})
self.assertEqual(settings_sync.names_arrived(data, {}, now=NOW), ({}, None))
def test_synced_name_is_trimmed_before_the_64_character_limit(self):
ident = b64(b"\x01" * 16)
label = " " + "x" * 64 + " "
data = settings_sync.message_data(True, 10, names={
ident: {"label": label, "set_at": 21, "by": ident},
})
updates, _own_name = settings_sync.names_arrived(data, {}, now=NOW)
self.assertEqual(updates[ident]["label"], "x" * 64)
def test_rename_peer_trims_limits_and_stamps_the_label(self):
peer = {"label": "Old", "label_set_at": 20}
renamed = settings_sync.rename_peer(peer, " " + "x" * 70 + " ", "author", now=19.8)
self.assertEqual(renamed, {"label": "x" * 64, "label_set_at": 21, "label_by": "author"})
def test_restored_names_get_new_stamps_for_peer_acceptance(self):
own = b64(b"\x01" * 16)
settings = {"machine_id": own, "name": "Current", "name_set_at": 40,
"name_by": own, "peers": []}
restored = settings_sync.restamp_names(settings,
{own: {"label": "Before sync", "set_at": 20, "by": own}}, own, now=30)
self.assertEqual(restored[own], {"label": "Before sync", "set_at": 41, "by": own})
def test_an_optional_design_state_keeps_its_own_stamp_and_effect_size(self):
values = {**settings_sync.mac_values(mac_raw()), "effect_size": "large"}
design_state = {"set_at": 63, "by": b64(b"\x03" * 16), "values": values}
data = settings_sync.message_data(False, 50, design_state=design_state)
self.assertFalse(data["on"])
self.assertEqual(data["design_sync"], design_state)
def test_a_settings_message_without_a_design_state_remains_readable(self):
data = settings_sync.message_data(False, 50)
self.assertIsNone(settings_sync.read_design_state(data, KEYS))
def test_a_design_state_is_validated_independently_of_same_on_all_machines(self):
values = {"glow_style": "beam", "unknown": "ignored"}
state = {"set_at": NOW, "by": b64(b"\x03" * 16), "values": values}
self.assertEqual(settings_sync.read_design_state(
{"on": False, "set_at": NOW, "by": b64(bytes(16)), "design_sync": state}, KEYS),
{"set_at": NOW, "by": state["by"],
"values": {"effect_size": "medium", "effect_size_fraction": 0.045,
"glow_style": "beam"}})
def test_an_invalid_effect_size_is_ignored_but_a_missing_one_defaults_to_medium(self):
state = {"set_at": NOW, "by": b64(bytes(16)),
"values": {"effect_size": "giant", "glow_style": "beam"}}
self.assertEqual(settings_sync.read_design_state(
{"on": False, "set_at": NOW, "by": b64(bytes(16)), "design_sync": state}, KEYS),
{"set_at": NOW, "by": state["by"], "values": {"glow_style": "beam"}})
def test_frame_rate_is_validated_and_an_older_peer_can_omit_it(self):
envelope = {"on": False, "set_at": NOW, "by": b64(bytes(16))}
valid = {"set_at": NOW, "by": b64(bytes(16)), "values": {"frame_rate": "quarter"}}
invalid = {**valid, "values": {"frame_rate": "eighth"}}
self.assertEqual(settings_sync.read_design_state({**envelope, "design_sync": valid}, KEYS)["values"],
{"effect_size_fraction": 0.045, "effect_size": "medium", "frame_rate": "quarter"})
self.assertNotIn("frame_rate", settings_sync.read_design_state(
{**envelope, "design_sync": invalid}, KEYS)["values"])
local = pc_config(frame_rate="quarter")
settings_sync.apply_pc(local, {"glow_style": "beam"})
self.assertEqual(local.frame_rate, "quarter")
def test_a_design_state_in_a_malformed_settings_envelope_is_ignored(self):
for outer in ({"on": "no"}, {"set_at": True}, {"by": "not an id"}):
data = {"on": False, "set_at": NOW, "by": b64(bytes(16)), **outer,
"design_sync": {"set_at": NOW + 1, "by": b64(bytes([1]) * 16),
"values": {"glow_style": "beam"}}}
self.assertIsNone(settings_sync.read_design_state(data, KEYS), outer)
def test_same_on_design_change_gets_a_new_local_design_stamp(self):
changed = settings_sync.design_change_stamp(
{"effect_length": "normal"}, {"effect_length": "long"}, 50,
{"set_at": 90}, b64(b"\x02" * 16), now=100,
)
self.assertEqual(changed, {"set_at": 100, "by": b64(b"\x02" * 16)})
self.assertIsNone(settings_sync.design_change_stamp(
{"effect_length": "long"}, {"effect_length": "long"}, 50,
{"set_at": 90}, b64(b"\x02" * 16), now=100,
))
def test_design_states_use_the_same_stamp_order_as_same_on_all_machines(self):
larger = {"set_at": 100, "by": b64(b"\x02" * 16), "values": {"glow_style": "beam"}}
self.assertTrue(settings_sync.design_arrived(larger, 100, b64(b"\x01" * 16)))
self.assertFalse(settings_sync.design_arrived(larger, 100, larger["by"]))
self.assertFalse(settings_sync.design_arrived(larger, 101, ""))
def test_design_follow_chain_keeps_the_leaders_stamp(self):
a_id, b_id = (b64(bytes([byte]) * 16) for byte in (1, 2))
a_state = {"set_at": 100, "by": a_id, "values": {"glow_style": "beam"}}
b = settings_sync.followed_design({"glow_style": "glow"}, a_state, a_id, a_id, False,
50, b64(bytes(16)))
c = settings_sync.followed_design({"glow_style": "glow"},
{"set_at": b["set_at"], "by": b["by"], "values": b["values"]},
b_id, b_id, False, 20, b64(bytes(16)))
self.assertTrue(b["changed"] and c["changed"])
self.assertEqual(c["values"]["glow_style"], "beam")
self.assertEqual((b["set_at"], b["by"], c["set_at"], c["by"]),
(100, a_id, 100, a_id))
def test_explicit_follow_adopts_all_design_values_despite_a_newer_local_stamp(self):
peer = b64(bytes([2]) * 16)
current = settings_sync.mac_values(mac_raw())
desired = dict(glow_style="beam", glow_colour="ocean", effect_length="long",
effect_size="large", effect_pace=2.0, effect_size_fraction=0.06,
frame_rate="display", shortcut_arrival=False, shortcut_arrival_style="locator")
state = {"set_at": 10, "by": peer, "values": desired}
taken = settings_sync.followed_design(current, state, peer, peer, False, 500, "", force=True)
self.assertEqual({key: taken["values"][key] for key in settings_sync.DESIGN_KEYS}, desired)
self.assertEqual(taken["values"]["resistance_px"], 120)
def test_follow_path_detects_a_cycle_even_when_values_are_identical(self):
own, peer = b64(bytes([1]) * 16), b64(bytes([2]) * 16)
state = {"set_at": 10, "by": peer, "values": {"glow_style": "beam"}, "path": [own, peer]}
taken = settings_sync.followed_design({"glow_style": "beam"}, state, peer, peer, False,
0, "", own_id=own)
self.assertTrue(taken["cycle"])
def test_follow_path_survives_validation_and_invalid_paths_are_rejected(self):
own, peer = b64(bytes([1]) * 16), b64(bytes([2]) * 16)
for path in ([own, peer], [], ["garbage"], [own, own], [None]):
data = settings_sync.message_data(False, 10, design_state={
"set_at": 10, "by": peer, "values": {"glow_style": "beam"}, "path": path})
state = settings_sync.read_design_state(data, KEYS)
if path == [own, peer]:
self.assertEqual(state["path"], path)
else:
self.assertIsNone(state)
def test_legacy_padded_author_and_source_produce_a_valid_downstream_path(self):
from core import protocol
source, own = (protocol.id_text(bytes([value]) * 16) for value in (1, 2))
state = {"set_at": 10, "by": source + "==", "values": {"glow_style": "beam"}}
taken = settings_sync.followed_design({"glow_style": "glow"}, state, source, source, False,
0, "", own_id=own)
advertised = {"set_at": 20, "by": own, "values": taken["values"], "path": taken["path"]}
received = settings_sync.read_design_state(settings_sync.message_data(False, 20, design_state=advertised), KEYS)
self.assertIsNotNone(received)
self.assertEqual(len(received["path"]), 2)
def test_follower_accepts_the_leaders_next_stamp_after_reannouncing_it(self):
a_id, b_id = b64(b"\x01" * 16), b64(b"\x02" * 16)
current = {"glow_style": "glow"}
first = {"set_at": 100, "by": a_id, "values": {"glow_style": "beam"}}
applied = settings_sync.followed_design(current, first, a_id, a_id, False,
50, "")
next_from_a = {"set_at": 101, "by": a_id, "values": {"glow_style": "flint"}}
updated = settings_sync.followed_design(
applied["values"], next_from_a, a_id, a_id, False,
applied["set_at"], applied["by"],
)
self.assertTrue(updated["changed"])
self.assertEqual(updated["values"]["glow_style"], "flint")
self.assertEqual((updated["set_at"], updated["by"]), (101, a_id))
def test_mutual_design_follow_converges_without_a_second_announcement(self):
a_id, b_id = b64(b"\x01" * 16), b64(b"\x02" * 16)
b_after_a = settings_sync.followed_design(
{"glow_style": "glow"}, {"set_at": 100, "by": a_id, "values": {"glow_style": "beam"}},
a_id, a_id, False, 90, b64(bytes(16)),
)
a_after_b = settings_sync.followed_design(
{"glow_style": "beam"},
{"set_at": b_after_a["set_at"], "by": b_after_a["by"], "values": b_after_a["values"]},
b_id, b_id, False, 100, a_id,
)
self.assertTrue(b_after_a["changed"])
self.assertIsNone(a_after_b)
def test_mutual_design_announcements_crossing_in_flight_converge_on_the_newer_stamp(self):
a_id, b_id = b64(bytes([1]) * 16), b64(bytes([2]) * 16)
ids = {"A": a_id, "B": b_id}
held = {
"A": {"values": {"glow_style": "beam"}, "set_at": 200, "by": a_id},
"B": {"values": {"glow_style": "glow"}, "set_at": 100, "by": b_id},
}
# Both link-up announcements are already in flight before either side reacts.
queue = [("A", "B", dict(held["A"])), ("B", "A", dict(held["B"]))]
sent = 0
while queue:
source, follower, incoming = queue.pop(0)
sent += 1
self.assertLess(sent, 10, "mutual follows kept re-announcing")
current = held[follower]
applied = settings_sync.followed_design(
current["values"], incoming,
source, source, False, current["set_at"], current["by"],
)
if applied is not None and applied["changed"]:
held[follower] = {"values": applied["values"], "set_at": applied["set_at"], "by": applied["by"]}
queue.append((follower, source, dict(held[follower])))
self.assertEqual(held["A"]["values"]["glow_style"], "beam")
self.assertEqual(held["B"]["values"]["glow_style"], "beam")
self.assertEqual((held["A"]["set_at"], held["A"]["by"]), (200, a_id))
self.assertEqual((held["B"]["set_at"], held["B"]["by"]), (200, a_id))
def test_design_follow_ignores_other_peers_and_waits_while_same_is_on(self):
state = {"set_at": 100, "by": b64(b"\x02" * 16), "values": {"glow_style": "beam"}}
peer = state["by"]
current = {"glow_style": "glow"}
self.assertIsNone(settings_sync.followed_design(current, state, peer, "", False, 0, ""))
self.assertIsNone(settings_sync.followed_design(current, state, peer, peer, True, 0, ""))
def test_a_newer_identical_design_keeps_its_stamp_without_an_announcement(self):
peer = b64(bytes([2]) * 16)
applied = settings_sync.followed_design(
{"glow_style": "beam"}, {"set_at": 100, "by": peer, "values": {"glow_style": "beam"}},
peer, peer, False, 50, "",
)
self.assertEqual(applied, {"changed": False, "values": {"glow_style": "beam"},
"set_at": 100, "by": peer})
def test_off_carries_no_values(self):
data = settings_sync.message_data(False, 50, settings_sync.mac_values(mac_raw()))
self.assertEqual(data, {"on": False, "set_at": 50, "by": ""})
def test_on_carries_crossing_and_design_and_never_the_notch_or_this_machines_own(self):
data = settings_sync.message_data(True, 50, settings_sync.mac_values(mac_raw()))
self.assertEqual(set(data["crossing"]), set(settings_sync.CROSSING_KEYS))
self.assertEqual(set(data["design"]), set(settings_sync.DESIGN_KEYS))
self.assertEqual(data["design"]["effect_size"], "medium")
self.assertIs(data["crossing"]["shortcut"], True)
flat = {**data["crossing"], **data["design"]}
for own in ("notch_style", "notch_after_ms", "haptics", "glow", "appearance", "edge", "hold_full_screen",
"methods", "edge_parts", "corner"):
self.assertNotIn(own, flat)
def test_groups_filter_values_and_layout_always_travels(self):
values = settings_sync.mac_values(mac_raw())
groups = ("crossing", "shortcut")
data = settings_sync.message_data(True, 50, values, groups=groups,
layout_state={"set_at": 3, "by": "", "tiles": {"x": {}}})
self.assertEqual(data["groups"], list(groups))
self.assertEqual(set(data["crossing"]),
set(settings_sync.GROUP_KEYS["crossing"] + settings_sync.GROUP_KEYS["shortcut"]))
self.assertEqual(set(data["design"]), set())
self.assertEqual(set(settings_sync.read(data, KEYS)[2]),
set(settings_sync.GROUP_KEYS["crossing"] + settings_sync.GROUP_KEYS["shortcut"]))
self.assertIn("layout", data)
def test_old_peer_values_use_only_groups_selected_here_and_never_change_them(self):
data = settings_sync.message_data(True, 50, settings_sync.mac_values(mac_raw(glow_style="beam")))
data.pop("groups", None)
self.assertEqual(set(settings_sync.read(data, KEYS, current_groups=("design",))[2]),
set(settings_sync.GROUP_KEYS["design"]))
# None chosen here: Same was off, and a 1.5.1 peer turning it on means every group, as here.
self.assertEqual(set(settings_sync.read(data, KEYS, current_groups=())[2]),
set(settings_sync.CROSSING_KEYS + settings_sync.DESIGN_KEYS))
self.assertEqual(settings_sync.arrival_groups(data, ()), settings_sync.ALL_GROUPS)
self.assertEqual(settings_sync.arrival_groups(dict(data, on=False), ()), ())
def test_legacy_off_keeps_local_group_selection_and_transmitted_off_state(self):
data = {"on": False, "set_at": 50, "by": b64(bytes([1]) * 16)}
self.assertEqual(settings_sync.arrival_groups(data, ("design",)), ("design",))
self.assertEqual(settings_sync.read(data, KEYS, current_groups=("design",)), (False, 50, {}))
def test_everything_expands_to_all_four_groups(self):
self.assertEqual(settings_sync.groups_for_choice(("everything",)), settings_sync.ALL_GROUPS)
def test_snapshot_revert_and_expiry(self):
snapshot = settings_sync.same_snapshot(("crossing", "design"), {"resistance_px": 40}, now=100)
self.assertTrue(settings_sync.snapshot_available(snapshot, now=100 + settings_sync.SNAPSHOT_TTL))
self.assertFalse(settings_sync.snapshot_available(snapshot, now=101 + settings_sync.SNAPSHOT_TTL))
self.assertEqual(settings_sync.restore_snapshot(snapshot, now=200),
{"groups": ["crossing", "design"], "values": {"resistance_px": 40}})
def test_snapshot_is_taken_only_before_an_accepted_change(self):
groups = ("crossing",)
current = {"resistance_px": 120, "glow_style": "glow"}
data = settings_sync.message_data(True, 101, {"resistance_px": 60}, by=b64(bytes([1]) * 16),
groups=("crossing",))
saved = settings_sync.snapshot_for_arrival(data, 100, KEYS, "", groups, current, now=NOW)
stale = settings_sync.snapshot_for_arrival(data, 101, KEYS, data["by"], groups, current, now=NOW)
self.assertEqual(saved["values"], {"resistance_px": 120})
self.assertIsNone(stale)
def test_a_group_selection_only_update_still_saves_the_previous_selection(self):
current = {"resistance_px": 120, "glow_style": "glow"}
data = settings_sync.message_data(True, 101, current, by=b64(bytes([1]) * 16),
groups=("design",))
saved = settings_sync.snapshot_for_arrival(data, 100, KEYS, "", ("crossing",), current, now=NOW)
self.assertEqual(saved["groups"], ["crossing"])
self.assertEqual(saved["values"], {"glow_style": "glow"})
def test_snapshot_can_keep_the_local_names_group(self):
names = {b64(bytes([2]) * 16): {"label": "Old", "set_at": 2, "by": b64(bytes([1]) * 16)}}
snapshot = settings_sync.same_snapshot(("names",), {}, now=100, names=names)
self.assertEqual(settings_sync.restore_snapshot(snapshot, now=100)["names"], names)
def test_selection_only_revert_keeps_values_edited_since_the_update(self):
current = {"resistance_px": 120, "glow_style": "glow"}
data = settings_sync.message_data(True, 101, current, groups=["design"])
snapshot = settings_sync.snapshot_for_arrival(data, 100, KEYS, "", ["crossing"], current, now=NOW)
self.assertEqual(settings_sync.restore_snapshot(snapshot, now=NOW)["values"], {})
self.assertEqual(settings_sync.revert_groups(snapshot, ["design"]), ["crossing"])
def test_value_revert_keeps_the_current_policy_on(self):
data = settings_sync.message_data(True, 101, {"resistance_px": 60}, groups=["crossing"])
snapshot = settings_sync.snapshot_for_arrival(data, 100, KEYS, "", [], {"resistance_px": 120}, now=NOW)
self.assertEqual(settings_sync.revert_groups(snapshot, ["crossing"]), ["crossing"])
def test_a_refused_trigger_does_not_replace_a_previous_undo_snapshot(self):
data = settings_sync.message_data(True, 101, {"trigger_key": "f13"}, groups=["shortcut"])
self.assertIsNone(settings_sync.snapshot_for_arrival(
data, 100, KEYS, "", ["shortcut"], {"trigger_key": "alt_r"}, now=NOW, applied_values={}))
def test_an_update_without_design_values_does_not_advance_direct_design(self):
current = settings_sync.mac_values(mac_raw())
self.assertIsNone(settings_sync.design_change_stamp(current, {"resistance_px": 60}, 10, None, ""))
self.assertIsNone(settings_sync.design_change_stamp(current, {}, 10, None, ""))
def test_names_obey_the_accepted_policy_when_an_old_selection_arrives_late(self):
own = b64(b"\x01" * 16)
data = settings_sync.message_data(True, 10, groups=["names"],
names={own: {"label": "Delayed", "set_at": 30, "by": own}})
self.assertEqual(settings_sync.names_arrived(data, {}, own_id=own, now=NOW,
policy_groups=["crossing"]), ({}, None))
def test_jump_keys_are_not_sent_by_same_on_all_machines(self):
values = settings_sync.mac_values(mac_raw())
values["jump_key"] = "ctrl+alt+2"
self.assertNotIn("jump_key", settings_sync.message_data(True, 50, values)["crossing"])
def test_a_round_trip_reads_back_what_was_sent(self):
values = settings_sync.mac_values(mac_raw())
on, set_at, read = settings_sync.read(settings_sync.message_data(True, 7, values), KEYS)
self.assertEqual((on, set_at), (True, 7))
self.assertEqual(read, values)
def test_a_value_this_end_cannot_hold_is_left_out_and_the_rest_kept(self):
data = settings_sync.message_data(True, 7, settings_sync.mac_values(mac_raw()))
data["crossing"]["trigger_key"] = "hyper"
data["crossing"]["resistance_px"] = 9000
data["design"]["glow_style"] = "from-the-future"
data["crossing"]["shortcut"] = "yes"
data["crossing"]["methods"] = ["edge"]
_on, _set_at, values = settings_sync.read(data, KEYS)
for dropped in ("trigger_key", "resistance_px", "glow_style", "shortcut", "methods"):
self.assertNotIn(dropped, values)
self.assertEqual(values["trigger_style"], "double_tap")
def test_a_key_that_cannot_be_the_trigger_is_left_out(self):
for name in ("browser_back", "browser_forward", "backspace", "tab", "enter", "esc", "space", "print_screen"):
data = settings_sync.message_data(True, 7, settings_sync.mac_values(mac_raw()))
data["crossing"]["trigger_key"] = name
_on, _set_at, values = settings_sync.read(data, KEYS | {name})
self.assertNotIn("trigger_key", values, name)
def test_the_message_names_who_made_the_change(self):
self.assertEqual(settings_sync.message_data(False, 5, by="QUJD"), {"on": False, "set_at": 5, "by": "QUJD"})
self.assertEqual(settings_sync.message_data(False, 5), {"on": False, "set_at": 5, "by": ""})
def test_malformed_data_is_not_a_message(self):
for data in (None, [], {}, {"on": "yes", "set_at": 1}, {"on": True}, {"on": True, "set_at": True}):
self.assertIsNone(settings_sync.read(data, KEYS))
def test_a_change_here_always_stamps_newer_than_what_is_held(self):
self.assertEqual(settings_sync.next_stamp(0, 1000.7), 1000)
self.assertEqual(settings_sync.next_stamp(1000, 1000.2), 1001)
# A peer's clock ahead of this one's: the change made here still wins.
self.assertEqual(settings_sync.next_stamp(5000, 1000), 5001)
def test_a_tie_goes_to_the_larger_id_as_bytes_and_a_lower_one_changes_nothing(self):
values = settings_sync.mac_values(mac_raw(glow_style="beam"))
big, small = b64(b"\x02" * 16), b64(b"\x01" * 16)
theirs = settings_sync.message_data(True, 100, values, by=big)
self.assertIsNotNone(settings_sync.arrived(theirs, 100, KEYS, by_here=small, now=NOW))
self.assertIsNone(settings_sync.arrived(theirs, 100, KEYS, by_here=big, now=NOW))
lower = settings_sync.message_data(True, 100, values, by=small)
self.assertIsNone(settings_sync.arrived(lower, 100, KEYS, by_here=big, now=NOW))
def test_compared_as_bytes_not_as_text(self):
# As text "AAAA..." sorts above "////...", but as bytes 0x00.. is below 0xff..
low, high = b64(b"\x00" * 16), b64(b"\xff" * 16)
self.assertGreater(low, high)
theirs = settings_sync.message_data(False, 9, by=high)
self.assertIsNotNone(settings_sync.arrived(theirs, 9, KEYS, by_here=low, now=NOW))
self.assertIsNone(settings_sync.arrived(settings_sync.message_data(False, 9, by=low), 9, KEYS, by_here=high, now=NOW))
def test_a_newer_stamp_wins_whatever_the_ids(self):
theirs = settings_sync.message_data(False, 101, by=b64(b"\x00" * 16))
self.assertEqual(settings_sync.arrived(theirs, 100, KEYS, by_here=b64(b"\xff" * 16), now=NOW)[:2], (False, 101))
def test_a_bad_by_is_not_a_message_and_a_missing_one_is_empty(self):
for by in (5, "not base64!", None, True):
data = {"on": False, "set_at": 9, "by": by}
self.assertIsNone(settings_sync.arrived(data, 0, KEYS, now=NOW), by)
self.assertIsNotNone(settings_sync.arrived({"on": False, "set_at": 9}, 0, KEYS, now=NOW))
def test_a_stamp_that_is_not_an_integer_is_not_a_message(self):
for set_at in (9.5, 9.0, "9", None, [9]):
data = {"on": False, "set_at": set_at, "by": b64(b"\x01" * 16)}
self.assertIsNone(settings_sync.read(data, KEYS), set_at)
self.assertIsNone(settings_sync.arrived(data, 0, KEYS, now=NOW), set_at)
def test_a_by_that_is_not_a_machine_id_in_length_is_not_a_message(self):
for raw in (b"", b"\x01", b"\x01" * 15, b"\x01" * 17, b"\x01" * 64):
data = {"on": False, "set_at": 9, "by": b64(raw)}
if raw:
self.assertIsNone(settings_sync.arrived(data, 0, KEYS, now=NOW), raw)
def test_a_stamp_more_than_a_day_ahead_or_past_2_to_the_53_is_ignored(self):
self.assertIsNotNone(settings_sync.arrived(settings_sync.message_data(False, NOW + 86400), 0, KEYS, now=NOW))
self.assertIsNone(settings_sync.arrived(settings_sync.message_data(False, NOW + 86401), 0, KEYS, now=NOW))
self.assertIsNone(settings_sync.arrived(settings_sync.message_data(False, 2 ** 53 - 1), 0, KEYS, now=2 ** 54))
self.assertIsNotNone(settings_sync.arrived(settings_sync.message_data(False, 2 ** 53 - 2), 0, KEYS, now=2 ** 54))
def test_a_local_change_after_a_far_ahead_stamp_still_stamps_held_plus_one(self):
self.assertEqual(settings_sync.next_stamp(NOW + 5000, NOW), NOW + 5001)
class AdapterTests(unittest.TestCase):
def test_left_out_fields_are_ignored_when_applying_synced_values(self):
raw = mac_raw()
applied = settings_sync.apply_mac(raw, {"left_out": True, "left_out_ways": ["edge"]})
config = pc_config()
settings_sync.apply_pc(config, {"left_out": True, "left_out_ways": ["edge"]})
self.assertEqual(applied, raw)
self.assertFalse(hasattr(config, "left_out"))
def test_size_is_read_applied_and_transmitted_on_both_machines(self):
mac = mac_raw(effect_size="large")
values = settings_sync.mac_values(mac)
self.assertEqual(values["effect_size"], "large")
self.assertEqual(settings_sync.apply_mac(mac_raw(), values)["crossing"]["effect_size"], "large")
message = settings_sync.message_data(True, 1, values)
self.assertEqual(message["design"]["effect_size"], "large")
self.assertEqual(settings_sync.read(message, KEYS)[2]["effect_size"], "large")
pc = pc_config(effect_size="small")
values = settings_sync.pc_values(pc)
self.assertEqual(values["effect_size"], "small")
target = pc_config()
settings_sync.apply_pc(target, values)
self.assertEqual(target.effect_size, "small")
def test_the_mac_keeps_its_notch_its_zones_and_its_own_rows(self):
raw = mac_raw()
values = settings_sync.mac_values(mac_raw(glow_style="beam", resistance_px=40))
values["trigger_key"] = "f13"
values["shortcut"] = False
applied = settings_sync.apply_mac(raw, values)
self.assertEqual(applied["crossing"]["methods"], ["edge", "notch"])
self.assertEqual((applied["crossing"]["glow_style"], applied["crossing"]["resistance_px"]), ("beam", 40))
self.assertEqual(applied["trigger_key"], "f13")
for own in ("notch_style", "notch_after_ms", "haptics", "glow", "edge", "edge_parts", "corner"):
self.assertEqual(applied["crossing"][own], raw["crossing"][own])
self.assertEqual(applied["appearance"], "dark")
self.assertEqual(raw["crossing"]["methods"], ["shortcut", "edge", "notch"])
def test_the_shortcut_is_added_to_the_ways_when_the_peer_has_it_on(self):
applied = settings_sync.apply_mac(mac_raw(methods=["corner"]), {"shortcut": True})
self.assertEqual(applied["crossing"]["methods"], ["corner", "shortcut"])
self.assertEqual(settings_sync.apply_mac(mac_raw(methods=["shortcut"]), {"shortcut": True})["crossing"]["methods"], ["shortcut"])
def test_the_shortcut_is_read_from_the_ways(self):
self.assertIs(settings_sync.mac_values(mac_raw(methods=["edge"]))["shortcut"], False)
self.assertIs(settings_sync.pc_values(pc_config(crossing_methods=["edge", "shortcut"]))["shortcut"], True)
def test_older_pc_config_reads_presets_when_continuous_fields_are_absent(self):
config = pc_config(crossing_methods=["edge", "shortcut"])
values = settings_sync.pc_values(config)
self.assertEqual((values["effect_pace"], values["effect_size_fraction"], values["shortcut"]),
(1.0, 0.045, True))
def test_a_values_dict_has_no_zones(self):
for values in (settings_sync.mac_values(mac_raw()), settings_sync.pc_values(pc_config())):
for zone in ("methods", "edge_parts", "corner"):
self.assertNotIn(zone, values)
def test_values_from_the_mac_land_on_the_pcs_fields_and_leave_its_own_and_its_zones(self):
config = pc_config()
values = settings_sync.mac_values(mac_raw(glow_colour="ocean", methods=["edge"]))
settings_sync.apply_pc(config, values)
self.assertEqual(config.crossing_methods, ["edge"])
self.assertEqual((config.crossing_edge_parts, config.crossing_corner), (["middle"], "top_left"))
self.assertEqual((config.glow_colour, config.trigger_key), ("ocean", "alt_r"))
self.assertEqual((config.edge_glow, config.appearance, config.mac_return_edge), (True, "light", "left"))
def test_the_pc_turns_its_shortcut_on_and_keeps_the_other_ways(self):
config = pc_config(crossing_methods=["edge"])
settings_sync.apply_pc(config, {"shortcut": True})
self.assertEqual(config.crossing_methods, ["edge", "shortcut"])
settings_sync.apply_pc(config, {"shortcut": False})
self.assertEqual(config.crossing_methods, ["edge"])
def test_a_change_is_seen_only_in_a_shared_value(self):
before = settings_sync.mac_values(mac_raw())
self.assertFalse(settings_sync.changed(before, settings_sync.mac_values(mac_raw(notch_style="island", glow=False, corner="bottom_left", edge_parts=["end"]))))
self.assertTrue(settings_sync.changed(before, settings_sync.mac_values(mac_raw(effect_length="long"))))
self.assertTrue(settings_sync.changed(before, settings_sync.mac_values(mac_raw(methods=["edge"]))))
def test_hold_full_screen_is_never_shared(self):
for values in (settings_sync.mac_values(mac_raw(hold_full_screen=True)), settings_sync.pc_values(pc_config())):
self.assertNotIn("hold_full_screen", values)
data = settings_sync.message_data(True, 1, settings_sync.mac_values(mac_raw(hold_full_screen=True)))
self.assertNotIn("hold_full_screen", {**data["crossing"], **data["design"]})
class RelayTests(unittest.TestCase):
PEERS = {"a": {"settings", "text"}, "b": {"settings"}, "c": set(), "d": {"settings"}}
def test_a_newer_state_goes_to_every_other_peer_that_takes_settings(self):
self.assertEqual(settings_sync.recipients(self.PEERS, source="a"), ["b", "d"])
def test_a_state_made_here_goes_to_every_peer_that_takes_settings(self):
self.assertEqual(settings_sync.recipients(self.PEERS), ["a", "b", "d"])
def test_a_peer_without_settings_is_never_a_recipient(self):
self.assertNotIn("c", settings_sync.recipients(self.PEERS))
def test_three_machines_in_a_line_all_reach_the_first_ones_change_and_nothing_loops(self):
# A - B - C; A and C are not linked. Each holds (set_at, by); B sends on what it takes.
links = {"A": {"B": {"settings"}}, "B": {"A": {"settings"}, "C": {"settings"}}, "C": {"B": {"settings"}}}
ids = {"A": b64(b"\x01" * 16), "B": b64(b"\x02" * 16), "C": b64(b"\x03" * 16)}
held = {name: (100, ids[name]) for name in links}
held["A"] = (200, ids["A"])
sent = []
queue = [("A", "B", settings_sync.message_data(True, 200, settings_sync.mac_values(mac_raw(glow_style="beam")), by=ids["A"]))]
while queue:
src, dst, data = queue.pop(0)
sent.append((src, dst))
assert len(sent) < 10, "looping"
taken = settings_sync.arrived(data, held[dst][0], KEYS, by_here=held[dst][1], now=NOW)
if taken is None:
continue
held[dst] = (taken[1], data["by"])
for other in settings_sync.recipients(links[dst], source=src):
queue.append((dst, other, data))
self.assertEqual([held[name][0] for name in "ABC"], [200, 200, 200])
self.assertEqual(sent, [("A", "B"), ("B", "C")])
class WordsTests(unittest.TestCase):
def test_a_shared_page_says_so_only_while_on(self):
own = "For this Mac only; the other machine keeps its own."
everyone = settings_sync.who(["Studio", "Laptop"])
self.assertEqual(settings_sync.scope("crossing", everyone, False, own), own)
self.assertEqual(settings_sync.scope("design", everyone, True, own),
"Style, colour, length, size and landing animation stay in step. Animation enable and window appearance stay local.")
self.assertEqual(settings_sync.scope("keyboard", everyone, True, own), own)
def test_one_machine_is_named_and_none_or_several_are_every_paired_machine(self):
self.assertEqual(settings_sync.who(["Studio"]), "Studio")
self.assertEqual(settings_sync.who([]), "every paired machine")
self.assertEqual(settings_sync.who(["Studio", "Laptop"]), "every paired machine")
self.assertEqual(settings_sync.scope("design", "Studio", True, "x"),
"Style, colour, length, size and landing animation stay in step. Animation enable and window appearance stay local.")
def test_the_switch_note_names_shared_values_and_an_old_peer(self):
self.assertIn("resistance, drag protection, Shortcut", settings_sync.switch_note("Studio", True, False))
self.assertIn("previous separate values are not restored", settings_sync.switch_note("Studio", False, False))
self.assertIn("compatible paired machines", settings_sync.switch_note("every paired machine", True, False))
self.assertIn("catch up when they reconnect", settings_sync.switch_detail())
self.assertIn("Studio's Beamer is too old", settings_sync.switch_note("Studio", True, True))
class RealIdTests(unittest.TestCase):
def test_a_by_in_the_unpadded_urlsafe_spelling_of_a_machine_id_is_read(self):
from core import protocol
ident = bytes(range(1, 17))
text = protocol.id_text(ident)
self.assertEqual(settings_sync._id(text), ident)
data = settings_sync.message_data(True, 100, {}, by=text)
self.assertIsNotNone(settings_sync.arrived(data, 0, {}))
def test_garbage_is_still_not_an_id(self):
self.assertIsNone(settings_sync._id("not base64!"))
self.assertIsNone(settings_sync._id(5))
class FollowRowsTests(unittest.TestCase):
PC, LIVE, AWAY, OLD = (b64(bytes([n]) * 16) for n in (1, 2, 3, 4))
def entries(self, *ids):
return [{"id": ident} for ident in ids]
def test_only_connected_machines_are_listed_and_away_ones_never_set_the_note(self):
caps = {self.PC: frozenset({"settings", "design_sync"})}
rows = settings_sync.follow_rows(self.entries(self.PC, self.AWAY), caps, {self.PC: {}})
self.assertEqual(rows, [({"id": self.PC}, None)])
self.assertIsNone(settings_sync.follow_note(rows))
def test_the_followed_machine_stays_listed_while_away(self):
rows = settings_sync.follow_rows(self.entries(self.PC, self.AWAY), {}, {self.AWAY: {}}, following=self.AWAY)
self.assertEqual(rows, [({"id": self.AWAY}, None)])
def test_why_each_connected_machine_cannot_be_chosen(self):
caps = {self.LIVE: frozenset({"settings", "design_sync"}), self.OLD: frozenset({"settings"})}
rows = settings_sync.follow_rows(self.entries(self.LIVE, self.OLD), caps, {})
self.assertEqual([why for _entry, why in rows], [settings_sync.DESIGN_UNAVAILABLE, settings_sync.NEEDS_DESIGN_SYNC])
self.assertEqual(settings_sync.follow_note(rows), settings_sync.OLD_PEER_NOTE)
self.assertEqual(settings_sync.follow_note(rows[:1]), settings_sync.DESIGN_UNAVAILABLE)
def test_nothing_connected_is_one_quiet_line(self):
rows = settings_sync.follow_rows(self.entries(self.AWAY), {}, {self.AWAY: {}})
self.assertEqual(rows, [])
self.assertEqual(settings_sync.follow_note(rows), settings_sync.NO_MACHINE_CONNECTED)
class FollowLockTests(unittest.TestCase):
PC, OTHER = (b64(bytes([n]) * 16) for n in (1, 2))
def test_following_a_paired_desktop_locks_its_design_controls(self):
desktops = [{"id": self.OTHER}, {"id": self.PC, "name": "DESK-PC"}]
self.assertEqual(settings_sync.follow_lock(self.PC, False, desktops), desktops[1])
self.assertEqual(settings_sync.following_banner("DESK-PC"), "Following DESK-PC's design")
def test_unlocked_with_no_selection_with_same_on_or_once_the_machine_is_unpaired(self):
desktops = [{"id": self.PC}]
self.assertIsNone(settings_sync.follow_lock("", False, desktops))
self.assertIsNone(settings_sync.follow_lock(self.PC, True, desktops))
self.assertIsNone(settings_sync.follow_lock(self.OTHER, False, desktops))
if __name__ == "__main__":
unittest.main()