One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
"""Input ownership and the responder's half of routing (WIRE.md sections 4 and
5), over real sockets on loopback against
LinkResponder, with scripted owners."""
import time
import unittest
from unittest import mock
from core import protocol, receiver
from core.return_edge import CornerPush, PartEdge, ReturnEdge, SpanEdge
from core.tests.responder_harness import B, C, D, HERE, TOKENS, Initiator, Machine, entry, wait_for
ACCEPT, REFUSE = protocol.MSG_ACCEPT, protocol.MSG_REFUSE
class IdleTakeover(unittest.TestCase):
def setUp(self):
self.machine = Machine([])
self.responder = self.machine.responder
self.now = 100.0
clock = mock.patch.object(receiver.time, "monotonic", side_effect=lambda: self.now)
clock.start()
self.addCleanup(clock.stop)
self.b = self.make_link(B)
self.c = self.make_link(C)
self.take(self.b, 1)
def make_link(self, peer):
link = mock.Mock(peer_id=peer, own_id=HERE, route=0, allow_drive=True, held={})
link.closed.is_set.return_value = False
return link
def take(self, link, route, **fields):
self.responder._on_focus(link, protocol.focus_v6(route, HERE, **fields))
def test_idle_owner_is_sent_home_with_the_new_driver_and_replaced_at_boundary(self):
self.now += 3.0
self.take(self.c, 1)
self.assertEqual(self.responder.owner, C)
self.b.post.assert_called_with({"type": protocol.MSG_SWITCH, "data": {
"route": 1, "next": protocol.id_text(B), "taken_over_by": protocol.id_text(C)}})
self.assertEqual(self.machine.owners, [B, None, C])
def test_owner_before_boundary_still_refuses(self):
self.now += 2.999
self.take(self.c, 1)
self.assertEqual(self.responder.owner, B)
self.c.post.assert_called_with(protocol.refuse_msg(1, "owned", other=B))
def test_valid_owner_input_refreshes_activity_but_non_owner_input_does_not(self):
self.now += 2.0
message = protocol.key_msg(protocol.MSG_KEYDOWN, "a")
message["data"]["seq"] = 1
self.responder._on_input(self.b, message)
self.now += 2.0
self.take(self.c, 1)
self.assertEqual(self.responder.owner, B)
self.responder._on_input(self.c, message)
self.now += 1.0
self.take(self.c, 2)
self.assertEqual(self.responder.owner, C)
self.assertEqual(self.b.held, {})
injected = self.machine.injected()
self.responder._on_input(self.b, message)
self.assertEqual(self.machine.injected(), injected)
self.responder._on_focus(self.b, protocol.focus_v6(2, B))
self.assertEqual(self.responder.owner, C)
self.take(self.b, 3)
self.b.post.assert_called_with(protocol.refuse_msg(3, "sent_home"))
new_input = protocol.key_msg(protocol.MSG_KEYDOWN, "b")
new_input["data"]["seq"] = 2
self.responder._on_input(self.c, new_input)
self.assertEqual(self.machine.injected(), [
("key", "a", True), ("key", "a", False), ("key", "b", True)])
def test_malformed_owner_input_does_not_refresh_activity(self):
self.now += 2.0
self.responder._on_input(self.b, {"type": protocol.MSG_MOUSEMOVE, "data": {"seq": 1}})
self.now += 1.0
self.take(self.c, 1)
self.assertEqual(self.responder.owner, C)
def test_stay_does_not_refresh_idle_time_or_steal_ownership(self):
self.now += 2.0
self.take(self.b, 2, stay=True, resistance_px=120, reach=[])
self.now += 1.0
self.take(self.c, 1, stay=True, resistance_px=120, reach=[])
self.assertEqual(self.responder.owner, B)
self.take(self.c, 2)
self.assertEqual(self.responder.owner, C)
def test_unsupported_input_heartbeat_and_clipboard_do_not_refresh_activity(self):
self.b.own_caps = frozenset()
self.b.response_time_enabled = True
self.now += 2.0
message = protocol.gesture_msg(protocol.GESTURE_SWIPE_UP)
message["data"]["seq"] = 1
self.responder._on_input(self.b, message)
self.responder._on_ping(self.b, protocol.ping_msg(probe=1))
self.responder._on_clipboard(self.b, protocol.clipboard_msg("clipboard"))
self.now += 1.0
self.take(self.c, 1)
self.assertEqual(self.responder.owner, C)
def ids(*peers):
return [protocol.id_text(peer) for peer in peers]
class Case(unittest.TestCase):
zones = ()
sides = {}
def setUp(self):
peers = [entry(peer, name, side=self.sides.get(peer, "")) for peer, name in ((B, "Bee"), (C, "Sea"), (D, "Dee"))]
self.machine = Machine(peers, self.zones).start()
self.addCleanup(self.machine.stop)
def link(self, peer=B, **hello):
link = Initiator(self.machine, peer)
self.addCleanup(link.close)
link.handshake(link.hello(**hello) if hello else None)
self.assertTrue(wait_for(lambda: peer in self.machine.responder.links()))
return link
def own(self, link, **fields):
route = link.take(**fields)
self.assertEqual(link.answer(route), (ACCEPT, {"route": route}))
self.assertTrue(wait_for(lambda: self.machine.responder.owner == link.peer))
return route
def refused(self, link, why, other=None, **fields):
"""`other`, when given, is the machine the refusal must name; the rest of the time it is not
checked, so the decision-order tests stay about the order."""
route = link.take(**fields)
kind, data = link.answer(route)
if other is not None:
self.assertEqual(data.get("other"), protocol.id_text(other))
self.assertEqual((kind, {key: value for key, value in data.items() if key != "other"}),
(REFUSE, {"route": route, "why": why}))
return data
def injected_from(self, count=None):
return self.machine.injected()
def peer_entry(self, peer):
return self.machine.settings.peer(TOKENS[peer])
class Taking(Case):
def test_two_peers_compete_and_the_second_gets_in_after_the_first_lets_go(self):
b, c = self.link(B), self.link(C)
self.own(b)
self.refused(c, "owned")
b.let_go()
self.assertTrue(wait_for(lambda: self.machine.responder.owner is None))
self.own(c)
self.assertEqual(self.machine.owners, [B, None, C])
def test_a_route_not_higher_than_the_last_accepted_gets_no_answer(self):
b = self.link(B)
self.own(b, route=5)
for route in (5, 4):
b.take(route=route)
self.assertIsNone(b.answer(route, timeout=0.3))
def test_the_decision_order(self):
b, c = self.link(B), self.link(C)
self.peer_entry(C)["allow_drive"] = False
self.machine.responder.peers_changed()
self.machine.away = True
# Malformed before everything.
self.refused(c, "malformed", resistance_px=5000)
# Then not allowed before busy.
self.refused(c, "not_allowed")
self.peer_entry(C)["allow_drive"] = True
self.machine.responder.peers_changed()
self.refused(c, "busy")
self.machine.away = False
with mock.patch.object(receiver, "SENT_HOME_SECONDS", 0.6):
self.own(b)
self.assertTrue(self.machine.responder.send_home())
b.let_go()
self.assertTrue(wait_for(lambda: self.machine.responder.owner is None))
self.own(c)
# Sent home before owned.
self.refused(b, "sent_home")
time.sleep(0.7)
self.refused(b, "owned")
def test_a_stay_from_a_machine_that_is_not_the_owner_is_never_accepted(self):
b, c = self.link(B), self.link(C)
self.refused(c, "malformed", stay=True, resistance_px=120, reach=[])
self.own(b)
route = c.take(stay=True, resistance_px=120, reach=[])
self.assertEqual(c.answer(route)[0], REFUSE)
self.assertEqual(self.machine.responder.owner, B)
def test_a_driven_desktop_is_busy(self):
self.machine.away = True
self.refused(self.link(B), "busy")
self.assertIsNone(self.machine.responder.owner)
def test_an_owned_refusal_names_the_owner_and_a_busy_one_the_machine_input_is_on(self):
b, c = self.link(B), self.link(C)
self.own(b)
self.refused(c, "owned", other=B)
b.let_go()
self.assertTrue(wait_for(lambda: self.machine.responder.owner is None))
# away() may say which machine this one's input is on; then busy names it.
self.machine.away = D
self.refused(c, "busy", other=D)
# Only a yes or no: busy, naming nothing.
self.machine.away = True
self.assertNotIn("other", self.refused(c, "busy"))
self.peer_entry(C)["allow_drive"] = False
self.machine.responder.peers_changed()
self.assertNotIn("other", self.refused(c, "not_allowed"))
def test_the_answer_comes_before_the_pointer_is_placed(self):
self.machine.desktop.slow = 1.0
b = self.link(B)
started = time.monotonic()
route = b.take(edge="left", offset=0.5, resistance_px=120, reach=[])
self.assertEqual(b.answer(route)[0], ACCEPT)
self.assertLess(time.monotonic() - started, 0.5)
self.assertTrue(wait_for(lambda: self.machine.desktop.placed == [(0, 540)]))
self.assertEqual(self.machine.arrivals, [("left", 0, 540)])
def test_a_take_by_the_shortcut_lands_nothing_and_says_where_the_pointer_is(self):
self.own(self.link(B))
self.assertTrue(wait_for(lambda: self.machine.arrivals == [(None, 960, 540)]))
self.assertEqual(self.machine.desktop.placed, [])
def test_the_owners_own_take_moves_the_pointer_in_place(self):
b = self.link(B)
self.own(b)
self.own(b, edge="top", offset=0.25)
self.assertTrue(wait_for(lambda: self.machine.desktop.placed == [(480, 0)]))
self.assertEqual(self.machine.owners, [B])
def test_a_focus_whose_route_or_target_is_malformed_is_ignored(self):
b = self.link(B)
b.send({"type": "focus", "data": {"route": 1.0, "target": protocol.id_text(HERE)}})
b.send({"type": "focus", "data": {"route": 2, "target": "nope"}})
self.assertIsNone(b.expect(ACCEPT, timeout=0.3))
self.assertIsNone(b.expect(REFUSE, timeout=0.1))
def test_strict_json_on_a_later_focus_is_malformed(self):
b = self.link(B)
text = '{"type":"focus","data":{"route":1,"target":"%s","resistance_px":%s}}'
for value in ("120.0", "true", "NaN"):
with self.subTest(value=value):
route = b.route + 1
b.route = route
raw = (text % (protocol.id_text(HERE), value)).replace('"route":1', '"route":%d' % route).encode()
with b.session.send_lock:
b.sock.sendall(b.session.seal_raw(raw))
self.assertEqual(b.answer(route), (REFUSE, {"route": route, "why": "malformed"}))
class NonOwners(Case):
def test_a_non_owners_input_is_dropped_and_acknowledged(self):
b, c = self.link(B), self.link(C)
self.own(b)
seq = c.key("keydown", "x")
self.assertIsNotNone(c.acked(seq))
self.assertEqual(self.machine.injected(), [])
def test_a_non_owners_clipboard_is_dropped_and_the_owners_is_set(self):
b, c = self.link(B), self.link(C)
self.own(b)
c.send(protocol.clipboard_msg("from c"))
b.send(protocol.clipboard_msg("from b"))
self.assertTrue(wait_for(lambda: self.machine.clipboard.set_calls == [("from b", None)]))
time.sleep(0.1)
self.assertEqual(self.machine.clipboard.set_calls, [("from b", None)])
def send_big(self, link, filler, size=protocol.SMALL_MESSAGE_BYTES + 1000):
"""A frame whose plaintext is `size` bytes, sealed for real so its counter advances."""
body = ('{"type":"%s","data":{},"z":"' % filler).encode() + b"a" * size + b'"}'
with link.session.send_lock:
frame = link.session.seal_raw(body)
link.sock.sendall(frame)
def test_a_non_owners_large_frame_is_authenticated_and_dropped_without_being_parsed(self):
b, c = self.link(B), self.link(C)
self.own(b)
parsed = []
real = protocol.parse_message
def watching(plain):
parsed.append(len(plain))
return real(plain)
with mock.patch.object(protocol, "parse_message", watching):
self.send_big(c, "x")
self.send_big(c, "clipboard")
c.send(protocol.paired_msg([D]))
self.assertTrue(wait_for(lambda: self.machine.paired == [(C, [D])]), "the link did not survive")
self.assertTrue(all(size < protocol.SMALL_MESSAGE_BYTES for size in parsed), parsed)
def test_a_take_refused_as_owned_then_a_clipboard_does_not_end_the_link(self):
b, c = self.link(B), self.link(C)
self.own(b)
self.refused(c, "owned")
c.send(protocol.clipboard_msg("c" * 200_000))
seq = c.key("keydown", "x")
self.assertIsNotNone(c.acked(seq))
self.assertEqual(self.machine.clipboard.set_calls, [])
def test_the_owners_large_clipboard_still_arrives(self):
b = self.link(B)
self.own(b)
text = "b" * 200_000
b.send(protocol.clipboard_msg(text))
self.assertTrue(wait_for(lambda: self.machine.clipboard.set_calls == [(text, None)]))
def test_a_non_owners_arrangement_settings_and_paired_are_handled(self):
self.own(self.link(B))
c = self.link(C)
c.send(protocol.arrangement_v6("left", 1790000000, C))
c.send(protocol.settings_msg({"on": True, "set_at": 1790000000, "by": protocol.id_text(C)}))
c.send(protocol.paired_msg([D]))
self.assertTrue(wait_for(lambda: self.machine.paired == [(C, [D])]))
self.assertEqual(self.machine.arrangements, [(C, {"edge": "left", "set_at": 1790000000, "by": C})])
self.assertEqual([peer for peer, _ in self.machine.settings_seen], [C])
def test_settings_from_a_peer_without_the_capability_are_ignored(self):
d = self.link(D, caps=["clipboard"])
d.send(protocol.settings_msg({"on": False, "set_at": 1790000000, "by": protocol.id_text(D)}))
d.send(protocol.paired_msg([B]))
self.assertTrue(wait_for(lambda: self.machine.paired == [(D, [B])]))
self.assertEqual(self.machine.settings_seen, [])
def test_a_non_owners_let_go_is_ignored(self):
b, c = self.link(B), self.link(C)
self.own(b)
c.let_go(target=D)
time.sleep(0.1)
self.assertEqual(self.machine.responder.owner, B)
b.key("keydown", "q")
self.assertTrue(wait_for(lambda: ("key", "q", True) in self.machine.injected()))
def test_not_allowed_keeps_the_link_for_arrangement(self):
self.peer_entry(B)["allow_drive"] = False
b = self.link(B)
self.refused(b, "not_allowed")
b.send(protocol.arrangement_v6("top", 1790000001, B))
self.assertTrue(wait_for(lambda: len(self.machine.arrangements) == 1))
self.assertFalse(b.closed.is_set())
class Ending(Case):
def hold(self, link):
link.key("keydown", "shift")
link.input({"type": "mousedown", "data": {"button": "left"}})
self.assertTrue(wait_for(lambda: ("button", "left", True) in self.machine.injected()))
def released(self):
calls = self.machine.injected()
return ("key", "shift", False) in calls and ("button", "left", False) in calls
def test_a_let_go_releases_what_the_owner_held(self):
b = self.link(B)
self.own(b)
self.hold(b)
b.let_go(target=C)
self.assertTrue(wait_for(self.released))
self.assertTrue(wait_for(lambda: self.machine.responder.owner is None))
self.assertEqual(self.machine.owners, [B, None])
def test_the_link_closing_releases(self):
b = self.link(B)
self.own(b)
self.hold(b)
b.close()
self.assertTrue(wait_for(self.released))
self.assertTrue(wait_for(lambda: self.machine.responder.owner is None and B not in self.machine.responder.links()))
def test_the_link_timing_out_releases(self):
with mock.patch.object(receiver, "LINK_READ_TIMEOUT_SECONDS", 0.4):
b = self.link(B)
self.own(b)
self.hold(b)
self.assertTrue(wait_for(self.released, timeout=2))
self.assertTrue(b.closed.wait(2))
def test_removing_the_owner_releases_and_closes_its_links(self):
b, c = self.link(B), self.link(C)
self.own(b)
self.hold(b)
self.machine.settings.data["peers"] = [p for p in self.machine.settings.data["peers"] if p["token"] != TOKENS[B]]
self.machine.responder.peers_changed()
self.assertTrue(wait_for(self.released))
self.assertTrue(b.closed.wait(2))
self.assertIsNone(self.machine.responder.owner)
self.assertFalse(c.closed.is_set())
def test_turning_allow_drive_off_and_on(self):
b = self.link(B)
route = self.own(b)
self.hold(b)
self.peer_entry(B)["allow_drive"] = False
self.machine.responder.peers_changed()
self.assertEqual(b.expect(REFUSE), {"route": route, "why": "not_allowed"})
self.assertEqual(b.expect(protocol.MSG_ACCEPTS), {"accepts": False})
self.assertTrue(self.released())
before = len(self.machine.injected())
seq = b.key("keydown", "z")
self.assertIsNotNone(b.acked(seq))
self.assertEqual(len(self.machine.injected()), before)
self.peer_entry(B)["allow_drive"] = True
self.machine.responder.peers_changed()
self.assertEqual(b.expect(protocol.MSG_ACCEPTS), {"accepts": True})
self.own(b)
def test_turning_in_use_off_releases_the_owner_and_closes_the_link(self):
b = self.link(B)
self.own(b)
self.hold(b)
self.peer_entry(B)["in_use"] = False
self.machine.responder.peers_changed()
self.assertTrue(wait_for(self.released))
self.assertTrue(b.closed.wait(2))
self.assertIsNone(self.machine.responder.owner)
self.assertTrue(wait_for(lambda: B not in self.machine.responder.links()))
def test_the_forced_end_after_a_send_home(self):
with mock.patch.object(receiver, "FORCED_END_SECONDS", 0.3), mock.patch.object(receiver, "SENT_HOME_SECONDS", 1.0):
b = self.link(B)
route = self.own(b)
self.hold(b)
self.assertTrue(self.machine.responder.send_home())
self.assertEqual(b.expect(protocol.MSG_SWITCH), {"route": route, "next": protocol.id_text(B)})
self.assertEqual(b.expect(REFUSE, timeout=1.0), {"route": route, "why": "sent_home"})
self.assertTrue(self.released())
self.assertIsNone(self.machine.responder.owner)
before = len(self.machine.injected())
seq = b.key("keydown", "z")
self.assertIsNotNone(b.acked(seq))
self.assertEqual(len(self.machine.injected()), before)
self.refused(b, "sent_home")
time.sleep(1.0)
self.own(b)
def test_an_owner_that_obeys_a_send_home_is_refused_for_a_while_too(self):
with mock.patch.object(receiver, "SENT_HOME_SECONDS", 0.5):
b = self.link(B)
self.own(b)
self.machine.responder.send_home()
b.expect(protocol.MSG_SWITCH)
b.let_go()
self.assertTrue(wait_for(lambda: self.machine.responder.owner is None))
self.refused(b, "sent_home")
time.sleep(0.6)
self.own(b)
def test_nothing_to_send_home(self):
self.assertFalse(self.machine.responder.send_home())
def test_each_link_keeps_its_own_seq(self):
b, c = self.link(B), self.link(C)
self.own(b)
for name in "abc":
b.key("keydown", name)
self.assertIsNotNone(b.acked(3))
b.let_go()
self.assertTrue(wait_for(lambda: self.machine.responder.owner is None))
self.own(c)
c.key("keydown", "d")
self.assertIsNotNone(c.acked(1))
time.sleep(0.5)
c.expect("nothing", timeout=0.1)
self.assertEqual(max(m["data"]["seq"] for m in c.seen if m["type"] == protocol.MSG_ACK), 1)
class TheClipboardOnLettingGo(Case):
def test_an_unchanged_clipboard_is_not_sent(self):
self.machine.clipboard.copy("copied before anyone drove")
b = self.link(B)
self.own(b)
b.let_go(target=C)
self.assertIsNone(b.expect(protocol.MSG_CLIPBOARD, timeout=0.4))
def test_a_change_made_here_is_sent(self):
b = self.link(B)
self.own(b)
self.machine.clipboard.copy("copied here")
b.let_go(target=C)
self.assertEqual(b.expect(protocol.MSG_CLIPBOARD), {"text": "copied here"})
def test_what_the_owner_brought_is_not_echoed(self):
b = self.link(B)
self.own(b)
b.send(protocol.clipboard_msg("brought"))
self.assertTrue(wait_for(lambda: self.machine.clipboard.set_calls))
b.let_go(target=C)
self.assertIsNone(b.expect(protocol.MSG_CLIPBOARD, timeout=0.4))
def test_nothing_is_sent_when_ownership_ends_any_other_way(self):
with mock.patch.object(receiver, "FORCED_END_SECONDS", 0.2):
b = self.link(B)
self.own(b)
self.machine.clipboard.copy("copied here")
self.machine.responder.send_home()
self.assertIsNotNone(b.expect(REFUSE))
self.assertIsNone(b.expect(protocol.MSG_CLIPBOARD, timeout=0.3))
class Zones(Case):
sides = {B: "left", C: "right", D: "top"}
zones = [{"peer": protocol.id_text(B), "kind": "edge"},
{"peer": protocol.id_text(C), "kind": "edge"},
{"peer": protocol.id_text(D), "kind": "edge"}]
def push(self, link, cursor, dx, dy):
self.machine.desktop.cursor = cursor
seq = link.move(dx, dy)
self.assertIsNotNone(link.acked(seq))
def test_reach_limits_the_zones_armed(self):
b = self.link(B)
route = self.own(b, resistance_px=120, reach=[C])
self.push(b, (960, 0), 0, -200)
self.assertIn(("move", 0, -200), self.machine.injected())
self.push(b, (1919, 500), 200, 0)
switch = b.expect(protocol.MSG_SWITCH)
self.assertEqual((switch["route"], switch["next"], switch["edge"]), (route, protocol.id_text(C), "left"))
self.assertAlmostEqual(switch["offset"], 500 / 1080, places=2)
def test_a_take_without_reach_arms_only_the_way_home(self):
b = self.link(B)
self.own(b)
self.push(b, (1919, 500), 200, 0)
self.assertIn(("move", 200, 0), self.machine.injected())
self.push(b, (0, 500), -200, 0)
self.assertEqual(b.expect(protocol.MSG_SWITCH)["next"], protocol.id_text(B))
def test_the_owners_resistance_is_used(self):
b = self.link(B)
self.own(b, resistance_px=500, reach=[])
self.push(b, (0, 500), -200, 0)
self.assertIsNone(b.expect(protocol.MSG_SWITCH, timeout=0.2))
self.assertEqual(self.machine.desktop.placed[-1], (0, 500))
self.assertNotIn(("move", -200, 0), self.machine.injected())
def test_resistance_out_of_range_is_malformed(self):
self.refused(self.link(B), "malformed", resistance_px=1001)
def test_after_a_switch_the_zones_are_disarmed_until_a_stay(self):
b = self.link(B)
self.own(b, reach=[C])
self.push(b, (1919, 500), 200, 0)
self.assertIsNotNone(b.expect(protocol.MSG_SWITCH))
self.push(b, (1919, 500), 200, 0)
self.assertIsNone(b.expect(protocol.MSG_SWITCH, timeout=0.2))
self.assertIn(("move", 200, 0), self.machine.injected())
self.own(b, stay=True, resistance_px=120, reach=[C])
self.push(b, (1919, 500), 200, 0)
self.assertIsNotNone(b.expect(protocol.MSG_SWITCH))
self.assertEqual(self.machine.arrivals, [(None, 960, 540)])
def test_held_edges_do_not_cross(self):
b = self.link(B)
self.own(b, reach=[C])
self.machine.responder.edges_held = lambda: True
self.push(b, (1919, 500), 200, 0)
self.assertIsNone(b.expect(protocol.MSG_SWITCH, timeout=0.2))
def test_the_send_home_names_no_position(self):
b = self.link(B)
route = self.own(b, reach=[C])
self.machine.responder.send_home()
self.assertEqual(b.expect(protocol.MSG_SWITCH), {"route": route, "next": protocol.id_text(B)})
# Its zones are disarmed with it.
self.push(b, (1919, 500), 200, 0)
self.assertIsNone(b.expect(protocol.MSG_SWITCH, timeout=0.2))
def test_a_zone_change_rearms_while_driven(self):
b = self.link(B)
self.own(b, reach=[C])
self.machine.settings.data["zones"][1]["off"] = True
self.machine.responder.rearm()
self.push(b, (1919, 500), 200, 0)
self.assertIsNone(b.expect(protocol.MSG_SWITCH, timeout=0.2))
class WrapWayBack(Case):
sides = {B: "right"}
zones = [{"peer": protocol.id_text(B), "kind": "edge", "display": "main", "side": "right"}]
def test_wrap_arrival_arms_its_way_back_until_the_visit_ends(self):
b = self.link(B)
self.own(b, edge="right", offset=0.5, display="main", side="left")
marker = (B, "left", "main", "right")
self.assertIn(marker, [(peer, model.edge, model.display, model.target_side)
for peer, model in self.machine.responder._armed])
self.machine.responder.rearm()
self.assertIn(marker, [(peer, model.edge, model.display, model.target_side)
for peer, model in self.machine.responder._armed])
b.let_go()
self.assertTrue(wait_for(lambda: self.machine.responder.owner is None))
self.assertEqual(self.machine.responder._armed, [])
def test_edge_off_does_not_add_a_way_back(self):
self.machine.responder._zones = lambda: []
b = self.link(B)
self.own(b, edge="right", offset=0.5, display="main", side="left")
self.assertEqual(self.machine.responder._armed, [])
class LeftOutDriverWayHome(Case):
"""The Mac on 14-10-2026, compiled from its real settings: Fedora (B here) left out but driving
it, and its only edges leading to the rig (C) on the right, top and bottom. A left-out driver
had no way home, so every push went on to the rig and back."""
zones = [{"peer": protocol.id_text(C), "kind": "edge", "display": "main", "side": side,
"target_side": opposite}
for side, opposite in (("right", "left"), ("top", "bottom"), ("bottom", "top"))]
def setUp(self):
peers = [entry(B, "Bee", left_out=True, way_back=True), entry(C, "Sea"), entry(D, "Dee")]
self.machine = Machine(peers, self.zones).start()
self.addCleanup(self.machine.stop)
def test_the_way_home_is_armed_at_the_arrival_side(self):
b = self.link(B)
self.own(b, edge="left", offset=0.5, display="main", side="left", reach=[C])
self.assertIn((B, "left", "main", "right"),
[(peer, model.edge, model.display, model.target_side)
for peer, model in self.machine.responder._armed])
class ZoneModels(unittest.TestCase):
peers = [entry(B, "Bee", side="left"), entry(C, "Sea", side="top"), entry(D, "Dee", side="")]
def models(self, zones, allowed=(B, C, D), resistance=150, notch=None):
return receiver.zone_models(zones, self.peers, set(allowed), resistance, notch)
def test_each_kind(self):
zones = [
{"peer": protocol.id_text(B), "kind": "edge"},
{"peer": protocol.id_text(C), "kind": "part", "parts": ["start", "end"]},
{"peer": protocol.id_text(B), "kind": "corner", "corner": "top_right", "edge": "right"},
{"peer": protocol.id_text(C), "kind": "notch"},
]
found = self.models(zones, notch=lambda: (100, 200))
kinds = [(peer, type(model)) for peer, model in found]
# Corners first, then edges, then parts, then the notch.
self.assertEqual(kinds, [(B, CornerPush), (B, ReturnEdge), (C, PartEdge), (C, SpanEdge)])
self.assertEqual([model.edge for _, model in found], ["right", "left", "top", "top"])
self.assertEqual({model.resistance_px for _, model in found}, {150})
self.assertEqual(found[2][1].parts, frozenset({"start", "end"}))
def test_one_peer_can_hold_edges_on_multiple_displays(self):
zones = [
{"peer": protocol.id_text(B), "kind": "edge", "display": "panel-left", "side": "right"},
{"peer": protocol.id_text(B), "kind": "part", "parts": ["middle"],
"display": "panel-right", "side": "bottom"},
]
found = self.models(zones, allowed=(B,))
self.assertEqual([(model.edge, model.display) for _, model in found],
[("right", "panel-left"), ("bottom", "panel-right")])
def test_what_is_left_out(self):
zones = [
{"peer": protocol.id_text(B), "kind": "edge", "off": True},
{"peer": "", "kind": "edge"},
{"peer": protocol.id_text(D), "kind": "edge"},
{"peer": protocol.id_text(C), "kind": "notch"},
{"peer": protocol.id_text(C), "kind": "edge"},
{"peer": "junk", "kind": "edge"},
{"peer": protocol.id_text(B), "kind": "sideways"},
]
self.assertEqual([peer for peer, _ in self.models(zones, allowed=(B, D))], [])
self.assertEqual([peer for peer, _ in self.models(zones)], [C])
def test_a_peers_zones_are_not_armed_when_it_is_not_in_use(self):
peers = [entry(B, "Bee", side="left", in_use=False)]
zones = [{"peer": protocol.id_text(B), "kind": "edge"}]
self.assertEqual(receiver.zone_models(zones, peers, {B}, 120), [])
def test_a_corner_lands_at_the_end_nearest_it(self):
self.assertEqual(receiver.corner_offset("top_right", "right"), 0.0)
self.assertEqual(receiver.corner_offset("top_right", "top"), 1.0)
self.assertEqual(receiver.corner_offset("bottom_left", "left"), 1.0)
self.assertEqual(receiver.corner_offset("bottom_left", "bottom"), 0.0)
if __name__ == "__main__":
unittest.main()
class DrivenNeverWaits(unittest.TestCase):
def test_driven_is_answered_while_the_responders_lock_is_held_by_another_thread(self):
import threading
machine = Machine([entry(B, "Bee")]).start()
self.addCleanup(machine.stop)
held, release, answered = threading.Event(), threading.Event(), []
def hold():
with machine.responder._lock:
held.set()
release.wait(3)
holder = threading.Thread(target=hold, daemon=True)
holder.start()
held.wait(3)
asker = threading.Thread(target=lambda: answered.append(machine.responder.driven), daemon=True)
asker.start()
asker.join(0.5)
release.set()
self.assertEqual(answered, [False], "driven waited for the lock")