One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
"""The owner's state machine (WIRE.md sections 4 and 5), without sockets: the messages it sends, on
which link, and what it does with this machine's input, for every event. A scripted clock drives
the timers."""
import unittest
from core import owner
from core.owner import LOCAL, Drop, Moved, Send, SendClipboard, SetClipboard, Unreachable
class Clock:
def __init__(self, now=1000.0):
self.now = now
def __call__(self):
return self.now
def key(kind, name, us=None):
data = {"key": name}
if us is not None:
data["us"] = us
return {"type": kind, "data": data}
def button(kind, name="left"):
return {"type": kind, "data": {"button": name}}
MOVE = {"type": "mousemove", "data": {"dx": 3, "dy": -1}}
def focuses(actions, peer=None):
return [a.message["data"] for a in actions
if isinstance(a, Send) and a.message["type"] == "focus" and (peer is None or a.peer == peer)]
def sent(actions, peer=None):
return [(a.peer, a.message) for a in actions if isinstance(a, Send) and (peer is None or a.peer == peer)]
def moved(actions):
found = [a for a in actions if isinstance(a, Moved)]
return found[-1] if found else None
class ByteIds(unittest.TestCase):
"""The apps name machines by their 16-byte ids, not by strings."""
def test_a_peer_that_refused_a_hand_over_stays_out_of_reach_for_three_seconds(self):
clock = Clock()
o = owner.Owner(b"A" * 16, clock)
b, c = b"B" * 16, b"C" * 16
for peer in (b, c):
o.link_up(peer, True)
o.go(b)
o.accept(b, {"route": o.route})
o.switch(b, {"route": o.route, "next": c})
actions = o.refuse(c, {"route": o.route, "why": "owned"})
stay = [a.message["data"] for a in actions if isinstance(a, Send) and a.message["data"].get("stay")]
self.assertEqual(stay[0]["reach"], [])
clock.now += owner.LEFT_OUT + 0.1
self.assertEqual(o.reach_for(b), [c])
class OwnerCase(unittest.TestCase):
def setUp(self):
self.clock = Clock()
self.o = owner.Owner("A", self.clock)
for peer in ("B", "C", "D"):
self.assertEqual(self.o.link_up(peer, True), [])
def take(self, peer, edge=None, offset=None):
actions = self.o.go(peer, edge, offset)
self.assertEqual(self.o.accept(peer, {"route": self.o.route}), [])
return actions
def switch(self, frm, nxt, route=None, **where):
return self.o.switch(frm, {"route": self.o.route if route is None else route, "next": nxt, **where})
def test_the_active_chain_keeps_every_machine_in_an_onward_crossing(self):
self.o.go("B")
self.assertEqual(self.o.chain, ("A", "B"))
self.o.switch("B", {"route": self.o.route, "next": "C"})
self.o.accept("C", {"route": self.o.route})
self.assertEqual(self.o.chain, ("A", "B", "C"))
def test_a_busy_refusal_keeps_the_machine_in_the_way_in_the_chain(self):
self.o.go("B")
self.o.refuse("B", {"route": self.o.route, "why": "busy", "other": "C"})
self.assertEqual(self.o.chain, ("A", "B", "C"))
class TakeFromHomeTests(OwnerCase):
def test_a_take_by_a_zone_carries_the_route_the_landing_the_resistance_and_the_reach(self):
actions = self.o.go("B", "left", 0.5)
self.assertEqual(focuses(actions), [{"route": 1, "target": "B", "edge": "left", "offset": 0.5,
"resistance_px": 120, "reach": ["C", "D"]}])
self.assertEqual(moved(actions), Moved("B", None, "asked", "left", 0.5))
self.assertEqual(self.o.on, "B")
self.assertEqual(self.o.reach_sent, ["C", "D"])
def test_a_take_carries_the_receiving_display_and_side(self):
self.assertEqual(focuses(self.o.go("B", "left", 0.5, display="panel-right", side="bottom")),
[{"route": 1, "target": "B", "edge": "left", "offset": 0.5,
"display": "panel-right", "side": "bottom",
"resistance_px": 120, "reach": ["C", "D"]}])
def test_a_take_by_the_shortcut_has_no_landing(self):
self.assertEqual(focuses(self.o.go("B")), [{"route": 1, "target": "B", "resistance_px": 120, "reach": ["C", "D"]}])
def test_a_phone_leaves_resistance_out(self):
phone = owner.Owner("P", self.clock, resistance_px=None)
phone.link_up("B", True)
self.assertEqual(focuses(phone.go("B")), [{"route": 1, "target": "B", "reach": []}])
def test_input_goes_at_once_without_waiting_for_the_answer(self):
self.o.go("B")
self.assertEqual(self.o.input(MOVE), [Send("B", MOVE)])
def test_at_home_input_stays_here(self):
self.assertEqual(self.o.input(MOVE), [LOCAL])
self.assertEqual(self.o.input(key("keydown", "a", "a")), [LOCAL])
def test_no_answer_within_a_second_brings_the_input_home(self):
self.o.go("B")
self.assertEqual(self.o.deadline(), 1001.0)
self.clock.now = 1000.99
self.assertEqual(self.o.tick(), [])
self.clock.now = 1001.0
actions = self.o.tick()
self.assertEqual(focuses(actions, "B"), [{"route": 2, "target": "A"}])
self.assertEqual(moved(actions), Moved(None, "B", "no_answer"))
self.assertFalse(self.o.away)
def test_an_accept_ends_the_wait(self):
self.take("B")
self.assertIsNone(self.o.deadline())
self.clock.now += 5
self.assertEqual(self.o.tick(), [])
self.assertEqual(self.o.on, "B")
def test_a_refusal_for_the_current_route_sends_the_input_home_saying_why(self):
for why in ("owned", "not_allowed", "busy", "sent_home", "malformed", "something_new"):
with self.subTest(why=why):
self.o.go("B")
actions = self.o.refuse("B", {"route": self.o.route, "why": why})
self.assertEqual(moved(actions).to, None)
self.assertEqual(moved(actions).why, why if why != "something_new" else "refused")
self.assertFalse(self.o.away)
self.clock.now += owner.SENT_HOME_FOR
def test_a_refusal_naming_the_machine_in_the_way_says_it_when_the_input_comes_home(self):
self.o.go("B")
self.assertEqual(moved(self.o.refuse("B", {"route": self.o.route, "why": "owned", "other": "C"})).other, "C")
self.clock.now += owner.SENT_HOME_FOR
self.o.go("B")
self.assertIsNone(moved(self.o.refuse("B", {"route": self.o.route, "why": "owned"})).other)
def test_a_machine_that_refused_a_take_is_not_taken_again_for_a_while(self):
# The live check, 01-10-2026: every push at the laptop's edge took the rig again while the
# Mac drove it, about 30 refusals and 30 notices in 20 seconds.
for why in ("owned", "busy", "not_allowed"):
with self.subTest(why=why):
self.o.go("B")
self.o.refuse("B", {"route": self.o.route, "why": why})
self.clock.now += owner.LEFT_OUT / 2
self.assertEqual(self.o.go("B"), [])
self.assertFalse(self.o.away)
self.clock.now += owner.LEFT_OUT / 2
self.assertEqual(moved(self.o.go("B")).to, "B")
self.o.go(None)
def test_a_machine_that_sent_this_one_home_is_left_alone_for_as_long_as_it_would_refuse(self):
# The live check, 01-10-2026: thirty "sent_home" refusals in three seconds between two machines.
self.o.go("B")
self.o.refuse("B", {"route": self.o.route, "why": "sent_home"})
self.clock.now += owner.SENT_HOME_FOR - 0.1
self.assertEqual(self.o.go("B"), [])
self.clock.now += 0.1
self.assertEqual(moved(self.o.go("B")).to, "B")
def test_the_sent_home_window_is_the_responders_own(self):
from core import receiver
self.assertEqual(owner.SENT_HOME_FOR, receiver.SENT_HOME_SECONDS)
def test_a_machine_held_back_does_not_hold_back_the_others(self):
self.o.go("B")
self.o.refuse("B", {"route": self.o.route, "why": "owned"})
self.assertEqual(moved(self.o.go("C")).to, "C")
def test_asking_for_a_machine_held_back_from_another_changes_nothing(self):
self.o.go("B")
self.o.refuse("B", {"route": self.o.route, "why": "owned"})
self.take("C")
route = self.o.route
self.assertEqual(self.o.go("B"), [])
self.assertEqual((self.o.on, self.o.route), ("C", route))
def test_a_hand_over_refused_as_sent_home_holds_back_as_long_as_the_refusal(self):
self.take("B")
self.switch("B", "C")
self.o.refuse("C", {"route": self.o.route, "why": "sent_home"})
self.clock.now += owner.SENT_HOME_FOR - 0.1
self.assertNotIn("C", self.o.reach_for(None))
self.clock.now += 0.1
self.assertIn("C", self.o.reach_for(None))
def test_a_refusal_for_an_old_route_is_ignored(self):
self.take("B")
self.o.link_up("E", True) # a stay, route 2
self.assertEqual(self.o.refuse("B", {"route": 1, "why": "owned"}), [])
self.assertEqual(self.o.on, "B")
self.assertEqual(moved(self.o.refuse("B", {"route": 2, "why": "owned"})).to, None)
def test_a_refusal_from_a_machine_the_input_is_not_on_is_ignored(self):
self.take("B")
self.assertEqual(self.o.refuse("C", {"route": self.o.route, "why": "owned"}), [])
def test_away_from_the_take_until_it_is_refused(self):
self.assertFalse(self.o.away)
self.o.go("B")
self.assertTrue(self.o.away)
self.o.refuse("B", {"route": 1, "why": "busy"})
self.assertFalse(self.o.away)
def test_two_desktops_taking_each_other_both_end_at_home_and_the_next_try_works(self):
self.o.go("B")
self.o.refuse("B", {"route": 1, "why": "busy"})
self.assertIsNone(self.o.on)
self.clock.now += owner.LEFT_OUT
self.take("B")
self.assertEqual(self.o.on, "B")
def test_a_peer_without_a_link_or_that_does_not_accept_is_not_taken(self):
self.o.link_up("E", False)
for peer in ("E", "Z"):
with self.subTest(peer=peer):
self.assertEqual(self.o.go(peer), [Unreachable(peer, "unreachable")])
self.assertFalse(self.o.away)
self.assertEqual(self.o.route, 0)
def test_going_where_the_input_already_is_does_nothing(self):
self.take("B")
self.assertEqual(self.o.go("B"), [])
self.o.go(None)
self.assertEqual(self.o.go(None), [])
self.assertEqual(self.o.go("A"), [])
class ReachTests(OwnerCase):
def test_reach_leaves_out_the_owner_the_target_and_peers_that_do_not_accept(self):
self.o.link_up("E", False)
self.assertEqual(focuses(self.o.go("B"))[0]["reach"], ["C", "D"])
def test_the_reach_is_kept_true_while_the_input_is_on_a_machine(self):
self.take("B")
self.assertEqual(focuses(self.o.link_up("E", True), "B"),
[{"route": 2, "target": "B", "stay": True, "resistance_px": 120, "reach": ["C", "D", "E"]}])
self.assertEqual(focuses(self.o.link_down("C"), "B")[0]["reach"], ["D", "E"])
self.assertEqual(focuses(self.o.accepts("D", False), "B"), [{"route": 4, "target": "B", "stay": True,
"resistance_px": 120, "reach": ["E"]}])
self.assertEqual(self.o.accepts("D", False), [])
self.assertEqual(self.o.reach_sent, ["E"])
def test_at_home_a_link_changing_sends_nothing(self):
self.assertEqual(self.o.link_up("E", True), [])
self.assertEqual(self.o.link_down("E"), [])
self.assertEqual(self.o.route, 0)
def test_accepts_for_a_peer_with_no_link_is_ignored(self):
self.take("B")
self.assertEqual(self.o.accepts("E", True), [])
class SwitchTests(OwnerCase):
def test_a_takeover_sends_input_home_with_the_new_driver(self):
self.take("B")
actions = self.switch("B", "A", taken_over_by="C")
self.assertEqual(moved(actions), Moved(None, "B", "taken_over", other="C"))
def test_a_switch_naming_the_owner_brings_the_input_home_landing_where_it_says(self):
self.take("B")
actions = self.switch("B", "A", edge="right", offset=0.25)
self.assertEqual(focuses(actions, "B"), [{"route": 2, "target": "A"}])
self.assertEqual(moved(actions), Moved(None, "B", "switch", "right", 0.25))
def test_a_send_home_with_an_old_route_is_honoured_within_the_visit(self):
self.take("B")
self.o.link_up("E", True) # a re-arm crossing B's send-home
self.assertEqual(moved(self.switch("B", "A", route=1)).to, None)
def test_a_send_home_from_an_earlier_visit_or_another_machine_is_ignored(self):
self.take("B") # route 1
self.take("C") # route 2
self.take("B") # route 3
for route in (1, 2):
self.assertEqual(self.switch("B", "A", route=route), [])
self.assertEqual(self.switch("C", "A", route=3), [])
self.assertEqual(self.o.on, "B")
def test_a_stale_switch_is_ignored(self):
self.take("B")
for _ in range(2): # four re-arms, to route 5
self.o.link_up("E", True)
self.o.link_down("E")
self.assertEqual(self.o.route, 5)
self.o.go("C") # the shortcut, route 6
self.assertEqual(self.switch("B", "D", route=5), [])
self.assertEqual(self.o.on, "C")
def test_a_switch_older_than_a_re_arm_is_ignored(self):
self.take("B")
self.o.link_up("E", True)
self.assertEqual(self.switch("B", "C", route=1), [])
self.assertEqual(self.o.on, "B")
def test_a_switch_from_a_machine_the_input_is_not_on_is_ignored(self):
self.take("B")
self.assertEqual(self.switch("C", "D"), [])
self.assertEqual(self.switch("C", "A"), [])
def test_the_chain_hand_over_waits_for_the_accept_holding_the_input(self):
self.take("B")
self.assertEqual(self.o.input(key("keydown", "a", "a")), [Send("B", key("keydown", "a", "a"))])
actions = self.switch("B", "C", edge="left", offset=0.5)
self.assertEqual(sent(actions), [("C", {"type": "focus", "data": {
"route": 2, "target": "C", "edge": "left", "offset": 0.5, "resistance_px": 120, "reach": ["B", "D"]}})])
self.assertEqual(self.o.on, "B")
self.assertTrue(self.o.away)
self.assertEqual(self.o.input(MOVE), [])
self.assertEqual(self.o.input(key("keyup", "a", "a")), [])
actions = self.o.accept("C", {"route": 2})
self.assertEqual(sent(actions), [
("B", key("keyup", "a", "a")),
("B", {"type": "focus", "data": {"route": 2, "target": "C"}}),
("C", MOVE),
])
self.assertEqual([a for a in actions if isinstance(a, SendClipboard)], [SendClipboard("C")])
clip_at = actions.index(SendClipboard("C"))
self.assertLess(actions.index(Send("B", {"type": "focus", "data": {"route": 2, "target": "C"}})), clip_at)
self.assertLess(clip_at, actions.index(Send("C", MOVE)))
self.assertEqual(moved(actions), Moved("C", "B", "switch", "left", 0.5))
self.assertEqual(self.o.on, "C")
self.assertEqual(self.o.reach_sent, ["B", "D"])
def test_a_hand_over_refused_names_the_machine_in_the_way(self):
# Opus review: an onward hand-over refused as owned came back as Unreachable without `other`.
self.take("B")
self.switch("B", "C")
actions = self.o.refuse("C", {"route": 2, "why": "owned", "other": "D"})
self.assertIn(Unreachable("C", "owned", "D"), actions)
def test_a_refusal_from_the_next_machine_re_arms_the_one_left_leaving_it_out_for_three_seconds(self):
self.take("B")
self.switch("B", "C")
self.o.input(MOVE)
actions = self.o.refuse("C", {"route": 2, "why": "owned"})
self.assertEqual(sent(actions), [
("B", {"type": "focus", "data": {"route": 3, "target": "B", "stay": True, "resistance_px": 120, "reach": ["D"]}}),
("B", MOVE),
])
self.assertIn(Unreachable("C", "owned"), actions)
self.assertIsNone(moved(actions))
self.assertEqual(self.o.on, "B")
self.assertEqual(self.o.deadline(), 1003.0)
self.clock.now = 1003.0
self.assertEqual(focuses(self.o.tick(), "B"), [{"route": 4, "target": "B", "stay": True, "resistance_px": 120,
"reach": ["C", "D"]}])
def test_no_answer_from_the_next_machine_re_arms_the_one_left(self):
self.take("B")
self.switch("B", "C")
self.clock.now = 1000.99
self.assertEqual(self.o.tick(), [])
self.clock.now = 1001.0
actions = self.o.tick()
self.assertEqual(focuses(actions, "B")[0]["reach"], ["D"])
self.assertIn(Unreachable("C", "no_answer"), actions)
self.assertEqual(focuses(actions, "C"), [])
def test_a_late_accept_is_let_go_naming_where_the_input_is_now(self):
# A hand-over given up closes its link, so what is still let go late is a take from home
# or from the owner's own shortcut, on a link that stayed up.
self.take("B")
self.o.go("C") # route 2, eager: B let go, C taken
self.o.go("D") # route 3, before C answered: C let go, D taken
self.assertEqual(sent(self.o.accept("C", {"route": 2})),
[("C", {"type": "focus", "data": {"route": 3, "target": "D"}})])
self.assertEqual(self.o.on, "D")
def test_a_late_accept_on_a_link_closed_for_it_is_ignored(self):
# Read before the link closed, and acted on after: the close already ended that ownership.
self.take("B")
self.switch("B", "C")
self.clock.now = 1001.0
self.assertIn(Drop("C"), self.o.tick())
self.assertEqual(self.o.accept("C", {"route": 2}), [])
self.assertEqual(self.o.on, "B")
def test_a_late_accept_after_coming_home_names_the_owner(self):
self.o.go("C")
self.clock.now = 1001.0
self.o.tick() # home, route 2
self.assertEqual(sent(self.o.accept("C", {"route": 1})),
[("C", {"type": "focus", "data": {"route": 2, "target": "A"}})])
def test_an_abandoned_hand_over_closes_the_next_machines_link_before_the_input_goes_anywhere(self):
# Its `accept` may still be on the way: closing the link is what ends an ownership nobody
# will use, however late that accept is or however long the owner remembers the take.
abandon = {
"no answer": lambda: (setattr(self.clock, "now", 1001.0), self.o.tick())[1],
"the shortcut home": lambda: self.o.go(None),
"the shortcut to the machine it is on": lambda: self.o.go("B"),
"the shortcut to a third machine": lambda: self.o.go("D"),
"a send-home from the machine left": lambda: self.switch("B", "A", route=1),
"the link to the machine left lost": lambda: self.o.link_down("B"),
}
for how, event in abandon.items():
with self.subTest(how=how):
self.setUp()
self.take("B")
self.switch("B", "C")
actions = event()
self.assertEqual([a for a in actions if isinstance(a, Drop)], [Drop("C")])
self.assertIsInstance(actions[0], Drop)
self.assertNotIn("C", self.o.reach_for(self.o.on))
def test_a_hand_over_answered_or_already_gone_closes_nothing(self):
answered = {
"refused": lambda: self.o.refuse("C", {"route": 2, "why": "owned"}),
"accepted": lambda: self.o.accept("C", {"route": 2}),
"its link lost": lambda: self.o.link_down("C"),
"taken again from here, on the same link": lambda: self.o.go("C"),
}
for how, event in answered.items():
with self.subTest(how=how):
self.setUp()
self.take("B")
self.switch("B", "C")
self.assertEqual([a for a in event() if isinstance(a, Drop)], [])
def test_a_take_from_home_with_no_answer_is_let_go_on_its_own_link_and_closes_nothing(self):
self.o.go("C")
self.clock.now = 1001.0
actions = self.o.tick()
self.assertEqual([a for a in actions if isinstance(a, Drop)], [])
self.assertEqual(focuses(actions, "C"), [{"route": 2, "target": "A"}])
def test_an_accept_for_a_route_never_taken_there_is_ignored(self):
self.take("B")
self.switch("B", "C")
self.assertEqual(self.o.accept("C", {"route": 99}), [])
self.assertEqual(self.o.accept("D", {"route": 2}), [])
self.assertEqual(self.o.accept("C", {"route": 1}), [])
self.assertEqual(self.o.on, "B")
def test_a_send_home_while_waiting_ends_the_wait_and_no_stay_follows(self):
self.take("B")
self.switch("B", "C")
self.assertEqual(moved(self.switch("B", "A", route=1)).to, None)
self.clock.now += 5
self.assertEqual(self.o.tick(), [])
def test_losing_the_link_to_the_machine_left_while_waiting_brings_the_input_home(self):
self.take("B")
self.switch("B", "C")
actions = self.o.link_down("B")
self.assertEqual(sent(actions), [])
self.assertEqual(moved(actions), Moved(None, "B", "link_lost"))
self.clock.now += 5
self.assertEqual(self.o.tick(), [])
def test_the_shortcut_while_waiting_ends_the_wait(self):
self.take("B")
self.switch("B", "C")
actions = self.o.go("D")
self.assertEqual(focuses(actions), [{"route": 3, "target": "D"},
{"route": 3, "target": "D", "resistance_px": 120, "reach": ["B"]}])
self.assertEqual(sent(actions)[0][0], "B")
self.o.accept("D", {"route": 3})
self.clock.now = 1001.0
self.assertEqual(self.o.tick(), [])
self.assertEqual(self.o.on, "D")
def test_the_shortcut_to_the_machine_waited_on_from_re_arms_it(self):
self.take("B")
self.switch("B", "C")
self.o.input(MOVE)
actions = self.o.go("B")
self.assertEqual(sent(actions), [
("B", {"type": "focus", "data": {"route": 3, "target": "B", "stay": True, "resistance_px": 120,
"reach": ["D"]}}),
("B", MOVE),
])
self.clock.now = 1001.0
self.assertEqual(self.o.tick(), [])
def test_losing_the_link_to_the_next_machine_while_waiting_is_a_refusal(self):
self.take("B")
self.switch("B", "C")
actions = self.o.link_down("C")
self.assertEqual(focuses(actions, "B")[0]["stay"], True)
self.assertIn(Unreachable("C", "link_lost"), actions)
def test_a_switch_to_a_peer_outside_the_reach_last_sent_is_unreachable_even_with_a_link(self):
self.take("B")
self.switch("B", "C")
self.o.refuse("C", {"route": 2, "why": "owned"}) # C left out; the stay is route 3
self.assertNotIn("C", self.o.reach_sent)
actions = self.switch("B", "C")
self.assertEqual(focuses(actions, "C"), [])
self.assertEqual(focuses(actions, "B")[0]["route"], 4)
self.assertIn(Unreachable("C", "unreachable"), actions)
def test_a_switch_to_a_peer_whose_link_dropped_is_unreachable_without_asking_it(self):
self.take("B")
self.assertEqual(focuses(self.o.link_down("C"), "B")[0]["reach"], ["D"])
actions = self.switch("B", "C")
self.assertEqual(sent(actions, "C"), [])
self.assertTrue(focuses(actions, "B")[0]["stay"])
self.assertIn(Unreachable("C", "unreachable"), actions)
def test_a_switch_without_a_landing_takes_without_one(self):
self.take("B")
self.assertNotIn("edge", focuses(self.switch("B", "C"), "C")[0])
class ComingHomeTests(OwnerCase):
def test_every_trigger_brings_the_input_home_saying_why(self):
triggers = {
"asked": lambda: self.o.go(None),
"switch": lambda: self.switch("B", "A"),
"owned": lambda: self.o.refuse("B", {"route": self.o.route, "why": "owned"}),
"link_lost": lambda: self.o.link_down("B"),
}
for why, trigger in triggers.items():
with self.subTest(why=why):
self.o.link_up("B", True)
self.take("B")
self.o.input(key("keydown", "shift"))
actions = trigger()
self.assertEqual(moved(actions), Moved(None, "B", why))
if why == "link_lost":
self.assertEqual(sent(actions), [])
else:
self.assertEqual(sent(actions), [("B", key("keyup", "shift")),
("B", {"type": "focus", "data": {"route": self.o.route, "target": "A"}})])
self.assertEqual(self.o.input(key("keyup", "shift")), [])
self.assertEqual(self.o.input(key("keyup", "shift")), [LOCAL])
self.clock.now += owner.LEFT_OUT
def test_the_owner_releases_what_it_pressed_there_before_letting_go(self):
self.take("B")
self.o.input(key("keydown", "shift"))
self.o.input(button("mousedown", "left"))
self.o.input(key("keydown", "A", "a"))
self.o.input(key("keyup", "A", "a"))
actions = self.o.go("C")
self.assertEqual(sent(actions, "B"), [
("B", key("keyup", "shift")),
("B", button("mouseup", "left")),
("B", {"type": "focus", "data": {"route": 2, "target": "C"}}),
])
self.assertEqual(self.o.input(key("keyup", "shift")), [])
self.assertEqual(self.o.input(button("mouseup", "left")), [])
self.assertEqual(self.o.input(key("keyup", "shift")), [Send("C", key("keyup", "shift"))])
def test_a_key_still_held_from_the_machine_left_repeats_nowhere(self):
self.take("B")
self.o.input(key("keydown", "a", "a"))
self.o.go(None)
self.assertEqual(self.o.input(key("keydown", "a", "a")), [])
self.assertEqual(self.o.input(key("keyup", "a", "a")), [])
self.assertEqual(self.o.input(key("keydown", "a", "a")), [LOCAL])
def test_input_held_for_a_hand_over_that_ends_at_home_goes_nowhere(self):
self.take("B")
self.switch("B", "C")
self.o.input(key("keydown", "x", "x"))
actions = self.switch("B", "A", route=1)
self.assertEqual(sent(actions, "C"), [])
self.assertEqual([m for p, m in sent(actions, "B") if m["type"] != "focus"], [])
self.assertEqual(self.o.input(key("keyup", "x", "x")), [])
class PressedHereTests(OwnerCase):
def test_a_key_pressed_here_is_released_here_after_the_input_leaves(self):
self.assertEqual(self.o.input(key("keydown", "ctrl")), [LOCAL])
self.take("B")
self.assertEqual(self.o.input(key("keydown", "ctrl")), [])
self.assertEqual(self.o.input(key("keyup", "ctrl")), [LOCAL])
self.assertEqual(self.o.input(key("keydown", "ctrl")), [Send("B", key("keydown", "ctrl"))])
def test_a_key_pressed_here_is_released_here_during_a_hand_over(self):
self.o.input(key("keydown", "ctrl"))
self.take("B")
self.switch("B", "C")
self.assertEqual(self.o.input(key("keyup", "ctrl")), [LOCAL])
def test_a_button_pressed_here_is_released_here(self):
self.o.input(button("mousedown"))
self.take("B")
self.assertEqual(self.o.input(button("mouseup")), [LOCAL])
class LinkTests(OwnerCase):
def test_a_second_link_from_the_peer_the_input_is_on_ends_the_visit(self):
self.take("B")
self.assertEqual(moved(self.o.link_up("B", True)), Moved(None, "B", "link_lost"))
self.assertIn("B", self.o.reach_for("C"))
def test_a_refusal_of_the_take_counts_while_a_re_arm_is_crossing_it(self):
self.o.go("C")
self.o.link_up("E", True) # a stay, route 2, before C answers the take
self.assertEqual(moved(self.o.refuse("C", {"route": 1, "why": "owned"})), Moved(None, "C", "owned"))
def test_a_take_is_forgotten_after_a_while(self):
self.o.go("B")
self.clock.now = 1001.0
self.o.tick()
self.clock.now = 1040.0
self.take("C")
self.assertEqual(self.o.accept("B", {"route": 1}), [])
class ClipboardTests(OwnerCase):
def test_a_copy_during_a_failed_chain_take_goes_before_replayed_input(self):
for outcome in ("refused", "timeout", "link_lost"):
with self.subTest(outcome=outcome):
clock = Clock()
o = owner.Owner("A", clock)
o.link_up("B", True)
o.link_up("C", True)
o.go("B")
o.accept("B", {"route": o.route})
o.switch("B", {"route": o.route, "next": "C"})
o.clipboard_changed()
self.assertEqual(o.clipboard_pending(), [])
paste = key("keydown", "v")
o.input(paste)
if outcome == "refused":
actions = o.refuse("C", {"route": o.route, "why": "owned"})
elif outcome == "timeout":
clock.now += owner.TAKE_WAIT
actions = o.tick()
else:
actions = o.link_down("C")
self.assertIn(SendClipboard("B"), actions)
self.assertLess(actions.index(SendClipboard("B")), actions.index(Send("B", paste)))
def test_a_failed_read_or_post_remains_pending_for_a_later_attempt(self):
self.take("B")
self.o.clipboard_failed("B")
self.assertEqual(self.o.clipboard_pending(), [SendClipboard("B")])
self.assertEqual(self.o.clipboard_pending(), [])
def test_a_copy_after_a_crossing_reaches_the_active_peer(self):
self.take("B")
for _ in range(50):
self.o.clipboard_changed()
self.assertEqual(self.o.clipboard_pending(), [SendClipboard("B")])
self.assertEqual(self.o.clipboard_pending(), [])
self.o.go(None)
self.o.clipboard_changed()
self.assertEqual(self.o.clipboard_pending(), [])
def test_a_retry_waits_for_the_take_to_be_accepted(self):
self.o.go("B")
self.o.clipboard_failed("B")
self.assertEqual(self.o.clipboard_pending(), [])
self.o.accept("B", {"route": self.o.route})
self.assertEqual(self.o.clipboard_pending(), [SendClipboard("B")])
def test_a_frame_started_before_let_go_cannot_consume_the_return_clipboard(self):
self.take("B")
self.o.go(None)
message = {"type": "clipboard", "data": {"text": "copied on B"}}
self.assertFalse(self.o.expects_clipboard("B", 999.9))
self.assertEqual(self.o.clipboard_arrived("B", 999.9, message), [])
self.assertEqual(self.o.clipboard_arrived("B", 1000.1, message), [SetClipboard(message)])
def test_a_refused_take_does_not_count_as_having_the_clipboard(self):
self.o.go("B")
self.o.refuse("B", {"route": 1, "why": "owned"})
self.clock.now += owner.LEFT_OUT
self.assertIn(SendClipboard("B"), self.take("B"))
def test_the_machine_left_keeps_its_clipboard_when_the_next_one_refuses_first(self):
self.take("B")
self.o.go("C")
self.o.refuse("C", {"route": 2, "why": "owned"})
message = {"type": "clipboard", "data": {"text": "copied on B"}}
self.assertEqual(self.o.clipboard_arrived("B", 1000.25, message), [SetClipboard(message)])
def test_a_machine_whose_link_was_lost_is_sent_the_clipboard_again(self):
# Its clipboard may still have been on the way, or waiting behind a slow read, when the link went.
self.take("B")
self.o.link_down("B")
self.o.link_up("B", True)
self.assertIn(SendClipboard("B"), self.take("B"))
def test_the_clipboard_goes_after_the_taking_focus_and_before_any_input(self):
actions = self.o.go("B")
focus_at = next(i for i, a in enumerate(actions) if isinstance(a, Send))
self.assertEqual(actions.index(SendClipboard("B")), focus_at + 1)
def test_the_clipboard_goes_only_where_it_is_not_already(self):
self.take("B")
self.o.go(None)
self.assertNotIn(SendClipboard("B"), self.take("B"))
self.o.go(None)
self.o.clipboard_changed()
self.assertIn(SendClipboard("B"), self.take("B"))
def test_the_machine_let_go_may_send_its_clipboard_once_within_ten_seconds(self):
self.take("B")
self.o.go(None)
message = {"type": "clipboard", "data": {"text": "copied on B"}}
self.assertEqual(self.o.clipboard_arrived("C", 1000.5, message), [])
self.assertEqual(self.o.clipboard_arrived("B", 1010.0, message), [SetClipboard(message)])
self.assertEqual(self.o.clipboard_arrived("B", 1010.0, message), [])
def test_only_a_machine_just_let_go_is_expected_to_send_a_clipboard(self):
# What a link asks before it reads a frame too large for anything but a clipboard.
self.assertFalse(self.o.expects_clipboard("B", 1000.0))
self.take("B")
self.assertFalse(self.o.expects_clipboard("B", 1000.0))
self.o.go(None)
self.assertTrue(self.o.expects_clipboard("B", 1000.5))
self.assertFalse(self.o.expects_clipboard("C", 1000.5))
# By when the frame began, as clipboard_arrived judges it: a large one on a slow link that
# began in time and finished a minute later is still the clipboard it would take.
self.clock.now += 60
self.assertTrue(self.o.expects_clipboard("B", 1010.0))
self.assertFalse(self.o.expects_clipboard("B", 1010.01))
def test_a_machine_whose_clipboard_came_is_not_expected_again(self):
self.take("B")
self.o.go(None)
self.o.clipboard_arrived("B", 1000.5, {"type": "clipboard", "data": {"text": "x"}})
self.assertFalse(self.o.expects_clipboard("B", 1000.6))
def test_a_clipboard_beginning_more_than_ten_seconds_after_the_let_go_is_dropped(self):
self.take("B")
self.o.go(None)
self.assertEqual(self.o.clipboard_arrived("B", 1010.01, {"type": "clipboard", "data": {"text": "x"}}), [])
def test_in_a_chain_the_clipboard_of_the_machine_left_goes_on_to_the_next(self):
self.take("B")
self.switch("B", "C")
self.o.accept("C", {"route": 2})
message = {"type": "clipboard", "data": {"text": "copied on B"}}
self.assertEqual(self.o.clipboard_arrived("B", 1000.1, message), [SetClipboard(message), Send("C", message)])
def test_a_clipboard_brought_home_goes_to_the_next_machine_taken_and_not_back(self):
self.take("B")
self.take("C")
self.o.go(None)
self.o.clipboard_arrived("C", 1000.1, {"type": "clipboard", "data": {"text": "copied on C"}})
self.assertIn(SendClipboard("B"), self.take("B"))
self.o.go(None)
self.assertNotIn(SendClipboard("C"), self.take("C"))
class RouteTests(OwnerCase):
def test_routes_only_rise_and_each_hand_over_shares_one(self):
self.take("B")
seen = [1]
ring = ["B", "C", "D"]
for n in range(1000):
here, there = ring[n % 3], ring[(n + 1) % 3]
if n % 2:
actions = self.switch(here, there)
taking = focuses(actions, there)
actions = self.o.accept(there, {"route": taking[0]["route"]})
letting_go = focuses(actions, here)
else:
actions = self.o.go(there)
taking, letting_go = focuses(actions, there), focuses(actions, here)
self.o.accept(there, {"route": taking[0]["route"]})
self.assertEqual(letting_go[0]["target"], there)
self.assertEqual(taking[0]["route"], letting_go[0]["route"])
self.assertGreater(taking[0]["route"], seen[-1])
seen.append(taking[0]["route"])
self.assertEqual(self.o.on, there)
self.assertEqual(self.o.route, seen[-1])
if __name__ == "__main__":
unittest.main()