Skip to content

One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.

4.1 KB
Raw Blame
"""Directional ACK latency and diagnostics, using real encrypted loopback links."""

import time
import unittest

from core import protocol
from core.tests.test_link import Side
from core.tests.responder_harness import B, HERE, TOKENS, Machine, entry, wait_for


class DirectionalLatencyTests(unittest.TestCase):
    def test_slow_receiver_delays_only_its_input_direction_and_logs_the_stage(self):
        slow = Machine([entry(B, "A")]).start()
        fast = Machine([entry(HERE, "B", token=TOKENS[B])], own=B).start()
        self.addCleanup(slow.stop)
        self.addCleanup(fast.stop)
        forward = Side(slow).link()
        backward = Side(fast, peer=B, own=HERE).link()
        self.addCleanup(forward.stop)
        self.addCleanup(backward.stop)
        forward.start()
        backward.start()
        self.assertTrue(wait_for(lambda: forward.live() and backward.live()))
        for link, target in ((forward, HERE), (backward, B)):
            self.assertTrue(link.post(protocol.focus_v6(1, target, resistance_px=120, reach=[])))
        self.assertTrue(wait_for(lambda: slow.responder.driven and fast.responder.driven))
        original = slow.injector.inject_key

        def delayed(key, down, us=None):
            time.sleep(0.02)
            original(key, down, us=us)

        slow.injector.inject_key = delayed
        inbound_route = slow.responder._links[B].timing.route
        with self.assertLogs("Beamer", "INFO") as captured:
            for _ in range(24):
                self.assertTrue(forward.send_input(protocol.key_msg("keydown", "a")))
            self.assertTrue(backward.send_input(protocol.key_msg("keydown", "a")))
            self.assertTrue(wait_for(lambda: forward._last_ack_seq == 24 and backward._last_ack_seq == 1))
            self.assertGreater(forward.round_trips()[-1], 0.35)
            self.assertGreater(forward.round_trips()[-1] - forward.round_trips()[0], 0.2)
            self.assertLess(backward.round_trips()[-1], 0.2)
            forward.stop()
            backward.stop()
            slow.stop()
            fast.stop()
            self.assertTrue(wait_for(lambda: any(inbound_route in line and "inject_ms" in line
                                                 for line in captured.output), 5.0))
        text = "\n".join(captured.output)
        self.assertIn("link timing inbound", text)
        self.assertIn("inject_ms", text)
        self.assertIn("dispatch_ms", text)

    def test_lock_wait_is_measured_separately_from_injection(self):
        machine = Machine([entry(B, "A")]).start()
        self.addCleanup(machine.stop)
        link = Side(machine).link()
        self.addCleanup(link.stop)
        link.start()
        self.assertTrue(wait_for(link.live))
        link.post(protocol.focus_v6(1, HERE, resistance_px=120, reach=[]))
        self.assertTrue(wait_for(lambda: machine.responder.driven))
        with machine.responder._lock:
            link.send_input(protocol.mousemove_msg(1, 1))
            self.assertTrue(wait_for(lambda: link._written_seq == 1))
            time.sleep(0.1)
        self.assertTrue(wait_for(lambda: link._last_ack_seq == 1))
        inbound = machine.responder._links[B]
        with inbound.timing.lock:
            lock_max = inbound.timing.stages["input_lock"][2]
            inject_max = inbound.timing.stages["inject"][2]
        self.assertGreater(lock_max, 50)
        self.assertLess(inject_max, lock_max)

    def test_route_logs_use_actual_socket_endpoints(self):
        machine = Machine([entry(B, "A")]).start()
        self.addCleanup(machine.stop)
        link = Side(machine).link()
        self.addCleanup(link.stop)
        with self.assertLogs("Beamer", "INFO") as captured:
            link.start()
            self.assertTrue(wait_for(link.live))
            self.assertTrue(wait_for(lambda: sum("link route" in line for line in captured.output) == 2))
            link.stop()
        text = "\n".join(captured.output)
        self.assertIn("link route outbound", text)
        self.assertIn("link route inbound", text)
        self.assertIn("127.0.0.1", text)
        self.assertIn("nodelay=1", text)


if __name__ == "__main__":
    unittest.main()