One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
import json
import os
import tempfile
import unittest
from pathlib import Path
from unittest import mock
import sys
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
import config as config_module
from core import protocol
import settings_store
from settings_store import SettingsError, SettingsStore, config_to_raw
class SettingsStoreTests(unittest.TestCase):
def test_unpin_survives_flat_saves_and_reload(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "settings.json"
store = SettingsStore(path)
store.save(self.valid_raw(), pin_address=True)
token = store.current()["peers"][0]["token"]
store.set_peer(token, host_pinned=False)
store.save(config_to_raw(store.load()))
self.assertIs(SettingsStore(path).current()["peers"][0]["host_pinned"], False)
def test_explicitly_saving_the_same_learnt_host_pins_it(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "settings.json"
store = SettingsStore(path)
store.save(self.valid_raw())
settings = store.current()
settings["peers"][0]["host_pinned"] = False
store.save_settings(settings)
raw = config_to_raw(store.load())
store.save(raw)
self.assertIs(store.current()["peers"][0]["host_pinned"], False)
store.save(raw, pin_address=True)
self.assertIs(SettingsStore(path).current()["peers"][0]["host_pinned"], True)
def test_editing_a_learnt_host_pins_it_and_survives_reload(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "settings.json"
store = SettingsStore(path)
store.save(self.valid_raw())
settings = store.current()
settings["peers"][0]["host_pinned"] = False
store.save_settings(settings)
self.assertIs(SettingsStore(path).current()["peers"][0]["host_pinned"], False)
raw = config_to_raw(store.load())
raw["host"] = "198.51.100.10"
store.save(raw)
peer = SettingsStore(path).current()["peers"][0]
self.assertEqual(peer["host"], "198.51.100.10")
self.assertIs(peer["host_pinned"], True)
def test_all_original_saved_colours_keep_their_id_and_stops(self):
import notch_beam
fixture = Path(__file__).resolve().parents[2] / 'core/tests/colour_packs_rc3.json'
palettes = json.loads(fixture.read_text())
with tempfile.TemporaryDirectory() as directory:
store = SettingsStore(Path(directory) / 'settings.json')
for value, stops in palettes.items():
with self.subTest(value=value):
raw = {**self.valid_raw(), 'crossing': {'glow_colour': value}}
store.save(raw)
saved = store.load().crossing['glow_colour']
self.assertEqual(saved, value)
self.assertEqual(notch_beam.palette_values(saved), stops)
def valid_raw(self):
return {
"host": "192.0.2.10",
"port": 24820,
"auth_token": "synthetic-token",
"trigger_key": "alt_r",
"double_tap_ms": 300,
"key_map": {"cmd": "ctrl", "cmd_r": "ctrl"},
"reconnect_interval_s": 2.0,
}
def test_save_is_private_and_round_trips_shared_schema(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "settings.json"
store = SettingsStore(path)
saved = store.save(self.valid_raw())
loaded = store.load()
self.assertEqual(saved, loaded)
self.assertEqual(path.stat().st_mode & 0o777, 0o600)
raw = json.loads(path.read_text(encoding="utf-8"))
self.assertEqual(raw["trigger_key"], "alt_r")
def test_both_directions_default_on_and_each_switch_round_trips(self):
with tempfile.TemporaryDirectory() as directory:
store = SettingsStore(Path(directory) / "settings.json")
loaded = store.save(self.valid_raw())
self.assertTrue(loaded.send_to_windows)
self.assertTrue(loaded.allow_windows_to_drive)
raw = config_to_raw(loaded)
raw["send_to_windows"] = False
loaded = store.save(raw)
self.assertFalse(loaded.send_to_windows)
self.assertTrue(loaded.allow_windows_to_drive)
self.assertFalse(store.load().send_to_windows)
def test_in_use_defaults_on_round_trips_and_rejects_non_booleans(self):
with tempfile.TemporaryDirectory() as directory:
store = SettingsStore(Path(directory) / "settings.json")
store.save(self.valid_raw())
entry = store.current()["peers"][0]
self.assertTrue(entry["in_use"])
store.set_peer(entry["token"], in_use=False)
self.assertFalse(store.current()["peers"][0]["in_use"])
with self.assertRaises(SettingsError):
store.set_peer(entry["token"], in_use="no")
def test_jump_key_round_trips_and_rejects_non_strings(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "settings.json"
store = SettingsStore(path)
store.save(self.valid_raw())
settings = store.current()
settings["peers"][0]["jump_key"] = "ctrl+shift+2"
store.save_settings(settings)
self.assertEqual(SettingsStore(path).current()["peers"][0]["jump_key"], "ctrl+shift+2")
settings["peers"][0]["jump_key"] = []
with self.assertRaises(SettingsError):
store.save_settings(settings)
def test_an_old_peer_without_a_jump_key_defaults_to_none(self):
with tempfile.TemporaryDirectory() as directory:
store = SettingsStore(Path(directory) / "settings.json")
store.save(self.valid_raw())
self.assertIsNone(store.current()["peers"][0].get("jump_key") or None)
def test_trigger_clash_is_refused_without_changing_the_saved_value_and_can_be_cleared(self):
with tempfile.TemporaryDirectory() as directory:
store = SettingsStore(Path(directory) / "settings.json")
store.save(self.valid_raw())
peer = store.current()["peers"][0]
store.set_jump_key(peer["id"], "ctrl+shift+2", "alt_r")
with self.assertRaises(SettingsError):
store.set_jump_key(peer["id"], "ctrl+f9", "f9")
self.assertEqual(store.current()["peers"][0]["jump_key"], "ctrl+shift+2")
store.set_jump_key(peer["id"], "", "alt_r")
self.assertEqual(store.current()["peers"][0]["jump_key"], "")
def test_the_full_screen_hold_defaults_off_and_preserves_each_saved_choice(self):
with tempfile.TemporaryDirectory() as directory:
store = SettingsStore(Path(directory) / "settings.json")
loaded = store.save(self.valid_raw())
self.assertFalse(loaded.crossing["hold_full_screen"])
for choice in (False, True):
raw = config_to_raw(loaded)
raw["crossing"]["hold_full_screen"] = choice
self.assertEqual(store.save(raw).crossing["hold_full_screen"], choice)
raw = config_to_raw(loaded)
raw["crossing"]["hold_full_screen"] = "no"
with self.assertRaises(SettingsError):
store.save(raw)
def test_appearance_defaults_to_system_and_each_choice_round_trips(self):
with tempfile.TemporaryDirectory() as directory:
store = SettingsStore(Path(directory) / "settings.json")
self.assertEqual(store.save(self.valid_raw()).appearance, "system")
for choice in ("light", "dark", "system"):
raw = config_to_raw(store.load())
raw["appearance"] = choice
store.save(raw)
self.assertEqual(store.load().appearance, choice)
raw = config_to_raw(store.load())
raw["appearance"] = "sepia"
self.assertEqual(store.save(raw).appearance, "system")
def test_a_hand_edited_appearance_loads_as_system(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "settings.json"
path.write_text(json.dumps({**self.valid_raw(), "appearance": "sepia"}), encoding="utf-8")
self.assertEqual(config_module.load_config(str(path)).appearance, "system")
def test_appearances_match_the_shared_tokens(self):
import sys
sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
import tokens
self.assertEqual(config_module.APPEARANCES, tokens.APPEARANCES)
def test_legacy_positional_key_map_is_replaced_by_the_semantic_default(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "settings.json"
raw = self.valid_raw()
raw["key_map"] = {
"alt": "alt", "alt_r": "alt",
"ctrl": "ctrl", "ctrl_r": "ctrl",
"cmd": "cmd", "cmd_r": "cmd",
}
loaded = SettingsStore(path).save(raw)
self.assertEqual(loaded.key_map["cmd"], "ctrl")
self.assertEqual(loaded.key_map["ctrl"], "cmd")
def test_hand_edited_key_map_survives(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "settings.json"
raw = self.valid_raw()
raw["key_map"] = {"cmd": "cmd", "ctrl": "alt"}
loaded = SettingsStore(path).save(raw)
self.assertEqual(loaded.key_map["cmd"], "cmd")
self.assertEqual(loaded.key_map["ctrl"], "alt")
def test_rejects_placeholder_token(self):
with tempfile.TemporaryDirectory() as directory:
raw = self.valid_raw()
raw["auth_token"] = "CHANGE_ME"
with self.assertRaises(SettingsError):
SettingsStore(Path(directory) / "settings.json").save(raw)
def test_rejects_unknown_trigger(self):
with tempfile.TemporaryDirectory() as directory:
raw = self.valid_raw()
raw["trigger_key"] = "not_a_key"
with self.assertRaises(SettingsError):
SettingsStore(Path(directory) / "settings.json").save(raw)
def test_config_without_crossing_keys_loads_the_defaults(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "config.json"
path.write_text(json.dumps(self.valid_raw()), encoding="utf-8")
loaded = SettingsStore(path).load()
self.assertEqual(loaded.trigger_style, "double_tap")
self.assertEqual(loaded.crossing, config_module.DEFAULT_CROSSING)
self.assertIsNot(loaded.crossing, config_module.DEFAULT_CROSSING)
def test_fresh_and_partial_crossing_use_colourful_but_keep_saved_signal(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "settings.json"
store = SettingsStore(path)
fresh = store.save(self.valid_raw())
self.assertEqual(fresh.crossing["glow_colour"], "colourful")
raw = config_to_raw(fresh)
raw["crossing"]["glow_colour"] = "signal"
store.save(raw)
self.assertEqual(SettingsStore(path).load().crossing["glow_colour"], "signal")
def test_showing_where_the_pointer_lands_is_on_for_an_old_config_and_round_trips_off(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "config.json"
raw = self.valid_raw()
raw["crossing"] = {"edge": "left", "glow_style": "rupture"}
path.write_text(json.dumps(raw), encoding="utf-8")
store = SettingsStore(path)
loaded = store.load()
self.assertTrue(loaded.crossing["shortcut_arrival"])
raw = config_to_raw(loaded)
raw["crossing"]["shortcut_arrival"] = False
store.save(raw)
self.assertFalse(store.load().crossing["shortcut_arrival"])
self.assertEqual(store.load().crossing["shortcut_arrival_style"], "match")
raw["crossing"]["shortcut_arrival_style"] = "discharge"
store.save(raw)
self.assertEqual(store.load().crossing["shortcut_arrival_style"], "discharge")
self.assertEqual(store.load().crossing["glow_style"], "rupture")
def test_the_length_defaults_to_normal_and_round_trips(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "config.json"
raw = config_to_raw(settings_store.editable_default_config())
path.write_text(json.dumps(raw))
store = SettingsStore(path)
self.assertEqual(store.load().crossing["effect_length"], "normal")
raw["crossing"]["effect_length"] = "short"
store.save(raw)
self.assertEqual(store.load().crossing["effect_length"], "short")
raw["crossing"]["effect_length"] = "forever"
with self.assertRaises(SettingsError):
store.save(raw)
def test_a_saved_warp_choice_reads_as_its_stand_in(self):
# Warp is offered nowhere for now; a Mac that chose it keeps working.
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "config.json"
raw = config_to_raw(settings_store.editable_default_config())
raw["crossing"].update(glow_style="hyperdrive", glow_colour="vaporwave", shortcut_arrival_style="light_slit")
path.write_text(json.dumps(raw))
crossing = SettingsStore(path).load().crossing
self.assertEqual((crossing["glow_style"], crossing["glow_colour"], crossing["shortcut_arrival_style"]),
("glow", "colourful", "match"))
def test_partial_crossing_object_keeps_the_other_defaults(self):
with tempfile.TemporaryDirectory() as directory:
raw = self.valid_raw()
raw["crossing"] = {"edge": "left", "resistance_px": 40}
raw["trigger_style"] = "hold"
loaded = SettingsStore(Path(directory) / "settings.json").save(raw)
self.assertEqual(loaded.crossing["edge"], "left")
self.assertEqual(loaded.crossing["resistance_px"], 40)
self.assertEqual(loaded.crossing["methods"], ["shortcut", "edge"])
self.assertTrue(loaded.crossing["haptics"])
self.assertEqual(loaded.trigger_style, "hold")
def test_rejects_bad_crossing_values_by_field(self):
cases = [
({"methods": ["edge", "telepathy"]}, "crossing.methods"),
({"edge": "sideways"}, "crossing.edge"),
({"corner": "middle"}, "crossing.corner"),
({"resistance_px": 501}, "crossing.resistance_px"),
({"resistance_px": -1}, "crossing.resistance_px"),
({"glow": "yes"}, "crossing.glow"),
({"shortcut_arrival": "yes"}, "crossing.shortcut_arrival"),
({"edge_parts": []}, "crossing.edge_parts"),
({"edge_parts": ["side"]}, "crossing.edge_parts"),
({"edge_parts": "middle"}, "crossing.edge_parts"),
({"edge_parts": [["middle"]]}, "crossing.edge_parts"),
({"edge_parts": [{}]}, "crossing.edge_parts"),
({"methods": [["edge"]]}, "crossing.methods"),
({"methods": ["part", "sideways"]}, "crossing.methods"),
({"shortcut_arrival_style": "sparkle"}, "crossing.shortcut_arrival_style"),
({"notch_style": "sparkle"}, "crossing.notch_style"),
({"notch_after_ms": 50}, "crossing.notch_after_ms"),
({"notch_after_ms": 1.5}, "crossing.notch_after_ms"),
({"haptic_feel": "thunderous"}, "crossing.haptic_feel"),
({"haptic_steps": "thirds"}, "crossing.haptic_steps"),
({"glow_style": "sparkle"}, "crossing.glow_style"),
({"glow_colour": "tartan"}, "crossing.glow_colour"),
]
with tempfile.TemporaryDirectory() as directory:
for crossing, field in cases:
with self.subTest(field=field):
raw = self.valid_raw()
raw["crossing"] = crossing
with self.assertRaises(SettingsError) as caught:
SettingsStore(Path(directory) / "settings.json").save(raw)
self.assertIn(field, str(caught.exception))
def test_every_crossing_effect_and_colour_pack_round_trips(self):
from core import effects
pairs = [(style, "signal") for style in effects.EFFECT_IDS]
pairs += [(style, colour) for style in ("glow", "beam", "aperture") for colour in effects.PACK_IDS]
pairs += list(zip(effects.EFFECT_IDS, effects.PACK_IDS))
with tempfile.TemporaryDirectory() as directory:
store = SettingsStore(Path(directory) / "settings.json")
for style, colour in pairs:
with self.subTest(style=style, colour=colour):
raw = self.valid_raw()
raw["crossing"] = {"glow_style": style, "glow_colour": colour}
store.save(raw)
loaded = store.load()
self.assertEqual((loaded.crossing["glow_style"], loaded.crossing["glow_colour"]), (style, colour))
def test_rejects_a_direction_or_a_pack_where_a_style_goes(self):
cases = [
({"glow_style": "membrane"}, "crossing.glow_style"),
({"glow_style": "Skin"}, "crossing.glow_style"),
({"glow_style": "neon"}, "crossing.glow_style"),
({"glow_colour": "rupture"}, "crossing.glow_colour"),
({"glow_colour": "atmosphere"}, "crossing.glow_colour"),
]
with tempfile.TemporaryDirectory() as directory:
for crossing, field in cases:
with self.subTest(crossing=crossing):
raw = self.valid_raw()
raw["crossing"] = crossing
with self.assertRaises(SettingsError) as caught:
SettingsStore(Path(directory) / "settings.json").save(raw)
self.assertIn(field, str(caught.exception))
def test_rejects_unknown_trigger_style(self):
with tempfile.TemporaryDirectory() as directory:
raw = self.valid_raw()
raw["trigger_style"] = "triple_tap"
with self.assertRaises(SettingsError):
SettingsStore(Path(directory) / "settings.json").save(raw)
def test_key_map_style_names_round_trip(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "settings.json"
raw = self.valid_raw()
raw["key_map"] = "positional"
loaded = SettingsStore(path).save(raw)
self.assertEqual(loaded.key_map, config_module.LEGACY_POSITIONAL_KEY_MAP)
self.assertEqual(config_to_raw(loaded)["key_map"], "positional")
self.assertEqual(json.loads(path.read_text(encoding="utf-8"))["key_map"], "positional")
raw["key_map"] = "semantic"
self.assertEqual(SettingsStore(path).save(raw).key_map, config_module.DEFAULT_KEY_MAP)
raw["key_map"] = "chaotic"
with self.assertRaises(SettingsError):
SettingsStore(path).save(raw)
if __name__ == "__main__":
unittest.main()
class LegacyPortTests(unittest.TestCase):
def raw(self, port):
return {
"host": "192.0.2.10",
"port": port,
"auth_token": "synthetic-token",
"trigger_key": "alt_r",
"double_tap_ms": 300,
"key_map": {"cmd": "ctrl", "cmd_r": "ctrl"},
"reconnect_interval_s": 2.0,
}
def test_the_old_default_port_is_moved_and_the_move_is_written_down(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "settings.json"
(Path(directory) / "config.json").write_text(json.dumps(self.raw(protocol.LEGACY_DEFAULT_PORT)), encoding="utf-8")
store = SettingsStore(path)
self.assertEqual(store.load().port, protocol.DEFAULT_PORT)
on_disk = json.loads(path.read_text(encoding="utf-8"))
self.assertEqual(on_disk["port"], protocol.DEFAULT_PORT)
self.assertEqual(on_disk["peers"][0]["port"], protocol.DEFAULT_PORT)
def test_a_port_someone_chose_is_left_alone(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "settings.json"
store = SettingsStore(path)
store.save(self.raw(9000))
self.assertEqual(store.load().port, 9000)
def test_both_ports_are_below_the_range_the_system_hands_out(self):
self.assertLess(protocol.DEFAULT_PORT, 49152)
self.assertLess(protocol.PAIRING_PORT, 49152)