One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
"""core.link.OutboundLink, the initiator's side of WIRE.md sections 2, 3 and 9, against a real
LinkResponder on loopback (responder_harness.Machine) and a scripted responder where a test needs
a peer that misbehaves."""
import errno
import socket
import struct
import threading
import time
import unittest
from unittest import mock
from core import protocol, receiver
from core import link as link_module
from core.link import OutboundLink
from core.tests.responder_harness import B, C, CAPS, HERE, TOKENS, Machine, Settings, entry, wait_for
LOOPBACK = "127.0.0.1"
class Side:
"""The initiator's own settings, with one peer entry for the machine it dials."""
def __init__(self, machine=None, peer=HERE, own=B, token=None, **fields):
port = machine.port if machine is not None else 24820
data = entry(peer, "Far", token=token or TOKENS[B], host=LOOPBACK, port=port, send=True, **fields)
self.settings = Settings([data])
self.settings.data["machine_id"] = protocol.id_text(own)
self.own = own
self.book = receiver.PeerBook(self.settings.load, self.settings.save)
self.states, self.ups, self.messages = [], [], []
def identity(self, **fields):
data = {"id": self.own, "name": "Near", "platform": "macos", "app": "1.5.0", "caps": list(CAPS), "port": 24820}
data.update(fields)
return data
def link(self, **kwargs):
kwargs.setdefault("reconnect_seconds", 0.05)
link = OutboundLink(
self.settings.data["peers"][0]["token"], self.book, self.identity,
state=lambda link, up, text: self.states.append((up, text)),
up=lambda link, fields: self.ups.append(fields),
message=lambda link, message: self.messages.append(message),
**kwargs,
)
return link
def peer(self):
return self.settings.data["peers"][0]
def last_text(self):
return self.states[-1][1] if self.states else None
def machine_with_peer(**kwargs):
from core.tests.responder_harness import entry as make
return Machine([make(B, "Peer")], **kwargs).start()
class ResponseTimeLinkTests(unittest.TestCase):
def test_capable_initiator_keeps_legacy_peer_pings_empty(self):
pings = []
def script(connection):
session, _hello = scripted_session(connection, TOKENS[B])
protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.1", CAPS, True))
connection.settimeout(3)
while len(pings) < 2:
message = protocol.recv_msg(connection, session)
if message["type"] == protocol.MSG_PING:
pings.append(message)
protocol.send_msg(connection, session, protocol.ack_v6(0, 0))
server = Scripted(script)
self.addCleanup(server.stop)
side = Side(None)
side.peer()["port"] = server.port
identity = side.identity
side.identity = lambda: identity(caps=list(CAPS) + ["ping_rtt"])
link = side.link(reconnect_seconds=30)
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: len(pings) >= 2, 4.0), pings)
self.assertTrue(side.ups)
self.assertTrue(all(message["data"] == {} for message in pings))
self.assertIsNone(link.response_time_ms)
def test_ping_responses_do_not_credit_or_acknowledge_stalled_input(self):
now = [10.0]
link = Side(None).link(clock=lambda: now[0])
link._live = True
link._response_time_enabled = True
link._written_seq = 1
link._sent_at.append((1, now[0]))
probe = link._response_time.new_probe()
link._response_time.sent(probe)
now[0] += 0.02
link._handle_ping(protocol.ping_msg(echo=probe))
self.assertEqual(link.response_time_ms, 20)
self.assertEqual(link._last_ack_seq, -1)
self.assertIsNone(link.last_ack_at)
self.assertEqual(link._ack_stall_credit, {})
now[0] = 10.0 + link_module.ACK_STALL_SECONDS + 0.01
with self.assertRaisesRegex(link_module.LinkEnded, "stopped acknowledging input"):
link._tick(now[0])
def test_negotiated_probes_measure_both_link_directions_and_clear_on_close(self):
caps = tuple(CAPS) + ("ping_rtt",)
machine = machine_with_peer(caps=caps)
self.addCleanup(machine.stop)
side = Side(machine)
side.identity = lambda: {
"id": side.own, "name": "Near", "platform": "macos", "app": "1.5.2",
"caps": list(caps), "port": 24820,
}
link = side.link()
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: link.response_time_ms is not None, 5.0))
self.assertIsNotNone(machine.responder.response_time_ms(B))
deadline = time.monotonic() + 3.2
while time.monotonic() < deadline:
self.assertTrue(link.send_input(protocol.mousemove_msg(1, 0)))
time.sleep(0.02)
self.assertIsNotNone(link.response_time_ms)
self.assertIsNotNone(machine.responder.response_time_ms(B))
link.stop()
self.assertIsNone(link.response_time_ms)
self.assertTrue(wait_for(lambda: machine.responder.response_time_ms(B) is None))
class Scripted:
"""A listener that runs `script(connection)` for each connection."""
def __init__(self, script):
self.script = script
self.listener = socket.socket()
self.listener.bind((LOOPBACK, 0))
self.listener.listen(4)
self.port = self.listener.getsockname()[1]
self.connections = 0
self.stopped = False
self.thread = threading.Thread(target=self._serve, daemon=True)
self.thread.start()
def _serve(self):
while not self.stopped:
try:
connection, _ = self.listener.accept()
except OSError:
return
self.connections += 1
threading.Thread(target=self._one, args=(connection,), daemon=True).start()
def _one(self, connection):
try:
self.script(connection)
except Exception:
pass
finally:
try:
connection.close()
except OSError:
pass
def stop(self):
self.stopped = True
self.listener.close()
def scripted_session(connection, token):
"""The responder's half of the handshake up to its own preamble; the session and hello."""
session = protocol.LinkSession(token, protocol.ROLE_RESPONDER)
session.accept_preamble(protocol.recv_link_preamble(connection, time.monotonic() + 5))
connection.sendall(session.preamble())
hello = protocol.read_hello(protocol.recv_first_msg(connection, session, time.monotonic() + 5))
return session, hello
class LinkHandshakeTests(unittest.TestCase):
def setUp(self):
self.machine = machine_with_peer()
self.addCleanup(self.machine.stop)
def start(self, side, **kwargs):
link = side.link(**kwargs)
self.addCleanup(link.stop)
link.start()
return link
def test_links_and_saves_what_the_welcome_taught(self):
side = Side(self.machine)
link = self.start(side)
self.assertTrue(wait_for(lambda: side.ups), side.states)
fields = side.ups[0]
self.assertEqual(fields["id"], HERE)
self.assertTrue(fields["accepts"])
self.assertEqual(fields["platform"], "windows")
self.assertIn("clipboard", fields["caps"])
self.assertTrue(link.live())
self.assertTrue(side.peer()["linked"])
self.assertEqual(side.peer()["name"], "Here")
self.assertEqual(link.peer_id, protocol.id_text(HERE))
self.assertTrue(wait_for(lambda: self.machine.links))
def test_accepts_is_false_when_the_peer_does_not_let_this_machine_drive(self):
self.machine.settings.peer(TOKENS[B])["allow_drive"] = False
side = Side(self.machine)
self.start(side)
self.assertTrue(wait_for(lambda: side.ups), side.states)
self.assertFalse(side.ups[0]["accepts"])
def test_a_different_id_than_the_entry_has_is_refused_and_taught_nothing(self):
side = Side(self.machine, peer=ident_other())
self.start(side)
self.assertTrue(wait_for(lambda: side.states and not side.states[-1][0]), side.states)
self.assertEqual(side.ups, [])
self.assertIn("different Beamer", side.last_text())
def test_a_typed_token_is_never_dialled(self):
side = Side(self.machine, token="hunter2")
link = self.start(side)
time.sleep(0.4)
self.assertEqual(self.machine.links, [])
self.assertFalse(link.live())
def test_a_migrated_entry_is_never_dialled_whatever_its_token(self):
for fields in ({"linked": False, "id": ""}, {"linked": True}):
with self.subTest(fields=fields):
side = Side(self.machine, from_1_4=True)
side.peer().update(fields)
now = [1000.0]
link = self.start(side, clock=lambda: now[0])
time.sleep(0.4)
self.assertEqual(self.machine.links, [])
self.assertFalse(link.live())
now[0] += 60
link.follow([{"name": "Far", "address": "127.0.0.2"}])
self.assertIsNone(link._try_host)
link.stop()
def test_send_off_is_not_dialled(self):
side = Side(self.machine)
side.peer()["send"] = False
self.start(side)
time.sleep(0.3)
self.assertEqual(self.machine.links, [])
def test_a_peer_that_does_not_know_the_key_id_closes_and_the_text_follows_linked(self):
for linked, expected in ((False, "Update Beamer on Far to 1.5.0"), (True, "closed the connection")):
side = Side(self.machine, token=other_token(), linked=linked)
link = self.start(side)
self.assertTrue(wait_for(lambda: side.states and not side.states[-1][0]), side.states)
self.assertIn(expected, side.last_text())
link.stop()
def test_an_entry_removed_stops_the_link(self):
side = Side(self.machine)
link = self.start(side)
self.assertTrue(wait_for(lambda: side.ups))
side.settings.data["peers"].clear()
self.assertTrue(wait_for(lambda: not link.live() and not link.running, 5.0))
def test_one_failed_read_of_the_settings_does_not_end_the_link(self):
side = Side(self.machine)
reads = []
load = side.settings.load
def flaky():
reads.append(1)
if len(reads) == 1:
raise PermissionError("settings.json is locked")
return load()
side.book = receiver.PeerBook(flaky, side.settings.save)
link = self.start(side)
self.assertTrue(wait_for(lambda: side.ups, 5.0), side.states)
self.assertTrue(link.running)
def ident_other():
return bytes((200 + i) % 256 for i in range(1, 17))
def other_token():
import base64
return base64.urlsafe_b64encode(bytes((9 + i) % 256 for i in range(32))).decode("ascii").rstrip("=")
class LinkRefusalTests(unittest.TestCase):
def serve(self, script):
server = Scripted(script)
self.addCleanup(server.stop)
return server
def link(self, side, **kwargs):
link = side.link(**kwargs)
self.addCleanup(link.stop)
link.start()
return link
def test_a_version_5_peer_is_named_as_older(self):
def script(connection):
connection.recv(62)
connection.sendall(b"BEAMY\x05" + bytes(8))
time.sleep(0.5)
server = self.serve(script)
side = Side(None)
side.peer()["port"] = server.port
self.link(side)
self.assertTrue(wait_for(lambda: side.states), side.states)
self.assertIn("Update Beamer on Far: it is older than this one", side.last_text())
def test_two_machines_of_one_name_are_told_apart_in_what_the_link_says(self):
def script(connection):
connection.recv(62)
connection.sendall(b"BEAMY\x05" + bytes(8))
time.sleep(0.5)
server = self.serve(script)
side = Side(None)
side.peer()["port"] = server.port
side.peer()["name"] = "Studio"
twin = entry(C, "studio", token=TOKENS[C], host="192.0.2.9", port=24820, send=True)
side.settings.data["peers"].append(twin)
self.link(side)
self.assertTrue(wait_for(lambda: side.states), side.states)
self.assertIn(f"Update Beamer on Studio ({protocol.id_text(HERE)[-4:]}): it is older than this one", side.last_text())
def test_a_newer_peer_says_this_machine_is_older(self):
def script(connection):
connection.recv(62)
connection.sendall(b"BEAMY\x07" + bytes(8))
time.sleep(0.5)
server = self.serve(script)
side = Side(None)
side.peer()["port"] = server.port
self.link(side)
self.assertTrue(wait_for(lambda: side.states))
self.assertIn("newer Beamer", side.last_text())
def test_a_peer_that_is_not_a_beamer_is_said_to_be_one_from_before_version_4(self):
def script(connection):
connection.recv(62)
time.sleep(6)
server = self.serve(script)
side = Side(None)
side.peer()["port"] = server.port
self.link(side)
self.assertTrue(wait_for(lambda: side.states, 8.0), side.states)
self.assertIn("before version 4", side.last_text())
def test_a_peer_that_answers_with_something_else_is_said_not_to_be_a_beamer(self):
def script(connection):
connection.recv(62)
connection.sendall(b"HTTP/1.1 400 Bad Request\r\n\r\n")
time.sleep(0.5)
server = self.serve(script)
side = Side(None)
side.peer()["port"] = server.port
self.link(side)
self.assertTrue(wait_for(lambda: side.states), side.states)
self.assertEqual(side.last_text(), "Far did not answer as a Beamer")
def test_a_responder_that_names_another_key_id_is_a_different_beamer(self):
def script(connection):
connection.recv(62)
connection.sendall(b"BEAMY\x06" + bytes(8) + bytes(16) + bytes(32))
time.sleep(0.5)
server = self.serve(script)
side = Side(None)
side.peer()["port"] = server.port
self.link(side)
self.assertTrue(wait_for(lambda: side.states))
self.assertIn("different Beamer", side.last_text())
def test_wrong_id_stops_dialling_until_the_entry_changes(self):
def script(connection):
session, _ = scripted_session(connection, TOKENS[B])
protocol.send_msg(connection, session, protocol.wrong_id_v6())
time.sleep(0.3)
server = self.serve(script)
side = Side(None)
side.peer()["port"] = server.port
link = self.link(side)
self.assertTrue(wait_for(lambda: side.states))
self.assertIn("under another machine: use Re-pair on Overview", side.last_text())
self.assertEqual(side.peer().get("dormant_reason"), "wrong_id")
seen = server.connections
time.sleep(0.5)
self.assertEqual(server.connections, seen)
side.peer()["host"] = "localhost"
self.assertTrue(wait_for(lambda: server.connections > seen, 3.0))
link.stop()
def closing_peer(self, **fields):
"""A peer that closes every handshake unanswered, dialled with a clock the test turns."""
def script(connection):
connection.recv(62)
server = self.serve(script)
side = Side(None, **fields)
side.peer()["port"] = server.port
now = [1000.0]
return server, side, now
def seen(self, side, count):
return wait_for(lambda: len(side.states) >= count, 5.0)
def test_a_machine_that_closes_unanswered_for_a_minute_is_said_to_have_removed_this_one_and_dialled_slowly(self):
# 06-10-2026: the lent laptop dialled the rig every two seconds on a pairing the rig no longer had.
server, side, now = self.closing_peer(linked=True)
self.link(side, clock=lambda: now[0])
self.assertTrue(self.seen(side, 3), side.states)
self.assertTrue(all("no longer has this pairing" not in text for _up, text in side.states))
self.assertIn("may have removed this machine", side.states[0][1])
now[0] += link_module.FORGOTTEN_AFTER_SECONDS
self.assertTrue(wait_for(lambda: "no longer has this pairing" in (side.last_text() or ""), 5.0), side.states)
self.assertEqual(side.last_text(), "Far no longer has this pairing: use Re-pair on Overview")
self.assertEqual(side.peer().get("dormant_reason"), "forgotten")
seen = server.connections
time.sleep(0.5)
self.assertEqual(server.connections, seen)
def test_a_peer_that_is_slow_to_answer_for_under_a_minute_is_never_said_to_have_removed_this_one(self):
server, side, now = self.closing_peer(linked=True)
self.link(side, clock=lambda: now[0])
self.assertTrue(self.seen(side, 2), side.states)
now[0] += link_module.FORGOTTEN_AFTER_SECONDS - 1
before = len(side.states)
self.assertTrue(self.seen(side, before + 3), side.states)
self.assertTrue(all("no longer has this pairing" not in text for _up, text in side.states))
def test_any_other_result_starts_the_minute_again(self):
server, side, now = self.closing_peer(linked=True)
refuse = [False]
def factory(address, timeout):
if refuse[0]:
raise ConnectionRefusedError(errno.ECONNREFUSED, "refused")
return socket.create_connection(address, timeout=timeout)
self.link(side, clock=lambda: now[0], socket_factory=factory)
self.assertTrue(self.seen(side, 2), side.states)
now[0] += link_module.FORGOTTEN_AFTER_SECONDS - 1
refuse[0] = True
self.assertTrue(wait_for(lambda: side.states and side.states[-1][1].endswith("not listening on this port."), 5.0),
side.states)
refuse[0] = False
now[0] += 5
before = len(side.states)
self.assertTrue(self.seen(side, before + 3), side.states)
self.assertTrue(all("no longer has this pairing" not in text for _up, text in side.states))
def test_a_machine_never_linked_that_closes_unanswered_is_never_said_to_have_removed_this_one(self):
server, side, now = self.closing_peer(linked=False)
self.link(side, clock=lambda: now[0])
self.assertTrue(self.seen(side, 2), side.states)
now[0] += 10 * link_module.FORGOTTEN_AFTER_SECONDS
before = len(side.states)
self.assertTrue(self.seen(side, before + 2), side.states)
self.assertTrue(all("no longer has this pairing" not in text for _up, text in side.states))
def test_invalid_hello_says_this_app_sent_something_unreadable(self):
def script(connection):
session, _ = scripted_session(connection, TOKENS[B])
protocol.send_msg(connection, session, protocol.invalid_hello_v6())
time.sleep(0.3)
server = self.serve(script)
side = Side(None)
side.peer()["port"] = server.port
self.link(side)
self.assertTrue(wait_for(lambda: side.states))
self.assertIn("could not read", side.last_text())
def test_a_welcome_naming_this_machine_is_closed_with_nothing_taught(self):
def script(connection):
session, _ = scripted_session(connection, TOKENS[B])
protocol.send_msg(connection, session, protocol.welcome_v6(B, "Me", "macos", "1.5.0", CAPS, True))
time.sleep(0.3)
server = self.serve(script)
side = Side(None)
side.peer()["port"] = server.port
side.peer()["id"] = ""
self.link(side)
self.assertTrue(wait_for(lambda: side.states))
self.assertIn("different Beamer", side.last_text())
self.assertEqual(side.peer()["id"], "")
self.assertEqual(side.ups, [])
class LinkLiveTests(unittest.TestCase):
def setUp(self):
self.machine = machine_with_peer()
self.addCleanup(self.machine.stop)
self.side = Side(self.machine)
self.link = self.side.link()
self.addCleanup(self.link.stop)
self.link.start()
self.assertTrue(wait_for(lambda: self.side.ups), self.side.states)
def take(self, route=1):
self.assertTrue(self.link.post(protocol.focus_v6(route, HERE, resistance_px=120, reach=[])))
self.assertTrue(wait_for(lambda: any(m["type"] == protocol.MSG_ACCEPT for m in self.side.messages)), self.side.messages)
def test_fast_overlapping_typing_survives_the_outbound_queue(self):
self.take()
expected = []
for _ in range(100):
for name, down in (("shift", True), ("a", True), ("b", True), ("a", False),
("b", False), ("shift", False), ("o", True), ("o", True),
("o", False), ("o", True), ("o", False)):
self.assertTrue(self.link.send_input(protocol.key_msg("keydown" if down else "keyup", name)))
expected.append(("key", name, down))
self.assertTrue(wait_for(lambda: self.link._last_ack_seq == len(expected)))
self.assertEqual(self.machine.injected(), expected)
def test_send_input_numbers_from_one_and_the_responder_injects_for_its_owner(self):
self.take()
self.assertTrue(self.link.send_input(protocol.key_msg("keydown", "a")))
self.assertTrue(self.link.send_input(protocol.mousemove_msg(3, 4)))
self.assertTrue(wait_for(lambda: ("move", 3, 4) in self.machine.injected()))
self.assertIn(("key", "a", True), self.machine.injected())
self.assertEqual(self.link.last_sent_seq, 2)
def test_a_slow_injection_logs_the_input_type_and_injection_call(self):
self.take()
original = self.machine.injector.inject_mouse_move
def slow_move(dx, dy):
time.sleep(0.26)
original(dx, dy)
self.machine.injector.inject_mouse_move = slow_move
with self.assertLogs(receiver.LOGGER, level="WARNING") as said:
self.assertTrue(self.link.send_input(protocol.mousemove_msg(3, 4)))
self.assertTrue(wait_for(lambda: any("slow input injection" in line for line in said.output), 2.0), said.output)
self.assertTrue(any("mousemove" in line and "inject_mouse_move" in line for line in said.output), said.output)
def test_a_shortcut_arrival_without_an_edge_is_logged(self):
with self.assertLogs(receiver.LOGGER, level="INFO") as said:
self.assertTrue(self.link.post(protocol.focus_v6(1, HERE, resistance_px=120, reach=[])))
self.assertTrue(wait_for(lambda: any("input arrived by its shortcut" in line for line in said.output), 2.0), said.output)
self.assertTrue(any("pointer stays at" in line for line in said.output), said.output)
def test_acks_give_round_trip_samples_that_are_never_negative(self):
self.take()
for _ in range(5):
self.link.send_input(protocol.mousemove_msg(1, 1))
time.sleep(0.03)
self.assertTrue(wait_for(lambda: self.link.round_trips()), "no round trip measured")
self.assertTrue(all(sample >= 0 for sample in self.link.round_trips()))
self.assertIsNotNone(self.link.last_ack_at)
def test_inbound_messages_other_than_acks_reach_the_callback(self):
self.link.post(protocol.focus_v6(1, HERE, resistance_px=120, reach=[]))
self.assertTrue(wait_for(lambda: self.side.messages))
self.assertEqual(self.side.messages[0]["type"], protocol.MSG_ACCEPT)
self.assertNotIn(protocol.MSG_ACK, [m["type"] for m in self.side.messages])
def test_a_clipboard_is_dropped_when_the_peer_lacks_the_capability(self):
self.link._caps = frozenset()
self.assertTrue(self.link.post(protocol.clipboard_msg("hello")))
time.sleep(0.2)
self.assertEqual(self.machine.clipboard.set_calls, [])
def test_settings_are_not_sent_to_a_peer_without_the_capability(self):
self.link._caps = frozenset()
self.assertTrue(self.link.post(protocol.settings_msg({"a": 1})))
time.sleep(0.2)
self.assertEqual(self.machine.settings_seen, [])
def test_focus_display_target_is_stripped_for_a_peer_without_displays(self):
self.link._caps = frozenset()
queued = []
self.link._enqueue = lambda message, seq: queued.append(message) or True
self.assertTrue(self.link.post(protocol.focus_v6(1, HERE, resistance_px=120, reach=[],
display="panel-right", side="bottom")))
message = queued[0]
self.assertNotIn("display", message["data"])
self.assertNotIn("side", message["data"])
def test_the_link_reconnects_after_the_responder_closes_it(self):
first = len(self.side.ups)
self.machine.responder.peers_changed()
self.side.peer()["linked"] = True
for link in list(self.machine.responder._links.values()):
link.close()
self.assertTrue(wait_for(lambda: len(self.side.ups) > first, 5.0), self.side.states)
def test_stop_ends_the_link_and_the_responder_sees_it_go(self):
self.link.stop()
self.assertTrue(wait_for(lambda: (protocol_id(B), False) in self.machine.links))
self.assertFalse(self.link.live())
def test_a_full_queue_reports_failure(self):
self.link._stall.set()
results = [self.link.send_input(protocol.key_msg("keydown", "a")) for _ in range(2100)]
self.link._stall.clear()
self.assertIn(False, results)
self.assertEqual(results.count(True), 2048)
def protocol_id(ident):
return ident
class LinkLivenessTests(unittest.TestCase):
def test_a_silent_peer_ends_the_link_after_two_seconds(self):
def script(connection):
session, hello = scripted_session(connection, TOKENS[B])
protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.0", CAPS, True))
time.sleep(6)
server = Scripted(script)
self.addCleanup(server.stop)
side = Side(None)
side.peer()["port"] = server.port
link = side.link(reconnect_seconds=30)
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: side.ups))
began = time.monotonic()
self.assertTrue(wait_for(lambda: "stopped responding" in (side.last_text() or ""), 5.0), side.states)
self.assertGreaterEqual(time.monotonic() - began, 1.5)
self.assertFalse(link.live())
def test_an_idle_link_pings_each_second(self):
pings = []
def script(connection):
session, hello = scripted_session(connection, TOKENS[B])
protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.0", CAPS, True))
connection.settimeout(3)
started = time.monotonic()
while time.monotonic() - started < 2.6:
try:
message = protocol.recv_msg(connection, session)
except OSError:
return
if message["type"] == protocol.MSG_PING:
pings.append(message)
protocol.send_msg(connection, session, protocol.ack_v6(0, 0))
server = Scripted(script)
self.addCleanup(server.stop)
side = Side(None)
side.peer()["port"] = server.port
link = side.link()
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: len(pings) >= 2, 4.0), pings)
def test_an_ack_ahead_of_anything_sent_ends_the_link(self):
def script(connection):
session, hello = scripted_session(connection, TOKENS[B])
protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.0", CAPS, True))
protocol.send_msg(connection, session, protocol.ack_v6(5, 0))
time.sleep(1)
server = Scripted(script)
self.addCleanup(server.stop)
side = Side(None)
side.peer()["port"] = server.port
link = side.link(reconnect_seconds=30)
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: side.ups))
self.assertTrue(wait_for(lambda: not link.live(), 3.0))
def test_an_ack_with_a_negative_held_us_ends_the_link(self):
def script(connection):
session, hello = scripted_session(connection, TOKENS[B])
protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.0", CAPS, True))
protocol.send_msg(connection, session, {"type": "ack", "data": {"seq": 0, "held_us": -1}})
time.sleep(1)
server = Scripted(script)
self.addCleanup(server.stop)
side = Side(None)
side.peer()["port"] = server.port
link = side.link(reconnect_seconds=30)
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: side.ups))
self.assertTrue(wait_for(lambda: not link.live(), 3.0))
def test_an_ack_that_says_locked_sets_peer_locked_until_one_that_does_not(self):
cleared = threading.Event()
def script(connection):
session, hello = scripted_session(connection, TOKENS[B])
protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.0", CAPS, True))
protocol.send_msg(connection, session, protocol.ack_v6(0, 0, locked=True))
cleared.wait(5)
protocol.send_msg(connection, session, protocol.ack_v6(0, 0))
time.sleep(2)
server = Scripted(script)
self.addCleanup(server.stop)
side = Side(None)
side.peer()["port"] = server.port
link = side.link(reconnect_seconds=30)
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: side.ups))
self.assertTrue(wait_for(lambda: link.peer_locked), side.states)
cleared.set()
self.assertTrue(wait_for(lambda: not link.peer_locked), side.states)
self.assertTrue(link.live())
class FakeClock:
def __init__(self):
self.now = 1000.0
def __call__(self):
return self.now
class AckStallTests(unittest.TestCase):
def test_a_blocked_clipboard_callback_is_included_in_ack_stall_credit(self):
clock = FakeClock()
def script(connection):
session, _hello = scripted_session(connection, TOKENS[B])
protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.2", CAPS, True))
connection.settimeout(5)
while True:
message = protocol.recv_msg(connection, session)
seq = message.get("data", {}).get("seq")
if seq:
break
clipboard = session.seal(protocol.clipboard_msg("c" * protocol.CLIPBOARD_MAX_BYTES))
acknowledgement = session.seal(protocol.ack_v6(seq, 0))
connection.sendall(clipboard + acknowledgement)
time.sleep(2)
server = Scripted(script)
self.addCleanup(server.stop)
side = Side(None)
side.peer()["port"] = server.port
link = side.link(clock=clock)
self.addCleanup(link.stop)
original_call = link._call
original_end = link._end_ack_pause
def advance_during_clipboard(index, *args):
if index == 2 and args[0].get("type") == protocol.MSG_CLIPBOARD:
clock.now += 2.0
original_call(index, *args)
def check_credit_before_the_queued_ack(ended):
original_end(ended)
link._tick(clock())
link._call = advance_during_clipboard
link._end_ack_pause = check_credit_before_the_queued_ack
link.start()
self.assertTrue(wait_for(lambda: side.ups))
self.assertTrue(link.send_input(protocol.key_msg("keydown", "a")))
self.assertTrue(wait_for(lambda: link._last_ack_seq == 1), side.states)
self.assertTrue(link.live())
def test_a_clipboard_trickling_in_does_not_count_as_an_ack_stall(self):
def script(connection):
session, _hello = scripted_session(connection, TOKENS[B])
protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.2", CAPS, True))
connection.settimeout(5)
while True:
message = protocol.recv_msg(connection, session)
seq = message.get("data", {}).get("seq")
if seq:
break
frame = session.seal(protocol.clipboard_msg("c" * protocol.CLIPBOARD_MAX_BYTES))
for offset in range(0, len(frame), 8192):
connection.sendall(frame[offset:offset + 8192])
time.sleep(0.12)
protocol.send_msg(connection, session, protocol.ack_v6(seq, 0))
time.sleep(2)
server = Scripted(script)
self.addCleanup(server.stop)
side = Side(None)
side.peer()["port"] = server.port
link = side.link()
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: side.ups))
self.assertTrue(link.send_input(protocol.key_msg("keydown", "a")))
self.assertTrue(wait_for(lambda: link._last_ack_seq == 1, 6.0), side.states)
self.assertTrue(link.live())
def test_a_live_heartbeat_cannot_keep_unacknowledged_input_away(self):
machine = machine_with_peer()
self.addCleanup(machine.stop)
side = Side(machine)
now = [100.0]
link = side.link(clock=lambda: now[0], reconnect_seconds=30)
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: side.ups), side.states)
self.assertTrue(link.post(protocol.focus_v6(1, HERE, resistance_px=120, reach=[])))
self.assertTrue(wait_for(lambda: any(m["type"] == protocol.MSG_ACCEPT for m in side.messages)))
self.assertTrue(link.send_input(protocol.key_msg("keydown", "a")))
self.assertTrue(wait_for(lambda: ("key", "a", True) in machine.injected()))
self.assertTrue(wait_for(lambda: link._last_ack_seq == 1))
injecting = threading.Event()
release = threading.Event()
self.addCleanup(release.set)
def blocked_move(dx, dy):
injecting.set()
release.wait(5)
machine.injector._add("move", dx, dy)
machine.injector.inject_mouse_move = blocked_move
self.assertTrue(all(link.send_input(protocol.mousemove_msg(1, 1)) for _ in range(50)))
self.assertTrue(injecting.wait(2), "the responder never began the blocked injection")
acknowledgements = []
original_ack = link._ack
def record_ack(ack):
acknowledgements.append(ack["seq"])
original_ack(ack)
link._ack = record_ack
self.assertTrue(wait_for(lambda: 1 in acknowledgements), acknowledgements)
now[0] += 1.51
self.assertTrue(wait_for(lambda: side.states and not side.states[-1][0]), side.states)
self.assertTrue(any(seq == 1 for seq in acknowledgements), acknowledgements)
self.assertIn("stopped acknowledging input", side.last_text())
release.set()
self.assertTrue(wait_for(lambda: ("release_all",) in machine.injector.seen()))
self.assertFalse(machine.responder.driven)
class LinkFollowTests(unittest.TestCase):
def link(self, clock, tried):
side = Side(None)
side.peer()["host"] = "192.168.77.7"
side.peer()["host_pinned"] = False
def factory(address, timeout=None):
tried.append(address)
raise OSError("no route")
link = side.link(socket_factory=factory, clock=clock, reconnect_seconds=0.02)
self.addCleanup(link.stop)
return side, link
def test_a_peer_not_in_use_has_no_dial_target(self):
side, _link = self.link(FakeClock(), [])
side.peer()["in_use"] = False
self.assertIsNone(OutboundLink._target(side.peer()))
def test_a_beacon_with_the_exact_name_is_tried_once_the_link_has_been_down_ten_seconds(self):
clock, tried = FakeClock(), []
side, link = self.link(clock, tried)
link.start()
self.assertTrue(wait_for(lambda: tried))
tried.clear()
beacon = [{"name": "Far", "address": "192.168.77.9"}, {"name": "Other", "address": "192.168.77.10"}]
link.follow(beacon)
time.sleep(0.2)
self.assertNotIn(("192.168.77.9", 24820), tried)
clock.now += 11
link.follow(beacon)
self.assertTrue(wait_for(lambda: ("192.168.77.9", 24820) in tried), tried)
self.assertNotIn(("192.168.77.10", 24820), tried)
tried.clear()
clock.now += 5
link.follow(beacon)
time.sleep(0.2)
self.assertNotIn(("192.168.77.9", 24820), tried)
clock.now += 30
link.follow(beacon)
self.assertTrue(wait_for(lambda: ("192.168.77.9", 24820) in tried), tried)
def test_discovery_matches_the_machine_name_not_its_local_label(self):
clock, tried = FakeClock(), []
side, link = self.link(clock, tried)
side.peer()["label"] = "Work Mac"
link.start()
self.assertTrue(wait_for(lambda: tried))
tried.clear()
clock.now += 11
link.follow([{"name": "Work Mac", "address": "192.168.77.9"}])
time.sleep(0.1)
self.assertNotIn(("192.168.77.9", 24820), tried)
link.follow([{"name": "Far", "address": "192.168.77.10"}])
self.assertTrue(wait_for(lambda: ("192.168.77.10", 24820) in tried), tried)
def test_a_beacon_that_names_another_machine_is_never_tried_and_one_at_its_address_is_tried_last(self):
clock, tried = FakeClock(), []
side, link = self.link(clock, tried)
side.settings.data["peers"].append(entry(C, "Far", token=TOKENS[C], host="192.168.77.20", port=24820, send=True))
link.start()
self.assertTrue(wait_for(lambda: tried))
beacons = [{"name": "Far", "address": "192.168.77.20"},
{"name": "Far", "address": "192.168.77.21", "id": protocol.id_text(C)},
{"name": "Far", "address": "192.168.77.22", "id": protocol.id_text(HERE)}]
tried.clear()
clock.now += 11
link.follow(beacons)
self.assertTrue(wait_for(lambda: ("192.168.77.22", 24820) in tried), tried)
self.assertNotIn(("192.168.77.20", 24820), tried)
# Two machines may have swapped addresses, so the other machine's saved one is still tried, last.
clock.now += 31
link.follow(beacons)
self.assertTrue(wait_for(lambda: ("192.168.77.20", 24820) in tried), tried)
self.assertNotIn(("192.168.77.21", 24820), tried)
def test_several_beacons_with_the_name_are_tried_in_turn(self):
clock, tried = FakeClock(), []
side, link = self.link(clock, tried)
link.start()
self.assertTrue(wait_for(lambda: tried))
beacons = [{"name": "Far", "address": "192.168.77.9"}, {"name": "Far", "address": "192.168.77.10"}]
for address in ("192.168.77.9", "192.168.77.10", "192.168.77.9"):
tried.clear()
clock.now += 31
link.follow(beacons)
self.assertTrue(wait_for(lambda: (address, 24820) in tried), (address, tried))
def test_a_failed_try_shows_nothing_and_saves_nothing(self):
clock, tried = FakeClock(), []
side, link = self.link(clock, tried)
link.start()
self.assertTrue(wait_for(lambda: tried))
clock.now += 11
link.follow([{"name": "Far", "address": "192.168.77.9"}])
self.assertTrue(wait_for(lambda: ("192.168.77.9", 24820) in tried))
self.assertEqual(side.peer()["host"], "192.168.77.7")
def test_the_address_is_saved_once_the_link_authenticates_there(self):
machine = machine_with_peer()
self.addCleanup(machine.stop)
clock = FakeClock()
side = Side(machine)
side.peer()["host"] = "10.255.255.1"
side.peer()["host_pinned"] = False
real = socket.create_connection
def factory(address, timeout=None):
if address[0] == "10.255.255.1":
raise OSError("no route")
return real(address, timeout=timeout)
link = side.link(socket_factory=factory, clock=clock)
self.addCleanup(link.stop)
link.start()
time.sleep(0.2)
clock.now += 11
link.follow([{"name": "Far", "address": LOOPBACK}])
self.assertTrue(wait_for(lambda: side.ups), side.states)
self.assertEqual(side.peer()["host"], LOOPBACK)
class LinkTunnelTests(unittest.TestCase):
def test_an_unreachable_host_falls_back_to_the_tunnel(self):
import errno
machine = machine_with_peer()
self.addCleanup(machine.stop)
side = Side(machine)
def factory(address, timeout=None):
raise OSError(errno.EHOSTUNREACH, "no route")
link = side.link(socket_factory=factory, tunnel=lambda: socket.create_connection((LOOPBACK, machine.port), timeout=1))
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: side.ups), side.states)
self.assertTrue(link.via_tunnel)
class LinkHeldTests(unittest.TestCase):
def test_held_us_is_taken_off_the_sample_and_never_goes_below_zero(self):
def script(connection):
session, hello = scripted_session(connection, TOKENS[B])
protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.0", CAPS, True))
message = protocol.recv_msg(connection, session)
while message["type"] == protocol.MSG_PING:
message = protocol.recv_msg(connection, session)
time.sleep(0.05)
protocol.send_msg(connection, session, protocol.ack_v6(message["data"]["seq"], 5_000_000))
time.sleep(0.5)
server = Scripted(script)
self.addCleanup(server.stop)
side = Side(None)
side.peer()["port"] = server.port
link = side.link()
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: side.ups))
link.send_input(protocol.mousemove_msg(1, 1))
self.assertTrue(wait_for(lambda: link.round_trips()))
self.assertEqual(link.round_trips(), [0.0])
class LinkReviewFindingsTests(unittest.TestCase):
"""What the cold review of the first version found, each shown failing before it was fixed."""
def test_an_ack_that_beats_the_writers_bookkeeping_does_not_end_the_link(self):
def script(connection):
session, hello = scripted_session(connection, TOKENS[B])
protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.0", CAPS, True))
connection.settimeout(5)
while True:
message = protocol.recv_msg(connection, session)
seq = message["data"].get("seq")
if seq:
protocol.send_msg(connection, session, protocol.ack_v6(seq, 0))
server = Scripted(script)
self.addCleanup(server.stop)
side = Side(None)
side.peer()["port"] = server.port
def slow_clock():
time.sleep(0.003)
return time.monotonic()
link = side.link(clock=slow_clock)
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: side.ups))
for _ in range(30):
self.assertTrue(link.send_input(protocol.mousemove_msg(1, 1)))
time.sleep(0.01)
time.sleep(0.3)
self.assertTrue(link.live(), side.states)
def test_stop_during_a_handshake_ends_the_thread_and_start_runs_it_again(self):
def script(connection):
time.sleep(6)
server = Scripted(script)
self.addCleanup(server.stop)
side = Side(None)
side.peer()["port"] = server.port
link = side.link(reconnect_seconds=0.05)
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: server.connections))
began = time.monotonic()
link.stop()
self.assertLess(time.monotonic() - began, 1.0)
self.assertFalse(link.running)
before = server.connections
link.start()
self.assertTrue(wait_for(lambda: server.connections > before), "the link did not dial again")
def test_stop_without_waiting_returns_at_once_reports_nothing_after_and_start_runs_it_again(self):
# A window removing machines must not wait on a link thread that is in a handshake.
def script(connection):
session, hello = scripted_session(connection, TOKENS[B])
time.sleep(0.5)
protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.0", CAPS, True))
time.sleep(1)
server = Scripted(script)
self.addCleanup(server.stop)
side = Side(None)
side.peer()["port"] = server.port
link = side.link()
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: server.connections))
time.sleep(0.1)
began = time.monotonic()
link.stop(wait=False)
self.assertLess(time.monotonic() - began, 0.05)
states, ups = list(side.states), list(side.ups)
time.sleep(1.2)
self.assertEqual((side.states, side.ups), (states, ups))
self.assertFalse(link.running)
before = server.connections
link.start()
self.assertTrue(wait_for(lambda: server.connections > before), "the link did not dial again")
def test_nothing_is_reported_after_stop_returns(self):
def script(connection):
session, hello = scripted_session(connection, TOKENS[B])
time.sleep(0.8)
protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.0", CAPS, True))
time.sleep(1)
server = Scripted(script)
self.addCleanup(server.stop)
side = Side(None)
side.peer()["port"] = server.port
link = side.link()
link.start()
self.assertTrue(wait_for(lambda: server.connections))
time.sleep(0.2)
link.stop()
states, ups, saved = list(side.states), list(side.ups), side.settings.saves
time.sleep(1.5)
self.assertEqual((side.states, side.ups, side.settings.saves), (states, ups, saved))
def test_a_failed_try_at_a_beacons_address_shows_nothing_and_blocks_nothing(self):
def script(connection):
connection.close()
server = Scripted(script)
self.addCleanup(server.stop)
clock = FakeClock()
side = Side(None)
side.peer()["host"] = "10.255.255.1"
side.peer()["host_pinned"] = False
side.peer()["port"] = server.port
real = socket.create_connection
def factory(address, timeout=None):
if address[0] == "10.255.255.1":
raise OSError("no route")
return real(address, timeout=timeout)
link = side.link(socket_factory=factory, clock=clock)
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: side.states))
clock.now += 11
shown = list(side.states)
link.follow([{"name": "Far", "address": LOOPBACK}])
self.assertTrue(wait_for(lambda: server.connections))
time.sleep(0.3)
self.assertEqual(side.states[: len(shown)], shown)
self.assertFalse(any("closed the connection" in text for _, text in side.states[len(shown):]))
def test_a_try_never_dials_a_peer_with_send_off(self):
tried = []
def factory(address, timeout=None):
tried.append(address)
raise OSError("no route")
clock = FakeClock()
side = Side(None)
link = side.link(socket_factory=factory, clock=clock, reconnect_seconds=0.02)
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: tried))
clock.now += 11
side.peer()["send"] = False
link._try_host = "192.168.77.9"
link._wake.set()
tried.clear()
time.sleep(0.4)
self.assertEqual(tried, [])
def test_a_peer_that_stops_reading_ends_the_link(self):
def script(connection):
session, hello = scripted_session(connection, TOKENS[B])
protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.0", CAPS, True))
for _ in range(60):
protocol.send_msg(connection, session, protocol.ack_v6(0, 0))
time.sleep(0.2)
server = Scripted(script)
self.addCleanup(server.stop)
side = Side(None)
side.peer()["port"] = server.port
link = side.link(reconnect_seconds=30)
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: side.ups))
big = protocol.clipboard_msg("x" * 200_000)
for _ in range(100):
if not link.post(big):
break
self.assertTrue(wait_for(lambda: not link.live(), 8.0), "a wedged writer kept the link up")
def test_only_one_ping_waits_in_the_queue(self):
side = Side(None)
link = side.link()
link._live = True
link._sock = object()
for _ in range(20):
link._tick_ping()
self.assertEqual(sum(1 for m in link._outbox if m["type"] == protocol.MSG_PING), 1)
def test_send_input_takes_only_input_and_filters_media_keys(self):
side = Side(None)
link = side.link()
link._live = True
link._sock = object()
link._caps = frozenset()
self.assertFalse(link.send_input(protocol.settings_msg({})))
self.assertTrue(link.send_input(protocol.key_msg("keydown", "volume_up")))
self.assertEqual(len(link._outbox), 0)
link._caps = frozenset({"media_keys"})
self.assertTrue(link.send_input(protocol.key_msg("keydown", "volume_up")))
self.assertEqual(len(link._outbox), 1)
def test_flush_waits_for_the_queue_to_be_written(self):
machine = machine_with_peer()
self.addCleanup(machine.stop)
side = Side(machine)
link = side.link()
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: side.ups))
link.post(protocol.focus_v6(1, HERE, resistance_px=120, reach=[]))
link.flush(2.0)
self.assertEqual(len(link._outbox), 0)
self.assertTrue(wait_for(lambda: machine.responder.owner == B))
def test_peer_locked_is_forgotten_on_a_new_link(self):
side = Side(None)
link = side.link()
link._locked = True
link._live = True
self.assertTrue(link.peer_locked)
link._reset_link_state()
self.assertFalse(link.peer_locked)
class LinkFramingTests(unittest.TestCase):
def serve(self, after_welcome):
def script(connection):
session, hello = scripted_session(connection, TOKENS[B])
protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.0", CAPS, True))
after_welcome(connection, session)
server = Scripted(script)
self.addCleanup(server.stop)
side = Side(None)
side.peer()["port"] = server.port
link = side.link(reconnect_seconds=30)
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: side.ups))
return side, link
def test_a_frame_that_arrives_a_byte_at_a_time_is_one_message(self):
def after(connection, session):
frame = session.seal(protocol.accept_msg(3))
for index in range(len(frame)):
connection.sendall(frame[index:index + 1])
time.sleep(0.002)
time.sleep(1)
side, link = self.serve(after)
self.assertTrue(wait_for(lambda: side.messages), side.states)
self.assertEqual(side.messages[0]["data"]["route"], 3)
def test_a_frame_that_takes_longer_than_its_deadline_from_its_first_byte_ends_the_link(self):
# A byte every tenth of a second keeps the link alive, so only the frame's own deadline,
# counted from its first length byte, can end it.
def after(connection, session):
connection.sendall(struct.pack(">I", 1000))
for _ in range(40):
connection.sendall(b"\x00")
time.sleep(0.1)
with mock.patch.object(protocol, "FRAME_COMPLETE_SECONDS", 0.8):
side, link = self.serve(after)
self.assertTrue(wait_for(lambda: side.states and not side.states[-1][0], 3.0), side.states)
self.assertIn("too long", side.last_text())
self.assertEqual(side.messages, [])
def test_a_frame_completed_after_its_deadline_is_not_dispatched(self):
class Socket:
def __init__(self, chunks):
self.chunks = iter(chunks)
def recv(self, size):
return next(self.chunks)
frame = struct.pack(">I", protocol.MIN_FRAME_BYTES) + bytes(protocol.MIN_FRAME_BYTES)
sock = Socket((frame[:1], frame[1:], b""))
times = iter((-1.0, 0.0, 0.25))
link = OutboundLink("", None, lambda: {}, clock=lambda: next(times, 0.3))
link._sock = sock
session = mock.Mock()
session.open_raw.return_value = b"{}"
with mock.patch.object(protocol, "FRAME_COMPLETE_SECONDS", 0.2):
with mock.patch.object(protocol, "parse_message", return_value={"type": "accept", "data": {}}):
with mock.patch.object(link, "_deal") as deal:
with self.assertRaisesRegex(link_module.LinkEnded, "took too long to send one message"):
link._read(sock, session, "peer")
deal.assert_not_called()
def test_two_frames_in_one_segment_are_two_messages(self):
def after(connection, session):
connection.sendall(session.seal(protocol.accept_msg(3)) + session.seal(protocol.accept_msg(4)))
time.sleep(1)
side, link = self.serve(after)
self.assertTrue(wait_for(lambda: len(side.messages) == 2))
def big(self, allowed):
"""A frame past SMALL_MESSAGE_BYTES, then a small one, to a link whose `large` hook says
`allowed`; what the link hands on, once the small one is through."""
parsed = []
real_parse = protocol.parse_message
filler = {"type": protocol.MSG_CLIPBOARD, "data": {"text": "x" * (protocol.SMALL_MESSAGE_BYTES + 10)}}
def after(connection, session):
connection.sendall(session.seal(filler) + session.seal(protocol.accept_msg(3)))
time.sleep(1)
def script(connection):
session, hello = scripted_session(connection, TOKENS[B])
protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.0", CAPS, True))
after(connection, session)
server = Scripted(script)
self.addCleanup(server.stop)
side = Side(None)
side.peer()["port"] = server.port
asked = []
link = side.link(reconnect_seconds=30, large=lambda link_, began: asked.append((link_, began)) or allowed)
self.addCleanup(link.stop)
with mock.patch.object(protocol, "parse_message", side_effect=lambda plain: parsed.append(len(plain)) or real_parse(plain)):
link.start()
self.assertTrue(wait_for(lambda: any(m.get("type") == protocol.MSG_ACCEPT for m in side.messages)), side.states)
self.assertEqual([who for who, _ in asked], [link])
self.assertIsInstance(asked[0][1], float)
self.assertTrue(link.live())
return side, parsed
def test_a_frame_too_large_for_anything_but_a_clipboard_is_never_parsed_unless_one_is_expected(self):
side, parsed = self.big(False)
self.assertEqual([m["type"] for m in side.messages], [protocol.MSG_ACCEPT])
self.assertTrue(all(size <= protocol.SMALL_MESSAGE_BYTES for size in parsed), parsed)
def test_an_expected_clipboard_of_any_size_is_handed_on(self):
side, parsed = self.big(True)
self.assertEqual([m["type"] for m in side.messages], [protocol.MSG_CLIPBOARD, protocol.MSG_ACCEPT])
def test_a_frame_claiming_more_than_the_maximum_ends_the_link(self):
def after(connection, session):
connection.sendall((protocol.MAX_FRAME_BYTES + 1).to_bytes(4, "big"))
time.sleep(1)
side, link = self.serve(after)
self.assertTrue(wait_for(lambda: not link.live(), 3.0))
def test_a_replayed_frame_ends_the_link(self):
def after(connection, session):
frame = session.seal(protocol.accept_msg(3))
connection.sendall(frame + frame)
time.sleep(1)
side, link = self.serve(after)
self.assertTrue(wait_for(lambda: not link.live(), 3.0))
self.assertEqual(len(side.messages), 1)
class GeminiFindingsTests(unittest.TestCase):
def test_a_link_that_is_down_refuses_what_its_capabilities_would_have_dropped(self):
side = Side(None)
link = side.link()
self.assertFalse(link.post(protocol.clipboard_msg("x")))
self.assertFalse(link.post(protocol.settings_msg({})))
self.assertFalse(link.send_input(protocol.gesture_msg("pinch")))
def test_a_drop_reason_is_forgotten_with_the_link(self):
side = Side(None)
link = side.link()
link._drop_reason = "stale"
link._reset_link_state()
self.assertIsNone(link._drop_reason)
def test_a_peer_that_never_acknowledges_cannot_grow_the_send_record_without_end(self):
side = Side(None)
link = side.link()
link._live = True
link._sock = object()
for index in range(link_module.SENT_RECORD_LIMIT + 1):
link._sent_at.append((index, 0.0))
with self.assertRaises(protocol.ProtocolError):
link._check_sent_record()
def test_pending_counts_input_waiting_to_be_written_and_input_not_yet_acknowledged(self):
side = Side(None)
link = side.link()
self.assertEqual(link.pending(), 0)
link._outbox.append(protocol.mousemove_msg(1, 1))
link._outbox.append(protocol.mousemove_msg(2, 2))
link._sent_at.append((1, 0.0))
self.assertEqual(link.pending(), 3)
class RoundTripLogTests(unittest.TestCase):
"""Section 9: every 60 seconds while input is on the link, the count, median, 95th percentile,
largest and mean held_us of the round trips measured since the last line."""
def setUp(self):
self.now = [100.0]
self.side = Side(None)
self.link = self.side.link(clock=lambda: self.now[0])
self.link.peer_name = "Far"
self.link._logged_at = 100.0
def acks(self, count, held_us=1000):
self.link._written_seq = count
for seq in range(1, count + 1):
self.link._sent_at.append((seq, 100.0))
self.now[0] = 100.2
for seq in range(1, count + 1):
self.link._ack({"seq": seq, "held_us": held_us * seq, "locked": False})
def test_the_minute_gives_count_median_95th_percentile_largest_and_mean_held(self):
self.acks(20)
with self.assertLogs("Beamer", "INFO") as logged:
self.now[0] = 160.1
self.link._tick(160.1)
text = logged.output[-1]
self.assertIn("round trip to Far", text)
self.assertIn("20 samples", text)
for word in ("median", "95th percentile", "largest", "mean held_us 10500"):
self.assertIn(word, text)
def test_a_minute_without_input_logs_nothing(self):
with self.assertNoLogs("Beamer", "INFO"):
self.now[0] = 160.1
self.link._tick(160.1)
def test_a_minute_with_input_but_no_advancing_ack_logs_the_pending_input(self):
self.link._written_seq = 5
self.link._sent_at.extend((seq, 100.0) for seq in range(1, 6))
with self.assertLogs("Beamer", "INFO") as logged:
self.now[0] = 160.1
self.link._log_round_trips()
self.assertIn("sent 5, acknowledged 0", logged.output[-1])
self.assertIn("oldest unacknowledged seq 1 for 60.1 s", logged.output[-1])
def test_what_was_logged_is_not_counted_again(self):
self.acks(5)
self.now[0] = 160.1
self.link._tick(160.1)
with self.assertNoLogs("Beamer", "INFO"):
self.now[0] = 220.2
self.link._tick(220.2)
class LinkHardwareTests(unittest.TestCase):
"""`hw` in the hello is the address on the interface towards the host this link dials."""
def hello_of(self, side, **kwargs):
seen = []
def script(connection):
session, hello = scripted_session(connection, TOKENS[B])
seen.append(hello)
protocol.send_msg(connection, session, protocol.welcome_v6(HERE, "Here", "windows", "1.5.0", CAPS, True))
time.sleep(1)
server = Scripted(script)
self.addCleanup(server.stop)
side.peer()["port"] = server.port
link = side.link(reconnect_seconds=30, **kwargs)
self.addCleanup(link.stop)
link.start()
self.assertTrue(wait_for(lambda: seen), side.states)
return seen[0]
def test_the_hook_is_asked_with_the_host_this_link_dials(self):
asked = []
side = Side(None)
hello = self.hello_of(side, hardware=lambda host: asked.append(host) or "aa:bb:cc:dd:ee:01")
self.assertEqual(asked, [LOOPBACK])
self.assertEqual(hello["hw"], "aa:bb:cc:dd:ee:01")
def test_the_hook_wins_over_the_identitys_own_hw(self):
side = Side(None)
side.identity = lambda: {"id": B, "name": "Near", "platform": "macos", "app": "1.5.0", "caps": list(CAPS),
"port": 24820, "hw": "11:11:11:11:11:11"}
hello = self.hello_of(side, hardware=lambda host: "aa:bb:cc:dd:ee:02")
self.assertEqual(hello["hw"], "aa:bb:cc:dd:ee:02")
def test_without_a_hook_the_identitys_hw_is_sent_as_before(self):
side = Side(None)
side.identity = lambda: {"id": B, "name": "Near", "platform": "macos", "app": "1.5.0", "caps": list(CAPS),
"port": 24820, "hw": "11:11:11:11:11:11"}
self.assertEqual(self.hello_of(side)["hw"], "11:11:11:11:11:11")
def test_a_hook_that_raises_sends_no_hw_and_the_link_still_comes_up(self):
def broken(host):
raise OSError("no adapter table")
side = Side(None)
hello = self.hello_of(side, hardware=broken)
self.assertIsNone(hello["hw"])
self.assertTrue(wait_for(lambda: side.ups), side.states)
def test_a_hook_that_knows_nothing_sends_no_hw(self):
side = Side(None)
self.assertIsNone(self.hello_of(side, hardware=lambda host: "")["hw"])
if __name__ == "__main__":
unittest.main()