One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
"""core/ways.py: a machine's zones read and written one peer at a time, the side settled with each
peer, the machine the shortcut picks, and the pairings a zone needs (WIRE.md sections 5 and 8)."""
import itertools
import time
import unittest
from core import crossing_state, protocol, ways
HERE = protocol.id_text(bytes(range(1, 17)))
A = protocol.id_text(bytes(range(20, 36)))
B = protocol.id_text(bytes(range(40, 56)))
C = protocol.id_text(bytes(range(60, 76)))
PHONE = protocol.id_text(bytes(range(80, 96)))
def peer(ident, name, **fields):
data = {"id": ident, "name": name, "platform": "windows", "host": "10.9.9.9", "port": 24820, "hw": "",
"send": True, "allow_drive": True, "side": "", "side_set_at": 0, "side_by": "", "paired_with": [],
"paired_at": 1, "linked": True, "from_1_4": False, "token": "k" + ident}
data.update(fields)
return data
def settings(*peers, zones=()):
return {"machine_id": HERE, "shortcut": True, "peers": list(peers), "zones": list(zones)}
def mac_corner_edge(corner, side):
return corner.split("_")[1]
def pc_corner_edge(corner, side):
return side if side in ways.EDGES else corner.split("_")[1]
MAC = ("edge", "part", "corner", "notch")
PC = ("edge", "part", "corner")
class ReadingOnePeer(unittest.TestCase):
def test_new_edges_and_corners_require_the_legacy_corner_keys_to_agree(self):
held = settings(peer(A, "Ay", ways={
"edge": True, "thirds": list(ways.PARTS), "edges": ["bottom", "left"],
"corner": True, "corner_at": "top_left", "corners": ["top_left", "bottom_right"],
"notch": False,
}))
self.assertEqual(ways.ways(held, A)["edges"], ["left", "bottom"])
self.assertEqual(ways.ways(held, A)["corners"], ["top_left", "bottom_right"])
held["peers"][0]["ways"]["corner_at"] = "top_right"
found = ways.ways(held, A)
self.assertEqual(found["corners"], ["top_right"])
def test_152_zones_migrate_as_one_corner_without_new_keys(self):
held = settings(peer(A, "Ay", ways={
"edge": True, "thirds": list(ways.PARTS), "corner": True,
"corner_at": "bottom_left", "notch": False,
}))
found = ways.ways(held, A)
self.assertEqual(found["corners"], ["bottom_left"])
self.assertEqual(found["edges"], [])
def test_a_peer_with_no_zones_reads_as_nothing_in_use_and_the_defaults(self):
found = ways.ways(settings(peer(A, "Ay", side="left")), A)
self.assertEqual(found, {"side": "left", "methods": ["edge"],
"parts": ["start", "middle", "end"], "corner": "top_left",
"edges": [], "corners": []})
def test_only_that_peers_zones_in_use_count(self):
held = settings(peer(A, "Ay", side="left"), peer(B, "Bee", side="right"), zones=[
{"peer": A, "kind": "edge"},
{"peer": A, "kind": "corner", "corner": "bottom_left", "edge": "left", "off": True},
{"peer": B, "kind": "part", "parts": ["start", "end"]},
{"peer": B, "kind": "corner", "corner": "top_right", "edge": "right"},
])
self.assertEqual(ways.ways(held, A), {"side": "left", "methods": ["edge"], "parts": ["start", "middle", "end"],
"corner": "bottom_left", "edges": [], "corners": []})
self.assertEqual(ways.ways(held, B), {"side": "right", "methods": ["part", "corner"], "parts": ["start", "end"],
"corner": "top_right", "edges": [], "corners": ["top_right"]})
def test_an_unknown_peer_reads_as_nothing(self):
self.assertEqual(ways.ways(settings(), A)["methods"], [])
class PageOffZones(unittest.TestCase):
def edit(self, held, methods):
return ways.edit(held, A, side="right", methods=methods, parts=[], corner="top_left", kinds=MAC,
corner_edge=mac_corner_edge, now=30)
def contact(self, *, peer_y=0, own_displays=False, peer_displays=False):
own = {"x": 0, "y": 0, "w": 160, "h": 100}
other = {"x": 160, "y": peer_y, "w": 160, "h": 100}
if own_displays:
own["displays"] = {"main": {"x": 0, "y": 0, "w": 160, "h": 100}}
if peer_displays:
other["displays"] = {"main": {"x": 0, "y": 0, "w": 160, "h": 100}}
return {HERE: own, A: other}
def test_unticking_edge_turns_off_unscoped_and_display_scoped_edge_zones(self):
held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
held["layout"] = self.contact(own_displays=True, peer_displays=True)
self.edit(held, ["shortcut"])
self.assertEqual(ways.ways(held, A)["methods"], [])
self.assertEqual(held["zones"], [])
self.assertFalse(ways.has_way(held, A))
self.assertFalse(ways.crosses_on_map(held, A))
self.edit(held, ["edge"])
zone = held["zones"][0]
self.assertEqual((zone["kind"], zone["display"], zone["side"]), ("edge", "main", "right"))
self.assertTrue(ways.has_way(held, A))
def test_page_does_not_turn_on_a_stale_scoped_zone(self):
held = settings(peer(A, "Ay", side="right"), zones=[
{"peer": A, "kind": "edge", "display": "0", "side": "right", "off": True},
])
self.edit(held, ["edge"])
self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
self.assertEqual(held["zones"][0]["kind"], "edge")
self.assertNotIn("off", held["zones"][0])
def test_compile_layout_keeps_a_page_off_scoped_zone_off(self):
held = settings(peer(A, "Ay", side="right"), zones=[
{"peer": A, "kind": "edge", "display": "main", "side": "right", "off": True, "page_off": True},
])
layout = {
HERE: {"x": 0, "y": 0, "w": 160, "h": 100,
"displays": {"main": {"x": 0, "y": 0, "w": 160, "h": 100}}},
A: {"x": 160, "y": 0, "w": 160, "h": 100,
"displays": {"main": {"x": 160, "y": 0, "w": 160, "h": 100}}},
}
result = ways.compile_layout(held, layout)
self.assertTrue(result["accepted"])
self.assertEqual(result["settings"]["peers"][0]["ways"]["edge"], False)
self.assertEqual(result["settings"]["zones"], [])
def test_unticked_edge_survives_compile_with_or_without_display_metadata(self):
for scoped in (False, True):
for own_displays in (False, True):
for peer_displays in (False, True):
for y in (0, 50):
with self.subTest(scoped=scoped, own_displays=own_displays,
peer_displays=peer_displays, y=y):
zone = {"peer": A, "kind": "edge", "off": True} if scoped else {"peer": A, "kind": "edge"}
held = settings(peer(A, "Ay", side="right"), zones=[zone])
layout = self.contact(peer_y=y, own_displays=own_displays, peer_displays=peer_displays)
held["layout"] = layout
self.edit(held, ["shortcut"])
for _ in range(2):
result = ways.compile_layout(held, layout, moved=A)
self.assertTrue(result["accepted"])
held = result["settings"]
self.assertFalse(ways.crosses_on_map(held, A))
self.assertNotIn("edge", ways.ways(held, A)["methods"])
self.assertNotIn("part", ways.ways(held, A)["methods"])
self.assertEqual(held["zones"], [])
self.edit(held, ["edge"])
self.assertTrue(ways.crosses_on_map(held, A))
self.assertTrue(all("page_off" not in zone and "off" not in zone
for zone in held["zones"]))
def test_a_page_off_mark_goes_with_a_contact_the_tile_has_left(self):
held = settings(peer(A, "Ay", side="top"), zones=[
{"peer": A, "kind": "edge", "display": "main", "side": "top", "off": True, "page_off": True},
])
layout = {
HERE: {"x": 0, "y": 0, "w": 160, "h": 100,
"displays": {"main": {"x": 0, "y": 0, "w": 160, "h": 100}}},
A: {"x": 160, "y": 0, "w": 160, "h": 100,
"displays": {"main": {"x": 160, "y": 0, "w": 160, "h": 100}}},
}
compiled = ways.compile_layout(held, layout)["settings"]
self.edit(compiled, ["shortcut"])
self.edit(compiled, ["edge"])
self.assertEqual(ways.ways(compiled, A)["methods"], ["edge"])
self.assertTrue(all(zone.get("side") != "top" for zone in compiled["zones"]))
def test_unticked_edge_survives_display_metadata_disappearing_and_returning(self):
held = settings(peer(A, "Ay", side="right"), zones=[
{"peer": A, "kind": "edge", "display": "main", "side": "right"},
])
self.edit(held, ["shortcut"])
for display in ("main", None, "replacement", None):
layout = self.contact(own_displays=display is not None)
if display not in (None, "main"):
layout[HERE]["displays"] = {display: {"x": 0, "y": 0, "w": 160, "h": 100}}
held = ways.compile_layout(held, layout)["settings"]
self.assertFalse(ways.crosses_on_map(held, A))
self.assertEqual(held["zones"], [])
def test_compile_without_display_metadata_does_not_record_a_page_untick_for_a_scoped_corner(self):
held = settings(peer(A, "Ay", side="right"), zones=[
{"peer": A, "kind": "corner", "display": "main", "side": "right",
"corner": "top_right", "edge": "right", "off": True, "aside": True},
])
held["layout"] = self.contact(own_displays=True, peer_displays=True)
held["peers"][0]["ways"] = {"edge": True, "thirds": list(ways.PARTS), "corner": True,
"corner_at": "top_right", "notch": False}
layout = self.contact()
compiled = ways.compile_layout(held, layout)["settings"]
corner = next(zone for zone in compiled["zones"] if zone["kind"] == "corner")
self.assertEqual((corner["kind"], corner["corner"], corner["side"]), ("corner", "top_right", "right"))
self.assertEqual(compiled["peers"][0]["ways"]["corner_at"], "top_right")
self.assertNotIn("page_off", corner)
def test_unscoped_page_off_mark_leaves_when_the_contact_changes_side(self):
held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
self.edit(held, ["shortcut"])
self.assertEqual(held["peers"][0]["ways"]["edge"], False)
held["layout"] = self.contact()
self.edit(held, ["edge"])
self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
self.assertTrue(ways.crosses_on_map(held, A))
def test_a_scoped_zone_set_aside_stays_off_once_the_page_turns_its_way_off(self):
held = settings(peer(A, "Ay", side="right"), zones=[
{"peer": A, "kind": "edge", "display": "0", "side": "right", "off": True, "aside": True},
])
self.edit(held, ["shortcut"])
before = held["peers"][0]["ways"].copy()
self.assertEqual(ways.settle_presence(held, "this Mac", lambda _peer: True, lambda _peer: False), [])
self.assertEqual(held["peers"][0]["ways"], before)
self.assertEqual(held["zones"], [])
def test_notch_does_not_light_the_map_contact(self):
held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "notch"}])
held["peers"][0]["ways"] = {"edge": False, "thirds": list(ways.PARTS), "corner": False,
"corner_at": "top_left", "notch": True}
self.assertTrue(ways.has_way(held, A))
self.assertFalse(ways.crosses_on_map(held, A))
def test_compiling_an_unticked_edge_keeps_the_notch_in_use(self):
held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
held["peers"][0]["ways"] = {"edge": False, "thirds": list(ways.PARTS), "corner": False,
"corner_at": "top_left", "notch": True}
layout = self.contact()
held["layout"] = layout
compiled = ways.compile_layout(held, layout, platform="mac")["settings"]
self.assertFalse(ways.crosses_on_map(compiled, A))
self.assertTrue(ways.has_way(compiled, A))
self.assertIn("notch", ways.ways(compiled, A)["methods"])
class WrapAroundWays(unittest.TestCase):
def test_wrap_edge_uses_free_thirds_and_records_the_map_entry(self):
held = settings(peer(A, "Ay", side="right", ways={
"edge": True, "thirds": list(ways.PARTS), "edges": ["left"],
"corner": False, "corner_at": "top_left", "corners": [], "notch": False,
}))
layout = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 160, "h": 100}}
out = ways.compile_layout(held, layout, capable={HERE, A}, now=100)
zone = next(z for z in out["settings"]["zones"] if z["side"] == "left")
self.assertEqual((zone["kind"], zone.get("parts"), zone.get("target_side")),
("edge", None, None))
self.assertEqual(out["tiles"][A]["wraps"], [
{"display": None, "side": "left", "parts": list(ways.PARTS)}])
def test_wrap_target_uses_the_outermost_peer_display_and_overlap_tie_break(self):
for displays, expected in (
({"main": {"x": 0, "y": 0, "w": 160, "h": 100}}, "main"),
({"a": {"x": 0, "y": 0, "w": 160, "h": 50},
"b": {"x": 0, "y": 50, "w": 160, "h": 50}}, "a"),
({"a": {"x": 0, "y": 0, "w": 80, "h": 100},
"b": {"x": 80, "y": 0, "w": 80, "h": 100}}, "b")):
with self.subTest(expected=expected):
held = settings(peer(A, "Ay", side="right", ways={
"edge": True, "thirds": list(ways.PARTS), "edges": ["left"],
"corner": False, "corner_at": "top_left", "corners": [], "notch": False,
}))
held["layout"] = {
HERE: {"x": 0, "y": 0, "w": 160, "h": 100,
"displays": {"own": {"x": 0, "y": 0, "w": 160, "h": 100}}},
A: {"x": 160, "y": 0, "w": 160, "h": 100, "displays": displays},
}
out = ways.compile_layout(held, held["layout"], capable={HERE, A}, now=100)
zone = next(z for z in out["settings"]["zones"] if z.get("side") == "left")
self.assertEqual((zone["target_display"], zone["target_side"]), (expected, "right"))
def test_wrap_edge_does_not_use_an_internal_display_edge(self):
held = settings(peer(A, "Ay", side="right", ways={
"edge": True, "thirds": list(ways.PARTS), "edges": ["left"],
"corner": False, "corner_at": "top_left", "corners": [], "notch": False,
}))
held["layout"] = {
HERE: {"x": 0, "y": 0, "w": 160, "h": 100,
"displays": {"left": {"x": 0, "y": 0, "w": 80, "h": 100},
"right": {"x": 80, "y": 0, "w": 80, "h": 100}}},
A: {"x": 160, "y": 0, "w": 160, "h": 100},
}
out = ways.compile_layout(held, held["layout"], capable={HERE, A}, now=100)
self.assertEqual(out["tiles"][A]["wraps"], [
{"display": "left", "side": "left", "parts": list(ways.PARTS)}])
def test_reach_reports_contact_holders_and_old_or_missing_tiles(self):
held = settings(peer(A, "Ay", side="right", ways={
"edge": True, "thirds": list(ways.PARTS), "edges": ["left"],
"corner": False, "corner_at": "top_left", "corners": [], "notch": False,
}), peer(B, "Bee", side="left"))
held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 160, "h": 100},
B: {"x": -160, "y": 0, "w": 160, "h": 100}}
held["peers"][0]["ways"]["edges"] = []
reach = ways.reach(held, A, platform="pc", capable={HERE, A, B})
self.assertEqual(reach["sides"]["left"], {"state": "held", "by": B})
self.assertEqual(reach["sides"]["right"], {"state": "contact", "by": A})
held["peers"][0]["caps"] = []
self.assertEqual(ways.reach(held, A, platform="pc", capable={HERE, B})["sides"]["left"],
{"state": "unavailable", "by": None})
self.assertEqual(ways.reach(held, A, platform="pc", capable={HERE, A, B})["sides"]["right"],
{"state": "contact", "by": A}, "an old peer keeps its contact chip, to turn Edge off")
held["layout"].pop(A)
self.assertEqual(ways.reach(held, A, platform="pc", capable={HERE, A, B})["sides"]["right"],
{"state": "contact", "by": A}, "no tile yet: placed by its side, as the compile does")
held["peers"][0].pop("caps")
held["layout"][A] = {"x": 40, "y": 0, "w": 160, "h": 100}
self.assertTrue(all(item == {"state": "unavailable", "by": None}
for item in ways.reach(held, A, platform="pc", capable={HERE, A, B})["sides"].values()))
def test_reach_uses_the_compiled_contact_and_wrap_assignment(self):
held = settings(peer(A, "Ay", side="right", ways={
"edge": True, "thirds": list(ways.PARTS), "edges": ["left"],
"corner": True, "corner_at": "top_left", "corners": ["top_left"], "notch": False,
}))
held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 160, "h": 100}}
reach = ways.reach(held, A, platform="mac", capable={HERE, A})
self.assertEqual(set(reach), {"sides", "corners"})
self.assertTrue(all(set(item) == {"state", "by"}
for section in reach.values() for item in section.values()))
self.assertEqual(reach["sides"]["right"], {"state": "contact", "by": A})
self.assertEqual(reach["sides"]["left"], {"state": "on", "by": None})
self.assertEqual(reach["sides"]["top"], {"state": "free", "by": None})
self.assertEqual(reach["sides"]["bottom"], {"state": "free", "by": None})
self.assertEqual(reach["corners"]["top_left"], {"state": "on", "by": None})
self.assertEqual(reach["corners"]["top_right"], {"state": "free", "by": None})
held["peers"][0]["ways"]["edge"] = False
reach = ways.reach(held, A, platform="mac", capable={HERE, A},
live=lambda _peer: True, gone=lambda _peer: False)
self.assertEqual(reach["sides"]["left"], {"state": "kept", "by": None})
def test_a_contact_holds_its_side_against_wraps_even_with_its_edge_off(self):
held = settings(peer(A, "Ay", side="right", ways={
"edge": True, "thirds": list(ways.PARTS), "edges": ["left"],
"corner": False, "corner_at": "top_left", "corners": [], "notch": False,
}), peer(B, "Bee", side="left", ways={
"edge": False, "thirds": list(ways.PARTS), "edges": [],
"corner": False, "corner_at": "top_left", "corners": [], "notch": False,
}))
held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 160, "h": 100},
B: {"x": -160, "y": 0, "w": 160, "h": 100}}
out = ways.compile_layout(held, held["layout"], capable={HERE, A, B}, now=100)
self.assertEqual(out["tiles"][A]["wraps"], [])
self.assertEqual(ways.reach(held, A, platform="pc", capable={HERE, A, B})["sides"]["left"],
{"state": "kept", "by": None})
held["peers"][0]["ways"]["edges"] = []
self.assertEqual(ways.reach(held, A, platform="pc", capable={HERE, A, B})["sides"]["left"],
{"state": "held", "by": B})
def test_reach_places_a_sideless_tileless_peer_and_answers_a_not_in_use_row_as_put_back(self):
held = settings(peer(A, "Ay", ways={
"edge": True, "thirds": list(ways.PARTS), "edges": ["left"],
"corner": False, "corner_at": "top_left", "corners": [], "notch": False,
}))
held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100}}
reach = ways.reach(held, A, platform="pc", capable={HERE, A})
self.assertIn("contact", {item["state"] for item in reach["sides"].values()})
held["layout"][A] = {"x": 160, "y": 0, "w": 160, "h": 100}
held["peers"][0]["in_use"] = False
reach = ways.reach(held, A, platform="pc", capable={HERE, A})
self.assertEqual(reach["sides"]["right"], {"state": "contact", "by": A})
self.assertEqual(reach["sides"]["left"], {"state": "on", "by": None})
def test_an_overlapping_peer_gets_no_wrap_zones(self):
held = settings(peer(A, "Ay", side="right", ways={
"edge": True, "thirds": list(ways.PARTS), "edges": ["left"],
"corner": False, "corner_at": "top_left", "corners": [], "notch": False,
}))
held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 100, "y": 0, "w": 160, "h": 100}}
out = ways.compile_layout(held, held["layout"], capable={HERE, A}, now=100)
self.assertEqual([zone for zone in out["settings"]["zones"] if zone["peer"] == A], [])
def test_a_wrap_lands_on_the_display_at_the_same_height_as_a_fraction_of_each_machine(self):
frames = [{"display": "a", "x": 0, "y": 100, "w": 100, "h": 50},
{"display": "z", "x": 0, "y": 150, "w": 100, "h": 50}]
leaving = {"display": "0", "x": 300, "y": 50, "w": 100, "h": 50}
own_tile = {"x": 300, "y": 0, "w": 100, "h": 100}
self.assertEqual(ways._wrap_target(frames, "right", leaving, own_tile)["display"], "z")
def test_the_one_corner_form_refuses_a_held_corner_without_a_write(self):
held = settings(peer(A, "Ay", side="right", ways={
"edge": True, "thirds": list(ways.PARTS), "edges": [],
"corner": True, "corner_at": "top_right", "corners": ["top_right"], "notch": False,
}), peer(B, "Bee", side="left", ways={
"edge": True, "thirds": list(ways.PARTS), "edges": [],
"corner": True, "corner_at": "bottom_left", "corners": ["bottom_left"], "notch": False,
}))
held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 160, "h": 100},
B: {"x": -160, "y": 0, "w": 160, "h": 100}}
out = crossing_state.edit_ways(held, A, platform="pc", corner=True, corner_at="bottom_left",
live=None, gone=None, now=100, capable={HERE, A, B})
self.assertFalse(out["changed"])
self.assertEqual(ways.ways(out["settings"], A)["corners"], ["top_right"])
def test_reach_shows_a_left_out_rows_kept_ways_and_a_corner_held_only_by_intent(self):
held = settings(peer(A, "Ay", side="right", ways={
"edge": True, "thirds": list(ways.PARTS), "edges": ["left"],
"corner": True, "corner_at": "top_left", "corners": ["top_left"], "notch": False,
}), peer(B, "Bee", ways={
"edge": True, "thirds": list(ways.PARTS), "edges": [],
"corner": True, "corner_at": "bottom_right", "corners": ["bottom_right"], "notch": False,
}))
held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 160, "h": 100},
B: {"x": 0, "y": 300, "w": 160, "h": 100}}
held["peers"][0]["left_out"] = True
reach = ways.reach(held, A, platform="pc", capable={HERE, A, B})
self.assertEqual(reach["sides"]["right"], {"state": "contact", "by": A})
self.assertEqual(reach["sides"]["left"], {"state": "on", "by": None})
self.assertEqual(reach["corners"]["top_left"], {"state": "on", "by": None})
self.assertEqual(reach["corners"]["bottom_right"], {"state": "held", "by": B})
self.assertEqual(reach["sides"]["right"], {"state": "contact", "by": A})
unavailable = ways.reach(held, A, platform="mac", capable={HERE, A}, gone=lambda _peer: True)
self.assertTrue(all(item == {"state": "unavailable", "by": None}
for section in unavailable.values() for item in section.values()))
def test_corner_screen_measures_left_and_top_from_the_tile_vertex(self):
screens = [
{"display": "far", "x": 500, "y": 500, "w": 100, "h": 100},
{"display": "near", "x": 1000, "y": 1000, "w": 100, "h": 100},
]
tile = {"x": 1000, "y": 1000, "w": 200, "h": 200}
self.assertEqual(ways._corner_screen(screens, "top_left", tile)["display"], "near")
def test_reach_marks_corners_unavailable_without_a_side_contact(self):
held = settings(peer(A, "Ay", ways={
"edge": True, "thirds": list(ways.PARTS), "edges": [],
"corner": False, "corner_at": "top_left", "corners": [], "notch": False,
}), peer(B, "Bee", side="right", ways={
"edge": True, "thirds": list(ways.PARTS), "edges": [],
"corner": True, "corner_at": "top_left", "corners": ["top_left"], "notch": False,
}))
held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 400, "y": 0, "w": 160, "h": 100},
B: {"x": 160, "y": 0, "w": 160, "h": 100}}
reach = ways.reach(held, A, platform="pc", capable={HERE, A, B})
self.assertEqual(reach["corners"]["top_left"], {"state": "unavailable", "by": None})
class LeavingOut(unittest.TestCase):
def test_leave_out_turns_every_zone_off_and_put_back_restores_only_the_recorded_kinds(self):
held = settings(peer(A, "Ay", side="right"), zones=[
{"peer": A, "kind": "edge"},
{"peer": A, "kind": "part", "parts": ["start"], "off": True},
{"peer": A, "kind": "corner", "corner": "bottom_left", "off": True},
])
held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 160, "h": 100}}
ways.leave_out(held, A)
self.assertTrue(held["peers"][0]["left_out"])
self.assertNotIn("left_out_ways", held["peers"][0])
self.assertEqual(held["peers"][0]["ways"], {"edge": True, "thirds": list(ways.PARTS),
"edges": [], "corner": False, "corner_at": "bottom_left",
"corners": [], "notch": False})
self.assertEqual(held["zones"], [])
self.assertFalse(ways.has_way(held, A))
ways.put_back(held, A)
self.assertNotIn("left_out", held["peers"][0])
self.assertNotIn("left_out_ways", held["peers"][0])
self.assertEqual(held["peers"][0]["ways"]["edge"], True)
self.assertEqual(held["peers"][0]["ways"]["thirds"], list(ways.PARTS))
self.assertTrue(ways.has_way(held, A))
def test_left_out_peer_arrangement_has_no_way_back_and_restoring_zones_restores_it(self):
held = settings(peer(A, "Ay", side="left"), zones=[{"peer": A, "kind": "edge"}])
ways.leave_out(held, A)
self.assertFalse(ways.has_way(held, A))
message = protocol.arrangement_v6("right", 1, protocol.read_id(HERE), way_back=ways.has_way(held, A))
self.assertIs(message["data"]["way_back"], False)
self.assertFalse(ways.way_back_state(held)[A][0])
ways.put_back(held, A)
self.assertTrue(ways.has_way(held, A))
message = protocol.arrangement_v6("right", 1, protocol.read_id(HERE), way_back=ways.has_way(held, A))
self.assertIs(message["data"]["way_back"], True)
self.assertTrue(ways.way_back_state(held)[A][0])
def test_leave_out_records_zones_temporarily_set_aside(self):
held = settings(peer(A, "Ay"), zones=[{"peer": A, "kind": "edge", "off": True, "aside": True}])
held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 160, "h": 100}}
ways.leave_out(held, A)
# A way set aside while its machine slept was still in use; Put back brings it back.
self.assertEqual(held["peers"][0]["ways"]["edge"], True)
ways.put_back(held, A)
self.assertEqual(held["peers"][0]["ways"]["edge"], True)
self.assertTrue(ways.has_way(held, A))
self.assertEqual(held["zones"], [{"peer": A, "kind": "edge", "side": "right",
"contact_span": [0.0, 1.0], "target_span": [0.0, 1.0]}])
class InactiveZones(unittest.TestCase):
def overlapping(self, inactive):
held = settings(
peer(A, "Ay", side="right", **inactive), peer(B, "Bee", side="right"),
zones=[{"peer": A, "kind": "edge"}],
)
held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 160, "h": 100},
B: {"x": 160, "y": 0, "w": 160, "h": 100}}
return held
def test_left_out_and_not_in_use_zones_do_not_clash(self):
for inactive in ({"left_out": True}, {"in_use": False}):
with self.subTest(inactive=inactive):
held = ways.compile_layout(self.overlapping(inactive), self.overlapping(inactive)["layout"])["settings"]
self.assertEqual([zone["peer"] for zone in held["zones"]], [B])
self.assertEqual(held["peers"][0]["ways"]["edge"], True)
def test_inactive_zone_does_not_block_a_missing_zone_in_ensure_zones(self):
for inactive in ({"left_out": True}, {"in_use": False}):
with self.subTest(inactive=inactive):
held = self.overlapping(inactive)
result = ways.compile_layout(held, held["layout"])
self.assertNotIn(A, [zone["peer"] for zone in result["settings"]["zones"]])
self.assertIn(B, [zone["peer"] for zone in result["settings"]["zones"]])
def test_a_not_in_use_peer_gets_an_off_zone_when_zones_are_ensured(self):
held = settings(peer(A, "Ay", in_use=False))
held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 160, "h": 100}}
result = ways.compile_layout(held, held["layout"])
self.assertEqual(result["settings"]["zones"], [])
self.assertEqual(result["settings"]["peers"][0]["ways"]["edge"], True)
def test_a_not_in_use_zone_set_aside_stays_off_when_its_peer_connects(self):
held = settings(peer(A, "Ay", side="right", in_use=False), zones=[{"peer": A, "kind": "edge"}])
before = ways.ways(held, A)
self.assertEqual(ways.settle_presence(held, "this PC", lambda _peer: True, lambda _peer: False), [])
self.assertEqual(ways.ways(held, A), before)
self.assertEqual(held["zones"], [{"peer": A, "kind": "edge"}])
def test_inactive_zone_does_not_make_a_share_offer(self):
for inactive in ({"left_out": True}, {"in_use": False}):
with self.subTest(inactive=inactive):
self.assertIsNone(ways.share_offer(self.overlapping(inactive), B))
self.assertEqual(ways.share(self.overlapping(inactive), "right",
{"start": B, "middle": B, "end": B}, kinds=MAC), [])
def test_arrangement_does_not_turn_off_a_zone_for_clashing_with_an_inactive_peer(self):
for inactive in ({"left_out": True}, {"in_use": False}):
with self.subTest(inactive=inactive):
held = self.overlapping(inactive)
held["peers"][1]["caps"] = ["layout"]
before = copy_settings = {key: value for key, value in held["layout"].items()}
changed, notices = ways.arrangement(held, B, "left", 2, B, "this PC")
self.assertFalse(changed)
self.assertEqual(notices, [])
self.assertEqual(held["layout"], before)
def test_put_back_keeps_restored_zones_off_when_another_peer_took_the_stretch(self):
held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="right"), zones=[{"peer": A, "kind": "edge"}])
held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 160, "h": 100},
B: {"x": 160, "y": 0, "w": 160, "h": 100}}
ways.leave_out(held, A)
ways.put_back(held, A)
owners = [zone["peer"] for zone in held["zones"] if zone["kind"] in ("edge", "part")]
self.assertEqual(len(owners), len(set(owners)))
self.assertTrue(held["peers"][0]["ways"]["edge"])
class JumpKeys(unittest.TestCase):
def test_changing_trigger_rejects_keys_used_in_an_existing_jump_chord(self):
held = settings(peer(A, "Ay", jump_key="ctrl+shift+f13"))
for trigger in ("ctrl", "ctrl_r", "shift_r", "f13"):
with self.subTest(trigger=trigger), self.assertRaises(ValueError):
ways.check_trigger_key(held, trigger)
ways.check_trigger_key(held, "alt_r")
def test_missing_jump_key_is_none(self):
self.assertIsNone(ways.jump_key(peer(A, "Ay")))
def test_trigger_key_cannot_be_recorded_as_a_jump_key(self):
held = settings(peer(A, "Ay"))
with self.assertRaisesRegex(ValueError, "trigger"):
ways.check_jump_key(held, A, "ctrl+f9", "f9")
def test_a_chord_with_the_trigger_key_or_its_modifier_is_refused(self):
# A chord holding the trigger's modifier would start its double-tap or hold, and leave the
# modifier held here once input had jumped away.
held = settings(peer(A, "Ay"))
for value, trigger in (("ctrl+f9", "f9"), ("ctrl+alt+2", "alt_r"), ("alt+2", "alt_r")):
with self.subTest(value=value), self.assertRaisesRegex(ValueError, "trigger"):
ways.check_jump_key(held, A, value, trigger)
self.assertEqual(ways.check_jump_key(held, A, "ctrl+cmd+2", "alt_r"), "ctrl+cmd+2")
def test_space_is_recorded_by_its_name_not_as_a_blank(self):
self.assertFalse(ways.valid_jump_key("cmd+ "))
self.assertEqual(ways.jump_chord(["cmd"], "space"), "cmd+space")
def test_shift_alone_is_not_enough_because_it_would_swallow_typing(self):
for value in ("shift+a", "shift+2"):
with self.subTest(value=value), self.assertRaises(ValueError):
ways.check_jump_key(settings(peer(A, "Ay")), A, value, "alt_r")
self.assertEqual(ways.jump_chord(["shift"], "a"), None)
def test_bare_modifiers_and_unrecognised_words_are_not_jump_chords(self):
for value in ("ctrl", "nonsense+2", "shift+ctrl+2"):
with self.subTest(value=value), self.assertRaises(ValueError):
ways.check_jump_key(settings(peer(A, "Ay")), A, value, "alt_r")
with self.assertRaises(ValueError):
ways.check_jump_key(settings(peer(A, "Ay")), A, 2, "alt_r")
def test_shifted_printable_keys_and_plus_have_stable_chords(self):
self.assertEqual(ways.jump_chord(["ctrl", "shift"], "@"), "ctrl+shift+@")
self.assertEqual(ways.jump_chord(["ctrl"], "+"), "ctrl+plus")
self.assertEqual(ways.jump_chord(["ctrl_r"], "2"), "ctrl+2")
def test_another_peers_jump_key_cannot_be_reused(self):
held = settings(peer(A, "Ay", jump_key="ctrl+shift+2"), peer(B, "Bee"))
with self.assertRaisesRegex(ValueError, "already"):
ways.check_jump_key(held, B, "ctrl+shift+2", "alt_r")
def test_clearing_a_jump_key_removes_it(self):
entry = peer(A, "Ay", jump_key="ctrl+shift+2")
self.assertIsNone(ways.check_jump_key(settings(entry), A, "", "alt_r"))
def test_a_chord_finds_its_in_use_machine(self):
held = settings(peer(A, "Ay", jump_key="ctrl+shift+2"), peer(B, "Bee", jump_key="ctrl+shift+3"))
self.assertEqual(ways.jump_peer(held["peers"], "ctrl+shift+3"), B)
def test_a_not_in_use_machines_jump_key_is_ignored(self):
held = settings(peer(A, "Ay", jump_key="ctrl+shift+2", in_use=False))
self.assertIsNone(ways.jump_peer(held["peers"], "ctrl+shift+2"))
class WritingOnePeer(unittest.TestCase):
def test_one_zone_of_each_kind_is_written_for_that_peer_and_the_others_are_left_alone(self):
other = {"peer": B, "kind": "edge"}
held = settings(peer(A, "Ay"), peer(B, "Bee", side="right"), zones=[other])
changed = ways.edit(held, A, side="left", methods=["corner"], parts=["start"], corner="top_left",
kinds=MAC, corner_edge=mac_corner_edge, now=1000)
self.assertTrue(changed)
mine = [zone for zone in held["zones"] if zone["peer"] == A]
self.assertEqual([zone["kind"] for zone in mine], ["corner"])
self.assertEqual(next(zone for zone in mine if zone["kind"] == "corner")["edge"], "left")
self.assertEqual(ways.ways(held, A)["parts"], ["start"])
self.assertEqual(ways.ways(held, B)["methods"], ["edge"])
def test_a_new_side_is_stamped_by_this_machine_and_never_below_the_last_stamp(self):
held = settings(peer(A, "Ay", side="right", side_set_at=5000, side_by=A))
self.assertTrue(ways.edit(held, A, side="top", methods=["edge"], parts=["middle"], corner="top_left",
kinds=PC, corner_edge=pc_corner_edge, now=100))
entry = held["peers"][0]
self.assertEqual((entry["side"], entry["side_set_at"], entry["side_by"]), ("top", 100, HERE))
def test_an_unchanged_side_keeps_its_stamp_and_says_so(self):
held = settings(peer(A, "Ay", side="right", side_set_at=5000, side_by=A))
self.assertFalse(ways.edit(held, A, side="right", methods=["part"], parts=["end"], corner="top_left",
kinds=PC, corner_edge=pc_corner_edge, now=9000))
self.assertEqual((held["peers"][0]["side_set_at"], held["peers"][0]["side_by"]), (5000, A))
def test_the_pc_corner_crosses_the_side(self):
held = settings(peer(A, "Ay"))
ways.edit(held, A, side="top", methods=["corner"], parts=["middle"], corner="top_left",
kinds=PC, corner_edge=pc_corner_edge, now=1)
corner = next(zone for zone in held["zones"] if zone["kind"] == "corner")
self.assertEqual(corner["edge"], "top")
def test_edge_and_its_thirds_both_on_write_the_thirds_off(self):
held = settings(peer(A, "Ay"))
ways.edit(held, A, side="left", methods=["edge", "part"], parts=["start"], corner="top_left",
kinds=PC, corner_edge=pc_corner_edge, now=1)
self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
def test_an_unknown_peer_raises(self):
with self.assertRaises(KeyError):
ways.edit(settings(), A, side="left", methods=[], parts=["middle"], corner="top_left",
kinds=PC, corner_edge=pc_corner_edge, now=1)
def test_a_zone_the_user_kept_keeps_its_other_fields(self):
held = settings(peer(A, "Ay", side="left"), zones=[{"peer": A, "kind": "edge", "off": True, "later": 1}])
ways.edit(held, A, side="left", methods=["edge"], parts=["middle"], corner="top_left",
kinds=PC, corner_edge=pc_corner_edge, now=1)
edge = next(zone for zone in held["zones"] if zone["kind"] == "edge")
self.assertEqual((edge["peer"], edge["side"]), (A, "left"))
self.assertNotIn("later", edge)
class Clashes(unittest.TestCase):
def compile(self, held, layout=None, platform="pc"):
if layout is None:
layout = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 160, "h": 50},
B: {"x": 160, "y": 50, "w": 160, "h": 50}}
result = ways.compile_layout(held, layout, platform=platform)
self.assertTrue(result["accepted"])
return result["settings"], result["tiles"]
def test_two_machines_on_one_whole_edge_clash_and_the_sentence_names_both(self):
held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="right"),
zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge"}])
compiled, _ = self.compile(held)
self.assertIsNone(ways.clash(compiled, "this Mac"))
self.assertEqual(crossing_thirds(compiled, A), ["start"])
self.assertEqual(crossing_thirds(compiled, B), ["middle", "end"])
def test_two_machines_on_different_thirds_of_one_edge_do_not_clash(self):
held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="right"), zones=[
{"peer": A, "kind": "part", "parts": ["start"]}, {"peer": B, "kind": "part", "parts": ["middle", "end"]}])
compiled, _ = self.compile(held)
self.assertIsNone(ways.clash(compiled, "this PC"))
self.assertEqual(crossing_thirds(compiled, A), ["start"])
self.assertEqual(crossing_thirds(compiled, B), ["middle", "end"])
def test_a_corner_inside_another_machines_edge_does_not_clash(self):
held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="top"), zones=[
{"peer": A, "kind": "edge"}, {"peer": B, "kind": "corner", "corner": "top_right", "edge": "top"}])
layout = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 160, "h": 100},
B: {"x": 160, "y": -100, "w": 100, "h": 100}}
compiled, _ = self.compile(held, layout)
self.assertIsNone(ways.clash(compiled, "this PC"))
self.assertIn("corner", [zone["kind"] for zone in compiled["zones"] if zone["peer"] == B])
def test_one_corner_for_two_machines_clashes(self):
held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="top"), zones=[
{"peer": A, "kind": "corner", "corner": "top_right", "edge": "right"},
{"peer": B, "kind": "corner", "corner": "top_right", "edge": "top"}])
layout = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 100, "h": 100},
B: {"x": 160, "y": 0, "w": 100, "h": 100}}
compiled, tiles = self.compile(held, layout)
self.assertIsNone(ways.clash(compiled, "this PC"))
self.assertEqual(tiles[A]["state"], "overlap")
self.assertFalse(compiled["zones"])
def test_one_notch_for_two_machines_clashes(self):
held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="top"), zones=[
{"peer": A, "kind": "notch"}, {"peer": B, "kind": "notch"}])
compiled, _ = self.compile(held, platform="mac")
self.assertIsNone(ways.clash(compiled, "this Mac"))
self.assertEqual([zone["peer"] for zone in compiled["zones"] if zone["kind"] == "notch"], [A])
def test_two_of_one_machines_own_zones_over_one_stretch_clash(self):
held = settings(peer(A, "Ay", side="right"), zones=[
{"peer": A, "kind": "edge"}, {"peer": A, "kind": "part", "parts": ["middle"]}])
compiled, _ = self.compile(held, {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 160, "h": 100}})
self.assertIsNone(ways.clash(compiled, "this Mac"))
self.assertEqual(len([zone for zone in compiled["zones"] if zone["peer"] == A]), 1)
def test_zones_that_are_off_never_clash(self):
held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="right"),
zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge", "off": True}])
compiled, _ = self.compile(held)
self.assertIsNone(ways.clash(compiled, "this PC"))
self.assertFalse(any(zone["peer"] == B for zone in compiled["zones"]))
class EveryMachineHasAWayIn(unittest.TestCase):
"""A machine paired, or one whose side arrives, crosses by its whole edge unless that edge is
another machine's already (the rig's beta.3 file of 01-10: the laptop's side set, no zone)."""
def test_a_machine_with_no_zone_gets_its_whole_edge(self):
held = settings(peer(A, "Ay", side="left"), peer(B, "Bee", side="right"), zones=[{"peer": A, "kind": "edge"}])
self.assertTrue(ways.ensure_zones(held))
self.assertTrue(any(zone["peer"] == B and zone["kind"] == "edge" and zone["side"] == "right"
for zone in held["zones"]))
self.assertFalse(ways.ensure_zones(held))
def test_one_whose_side_is_another_machines_edge_gets_it_off_so_the_settings_stay_readable(self):
held = settings(peer(A, "Ay", side="left"), peer(B, "Bee", side="left"), zones=[{"peer": A, "kind": "edge"}])
ways.ensure_zones(held)
self.assertTrue(all("off" not in zone for zone in held["zones"]))
self.assertEqual(ways.ways(held, B)["methods"], ["edge"])
self.assertIsNone(ways.clash(held, "this PC"))
def test_a_machine_with_its_zones_all_off_keeps_them_as_they_are(self):
held = settings(peer(A, "Ay", side="left"), zones=[{"peer": A, "kind": "edge", "off": True}])
self.assertTrue(ways.ensure_zones(held))
self.assertEqual(held["zones"], [])
self.assertNotIn("edge", ways.ways(held, A)["methods"])
def test_a_phone_and_an_entry_with_no_id_get_none(self):
held = settings(peer(PHONE, "Phone", port=0, host="", send=False), peer("", "Old", from_1_4=True))
self.assertTrue(ways.ensure_zones(held))
self.assertEqual(held["zones"], [])
def test_an_arrangement_for_a_machine_with_no_zone_gives_it_its_edge(self):
held = settings(peer(A, "Ay", side="left"), peer(B, "Bee"), zones=[{"peer": A, "kind": "edge"}])
self.assertEqual(ways.arrangement(held, B, "left", 20, B, "this PC"), (True, []))
self.assertTrue(any(zone["peer"] == B and zone["kind"] == "edge" for zone in held["zones"]))
def test_an_arrangement_onto_another_machines_edge_gives_it_the_edge_off_and_says_so(self):
held = settings(peer(A, "MacBook Pro", side="left"), peer(B, "Laptop"), zones=[{"peer": A, "kind": "edge"}])
changed, notices = ways.arrangement(held, B, "right", 20, B, "this PC")
self.assertTrue(changed)
self.assertEqual(notices, [])
self.assertEqual(held["peers"][1]["side"], "left")
self.assertTrue(all("off" not in zone for zone in held["zones"]))
class Blocked(unittest.TestCase):
def test_a_machine_whose_side_is_taken_and_has_no_way_in_is_told_which_machine_has_it(self):
held = settings(peer(A, "MacBook Pro", side="left"), peer(B, "Laptop", side="left"),
zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge", "off": True}])
self.assertEqual(ways.blocked_sentence(held, B, "this PC"),
"Laptop has no way in: MacBook Pro already leads from the left edge of this PC. "
"Give each its own thirds of that edge by moving the machines on the map, or move one to another side.")
self.assertEqual(ways.blocked_sentence(held, A, "this PC"), "")
def test_thirds_left_free_by_another_machine_are_no_block(self):
held = settings(peer(A, "MacBook Pro", side="left"), peer(B, "Laptop", side="left"), zones=[
{"peer": A, "kind": "part", "parts": ["start"]}, {"peer": B, "kind": "part", "parts": ["end"]}])
self.assertEqual(ways.blocked_sentence(held, B, "this PC"), "")
def test_a_machine_with_a_corner_in_use_is_not_blocked(self):
held = settings(peer(A, "MacBook Pro", side="left"), peer(B, "Laptop", side="left"), zones=[
{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge", "off": True},
{"peer": B, "kind": "corner", "corner": "top_left", "edge": "left"}])
self.assertEqual(ways.blocked_sentence(held, B, "this PC"), "")
def test_a_machine_with_no_side_is_not_blocked(self):
held = settings(peer(A, "MacBook Pro", side="left"), peer(B, "Laptop"), zones=[{"peer": A, "kind": "edge"}])
self.assertEqual(ways.blocked_sentence(held, B, "this PC"), "")
class WayBack(unittest.TestCase):
"""What a machine tells another with its `arrangement`: whether it has a zone in use leading there."""
def test_a_zone_in_use_with_a_side_or_a_corner_is_a_way(self):
held = settings(peer(A, "Ay", side="left"), peer(B, "Bee"), peer(C, "Sea", side="top"), zones=[
{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge"},
{"peer": C, "kind": "edge", "off": True}, {"peer": C, "kind": "corner", "corner": "top_left", "edge": "top"}])
self.assertEqual([ways.has_way(held, ident) for ident in (A, B, C)], [True, False, True])
def test_an_arrangement_keeps_what_the_sender_said_whether_or_not_its_side_is_newer(self):
held = settings(peer(A, "Ay", side="left", side_set_at=50, side_by=A))
self.assertEqual(ways.arrangement(held, A, "right", 50, A, "this PC", way_back=False), (True, []))
self.assertIs(held["peers"][0]["way_back"], False)
self.assertEqual(ways.arrangement(held, A, "right", 50, A, "this PC", way_back=False), (False, []))
self.assertEqual(ways.arrangement(held, A, "right", 50, A, "this PC"), (False, []))
self.assertIs(held["peers"][0]["way_back"], False)
self.assertEqual(ways.arrangement(held, A, "right", 50, A, "this PC", way_back=True), (True, []))
self.assertIs(held["peers"][0]["way_back"], True)
def test_the_sentence_names_the_machine_with_no_way_back(self):
held = settings(peer(A, "Desk-PC", way_back=False), peer(B, "Bee", way_back=True), peer(C, "Sea"))
self.assertEqual(ways.no_way_back_sentence(held, A),
"Desk-PC has no way back to this machine: none of its edges leads here. Its own "
"Crossing page says why.")
self.assertEqual(ways.no_way_back_sentence(held, B), "")
self.assertEqual(ways.no_way_back_sentence(held, C), "")
def test_with_no_way_back_the_sender_names_the_machine_whose_zone_holds_that_side(self):
# The laptop on 02-10-2026: the Mac and the rig both on its left, the rig's edge in use.
held = settings(peer(A, "Mac", side="left"), peer(B, "Rig", side="left"),
zones=[{"peer": A, "kind": "edge", "off": True}, {"peer": B, "kind": "edge"}])
self.assertEqual(ways.way_back_by(held, A), B)
self.assertIsNone(ways.way_back_by(held, B))
held["zones"][0].pop("off")
held["zones"][1]["off"] = True
self.assertIsNone(ways.way_back_by(held, A))
# Off by choice, with nobody else on that side: no way back, and nobody in the way.
held["zones"][0]["off"] = True
self.assertIsNone(ways.way_back_by(held, A))
def test_what_each_machine_is_told_of_its_way_back_so_a_change_reaches_every_machine_it_touches(self):
# Moving one machine can open or close another's way back: Sol's review, 02-10-2026.
held = settings(peer(A, "Mac", side="left"), peer(B, "Rig", side="left"),
zones=[{"peer": A, "kind": "edge", "off": True}, {"peer": B, "kind": "edge"}])
before = ways.way_back_state(held)
self.assertEqual(before, {A: (False, B), B: (True, None)})
held["peers"][1]["side"] = "right"
held["zones"][0].pop("off")
after = ways.way_back_state(held)
self.assertEqual(sorted(peer for peer in after if after[peer] != before.get(peer)), [A])
def test_an_arrangement_keeps_who_is_in_the_way_only_beside_a_way_back_of_false(self):
held = settings(peer(A, "Ay", side="left", side_set_at=50, side_by=A))
self.assertEqual(ways.arrangement(held, A, "right", 50, A, "this PC", way_back=False, way_back_by=C), (True, []))
self.assertEqual(held["peers"][0]["way_back_by"], C)
ways.arrangement(held, A, "right", 50, A, "this PC", way_back=False)
self.assertNotIn("way_back_by", held["peers"][0])
ways.arrangement(held, A, "right", 50, A, "this PC", way_back=False, way_back_by=C)
ways.arrangement(held, A, "right", 50, A, "this PC", way_back=True, way_back_by=C)
self.assertNotIn("way_back_by", held["peers"][0])
# This machine's own id, or one that is not an id, is ignored as if absent.
for odd in (HERE, "x"):
ways.arrangement(held, A, "right", 50, A, "this PC", way_back=False, way_back_by=odd)
self.assertNotIn("way_back_by", held["peers"][0])
def test_the_sentence_names_the_machine_in_the_way_and_where_to_change_it(self):
held = settings(peer(A, "Laptop-PC", side="right", way_back=False, way_back_by=B), peer(B, "Desk-PC"))
self.assertEqual(ways.no_way_back_sentence(held, A),
"Laptop-PC has Desk-PC on its left too, so none of its edges leads back here. On "
"Laptop-PC's Crossing page, share that side by thirds or move one of them.")
held["peers"][0]["way_back_by"] = C
self.assertEqual(ways.no_way_back_sentence(held, A),
"Laptop-PC has another machine on its left too, so none of its edges leads back here. On "
"Laptop-PC's Crossing page, share that side by thirds or move one of them.")
class Arrangement(unittest.TestCase):
def test_a_newer_arrangement_sets_the_opposite_side_for_that_peer_only(self):
held = settings(peer(A, "Ay", side="left", side_set_at=10, side_by=HERE), peer(B, "Bee", side="right"))
changed, notices = ways.arrangement(held, A, "left", 20, A, "this PC")
self.assertTrue(changed)
self.assertEqual(notices, [])
self.assertEqual((held["peers"][0]["side"], held["peers"][0]["side_set_at"], held["peers"][0]["side_by"]),
("right", 20, A))
self.assertEqual(held["peers"][1]["side"], "right")
def test_an_older_one_or_a_tie_lost_on_the_id_changes_nothing(self):
held = settings(peer(A, "Ay", side="left", side_set_at=10, side_by=C))
self.assertEqual(ways.arrangement(held, A, "left", 9, A, "this PC"), (False, []))
self.assertEqual(ways.arrangement(held, A, "left", 10, A, "this PC"), (False, []))
self.assertEqual(held["peers"][0]["side"], "left")
def test_a_tie_won_on_the_id_applies(self):
held = settings(peer(A, "Ay", side="left", side_set_at=10, side_by=A))
self.assertEqual(ways.arrangement(held, A, "left", 10, C, "this PC"), (True, []))
def test_a_side_that_now_overlaps_turns_the_senders_zones_off_and_names_both(self):
held = settings(peer(A, "Ay", side="left"), peer(B, "Bee", side="right"),
zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge"}])
held["peers"][0]["caps"] = ["layout"]
held["peers"][1]["caps"] = ["layout"]
held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": -160, "y": 0, "w": 160, "h": 100},
B: {"x": 160, "y": 0, "w": 160, "h": 100}}
before = [dict(zone) for zone in held["zones"]]
changed, notices = ways.arrangement(held, A, "left", 20, A, "this Mac")
self.assertFalse(changed)
self.assertEqual(notices, [])
self.assertEqual(held["zones"], before)
def test_an_unknown_peer_bad_edge_or_bad_by_changes_nothing(self):
held = settings(peer(A, "Ay", side="left"))
self.assertEqual(ways.arrangement(held, B, "left", 20, B, "this PC"), (False, []))
self.assertEqual(ways.arrangement(held, A, "middle", 20, A, "this PC"), (False, []))
self.assertEqual(ways.arrangement(held, A, "left", 20, "nope", "this PC"), (False, []))
class TheShortcutsMachine(unittest.TestCase):
def test_the_machine_input_was_last_on_while_it_can_take_input(self):
peers = [peer(A, "Ay"), peer(B, "Bee")]
self.assertEqual(ways.shortcut_peer(peers, B, lambda ident: True), B)
def test_else_the_first_that_can_take_input(self):
peers = [peer(A, "Ay"), peer(B, "Bee"), peer(C, "Sea")]
self.assertEqual(ways.shortcut_peer(peers, A, lambda ident: ident == C), C)
self.assertEqual(ways.shortcut_peer(peers, None, lambda ident: ident != A), B)
def test_else_the_first_this_machine_sends_to_so_the_refusal_or_the_wake_names_it(self):
peers = [peer(A, "Ay", send=False), peer(B, "Bee"), peer(C, "Sea")]
self.assertEqual(ways.shortcut_peer(peers, None, lambda ident: False), B)
def test_a_machine_this_one_does_not_send_to_is_never_picked(self):
peers = [peer(A, "Ay", send=False)]
self.assertIsNone(ways.shortcut_peer(peers, A, lambda ident: True))
def test_a_machine_not_in_use_is_never_picked(self):
peers = [peer(A, "Ay", in_use=False), peer(B, "Bee")]
self.assertEqual(ways.shortcut_peer(peers, A, lambda ident: True), B)
def test_a_phone_or_an_entry_without_an_id_is_never_picked(self):
peers = [peer(PHONE, "Phone", port=0, host="", send=False), peer("", "Old", from_1_4=True)]
self.assertIsNone(ways.shortcut_peer(peers, None, lambda ident: True))
def test_nothing_paired_picks_nothing(self):
self.assertIsNone(ways.shortcut_peer([], None, lambda ident: True))
class MissingPairings(unittest.TestCase):
def test_a_machine_that_may_drive_this_one_and_is_not_paired_with_the_zones_peer_is_named(self):
held = settings(peer(A, "Ay", paired_with=[B]), peer(B, "Bee", paired_with=[A]), peer(C, "Sea", paired_with=[A]))
self.assertEqual([entry["id"] for entry in ways.missing_pairings(held, B)], [C])
self.assertEqual([entry["id"] for entry in ways.missing_pairings(held, A)], [])
def test_a_machine_not_allowed_to_drive_this_one_needs_no_pairing(self):
held = settings(peer(A, "Ay"), peer(B, "Bee", allow_drive=False))
self.assertEqual(ways.missing_pairings(held, A), [])
def test_a_machine_not_in_use_needs_no_pairing(self):
held = settings(peer(A, "Ay"), peer(B, "Bee", in_use=False))
self.assertEqual(ways.missing_pairings(held, A), [])
def test_a_machine_that_has_never_linked_is_not_judged(self):
held = settings(peer(A, "Ay"), peer(B, "Bee", linked=False))
self.assertEqual(ways.missing_pairings(held, A), [])
def test_a_phone_that_may_drive_this_one_counts(self):
held = settings(peer(A, "Ay"), peer(PHONE, "Phone", port=0, host="", send=False))
self.assertEqual([entry["id"] for entry in ways.missing_pairings(held, A)], [PHONE])
def test_the_sentence_names_each_machine_and_the_one_it_needs(self):
held = settings(peer(A, "Ay"), peer(B, "Bee", paired_with=[]))
self.assertEqual(ways.missing_sentence(held, A, "this Mac"),
"While Bee drives this Mac, this way to Ay does nothing: Bee is not paired with Ay. "
"Pair them to use it from there too.")
held["peers"].append(peer(C, "Sea"))
self.assertEqual(ways.missing_sentence(held, A, "this Mac"),
"While Bee or Sea drives this Mac, this way to Ay does nothing: neither is paired "
"with Ay. Pair them to use it from there too.")
self.assertEqual(ways.missing_sentence(settings(peer(A, "Ay")), A, "this Mac"), "")
class TheShownDefault(unittest.TestCase):
"""The Mac's page shows Right for its one machine before a side is set, so the settings hold it
from the moment that machine is paired, not from the first save (beta.4: Edge did nothing until
a save of another way wrote it)."""
def test_the_one_machine_not_placed_holds_right_unstamped_so_its_edge_fires(self):
held = settings(peer(A, "Ay"), zones=[{"peer": A, "kind": "edge"}])
self.assertFalse(ways.has_way(held, A))
self.assertTrue(ways.default_side(held))
entry = held["peers"][0]
self.assertEqual((entry["side"], entry["side_set_at"], entry["side_by"]), ("right", 0, ""))
self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
self.assertFalse(ways.default_side(held))
def test_the_held_default_loses_to_a_side_the_peer_chooses(self):
held = settings(peer(A, "Ay"), zones=[{"peer": A, "kind": "edge"}])
ways.default_side(held)
self.assertEqual(ways.arrangement(held, A, "bottom", int(time.time()) + 1, A, "this Mac"), (True, []))
self.assertEqual(held["peers"][0]["side"], "top")
def test_a_default_never_moves_a_side_already_set(self):
held = settings(peer(A, "Ay", side="left", side_set_at=5, side_by=A), zones=[{"peer": A, "kind": "edge"}])
self.assertFalse(ways.default_side(held))
self.assertEqual(held["peers"][0]["side"], "left")
def test_with_several_machines_none_is_given_a_side_nobody_chose(self):
held = settings(peer(A, "Ay"), peer(B, "Bee"),
zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge", "off": True}])
self.assertFalse(ways.default_side(held))
self.assertEqual([entry["side"] for entry in held["peers"]], ["", ""])
def test_a_machine_paired_beside_the_one_migrated_from_1_4_is_given_no_side(self):
# The migrated entry has no id and holds the 1.4 side: Right as well would clash with it.
held = settings(peer("", "Studio", side="right", from_1_4=True), peer(A, "Ay"),
zones=[{"peer": "", "kind": "edge"}, {"peer": A, "kind": "edge"}])
self.assertFalse(ways.default_side(held))
self.assertEqual(held["peers"][1]["side"], "")
def test_a_phone_alone_is_given_no_side(self):
held = settings(peer(PHONE, "Phone", port=0, host="", send=False))
self.assertFalse(ways.default_side(held))
class TheCornerFollowsAnArrivingSide(unittest.TestCase):
def test_a_corner_that_crosses_the_side_is_rewritten_for_the_side_that_arrives(self):
held = settings(peer(A, "Ay", side="top", side_set_at=5, side_by=A),
zones=[{"peer": A, "kind": "corner", "corner": "top_right", "edge": "top"}])
self.assertEqual(ways.arrangement(held, A, "left", 10, A, "this PC", corner_edge=pc_corner_edge), (True, []))
self.assertEqual((held["peers"][0]["side"], held["zones"][0]["edge"]), ("right", "right"))
class SharingASide(unittest.TestCase):
"""Shared stretches come from geometry; the old offer/share entry points do not mutate intent."""
def two_on_the_right(self, rig_zone=None):
return settings(peer(A, "Desk-PC", side="right"), peer(B, "Laptop-PC", side="right"),
zones=[rig_zone or {"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge", "off": True}])
def test_a_machine_whose_side_another_holds_whole_is_offered_the_end_third(self):
held = self.two_on_the_right()
self.assertIsNone(ways.share_offer(held, B))
self.assertEqual(ways.ways(held, A)["parts"], list(ways.PARTS))
self.assertEqual(ways.ways(held, B)["methods"], [])
def test_free_thirds_go_to_the_machine_asking(self):
held = self.two_on_the_right({"peer": A, "kind": "part", "parts": ["end"]})
self.assertIsNone(ways.share_offer(held, B))
self.assertEqual(ways.ways(held, A)["parts"], ["end"])
def test_nothing_is_offered_where_nothing_is_in_the_way(self):
held = settings(peer(A, "Ay", side="left"), peer(B, "Bee", side="right"),
zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge", "off": True}])
self.assertIsNone(ways.share_offer(held, B))
self.assertIsNone(ways.share_offer(self.two_on_the_right(), A))
self.assertEqual(ways.share(self.two_on_the_right(), "right",
{"start": A, "middle": A, "end": A}, kinds=MAC), [])
def test_sharing_writes_each_machines_thirds_and_turns_their_whole_edges_off(self):
held = self.two_on_the_right()
before = [dict(zone) for zone in held["zones"]]
self.assertEqual(ways.share(held, "right", {"start": A, "middle": A, "end": B}, kinds=MAC), [])
self.assertEqual(held["zones"], before)
held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 160, "h": 33},
B: {"x": 160, "y": 67, "w": 160, "h": 33}}
held["zones"] = [{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge"}]
compiled = ways.compile_layout(held, held["layout"])["settings"]
self.assertEqual(crossing_thirds(compiled, A), ["start"])
self.assertEqual(crossing_thirds(compiled, B), ["end"])
def test_sharing_replaces_an_older_page_pick(self):
held = self.two_on_the_right({"peer": A, "kind": "part", "parts": ["start"], "page_parts": ["start"]})
ways.share(held, "right", {"start": B, "middle": A, "end": B}, kinds=MAC)
self.assertEqual(ways.ways(held, A)["parts"], ["start"])
held["peers"][1]["ways"] = {"edge": True, "thirds": ["end"], "corner": False,
"corner_at": "top_left", "notch": False}
compiled = ways.compile_layout(held, beside(own_displays=True), moved=A)["settings"]
self.assertEqual(ways.ways(compiled, B)["parts"], ["end"])
self.assertTrue(all("page_parts" not in zone and "page_off" not in zone for zone in compiled["zones"]))
def compiled(self):
held = settings(peer(A, "Desk-PC", side="right"), peer(B, "Laptop-PC", side="right"),
zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge", "off": True}])
return ways.compile_layout(held, beside(own_displays=True), moved=A)["settings"]
def test_on_a_compiled_map_a_machine_left_with_no_third_stays_off_through_the_next_compile(self):
held = self.compiled()
intent = dict(held["peers"][0]["ways"])
self.assertEqual(ways.share(held, "right", {"start": B, "middle": B, "end": B}, kinds=MAC), [])
self.assertEqual(held["peers"][0]["ways"], intent)
held = ways.compile_layout(held, beside(own_displays=True), moved=A)["settings"]
self.assertEqual(ways.ways(held, A)["parts"], list(ways.PARTS))
self.assertTrue(ways.crosses_on_map(held, A))
def test_on_a_compiled_map_a_machine_given_a_third_keeps_it_through_the_next_compile(self):
held = self.compiled()
ways.share(held, "right", {"start": A, "middle": B, "end": B}, kinds=MAC)
self.assertEqual(ways.ways(held, A)["parts"], list(ways.PARTS))
held = ways.compile_layout(held, beside(own_displays=True), moved=A)["settings"]
self.assertEqual(ways.ways(held, A)["parts"], list(ways.PARTS))
def test_a_share_that_gives_a_third_back_relights_an_edge_it_turned_off(self):
held = self.compiled()
ways.share(held, "right", {"start": B, "middle": B, "end": B}, kinds=MAC)
ways.share(held, "right", {"start": B, "middle": A, "end": B}, kinds=MAC)
held = ways.compile_layout(held, beside(own_displays=True), moved=A)["settings"]
self.assertEqual(ways.ways(held, A)["parts"], list(ways.PARTS))
def test_a_machine_on_that_side_left_with_no_third_crosses_there_no_more(self):
held = self.two_on_the_right()
ways.share(held, "right", {"start": B, "middle": B, "end": B}, kinds=MAC)
self.assertTrue(ways.has_way(held, A))
self.assertEqual(ways.ways(held, A)["parts"], list(ways.PARTS))
def test_a_machine_left_with_no_third_keeps_a_part_zone_the_settings_accept(self):
# Sol's review: an empty `parts` made the Mac's store refuse the whole share.
held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="right"), peer(C, "Sea", side="right"),
zones=[{"peer": A, "kind": "part", "parts": ["start", "middle"]},
{"peer": C, "kind": "part", "parts": ["end"]},
{"peer": B, "kind": "edge", "off": True}])
ways.share(held, "right", {"start": A, "middle": A, "end": B}, kinds=MAC)
sea = next(zone for zone in held["zones"] if zone["peer"] == C and zone["kind"] == "part")
self.assertEqual(sea["parts"], ["end"])
self.assertNotIn("off", sea)
def test_sharing_reports_every_machine_whose_way_back_it_changed_not_only_whose_zones(self):
# Sol's review: Sea's blocker moved from Ay to Bee, and only Ay and Bee were told.
held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="right"), peer(C, "Sea", side="right"),
zones=[{"peer": B, "kind": "part", "parts": ["middle"], "off": True},
{"peer": A, "kind": "edge"},
{"peer": B, "kind": "edge", "off": True},
{"peer": C, "kind": "edge", "off": True}])
before = ways.way_back_state(held)
changed = ways.share(held, "right", {"start": A, "middle": A, "end": B}, kinds=MAC)
self.assertEqual(changed, [])
self.assertEqual(ways.way_back_state(held), before)
def test_a_split_naming_a_machine_not_on_that_side_or_leaving_a_third_out_is_refused(self):
held = self.two_on_the_right()
held["peers"].append(peer(C, "Sea", side="left"))
before = [dict(zone) for zone in held["zones"]]
for thirds in ({"start": A, "middle": A, "end": C}, {"start": A, "middle": B}):
with self.subTest(thirds=thirds):
with self.assertRaises(ValueError):
ways.share(held, "right", thirds, kinds=MAC)
self.assertEqual(held["zones"], before)
class AMachineThatIsGone(unittest.TestCase):
"""Unavailable peers are omitted from compiled zones without changing their saved intent."""
def pc_with_a_gone_machine_on_the_right(self):
return settings(peer(A, "MacBook Pro", side="bottom"), peer(B, "live-usb", side="right"),
zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge"}])
@staticmethod
def only(*idents):
return lambda ident: ident in idents
def test_an_arrangement_from_a_machine_that_is_here_takes_the_side_from_one_that_is_not(self):
held = self.pc_with_a_gone_machine_on_the_right()
held["peers"][0]["caps"] = ["layout"]
before = dict(held.get("layout", {}))
changed, notices = ways.arrangement(held, A, "left", 20, A, "this PC", live=self.only(A))
self.assertFalse(changed)
self.assertEqual(notices, [])
self.assertEqual(held["peers"][0]["side"], "bottom")
self.assertEqual(held.get("layout", {}), before)
self.assertEqual(ways.give_way(held, B, "this PC", self.only(A)), [])
self.assertTrue(ways.has_way(held, B))
def test_without_liveness_the_machine_arriving_still_gives_way_as_before(self):
held = self.pc_with_a_gone_machine_on_the_right()
before = [dict(zone) for zone in held["zones"]]
self.assertEqual(ways.give_way(held, A, "this PC"), [])
self.assertEqual(held["zones"], before)
self.assertTrue(ways.ways(held, A)["methods"] == ["edge"])
def test_two_machines_that_are_both_here_keep_the_rule_and_the_share_offer(self):
held = self.pc_with_a_gone_machine_on_the_right()
held["peers"][0]["caps"] = ["layout"]
self.assertEqual(ways.arrangement(held, A, "left", 20, A, "this PC", live=self.only(A, B)), (False, []))
self.assertIsNone(ways.share_offer(held, A, live=self.only(A, B)))
self.assertTrue(ways.has_way(held, B))
def test_a_machine_that_is_not_here_is_offered_no_third_and_blocks_nothing(self):
held = settings(peer(A, "MacBook Pro", side="right"), peer(B, "live-usb", side="right"),
zones=[{"peer": A, "kind": "edge", "off": True}, {"peer": B, "kind": "edge"}])
layout = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 160, "h": 100},
B: {"x": 160, "y": 0, "w": 160, "h": 100}}
result = ways.compile_layout(held, layout, gone=self.only(B))
self.assertNotIn(B, [zone["peer"] for zone in result["settings"]["zones"]])
self.assertTrue(result["settings"]["peers"][1]["ways"]["edge"])
self.assertIsNone(ways.share_offer(held, A, live=self.only(A)))
def test_choosing_the_edge_on_the_crossing_page_takes_it_from_a_machine_that_is_not_here(self):
# "I tried to set up edge but it wasn't clicking": the edit, then the clash check the stores make.
held = settings(peer(A, "MacBook Pro", side="right"), peer(B, "live-usb", side="right"),
zones=[{"peer": A, "kind": "edge", "off": True}, {"peer": B, "kind": "edge"}])
held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": 160, "y": 0, "w": 160, "h": 100},
B: {"x": 160, "y": 0, "w": 160, "h": 100}}
ways.edit(held, A, side="right", methods=["edge"], parts=[], corner="top_left", kinds=PC,
corner_edge=pc_corner_edge, now=30)
self.assertIsNone(ways.clash(held, "this PC"))
self.assertEqual(ways.give_way(held, A, "this PC", self.only(A)), [])
self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
def test_giving_way_leaves_zones_elsewhere_and_machines_that_are_here_alone(self):
held = settings(peer(A, "Mac", side="right"), peer(B, "Gone", side="left"), peer(C, "Here", side="top"),
zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge"}, {"peer": C, "kind": "edge"}])
before = [dict(zone) for zone in held["zones"]]
self.assertEqual(ways.give_way(held, A, "this PC", self.only(A, C)), [])
self.assertEqual(ways.give_way(held, A, "this PC", None), [])
self.assertEqual(held["zones"], before)
class AMachineThatIsAsleep(unittest.TestCase):
"""Sleep and reconnect events preserve intent; zones are regenerated from current contacts."""
def asleep(self):
held = settings(peer(A, "MacBook Pro", side="right"), peer(B, "Laptop", side="right"),
zones=[{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge", "off": True}])
ways.edit(held, B, side="right", methods=["edge"], parts=[], corner="top_left", kinds=PC,
corner_edge=pc_corner_edge, now=30)
return held
@staticmethod
def zone(held, peer_id):
return next(zone for zone in held["zones"] if zone["peer"] == peer_id and zone["kind"] == "edge")
def test_a_machine_with_no_link_has_its_zone_set_aside_not_lost(self):
held = self.asleep()
notices = ways.give_way(held, B, "this PC", lambda ident: ident == B)
self.assertEqual(notices, [])
self.assertTrue(ways.has_way(held, A))
self.assertEqual(held["peers"][0]["ways"]["edge"], True)
self.assertFalse(any("aside" in zone for zone in held["zones"]))
def test_the_zone_comes_back_when_the_machine_connects_and_the_stretch_is_free(self):
held = self.asleep()
ways.give_way(held, B, "this PC", lambda ident: ident == B)
live, gone = (lambda ident: True), (lambda ident: False)
self.assertFalse(ways.presence_due(held, live, gone))
self.assertEqual(ways.settle_presence(held, "this PC", live, gone), [])
self.assertTrue(ways.has_way(held, A))
self.assertFalse(ways.presence_due(held, live, gone))
def test_a_left_out_zone_stays_off_when_its_machine_connects(self):
held = self.asleep()
ways.give_way(held, B, "this PC", lambda ident: ident == B)
ways.leave_out(held, A)
self.assertEqual(ways.settle_presence(held, "this PC", lambda _ident: True, lambda _ident: False), [])
self.assertNotIn(A, [zone["peer"] for zone in held["zones"]])
self.assertTrue(held["peers"][0]["ways"]["edge"])
self.assertFalse(ways.has_way(held, A))
def test_it_waits_while_the_machine_is_still_asleep(self):
held = self.asleep()
ways.give_way(held, B, "this PC", lambda ident: ident == B)
before = [dict(zone) for zone in held["zones"]]
self.assertFalse(ways.presence_due(held, lambda ident: ident == B, lambda ident: False))
self.assertEqual(ways.settle_presence(held, "this PC", lambda ident: ident == B, lambda ident: False), [])
self.assertEqual(held["zones"], before)
def test_a_machine_back_over_a_stretch_another_holds_stays_off_and_says_so(self):
held = self.asleep()
ways.give_way(held, B, "this PC", lambda ident: ident == B)
notices = ways.settle_presence(held, "this PC", lambda ident: True, lambda ident: False)
self.assertEqual(notices, [])
self.assertTrue(ways.has_way(held, A))
self.assertIsNone(ways.share_offer(held, A, live=lambda ident: True))
def test_a_machine_that_removed_this_pairing_stays_off_for_good_and_the_page_says_so(self):
held = self.asleep()
ways.give_way(held, B, "this PC", lambda ident: ident == B)
gone = lambda ident: ident == A
notices = ways.settle_presence(held, "this PC", lambda ident: ident == B, gone)
self.assertEqual(notices, [])
self.assertEqual(held["peers"][0]["ways"]["edge"], True)
self.assertFalse(ways.presence_due(held, lambda ident: True, lambda ident: False))
self.assertIn("no longer has this pairing", ways.gone_sentence(held, A, "this PC", gone))
self.assertEqual(ways.gone_sentence(held, B, "this PC", gone), "")
def test_a_zone_the_user_changes_while_it_is_set_aside_is_no_longer_set_aside(self):
for methods in (["edge"], []):
with self.subTest(methods=methods):
held = self.asleep()
ways.give_way(held, B, "this PC", lambda ident: ident == B)
before = dict(held["peers"][0]["ways"])
ways.edit(held, A, side="right", methods=methods, parts=[], corner="top_left", kinds=PC,
corner_edge=pc_corner_edge, now=40)
self.assertNotIn("aside", str(held["zones"]))
expected_edge = bool(methods)
self.assertEqual(held["peers"][0]["ways"]["edge"], expected_edge)
self.assertEqual(ways.settle_presence(held, "this PC", lambda ident: True, lambda ident: False), [])
if methods:
self.assertEqual(held["peers"][0]["ways"]["edge"], before["edge"])
class TheShortcutIsNotTakenByAStaleEntry(unittest.TestCase):
def test_with_nothing_ready_the_machine_last_used_is_named_before_an_older_entry(self):
# The lent laptop listed the PC's old pairing first; the shortcut named it rather than the Mac.
peers = [peer(A, "Old PC"), peer(B, "MacBook Pro")]
self.assertEqual(ways.shortcut_peer(peers, B, lambda ident: False), B)
self.assertEqual(ways.shortcut_peer(peers, None, lambda ident: False), A)
THIRDS_COMBINATIONS = [list(combo) for size in (1, 2, 3)
for combo in itertools.combinations(ways.PARTS, size)]
def beside(own_displays=False, peer_displays=False, peer_y=0, peer_h=100):
layout = {HERE: {"x": 0, "y": 0, "w": 150, "h": 99},
A: {"x": 150, "y": peer_y, "w": 150, "h": peer_h}}
for ident, displays in ((HERE, own_displays), (A, peer_displays)):
if displays:
layout[ident]["displays"] = {"main": {"x": 0, "y": 0, "w": layout[ident]["w"], "h": layout[ident]["h"]}}
return layout
def crossing_thirds(held, peer_id=A):
"""The thirds of this machine's side a push actually crosses by, from the zones in use."""
found = set()
for zone in held["zones"]:
if zone.get("peer") != peer_id or zone.get("off") is True:
continue
if zone["kind"] == "edge":
found.update(ways.PARTS)
elif zone["kind"] == "part":
found.update(zone["parts"])
return [part for part in ways.PARTS if part in found]
class PartOfTheEdgeIsOneChoiceWithTheEdge(unittest.TestCase):
"""Edge and Part of the edge are one choice in two forms: every third, or the thirds picked."""
def page(self, held, thirds, extra=()):
methods, parts = ways.pick_thirds(list(extra), thirds)
result = crossing_state.edit_ways(held, A, platform="mac", edge=bool(set(methods) & {"edge", "part"}),
thirds=parts, corner="corner" in methods, corner_at="top_left",
notch="notch" in methods, live=None, gone=None, now=30)
held.clear()
held.update(result["settings"])
def test_picking_thirds_names_the_form(self):
for thirds in THIRDS_COMBINATIONS:
with self.subTest(thirds=thirds):
methods, parts = ways.pick_thirds(["shortcut", "corner"], thirds)
self.assertEqual(parts, thirds)
self.assertEqual(methods, ["shortcut", "edge" if len(thirds) == 3 else "part", "corner"])
self.assertEqual(ways.picked_thirds(methods, parts), thirds)
self.assertEqual(ways.pick_thirds(["edge", "notch"], []), (["notch"], ["middle"]))
def test_a_click_on_a_third_toggles_it_the_last_turns_edge_off_and_one_while_off_lights_it_alone(self):
# The Ledger spec (docs/spec-crossing-page-a-ledger-10-10-2026.md section 3.3), map and ledger alike.
self.assertEqual(ways.toggle_third(["edge"], [], "middle"), (["part"], ["start", "end"]))
self.assertEqual(ways.toggle_third(["part"], ["start", "end"], "middle"), (["edge"], list(ways.PARTS)))
self.assertEqual(ways.toggle_third(["part"], ["middle"], "middle"), ([], ["middle"]))
self.assertEqual(ways.toggle_third(["part", "corner"], ["end"], "end"), (["corner"], ["end"]))
self.assertEqual(ways.toggle_third(["corner"], ["start", "end"], "middle"), (["part", "corner"], ["middle"]))
for thirds in THIRDS_COMBINATIONS:
for part in ways.PARTS:
with self.subTest(thirds=thirds, part=part):
methods, parts = ways.pick_thirds([], thirds)
after = ways.picked_thirds(*ways.toggle_third(methods, parts, part))
self.assertEqual(after, sorted(set(thirds) ^ {part}, key=ways.PARTS.index))
def test_the_edge_text_turns_off_keeping_the_thirds_and_on_as_the_whole_edge(self):
self.assertEqual(ways.toggle_edge(["part", "corner"], ["start", "end"]), (["corner"], ["start", "end"]))
self.assertEqual(ways.toggle_edge(["corner"], ["start", "end"]), (["edge", "corner"], list(ways.PARTS)))
self.assertEqual(ways.toggle_edge(["edge"], list(ways.PARTS)), ([], list(ways.PARTS)))
def test_a_corner_is_held_by_one_machine_and_refused_to_the_others(self):
held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="left"), zones=[])
held["peers"][0]["ways"] = {"edge": True, "thirds": list(ways.PARTS), "corner": True, "corner_at": "top_left"}
self.assertEqual(ways.corner_holder(held, "top_left", exclude=B), A)
self.assertIsNone(ways.corner_holder(held, "top_left", exclude=A))
self.assertIsNone(ways.corner_holder(held, "top_right", exclude=B))
held["peers"][0]["left_out"] = True
self.assertIsNone(ways.corner_holder(held, "top_left", exclude=B))
def test_a_diagonal_corner_contact_holds_the_corner_too(self):
held = settings(peer(A, "Ay"), peer(B, "Bee"))
held["layout"] = {HERE: {"x": 0, "y": 0, "w": 160, "h": 100},
A: {"x": -160, "y": -100, "w": 160, "h": 100},
B: {"x": 160, "y": 100, "w": 160, "h": 100}}
self.assertEqual(ways.corner_holder(held, "top_left", exclude=B), A)
def test_every_combination_round_trips_through_the_settings(self):
for thirds in THIRDS_COMBINATIONS:
with self.subTest(thirds=thirds):
held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
self.page(held, thirds)
read = ways.ways(held, A)
self.assertEqual(ways.picked_thirds(read["methods"], read["parts"]), thirds)
self.assertEqual(crossing_thirds(held), thirds)
def test_every_combination_survives_compiling_the_map_with_or_without_display_metadata(self):
for thirds in THIRDS_COMBINATIONS:
for own_displays in (False, True):
for peer_displays in (False, True):
with self.subTest(thirds=thirds, own_displays=own_displays, peer_displays=peer_displays):
held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
self.page(held, thirds)
layout = beside(own_displays, peer_displays)
for _ in range(2):
result = ways.compile_layout(held, layout, moved=A)
held = result["settings"]
read = ways.ways(held, A)
self.assertEqual(ways.picked_thirds(read["methods"], read["parts"]), thirds)
self.assertTrue(ways.crosses_on_map(held, A))
self.assertEqual(result["tiles"][A]["state"], "edge" if len(thirds) == 3 else "part")
scoped = [zone for zone in held["zones"]
if zone.get("display") is not None and zone.get("off") is not True]
if own_displays:
# The display's own contact crosses only by the picked thirds.
self.assertEqual(crossing_thirds({"zones": scoped}), thirds)
def test_a_pick_made_after_the_map_compiled_narrows_every_contact_and_widens_back(self):
held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
held = ways.compile_layout(held, beside(own_displays=True), moved=A)["settings"]
self.page(held, ["start", "end"])
scoped = [zone for zone in held["zones"] if zone.get("display") == "main"]
self.assertEqual(crossing_thirds({"zones": scoped}), ["start", "end"])
self.page(held, list(ways.PARTS))
scoped = [zone for zone in held["zones"] if zone.get("display") == "main"]
self.assertEqual(crossing_thirds({"zones": scoped}), list(ways.PARTS))
self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
self.assertFalse(any("page_parts" in zone for zone in held["zones"]))
def test_a_tile_touching_only_some_thirds_crosses_by_the_picked_ones_it_touches(self):
held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
self.page(held, ["start", "end"])
# Against the top two thirds only: the bottom third is picked but not touched.
layout = beside(own_displays=True, peer_y=-34, peer_h=100)
result = ways.compile_layout(held, layout, moved=A)
held = result["settings"]
scoped = [zone for zone in held["zones"] if zone.get("display") == "main"]
self.assertEqual(crossing_thirds({"zones": scoped}), ["start"])
self.assertEqual(ways.ways(held, A)["parts"], ["start", "end"])
# Against the middle only: nothing picked is touched, and the map says so.
result = ways.compile_layout(held, beside(own_displays=True, peer_y=33, peer_h=33), moved=A)
self.assertEqual(result["tiles"][A]["state"], "gap")
self.assertEqual(result["tiles"][A]["sentence_keys"], ["unpicked"])
self.assertTrue(result["tiles"][A]["unpicked"])
self.assertIn("{name}", ways.ATLAS_SENTENCES["unpicked"])
def test_a_pick_a_clash_turned_off_reads_as_off_and_an_untouched_pick_as_on(self):
held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
self.page(held, ["start"])
held["zones"][0]["off"] = True
self.assertIn("part", ways.ways(held, A)["methods"])
self.assertEqual(ways.ways(held, A)["parts"], ["start"])
self.page(held, ["start"])
held = ways.compile_layout(held, beside(own_displays=True, peer_y=33, peer_h=33), moved=A)["settings"]
self.assertFalse(ways.crosses_on_map(held, A))
self.assertIn("part", ways.ways(held, A)["methods"])
self.assertTrue(all("off" not in zone for zone in held["zones"]))
self.page(held, ["start", "middle"])
self.assertTrue(ways.crosses_on_map(held, A))
self.assertFalse(any(zone.get("unpicked") for zone in held["zones"]))
def test_leave_out_and_put_back_keep_the_pick_whether_or_not_it_touches(self):
for peer_y, peer_h, crossing in ((0, 100, ["start"]), (33, 33, [])):
with self.subTest(peer_y=peer_y):
held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
self.page(held, ["start"])
held = ways.compile_layout(held, beside(own_displays=True, peer_y=peer_y, peer_h=peer_h),
moved=A)["settings"]
ways.leave_out(held, A)
self.assertFalse(ways.crosses_on_map(held, A))
ways.put_back(held, A)
self.assertIn("part", ways.ways(held, A)["methods"])
self.assertEqual(ways.ways(held, A)["parts"], ["start"])
scoped = [zone for zone in held["zones"] if zone.get("display") == "main"]
self.assertEqual(crossing_thirds({"zones": scoped}), crossing)
def test_put_back_leaves_off_a_third_another_machine_took_meanwhile(self):
held = settings(peer(A, "Ay", side="right"), peer(B, "Bee", side="right"),
zones=[{"peer": A, "kind": "edge"}])
self.page(held, ["start"])
layout = beside(own_displays=True)
held = ways.compile_layout(held, layout, moved=A)["settings"]
ways.leave_out(held, A)
ways.put_back(held, A)
scoped = [zone for zone in held["zones"] if zone.get("peer") == A and zone.get("display") == "main"]
self.assertEqual(crossing_thirds({"zones": scoped}), ["start"])
self.assertIsNone(ways.clash(held, "here"))
def test_a_contact_the_tile_has_left_is_not_revived_by_a_later_pick(self):
held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
self.page(held, ["start"])
held = ways.compile_layout(held, beside(own_displays=True), moved=A)["settings"]
away = beside(own_displays=True)
away[A]["x"] = 400
held = ways.compile_layout(held, away, moved=A)["settings"]
self.page(held, ["start", "middle"])
scoped = [zone for zone in held["zones"] if zone.get("display") == "main"]
self.assertEqual(crossing_thirds({"zones": scoped}), [])
def test_edge_off_still_holds_with_thirds_picked_and_comes_back_whole(self):
for own_displays in (False, True):
with self.subTest(own_displays=own_displays):
held = settings(peer(A, "Ay", side="right"), zones=[{"peer": A, "kind": "edge"}])
self.page(held, ["start", "end"])
held = ways.compile_layout(held, beside(own_displays), moved=A)["settings"]
self.page(held, [], extra=["shortcut"])
for _ in range(2):
held = ways.compile_layout(held, beside(own_displays), moved=A)["settings"]
self.assertFalse(ways.crosses_on_map(held, A))
self.assertEqual(ways.picked_thirds(**{k: ways.ways(held, A)[k] for k in ("methods", "parts")}), [])
self.page(held, list(ways.PARTS))
self.assertTrue(ways.crosses_on_map(held, A))
self.assertEqual(ways.ways(held, A)["methods"], ["edge"])
def test_the_edge_tile_names_its_form(self):
cases = {("start", "end"): "Top and bottom thirds", ("middle",): "Middle third",
("start", "middle", "end"): "Whole edge", (): "Whole edge or the thirds you pick"}
for thirds, words in cases.items():
with self.subTest(thirds=thirds):
self.assertEqual(ways.edge_form_detail("right", *ways.pick_thirds([], thirds)), words)
self.assertEqual(ways.edge_form_detail("top", ["part"], ["start", "middle"]), "Left and middle thirds")
self.assertEqual(ways.edge_form_detail("", ["edge"], [], here="This PC"), "Place it beside This PC on the map")
def test_the_map_click_targets_are_the_thirds_a_contact_covers(self):
own = {"x": 0, "y": 0, "w": 150, "h": 99}
self.assertEqual([third for third, *_ in ways.third_stretches(("right", 0, 99), own)], list(ways.PARTS))
self.assertEqual(ways.third_stretches(("right", 0, 50), own),
[("start", "right", 0, 33.0), ("middle", "right", 33.0, 50)])
self.assertEqual(ways.third_stretches(("corner", "top_right", ""), own), [])
if __name__ == "__main__":
unittest.main()