One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
"""Three machines on the Qt app: shortcut targets, tray items, Atlas tile selection and drops,
local ways, and Pause counting every machine's zones (WIRE.md sections 5 and 8)."""
import json
import os
import sys
import tempfile
import unittest
from unittest import mock
from pathlib import Path
from types import SimpleNamespace
sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
from tests.links_rig import B, C, HERE, Rig, edge_zone
import app_config
import pages_win
import sender as sender_module
from core import crossing_state, protocol
from core import ways
from core.tests import responder_harness as harness
try:
from PySide6.QtWidgets import QApplication, QLabel
import diagram
import kvm_bridge_win
import theme
except ImportError: # PySide6 is only in the Windows venv
kvm_bridge_win = None
D = harness.D
BT, CT, DT = protocol.id_text(B), protocol.id_text(C), protocol.id_text(D)
HIGH_ID = bytes([200]) * 16
HIGH = protocol.id_text(HIGH_ID)
def target_of(message):
return protocol.read_id(message["data"]["target"])
class ShortcutMachineTests(unittest.TestCase):
"""The shortcut, the Send button and the tray send input where core.ways.shortcut_peer says."""
def rig(self, up, **entries):
shortcut_goes_to = entries.pop("shortcut_goes_to", "last")
peers = [harness.entry(B, "Bee", side="left", **entries.get("b", {})),
harness.entry(C, "Sea", side="right", **entries.get("c", {}))]
return Rig(entries=peers, zones=[edge_zone(B), edge_zone(C)], up=up,
shortcut_goes_to=shortcut_goes_to)
def test_with_the_first_machine_down_the_shortcut_takes_one_that_is_up(self):
rig = self.rig(up=(C,))
self.assertTrue(rig.sender.set_redirecting(True))
self.assertEqual(rig.sender.owner, C)
self.assertEqual(target_of(rig.sent(C, "focus")[0]), C)
def test_hold_shortcut_announces_an_unready_last_machine(self):
rig = self.rig(up=(C,))
rig.sender._last_on = BT
rig.sender.hold_shortcut(True)
self.assertEqual(rig.sender.owner, C)
self.assertEqual(rig.alerts, ["Skipped Bee: not connected."])
def test_the_shortcut_goes_back_to_the_machine_input_was_last_on(self):
rig = self.rig(up=(B, C))
rig.sender.go(C)
rig.accept_take(C)
rig.sender.set_redirecting(False)
self.assertEqual(rig.sender.shortcut_target(), C)
self.assertTrue(rig.sender.set_redirecting(True))
self.assertEqual(rig.sender.owner, C)
def test_next_shortcut_cycles_through_drawing_order_and_home(self):
rig = self.rig(up=(B, C), shortcut_goes_to="next")
rig.sender.toggle_shortcut()
self.assertEqual(rig.sender.owner, C)
rig.sender.toggle_shortcut()
self.assertEqual(rig.sender.owner, B)
rig.sender.toggle_shortcut()
self.assertIsNone(rig.sender.owner)
def test_shortcut_at_home_asks_to_push_to_its_target_then_moves_when_captured(self):
rig = self.rig(up=(B, C))
rig.sender.input_held = lambda: False
requested = []
def push_out(peer, on_captured, on_failed):
requested.append((peer, on_captured, on_failed))
return True
rig.sender.push_out = push_out
rig.sender.toggle_shortcut()
self.assertEqual(len(requested), 1)
peer, captured, _failed = requested[0]
self.assertEqual(peer, rig.sender.shortcut_target())
self.assertEqual(rig.sender.owner, None)
self.assertEqual(rig.alerts, [])
rig.sender.input_held = lambda: True
captured()
self.assertEqual(rig.sender.owner, peer)
def test_failed_push_out_alerts_with_the_target_name(self):
rig = self.rig(up=(B, C))
rig.sender.input_held = lambda: False
requests = []
rig.sender.push_out = lambda peer, on_captured, on_failed: requests.append((peer, on_failed)) or True
rig.sender.toggle_shortcut()
requests[0][1]()
self.assertEqual(rig.alerts, ["Cannot switch — the desktop did not let Beamer send input to Bee"])
def test_no_push_out_keeps_the_existing_wayland_alert(self):
rig = self.rig(up=(B, C))
rig.sender.input_held = lambda: False
rig.sender.toggle_shortcut()
self.assertEqual(rig.alerts, ["Cannot switch — on this desktop input goes to another machine only by pushing the pointer through an edge"])
def test_push_out_refusal_falls_back_to_the_existing_wayland_alert(self):
rig = self.rig(up=(B, C))
rig.sender.input_held = lambda: False
rig.sender.push_out = lambda peer, on_captured, on_failed: False
rig.sender.toggle_shortcut()
self.assertEqual(rig.alerts, ["Cannot switch — on this desktop input goes to another machine only by pushing the pointer through an edge"])
def test_models_toward_returns_only_that_peers_models_and_none_while_edges_are_held(self):
rig = self.rig(up=(B, C))
models = rig.sender.models_toward(B)
self.assertTrue(models)
self.assertEqual(models, [model for peer, model in rig.sender._models if peer == B])
rig.sender.crossing_paused = True
self.assertEqual(rig.sender.models_toward(B), [])
def test_next_shortcut_passes_over_a_machine_that_just_refused_and_comes_home(self):
# The owner ignores a move to a machine it holds back, so choosing it left input where it was.
rig = self.rig(up=(B, C), shortcut_goes_to="next")
rig.sender.toggle_shortcut()
self.assertEqual(rig.sender.owner, C)
rig.sender._owner._hold_back(B, "refused")
rig.sender.toggle_shortcut()
self.assertIsNone(rig.sender.owner)
def test_a_machine_that_does_not_accept_input_is_passed_over(self):
rig = self.rig(up=(C,))
rig.bring_up(B, accepts=False)
self.assertEqual(rig.sender.shortcut_target(), C)
def test_a_machine_this_pc_does_not_send_to_is_never_picked(self):
rig = self.rig(up=(B, C), b={"send": False})
self.assertEqual(rig.sender.shortcut_target(), C)
def test_with_every_machine_down_the_first_is_woken(self):
rig = self.rig(up=(), b={"hw": "aa:bb:cc:dd:ee:ff"})
woken = []
rig.sender._wake_sender = lambda address, host: woken.append(address)
self.addCleanup(rig.sender._stop_event.set)
self.assertFalse(rig.sender.set_redirecting(True))
self.assertTrue(rig.sender.is_waking(B))
self.assertFalse(rig.sender.is_waking(C))
def test_with_every_machine_down_and_none_to_wake_the_first_is_named(self):
rig = self.rig(up=())
rig.sender.on_status(rig.links.key_of(rig.settings.data["peers"][0]), False, "Bee is unreachable")
self.assertFalse(rig.sender.set_redirecting(True))
self.assertEqual(rig.alerts, ["Cannot switch — Bee is unreachable"])
def test_the_status_is_the_shortcut_machines(self):
rig = self.rig(up=(C,))
rig.sender.on_status(rig.links.key_of(rig.settings.data["peers"][0]), False, "Bee is unreachable")
rig.sender.on_status(rig.links.key_of(rig.settings.data["peers"][1]), True, "Connected to Sea")
self.assertTrue(rig.sender.connected)
self.assertEqual(rig.sender.status, "Connected to Sea")
def test_the_status_does_not_name_a_machine_not_in_use(self):
rig = self.rig(up=(), b={"in_use": False})
rig.sender.on_status(rig.links.key_of(rig.settings.data["peers"][0]), False, "Bee is unreachable")
self.assertEqual(rig.sender.status, sender_module.NOT_CONNECTED_STATUS)
class SetWaysTests(unittest.TestCase):
"""Each machine's side and zones are written one machine at a time, under the settings lock, and
never by a flat save."""
def setUp(self):
directory = tempfile.TemporaryDirectory()
self.addCleanup(directory.cleanup)
self.path = Path(directory.name) / "settings.json"
settings = app_config.migrate(None, machine_id=protocol.id_text(harness.HERE))
settings["peers"] = [
harness.entry(B, "Bee", side="left", side_set_at=100, side_by=HIGH),
harness.entry(C, "Sea", platform="windows"),
]
for entry in settings["peers"]:
entry["caps"] = []
settings["zones"] = [{"peer": BT, "kind": "edge"}]
app_config.write_settings(self.path, settings)
def saved(self):
return json.loads(self.path.read_text(encoding="utf-8"))
def peer(self, ident):
return next(item for item in self.saved()["peers"] if item["id"] == ident)
def zones(self, ident):
return {zone["kind"]: zone for zone in self.saved()["zones"] if zone["peer"] == ident}
def test_reading_the_settings_gives_a_machine_with_no_zone_its_edge_and_writes_it(self):
# The rig's beta.3 file of 01-10-2026: the laptop paired second, its side set, no zone at all.
settings = self.saved()
settings["peers"][1]["side"] = "right"
app_config.write_settings(self.path, settings)
loaded = app_config.load_settings(self.path)
self.assertIn({"peer": CT, "kind": "edge"}, loaded["zones"])
self.assertIn({"peer": CT, "kind": "edge"}, self.saved()["zones"])
def test_old_peer_on_a_taken_side_keeps_intent_without_an_overlapping_zone(self):
settings = self.saved()
settings["peers"][1]["side"] = "left"
app_config.write_settings(self.path, settings)
loaded = app_config.load_settings(self.path)
self.assertFalse(any(z["peer"] == CT for z in loaded["zones"]))
self.assertTrue(loaded["peers"][1]["ways"]["edge"])
self.assertIn("Sea has no way in", ways.blocked_sentence(loaded, CT, "this PC"))
def test_way_edit_writes_one_peers_intent_and_keeps_both_sides(self):
settings = self.saved()
settings["peers"][1]["side"] = "right"
app_config.write_settings(self.path, settings)
self.assertFalse(app_config.set_ways(self.path, CT, side="top", methods=["part", "corner"], parts=["end"], corner="bottom_right"))
self.assertEqual(self.peer(CT)["side"], "right")
self.assertEqual(self.zones(CT)["part"]["parts"], ["end"])
self.assertNotIn("edge", self.zones(CT))
self.assertEqual(self.zones(CT)["corner"]["edge"], "right")
self.assertEqual(self.zones(BT), {"edge": {"peer": BT, "kind": "edge"}})
def test_an_unchanged_side_is_not_a_move(self):
self.assertFalse(app_config.set_ways(self.path, BT, side="left", methods=["edge"], parts=["middle"], corner="top_left"))
self.assertEqual(self.peer(BT)["side_set_at"], 100)
def test_no_side_given_keeps_the_side_held_whatever_the_window_last_read(self):
settings = self.saved()
settings["peers"][0]["side"] = "top"
app_config.write_settings(self.path, settings)
self.assertFalse(app_config.set_ways(self.path, BT, methods=["edge", "corner"], parts=["middle"], corner="top_left"))
self.assertEqual(self.peer(BT)["side"], "top")
self.assertEqual(self.zones(BT)["corner"]["edge"], "top")
def test_shared_side_way_edit_saves_intent_without_a_clash_refusal(self):
settings = self.saved()
settings["peers"][1]["side"] = "left"
app_config.write_settings(self.path, settings)
app_config.set_ways(self.path, CT, methods=["edge"], parts=["middle"], corner="top_left")
self.assertTrue(self.peer(CT)["ways"]["edge"])
self.assertFalse(any(z["peer"] == CT for z in self.saved()["zones"]))
self.assertEqual(self.zones(BT), {"edge": {"peer": BT, "kind": "edge"}})
def test_a_machine_that_is_not_paired_is_an_error(self):
with self.assertRaises(app_config.ConfigError):
app_config.set_ways(self.path, DT, side="left", methods=[], parts=["middle"], corner="top_left")
def test_a_flat_save_never_writes_a_side_or_a_zone(self):
stale = app_config.load_config(self.path)
settings = self.saved()
settings["peers"][0].update(side="top", side_set_at=300, side_by=HIGH)
app_config.write_settings(self.path, settings)
app_config.save_config(self.path, app_config.replace(
stale, crossing_methods=["part"], crossing_edge_parts=["start"], mac_return_edge="bottom",
arrangement_set_at=400, pointer_speed=2.0))
saved = self.saved()
self.assertEqual((saved["peers"][0]["side"], saved["peers"][0]["side_set_at"], saved["peers"][0]["side_by"]),
("top", 300, HIGH))
self.assertEqual(saved["zones"], [{"peer": BT, "kind": "edge"}])
self.assertFalse(saved["shortcut"])
self.assertEqual(saved["pointer_speed"], 2.0)
def test_a_flat_save_keeps_a_name_and_hardware_address_learnt_since_the_window_read(self):
stale = app_config.load_config(self.path)
settings = self.saved()
settings["peers"][0].update(name="Bee Studio", hw="aa:bb:cc:dd:ee:01")
app_config.write_settings(self.path, settings)
app_config.save_config(self.path, app_config.replace(stale, pointer_speed=2.0))
self.assertEqual((self.peer(BT)["name"], self.peer(BT)["hw"]), ("Bee Studio", "aa:bb:cc:dd:ee:01"))
app_config.save_config(self.path, app_config.replace(stale, mac_host="192.0.2.99", paired_with="",
mac_hardware_address=""))
self.assertEqual((self.peer(BT)["host"], self.peer(BT)["name"], self.peer(BT)["hw"]), ("192.0.2.99", "", ""))
def test_an_arrangement_rewrites_the_edge_that_machines_corner_crosses(self):
settings = self.saved()
settings["zones"].append({"peer": BT, "kind": "corner", "corner": "top_right", "edge": "left"})
app_config.write_settings(self.path, settings)
self.assertEqual(app_config.apply_arrangement(self.path, BT, "left", 500, HIGH), (True, []))
self.assertEqual((self.peer(BT)["side"], self.zones(BT)["corner"]["edge"]), ("right", "right"))
def test_old_peer_arrangement_compiles_without_historical_off_zones(self):
changed, notices = app_config.apply_arrangement(self.path, CT, "right", 500, HIGH)
self.assertTrue(changed)
self.assertEqual(self.peer(CT)["side"], "left")
self.assertEqual(notices, [])
self.assertEqual(self.zones(CT), {})
self.assertTrue(self.peer(CT)["ways"]["edge"])
class DiagramGeometryTests(unittest.TestCase):
SCREEN = (120.0, 75.0)
def test_machines_sharing_a_side_are_ordered_by_their_thirds_then_the_list(self):
slots = pages_win.side_slots([
{"side": "right", "methods": ["part"], "parts": ["end"]},
{"side": "right", "methods": ["part"], "parts": ["start"]},
{"side": "top", "methods": [], "parts": ["middle"]},
{"side": "", "methods": ["corner"], "parts": ["middle"]},
])
self.assertEqual(slots, [("right", 0.5, 1.0), ("right", 0.0, 0.5), ("top", 0.0, 1.0), None])
def test_one_machine_sits_where_the_pair_always_did(self):
for side, offset in (("right", (134.0, 0.0)), ("left", (-134.0, 0.0)), ("top", (0.0, -89.0)), ("bottom", (0.0, 89.0))):
pc, (other,), _height = pages_win.layout_rects(400.0, 0.0, [(pages_win.SIDE_ANGLE[side], 0.0, 1.0)], self.SCREEN, 14.0)
self.assertEqual((other[0] - pc[0], other[1] - pc[1]), offset, side)
self.assertEqual(other[2:], self.SCREEN)
pc, (other,), height = pages_win.layout_rects(400.0, 10.0, [(0.0, 0.0, 1.0)], self.SCREEN, 14.0)
self.assertEqual(height, 75.0)
self.assertEqual((pc[0] + other[0] + other[2]) / 2.0, 200.0)
self.assertEqual(pc[1], 10.0)
_pc, _rects, stacked = pages_win.layout_rects(400.0, 0.0, [(90.0, 0.0, 1.0)], self.SCREEN, 14.0)
self.assertEqual(stacked, 164.0)
def test_a_row_puts_this_pc_in_the_middle(self):
pc, (left, right), height = pages_win.layout_rects(
500.0, 0.0, [(180.0, 0.0, 1.0), (0.0, 0.0, 1.0)], self.SCREEN, 14.0)
self.assertEqual(pc[0] + pc[2] / 2.0, 250.0)
self.assertEqual(left[0] + left[2] + 14.0, pc[0])
self.assertEqual(right[0], pc[0] + pc[2] + 14.0)
self.assertEqual(height, 75.0)
def test_two_on_one_side_are_each_half_as_long_and_split_it(self):
pc, (top, bottom), _height = pages_win.layout_rects(
500.0, 0.0, [(0.0, 0.0, 0.5), (0.0, 0.5, 1.0)], self.SCREEN, 14.0)
self.assertEqual(top[2:], (60.0, 37.5))
self.assertEqual(bottom[2:], (60.0, 37.5))
self.assertEqual(top[0], pc[0] + pc[2] + 14.0)
self.assertEqual((top[1], bottom[1] + bottom[3]), (pc[1], pc[1] + pc[3]))
def test_an_l_has_one_beside_and_one_above(self):
pc, (right, above), height = pages_win.layout_rects(
500.0, 0.0, [(0.0, 0.0, 1.0), (90.0, 0.0, 1.0)], self.SCREEN, 14.0)
self.assertEqual((right[0], right[1]), (pc[0] + pc[2] + 14.0, pc[1]))
self.assertEqual((above[0], above[1] + above[3] + 14.0), (pc[0], pc[1]))
self.assertEqual(above[1], 0.0)
self.assertEqual(height, 164.0)
def test_with_several_machines_this_pc_stays_in_the_middle_whatever_the_sides(self):
for placed in ([(0.0, 0.0, 1.0), (90.0, 0.0, 1.0)], [(0.0, 0.0, 0.5), (0.0, 0.5, 1.0)]):
pc, _rects, _height = pages_win.layout_rects(500.0, 0.0, placed, self.SCREEN, 14.0, centre_pc=True)
self.assertEqual(pc[0] + pc[2] / 2.0, 250.0, placed)
pc, (_left, right), _height = pages_win.layout_rects(
300.0, 0.0, [(0.0, 0.0, 1.0), (90.0, 0.0, 1.0)], self.SCREEN, 14.0, centre_pc=True)
self.assertEqual(pc[0] + pc[2] / 2.0, 150.0)
self.assertLessEqual(right[0] + right[2], 300.001)
def test_a_narrow_width_shrinks_the_drawing_to_fit(self):
pc, (left, right), _height = pages_win.layout_rects(
300.0, 0.0, [(180.0, 0.0, 1.0), (0.0, 0.0, 1.0)], self.SCREEN, 14.0)
self.assertGreaterEqual(left[0], -0.001)
self.assertLessEqual(right[0] + right[2], 300.001)
self.assertLess(pc[2], 120.0)
def test_nobody_goes_through_this_pc_on_the_way_round(self):
for start, end in ((0.0, 1.0), (0.0, 0.5), (0.5, 1.0)):
for angle in range(0, 360, 5):
pc, (other,), _height = pages_win.layout_rects(500.0, 0.0, [(float(angle), start, end)], self.SCREEN, 14.0)
apart_x = other[0] >= pc[0] + pc[2] or other[0] + other[2] <= pc[0]
apart_y = other[1] >= pc[1] + pc[3] or other[1] + other[3] <= pc[1]
self.assertTrue(apart_x or apart_y, (angle, start, end))
def test_the_description_names_every_machine_and_its_side(self):
machines = [
{"label": "Bee", "side": "right", "methods": ["edge"], "parts": ["middle"], "corner": "top_left", "chosen": True},
{"label": "Sea", "side": "top", "methods": [], "parts": ["middle"], "corner": "top_left", "chosen": False},
{"label": "Dee", "side": "", "methods": [], "parts": ["middle"], "corner": "top_left", "chosen": False},
]
text = pages_win.diagram_description(machines, "Right Ctrl", "hold", True)
self.assertIn("Bee is to the right of this PC", text)
self.assertIn("Sea is above this PC", text)
self.assertIn("Not placed yet: Dee", text)
self.assertIn("Input moves to Bee when you push through the whole right edge", text)
def test_the_unplaced_line_names_them_all(self):
self.assertEqual(pages_win.unplaced_line(["Sea"]), "Not placed yet: Sea")
self.assertEqual(pages_win.unplaced_line(["Sea", "Dee", "Eff"]), "Not placed yet: Sea, Dee and Eff")
self.assertEqual(pages_win.unplaced_line([]), "")
class WordingTests(unittest.TestCase):
def test_the_summary_and_the_unlearned_side_name_the_machine(self):
self.assertEqual(pages_win.ways_summary(["edge"], "right", [], "top_left", "F13", "hold", "Sea"),
"Input moves to Sea when you push through the whole right edge.")
self.assertIn("on Sea", pages_win.not_learned_edge("Sea"))
self.assertIn("the other machine", pages_win.not_learned_edge())
def test_no_page_purpose_pictures_exactly_one_other_machine(self):
for _key, _name, purpose in pages_win.PAGES:
self.assertNotIn("the other machine", purpose)
for line in pages_win.SCOPE.values():
self.assertNotIn("the other machine", line)
@unittest.skipIf(kvm_bridge_win is None, "needs PySide6")
class WindowTests(unittest.TestCase):
"""The real window, built offscreen from a settings file, which starts no receiver, hooks or announcer."""
PEERS = None
def setUp(self):
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
self.app = QApplication.instance() or QApplication([])
theme.init_fonts()
directory = tempfile.TemporaryDirectory()
self.addCleanup(directory.cleanup)
self.path = Path(directory.name) / "settings.json"
settings = app_config.migrate(None, machine_id=protocol.id_text(harness.HERE))
settings["peers"] = self.PEERS if self.PEERS is not None else [
harness.entry(B, "Bee", side="left", side_set_at=100, side_by=HIGH, paired_with=[]),
harness.entry(C, "Sea", platform="windows", allow_drive=False),
]
settings["zones"] = [{"peer": BT, "kind": "edge"}]
settings["port"] = harness.free_port()
app_config.write_settings(self.path, settings)
self.window = kvm_bridge_win.WindowsApplication(self.path)
self.linked = {BT, CT}
self.window._live = lambda peer: peer in self.linked
self.sent = []
self.window._send_to = lambda peer, message: self.sent.append((peer, message)) or True
self.window._refresh_window()
def tearDown(self):
self.window.server.stop()
self.window.deleteLater()
def saved(self):
return json.loads(self.path.read_text(encoding="utf-8"))
def peer(self, ident):
return next(item for item in self.saved()["peers"] if item["id"] == ident)
class ShortcutCycleRefreshTests(WindowTests):
def test_ticked_cycle_remains_visible_after_peer_state_refresh(self):
self.window._config.shortcut_goes_to = "ticked"
self.window._refresh_peers()
rows = [row for row in self.window.machines.rows.values() if not row._phone]
self.assertEqual(len(rows), 2)
self.assertTrue(all(row.shortcut_cycle.isVisibleTo(self.window.machines) for row in rows))
self.window._refresh_peer_states()
self.assertTrue(all(row.shortcut_cycle.isVisibleTo(self.window.machines) for row in rows))
class HeaderResponseTests(WindowTests):
def test_active_sender_peer_uses_outgoing_measurement_before_other_driver(self):
outgoing, incoming = B, C
link = SimpleNamespace(live=lambda: True, response_time_ms=23)
links = SimpleNamespace(_by_peer={outgoing: link}, up=lambda peer: peer == outgoing,
_link=lambda peer: link if peer == outgoing else None)
with mock.patch.object(self.window, "sender", SimpleNamespace(owner=outgoing, links=links)), \
mock.patch.object(self.window, "server", SimpleNamespace(owner=incoming, links=lambda: {incoming},
response_time_ms=lambda _peer: 91)):
self.assertEqual(self.window._header_response_time(), ("Bee", 23, True))
def test_receive_only_driver_uses_incoming_measurement(self):
sender = SimpleNamespace(owner=None, links=SimpleNamespace(up=lambda _peer: False, _link=lambda _peer: None))
server = SimpleNamespace(owner=C, links=lambda: {C}, response_time_ms=lambda peer: 42 if peer == C else None)
with mock.patch.object(self.window, "sender", sender), mock.patch.object(self.window, "server", server):
self.assertEqual(self.window._header_response_time(), ("Sea", 42, True))
def test_windows_identity_advertises_ping_response_measurements(self):
self.assertIn("ping_rtt", self.window._identity()["caps"])
class CrossingPageTests(WindowTests):
def drop(self, peer, x, y, w=160, h=100, positions=None):
layout = {key: dict(tile) for key, tile in self.window.atlas_canvas.tiles.items()}
layout.update(positions or {})
layout[peer] = {"x": x, "y": y, "w": w, "h": h}
self.window._choose_machine(peer)
return self.window._layout_dropped(layout, peer)
def sharing_side(self):
settings = app_config.load_settings(self.path)
for peer in settings["peers"]:
peer.update(side="right", side_set_at=100 if peer["id"] == BT else 200, side_by=HIGH)
settings["zones"] = [{"peer": BT, "kind": "edge"}, {"peer": CT, "kind": "edge", "off": True}]
app_config.write_settings(self.path, settings)
self.window._pull_peer_fields()
self.window._choose_machine(CT)
return self.window
def test_offline_picture_peer_keeps_its_zone_when_another_edge_is_edited(self):
window = self.sharing_side()
self.linked = {CT}
before = dict(self.bee_zone())
window._ledger_edge(CT)
window._ledger_edge(CT)
self.assertEqual(self.bee_zone(), before)
self.assertTrue(self.peer(CT)["ways"]["edge"])
self.assertFalse(any("aside" in zone for zone in self.saved()["zones"]))
def lid_shut(self):
"""Keep Bee offline while Sea edits its ways."""
window = self.sharing_side()
self.linked = {CT}
window._choose_machine(CT)
self.assertTrue(window._write_ways(methods=["edge"]))
self.alerts = []
window._on_alert = lambda title, message: self.alerts.append(message)
return window
def bee_zone(self):
return next(zone for zone in app_config.load_settings(self.path)["zones"]
if zone["peer"] == BT and zone["kind"] == "edge")
def test_offline_picture_peer_keeps_its_zone_and_reconnection_adds_no_glue(self):
window = self.lid_shut()
before = self.saved()
self.assertNotIn("aside", self.bee_zone())
self.linked = {BT, CT}
window._settle_presence()
self.assertEqual(self.saved(), before)
self.assertEqual(self.alerts, [])
def test_reconnecting_picture_peer_keeps_allocations_and_ledger_status_updates(self):
window = self.lid_shut()
before = self.saved()["zones"]
self.linked = {BT, CT}
window._settle_presence()
window._reflect_ways()
self.assertEqual(self.saved()["zones"], before)
self.assertEqual(self.alerts, [])
self.assertIn("Linked", window.crossing_ledger.rows[BT].status.text())
def test_forgotten_peer_has_no_zones_but_keeps_intent_and_a_ledger_row(self):
window = self.lid_shut()
settings = self.saved()
settings["peers"][0].update(dormant=True, dormant_reason="forgotten")
app_config.write_settings(self.path, settings)
window._pull_peer_fields()
window._write_ways(peer=CT, edge=True)
self.assertFalse(any(z["peer"] == BT for z in self.saved()["zones"]))
self.assertTrue(self.peer(BT)["ways"]["edge"])
self.assertIn(BT, window.atlas_canvas.shelf_ids)
self.assertIn(BT, window.crossing_ledger.rows)
self.assertFalse(hasattr(window, "left_out_shelf"))
def test_selected_machine_is_named_in_its_ledger_row(self):
window = self.sharing_side()
self.assertEqual(window.crossing_ledger.rows[CT].name.full_text, "Sea")
self.assertTrue(window.crossing_ledger.rows[CT].selected)
self.assertFalse(hasattr(window, "blocked_note"))
def test_removing_a_machine_that_shared_a_side_leaves_the_zones_as_a_fresh_compile(self):
# rc16 bug hunt #6 suspected the PC kept stale zones until the next link-up, as it skips the
# Mac's compile on save; the narrowed thirds are the remaining machine's own saved choice, so
# a compile changes nothing. This holds that.
self.sharing_side()
self.assertTrue(self.drop(CT, 160, 80, 160, 20, {BT: dict(x=160, y=0, w=160, h=80)}))
self.assertIn((BT, "part"), {(z["peer"], z["kind"]) for z in self.saved()["zones"]})
self.window._remove_peer(harness.TOKENS[C])
saved = self.saved()
compiled = crossing_state.migrate(saved, "pc", capable=self.window._layout_capable())["settings"]
self.assertEqual(saved["zones"], compiled["zones"])
self.assertNotIn(CT, {zone["peer"] for zone in saved["zones"]})
def test_dropping_tiles_on_separate_thirds_saves_and_tells_the_new_way_back(self):
window = self.sharing_side()
self.assertTrue(self.drop(CT, 160, 67, 160, 33, {BT: dict(x=160, y=0, w=160, h=33)}))
zones = {(z["peer"], z["kind"]): z for z in self.saved()["zones"]}
self.assertEqual(zones[(BT, "part")]["parts"], ["start"])
self.assertEqual(zones[(CT, "part")]["parts"], ["end"])
self.assertNotIn((BT, "edge"), zones)
self.assertNotIn((CT, "edge"), zones)
self.assertEqual(self.peer(BT)["side"], "right")
self.assertEqual(self.peer(CT)["side"], "right")
self.assertEqual({peer for peer, _data in self.arrangements()}, {B, C})
self.assertTrue(all(data["way_back"] for _, data in self.arrangements()))
def test_overlapping_drop_lands_only_at_an_accepted_free_position(self):
window = self.sharing_side()
self.assertTrue(self.drop(CT, 160, -50))
layout = self.saved()["layout"]
self.assertFalse(ways._overlaps(layout[BT], layout[CT]))
self.assertEqual(window.atlas_canvas.tiles[CT], layout[CT])
def test_an_overlapping_partial_tile_is_sent_to_a_free_snap(self):
window = self.sharing_side()
self.assertTrue(self.drop(CT, 160, -50, 160, 33))
layout = self.saved()["layout"]
self.assertFalse(ways._overlaps(layout[BT], layout[CT]))
self.assertFalse(ways._overlaps(layout[window._config.machine_id], layout[CT]))
def test_with_two_machines_paired_the_page_offers_a_choice_of_machine(self):
window = self.window
self.assertEqual(set(window.atlas_canvas.tiles), {window._config.machine_id, BT, CT})
self.assertEqual((window.atlas_canvas.labels[BT], window.atlas_canvas.labels[CT]), ("Bee", "Sea"))
self.assertEqual(window.atlas_canvas.selected, BT)
self.assertEqual(ways.ways(window._crossing_settings(), BT)["side"], "left")
self.assertEqual(window.crossing_ledger.rows[BT].name.full_text, "Bee")
def test_choosing_a_machine_shows_its_ways(self):
window = self.window
window._choose_machine(CT)
self.assertEqual(ways.ways(window._crossing_settings(), CT)["methods"], ["edge"])
self.assertEqual(window.crossing_ledger.rows[CT].name.full_text, "Sea")
self.assertTrue(window.crossing_ledger.rows[CT].selected)
self.assertFalse(window.crossing_ledger.rows[BT].selected)
self.assertEqual(window.atlas_canvas.selected, CT)
def test_a_side_set_here_is_that_machines_alone_and_is_sent_to_it(self):
window = self.window
window._choose_machine(CT)
self.assertTrue(self.drop(CT, 160, 0))
self.assertEqual(self.peer(CT)["side"], "right")
self.assertEqual(self.peer(BT)["side"], "left")
(peer, message), = self.sent
self.assertEqual(peer, C)
self.assertEqual(message["data"]["edge"], "right")
self.assertEqual(message["data"]["set_at"], self.peer(CT)["side_set_at"])
def arrangements(self):
return [(peer, message["data"]) for peer, message in self.sent if message["type"] == protocol.MSG_ARRANGEMENT]
def test_ledger_way_changes_tell_the_peer_its_current_return_way(self):
next(chip for chip in self.window.crossing_ledger.rows[BT].edge_chips.chips.values() if chip.kind == "contact").click()
peer, data = self.arrangements()[-1]
self.assertEqual(peer, B)
self.assertFalse(data["way_back"])
self.assertEqual(data["edge"], self.peer(BT)["side"])
self.window.crossing_ledger.rows[BT].corner_grid.buttons["top_left"].click()
self.assertTrue(self.arrangements()[-1][1]["way_back"])
def test_moving_one_machine_tells_every_machine_whose_way_back_it_changed(self):
self.assertTrue(self.drop(BT, -400, 0, positions={CT: dict(x=400, y=200, w=160, h=100)}))
told = {peer: data for peer, data in self.arrangements()}
self.assertEqual(set(told), {B, C})
self.assertTrue(all(data["way_back"] is False for data in told.values()))
def test_removing_a_left_out_machine_keeps_the_remaining_crossing(self):
self.window._canvas_left_out(CT, True)
self.sent.clear()
self.window._remove_peer(harness.TOKENS[C])
saved = self.saved()
self.assertEqual([p["id"] for p in saved["peers"]], [BT])
self.assertTrue(ways.has_way(saved, BT))
self.assertFalse(any(peer == C for peer, _data in self.arrangements()))
def test_picture_peer_return_way_changes_are_saved_without_an_answer(self):
window = self.window
before = self.saved()["layout"]
window.bridge.arrangement.emit(CT, "left", 500, HIGH, True, None)
self.assertTrue(self.peer(CT)["way_back"])
self.assertEqual(self.saved()["layout"], before)
self.assertEqual(self.arrangements(), [])
window.bridge.arrangement.emit(CT, "left", 500, HIGH, False, None)
self.assertFalse(self.peer(CT)["way_back"])
self.assertEqual(self.arrangements(), [])
def test_every_link_up_says_whether_a_way_leads_to_that_machine(self):
told = lambda: next(m["data"] for m in self.window._announce(B) if m["type"] == protocol.MSG_ARRANGEMENT)
self.assertIs(told()["way_back"], True)
self.assertTrue(self.drop(BT, -400, 0))
self.assertIs(told()["way_back"], False)
def test_either_link_hands_on_way_back(self):
heard = []
self.window.bridge.arrangement.connect(lambda *args: heard.append(args))
read = {"edge": "left", "set_at": 500, "by": HIGH_ID, "way_back": False}
self.window.server._callbacks["arrangement"](C, read)
self.window.sender.arrangement_callback(C, {**read, "set_at": 501, "way_back": True})
self.assertEqual([args[4] for args in heard], [False, True])
def test_drop_over_another_machine_saves_a_nonoverlapping_snap(self):
window = self.window
self.assertTrue(self.drop(CT, -160, 0))
saved = self.saved()["layout"]
self.assertFalse(ways._overlaps(saved[BT], saved[CT]))
self.assertEqual(window.atlas_canvas.selected, CT)
def test_ways_written_here_reach_that_machines_zones_only(self):
window = self.window
self.assertTrue(self.drop(CT, 160, 0))
before = dict(self.peer(BT)["ways"])
window.crossing_ledger.rows[CT].corner_grid.buttons["bottom_right"].click()
corners = [z for z in self.saved()["zones"] if z["peer"] == CT and z["kind"] == "corner"]
self.assertEqual(corners[0]["corner"], "bottom_right")
self.assertEqual(self.peer(BT)["ways"], before)
def test_the_shortcut_stays_this_pcs_own(self):
window = self.window
window._ways_changed("shortcut", False)
self.assertFalse(self.saved()["shortcut"])
window._choose_machine(BT)
self.assertFalse(self.saved()["shortcut"])
self.assertTrue(self.peer(BT).get("shortcut_cycle", True))
def test_selected_machine_stays_named_without_a_missing_way_inspector(self):
window = self.window
window._choose_machine(CT)
self.assertEqual(window.crossing_ledger.rows[CT].name.full_text, "Sea")
self.assertTrue(window.crossing_ledger.rows[CT].selected)
self.assertFalse(hasattr(window, "missing_note"))
def test_picture_arrangement_keeps_layout_and_selects_its_ledger_row(self):
window = self.window
before = self.saved()["layout"]
window._on_arrangement(CT, "right", 500, HIGH)
window._choose_machine(CT)
self.assertEqual(self.saved()["layout"], before)
self.assertTrue(window.crossing_ledger.rows[CT].selected)
self.assertFalse(hasattr(window, "blocked_note"))
def test_picture_peer_return_way_flag_updates_without_a_notice_block(self):
window = self.window
window._on_arrangement(BT, "right", 50, HIGH, False)
self.assertFalse(self.peer(BT)["way_back"])
window._on_arrangement(BT, "right", 50, HIGH, True)
self.assertTrue(self.peer(BT)["way_back"])
self.assertFalse(hasattr(window, "no_way_back_note"))
def test_arrangement_keeps_the_return_way_holder_without_a_notice_block(self):
window = self.window
window._on_arrangement(CT, "right", 500, HIGH, False, BT)
self.assertEqual(self.peer(CT)["way_back_by"], BT)
self.assertFalse(hasattr(window, "no_way_back_note"))
def test_nonselected_picture_arrangement_keeps_its_side_and_layout(self):
window = self.window
before = self.saved()["layout"]
side = self.peer(CT)["side"]
window._on_arrangement(CT, "left", 500, HIGH, True)
self.assertEqual(window.atlas_canvas.selected, BT)
self.assertEqual(self.peer(CT)["side"], side)
self.assertEqual(self.saved()["layout"], before)
self.assertTrue(self.peer(CT)["way_back"])
def test_the_diagram_draws_every_machine(self):
window = self.window
window._choose_machine(CT)
self.assertTrue(self.drop(CT, 160, 0))
canvas = window.atlas_canvas
own = canvas.tiles[window._config.machine_id]
self.assertEqual(ways._rect_contact(own, canvas.tiles[BT])[0], "left")
self.assertEqual(ways._rect_contact(own, canvas.tiles[CT])[0], "right")
self.assertEqual(canvas.selected, CT)
self.assertEqual((canvas.labels[BT], canvas.labels[CT]), ("Bee", "Sea"))
def test_pause_counts_every_machines_zones(self):
window = self.window
window._choose_machine(BT)
self.assertTrue(self.drop(BT, -400, 0,
positions={CT: {"x": 400, "y": 200, "w": 160, "h": 100}}))
self.assertFalse(window._crossing_state_args()[4])
window._choose_machine(CT)
self.assertTrue(self.drop(CT, 160, 0))
self.assertTrue(window._crossing_state_args()[4])
def test_granular_same_groups_name_each_shared_area(self):
self.assertEqual(set(self.window.same_checks), {"crossing", "design", "shortcut", "names", "everything"})
self.assertIn("Names shares this machine's name and paired-machine labels",
self.window.same_content_note.text())
class OneMachineTests(WindowTests):
PEERS = [harness.entry(B, "Bee", side="left")]
def test_one_machine_is_selected_on_the_canvas_with_its_existing_way(self):
window = self.window
self.assertEqual(set(window.atlas_canvas.tiles), {window._config.machine_id, BT})
self.assertEqual(window.atlas_canvas.selected, BT)
self.assertEqual(window.crossing_ledger.rows[BT].name.full_text, "Bee")
self.assertEqual(ways.ways(window._crossing_settings(), BT)["side"], "left")
self.assertEqual(ways.ways(window._crossing_settings(), BT)["methods"], ["edge"])
def test_the_tray_has_no_item_per_machine_and_the_button_names_it(self):
window = self.window
self.assertEqual(window.machine_actions, {})
self.assertEqual(window.redirect_action.text(), "Send input to Bee")
self.assertTrue(window.redirect_action.isVisible())
class TrayTests(WindowTests):
def setUp(self):
# The tray of a desktop that can send input from a menu; on Wayland only an edge can
# (test_linux_start), and a Linux test run over SSH reads as Wayland.
patcher = mock.patch("platform_parts.WAYLAND", False)
patcher.start()
self.addCleanup(patcher.stop)
super().setUp()
def test_tray_groups_status_version_connection_directions_and_settings(self):
window = self.window
actions = window.tray_menu.actions()
self.assertIs(actions[0], window.status_action)
self.assertTrue(actions[1].isSeparator())
self.assertIs(actions[2], window.header_action)
self.assertTrue(actions[3].isSeparator())
labels = [action.text() for action in actions if not action.isSeparator()]
self.assertLess(labels.index("Send input to Bee"), labels.index("Pause crossing"))
self.assertLess(labels.index("Pause crossing"), labels.index(window.send_action.text()))
self.assertLess(labels.index(window.send_action.text()), labels.index(window.drive_action.text()))
self.assertLess(labels.index(window.drive_action.text()), labels.index("Settings…"))
self.assertEqual(window.open_action.text(), "Settings…")
def test_each_machine_this_pc_sends_to_has_its_own_tray_item(self):
window = self.window
self.assertEqual([action.text() for action in window.machine_actions.values()],
["Send input to Bee", "Send input to Sea"])
went = []
window.sender.go = lambda peer, *args: went.append(peer) or True
window.machine_actions[CT].trigger()
self.assertEqual(went, [C])
self.assertFalse(window.redirect_action.isVisible())
def test_a_machine_whose_link_is_down_is_dimmed_as_unavailable(self):
window = self.window
self.linked = {BT}
window._refresh_tray_machines()
bee, sea = window.machine_actions[BT], window.machine_actions[CT]
self.assertEqual((bee.text(), bee.isEnabled()), ("Send input to Bee", True))
self.assertEqual((sea.text(), sea.isEnabled()), ("Sea is unavailable", False))
self.linked = {BT, CT}
window._refresh_tray_machines()
self.assertEqual((sea.text(), sea.isEnabled()), ("Send input to Sea", True))
def test_active_target_row_returns_input_and_owner_changes_update_existing_rows(self):
window = self.window
returned = []
went = []
sender = SimpleNamespace(redirecting=True, owner=C,
set_redirecting=lambda enabled: returned.append(enabled),
go=lambda peer, *args: went.append(peer) or True,
shortcut_target=lambda: C)
with mock.patch.object(window, "sender", sender):
window._refresh_tray_machines()
sea = window.machine_actions[CT]
bee = window.machine_actions[BT]
self.assertEqual(sea.text(), "Bring input back")
self.assertTrue(sea.isEnabled())
self.assertFalse(window.redirect_action.isVisible())
sea.trigger()
self.assertEqual(returned, [False])
sender.owner = B
window._refresh_tray_machines()
self.assertIs(window.machine_actions[CT], sea)
self.assertIs(window.machine_actions[BT], bee)
self.assertEqual(sea.text(), "Send input to Sea")
self.assertEqual(bee.text(), "Bring input back")
sea.trigger()
self.assertEqual(went, [C])
next(entry for entry in window._peer_entries if entry["id"] == CT)["name"] = "Seaside"
window._labels_by_id[C] = "Seaside"
window._refresh_tray_machines()
self.assertIs(window.machine_actions[CT], sea)
self.assertEqual(sea.text(), "Send input to Seaside")
sender.redirecting = False
sender.owner = None
window._refresh_tray_machines()
self.assertEqual(sea.text(), "Send input to Seaside")
self.assertEqual(bee.text(), "Send input to Bee")
window._peer_entries = [entry for entry in window._peer_entries if entry.get("id") == CT]
window._refresh_tray_machines()
self.assertEqual(window.machine_actions, {})
self.assertTrue(window.redirect_action.isVisible())
self.assertEqual(window._redirect_text(), "Send input to Seaside")
window._peer_entries = []
window._refresh_tray_machines()
self.assertEqual(window.machine_actions, {})
self.assertTrue(window.redirect_action.isVisible())
def test_direction_switches_name_every_machine_and_distinguish_mixed_none_and_all(self):
window = self.window
def set_directions(send, allow_drive):
settings = self.saved()
for entry, sends, allows in zip(settings["peers"], send, allow_drive):
entry["send"] = sends
entry["allow_drive"] = allows
app_config.write_settings(self.path, settings)
window._pull_peer_fields()
window._refresh_tray_directions()
set_directions((True, False), (False, True))
self.assertEqual(window.send_action.text(), "This PC drives every machine (some enabled)")
self.assertEqual(window.drive_action.text(), "Every machine drives this PC (some enabled)")
self.assertFalse(window.send_action.isChecked())
self.assertFalse(window.drive_action.isChecked())
window._after_peers_edit = lambda: None
window.send_action.trigger()
self.assertTrue(all(entry["send"] is True for entry in self.saved()["peers"]))
self.assertTrue(window.send_action.isChecked())
set_directions((False, False), (False, False))
self.assertEqual(window.send_action.text(), "This PC drives every machine")
self.assertEqual(window.drive_action.text(), "Every machine drives this PC")
self.assertFalse(window.send_action.isChecked())
self.assertFalse(window.drive_action.isChecked())
set_directions((True, True), (True, True))
self.assertTrue(window.send_action.isChecked())
self.assertTrue(window.drive_action.isChecked())
window.send_action.trigger()
self.assertTrue(all(entry["send"] is False for entry in self.saved()["peers"]))
def test_zero_peers_leave_the_disabled_general_send_action_available(self):
window = self.window
window._peer_entries = []
window._refresh_tray_directions()
window._refresh_tray_machines()
self.assertFalse(window.send_action.isEnabled())
self.assertFalse(window.drive_action.isEnabled())
self.assertEqual(window.machine_actions, {})
self.assertTrue(window.redirect_action.isVisible())
def test_the_send_button_names_the_machine_the_shortcut_would_pick(self):
window = self.window
window.sender.shortcut_target = lambda: C
window._refresh_window()
self.assertEqual(window.redirect_button.text(), "Send input to Sea")
@unittest.skipIf(kvm_bridge_win is None, "needs PySide6")
class DiagramWidgetTests(unittest.TestCase):
def setUp(self):
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
self.app = QApplication.instance() or QApplication([])
def machine(self, key, label, side, methods=(), chosen=False, parts=("middle",)):
return {"key": key, "label": label, "side": side, "methods": list(methods), "parts": list(parts),
"corner": "top_left", "chosen": chosen}
def test_each_machines_marks_are_its_own_and_the_unplaced_are_named_underneath(self):
picture = diagram.ArrangementDiagram()
picture.resize(500, picture.height())
picture.set_machines([self.machine("b", "Bee", "left", ["edge"], chosen=True),
self.machine("c", "Sea", "right", ["part"], parts=["end"]),
self.machine("d", "Dee", "")], "Right Ctrl", "hold", True)
self.assertEqual(picture._marks[("edge", "b", "left")], 1.0)
self.assertEqual(picture._marks[("part", "c", "right", "end")], 1.0)
self.assertEqual(picture._marks[("part", "c", "right", "start")], 0.0)
self.assertEqual(picture._unplaced, "Not placed yet: Dee")
self.assertFalse(picture.grab().isNull())
def test_one_machine_with_no_side_is_drawn_on_the_right_but_no_edge_lights_until_a_side_is_held(self):
# This PC's engine crosses no edge for a machine with no side, as the page's Not learned yet says.
picture = diagram.ArrangementDiagram()
picture.set_machines([self.machine("b", "Bee", "", ["edge", "part"], chosen=True)], "Right Ctrl", "hold", False)
self.assertEqual(picture._unplaced, "")
self.assertEqual(diagram._drawn_side({"side": ""}, True), "right")
self.assertEqual(picture._marks[("edge", "b", "right")], 0.0)
self.assertEqual(picture._marks[("track", "b", "right")], 0.0)
self.assertEqual(picture._marks[("part", "b", "right", "middle")], 0.0)
picture.set_machines([self.machine("b", "Bee", "right", ["edge"], chosen=True)], "Right Ctrl", "hold", False)
self.assertEqual(picture._marks[("edge", "b", "right")], 1.0)
@unittest.skipIf(kvm_bridge_win is None, "needs PySide6")
class TrayRouteTests(unittest.TestCase):
def setUp(self):
self.app = SimpleNamespace(
sender=SimpleNamespace(redirecting=False, owner=None, route_chain=(HERE, B, C)),
server=SimpleNamespace(owner=None),
_labels_by_id={B: "PC", C: "Linux"},
_identity=lambda: {"id": HERE, "name": "Mac"},
_label_of=lambda peer: {B: "PC", C: "Linux"}.get(peer, "another machine"),
)
def test_tray_state_names_the_machine_that_drives_this_pc(self):
self.assertEqual(kvm_bridge_win.WindowsApplication._drive_status(self.app), "Idle")
self.app.sender.redirecting = True
self.app.sender.owner = B
self.assertEqual(kvm_bridge_win.WindowsApplication._drive_status(self.app), "Driving PC")
self.app.sender.redirecting = False
self.app.server.owner = C
self.assertEqual(kvm_bridge_win.WindowsApplication._drive_status(self.app), "Driven by Linux")
def test_crossing_route_shows_the_whole_chain_in_order(self):
self.assertEqual(kvm_bridge_win.WindowsApplication._current_chain_sentence(self.app),
"Current chain: Mac → PC → Linux")
if __name__ == "__main__":
unittest.main()