Skip to content

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

13.1 KB
Raw Blame
"""Synthetic map numbering, both Mac links, and non-activating display panels."""

import logging
import sys
import threading
import unittest
from pathlib import Path
from types import SimpleNamespace
from unittest import mock

sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))

import AppKit

AppKit.NSApplication.sharedApplication()

import bridge
import diagram
import identify_overlay
from core import identify_screens, protocol, ways
from core.return_edge import Rect
from test_crossing_page_machines import Page

OWN = protocol.id_text(bytes(range(1, 17)))
PEER = protocol.id_text(bytes(range(21, 37)))
OLDER = protocol.id_text(bytes(range(41, 57)))
PHONE = protocol.id_text(bytes(range(61, 77)))
DISPLAYS = {"0": dict(x=1920, y=0, w=1512, h=982),
            "1": dict(x=0, y=0, w=1920, h=1080)}


class OverlayTests(unittest.TestCase):
    def setUp(self):
        self.overlay = identify_overlay.IdentifyOverlay(logging.getLogger("identify-test"))
        self.addCleanup(self.overlay.hide)
        self.later = []
        patcher = mock.patch.object(identify_overlay.AppHelper, "callLater",
                                   lambda delay, callback, *args: self.later.append((delay, callback, args)))
        patcher.start()
        self.addCleanup(patcher.stop)
        patcher = mock.patch.object(identify_overlay.desktop_mac, "display_map", return_value={
            "0": Rect(1920, 0, 1512, 982), "1": Rect(0, 0, 1920, 1080)})
        patcher.start()
        self.addCleanup(patcher.stop)

    def test_numbered_panels_ignore_clicks_and_never_become_key_or_main(self):
        app = AppKit.NSApplication.sharedApplication()
        key, main = app.keyWindow(), app.mainWindow()
        self.overlay.show({"0": 2, "1": 1})
        self.assertEqual([panel.identify_number for panel in self.overlay.panels], [2, 1])
        for panel in self.overlay.panels:
            self.assertTrue(panel.ignoresMouseEvents())
            self.assertFalse(panel.canBecomeKeyWindow())
            self.assertFalse(panel.canBecomeMainWindow())
            self.assertTrue(panel.styleMask() & AppKit.NSWindowStyleMaskNonactivatingPanel)
            self.assertTrue(panel.collectionBehavior() & AppKit.NSWindowCollectionBehaviorFullScreenAuxiliary)
        self.assertEqual(app.keyWindow(), key)
        self.assertEqual(app.mainWindow(), main)

    def test_each_label_is_centred_on_its_physical_display(self):
        self.overlay.show({"0": 2, "1": 1})
        for panel, centre in zip(self.overlay.panels, (2676, 960)):
            frame = panel.frame()
            self.assertEqual(frame.origin.x + frame.size.width / 2, centre)

    def test_timeout_hides_and_releases_all_panels_after_three_seconds(self):
        self.overlay.show({"0": 2, "1": 1})
        panels = list(self.overlay.panels)
        delay, expire, args = self.later[-1]
        self.assertEqual(delay, 3.0)
        expire(*args)
        self.assertEqual(self.overlay.panels, [])
        self.assertFalse(any(panel.isVisible() for panel in panels))

    @mock.patch("time.monotonic", return_value=0.0)
    def test_repeat_does_not_replace_panels_or_extend_expiry_and_reopens_at_boundary(self, clock):
        self.overlay.show({"0": 2, "1": 1})
        previous = list(self.overlay.panels)
        _delay, old_expire, old_args = self.later[-1]
        clock.return_value = 2.9
        for _ in range(100):
            self.overlay.show({"0": 1, "1": 2})
        self.assertEqual(self.overlay.panels, previous)
        self.assertEqual(len(self.later), 1)
        clock.return_value = 3.0
        self.overlay.show({"0": 2, "1": 1})
        old_expire(*old_args)
        self.assertEqual(len(self.overlay.panels), 2)
        self.assertTrue(self.overlay.panels[0].isVisible())
        self.assertFalse(any(panel.isVisible() for panel in previous))
        _delay, expire, args = self.later[-1]
        expire(*args)
        self.assertEqual(self.overlay.panels, [])

    @mock.patch("time.monotonic", return_value=0.0)
    def test_failed_show_and_explicit_hide_do_not_reset_request_limit(self, clock):
        with mock.patch.object(identify_overlay.desktop_mac, "display_map", side_effect=RuntimeError("unavailable")):
            self.overlay.show({"0": 1})
        self.overlay.hide()
        clock.return_value = 2.9
        self.overlay.show({"0": 1})
        self.assertEqual(self.overlay.panels, [])
        clock.return_value = 3.0
        self.overlay.show({"0": 1})
        self.assertEqual(len(self.overlay.panels), 2)

    def test_stale_request_is_replaced_by_numbers_for_all_current_displays(self):
        self.overlay.show({"missing": 3})
        self.assertEqual([panel.identify_number for panel in self.overlay.panels], [1, 2])

    def test_newly_attached_display_is_identified_with_the_same_live_numbering(self):
        self.overlay.show({"1": 1})
        self.assertEqual([panel.identify_number for panel in self.overlay.panels], [1, 2])


class RoutingTests(unittest.TestCase):
    def setUp(self):
        self.controller = object.__new__(bridge.KVMController)
        self.settings = dict(machine_id=OWN, peers=[dict(id=PEER, port=24820),
                            dict(id=OLDER, port=24820), dict(id=PHONE, port=0)],
                            layout_set_at=1, layout={OWN: dict(x=0, y=0, w=320, h=100, displays=DISPLAYS),
                            PEER: dict(x=320, y=0, w=320, h=100, displays=DISPLAYS)})
        self.controller.book = SimpleNamespace(lock=threading.RLock(), _load=lambda: self.settings,
                                              peers=lambda: self.settings["peers"])
        self.controller.identity = lambda: {"id": protocol.read_id(OWN)}
        self.controller.crossing_displays_changed = mock.Mock()
        self.controller.on_identify_screens = mock.Mock()
        self.controller.logger = logging.getLogger("identify-routing-test")
        self.controller._peers_up = {}
        self.controller.responder = None

    def link(self, peer, capable=True):
        return SimpleNamespace(peer_id=peer, live=lambda: True, post=mock.Mock(),
                               caps={"identify_screens"} if capable else set())

    def test_local_and_peer_labels_match_the_map_and_older_peers_receive_nothing(self):
        current, older, phone = self.link(PEER), self.link(OLDER, False), self.link(PHONE)
        self.controller._peers_up = {PEER: current, OLDER: older, PHONE: phone}
        self.controller.identify_screens()
        expected = identify_screens.display_numbers(ways.derive_layout(self.settings, gap=0)[OWN])
        self.controller.on_identify_screens.assert_called_once_with(expected)
        self.assertEqual(protocol.read_identify_screens(current.post.call_args.args[0]), expected)
        older.post.assert_not_called()
        phone.post.assert_not_called()

    def test_inbound_only_link_receives_once_and_dual_link_is_not_duplicated(self):
        current = self.link(PEER)
        self.controller._peers_up = {PEER: current}
        server = SimpleNamespace(links=lambda: [protocol.read_id(PEER), protocol.read_id(OLDER)],
                                 caps_of=lambda _peer: {"identify_screens"}, send=mock.Mock())
        self.controller.responder = server
        self.controller.identify_screens()
        self.assertEqual(current.post.call_count, 1)
        self.assertEqual(server.send.call_count, 1)
        self.assertEqual(server.send.call_args.args[0], protocol.read_id(OLDER))

    def test_received_request_is_local_only_and_requires_capable_desktop(self):
        labels = {"0": 2, "1": 1}
        self.controller._link_message(self.link(PEER), protocol.identify_screens_msg(labels))
        self.controller.on_identify_screens.assert_called_once_with(labels)
        self.controller.on_identify_screens.reset_mock()
        self.controller._link_message(self.link(OLDER, False), protocol.identify_screens_msg(labels))
        self.controller._link_message(self.link(PHONE), protocol.identify_screens_msg(labels))
        self.controller.on_identify_screens.assert_not_called()


class MapTests(unittest.TestCase):
    def test_smallest_valid_tiles_keep_title_number_and_cycle_within_the_tile(self):
        smallest = ways.resize_tile(dict(x=0, y=0, w=160, h=100), 40)
        self.assertEqual((smallest["w"], smallest["h"]), (40, 25))
        for height in (25, 28, 31):
            canvas = diagram.AtlasCanvas.alloc().init().setup()
            canvas.setFrame_(((0, 0), (600, 300)))
            tiles = {OWN: dict(smallest, h=height), PEER: dict(smallest, x=40, h=height)}
            canvas.show_layout(tiles, {}, {OWN: "This Mac", PEER: "A long peer name"}, OWN, OWN,
                               cycle={PEER: True}, cycle_enabled=True)
            frames = {OWN: (20, 20, 40, height), PEER: (60, 20, 40, height)}
            with mock.patch.object(canvas, "_map", return_value=(frames, 1)):
                canvas._draw(False)
            for key, (x, y, width, tile_height) in frames.items():
                title = canvas.label_for_tile[key]
                number = canvas.display_number_layers[key][0]
                cycle = canvas.cycle_for_tile[key]
                visible = [title, number] + ([] if cycle.isHidden() else [cycle])
                self.assertGreaterEqual(title.frame().size.width, 24)
                self.assertGreaterEqual(title.frame().size.height, 12)
                for layer in visible:
                    box = layer.frame()
                    self.assertGreaterEqual(box.origin.x, x)
                    self.assertGreaterEqual(box.origin.y, y)
                    self.assertLessEqual(box.origin.x + box.size.width, x + width)
                    self.assertLessEqual(box.origin.y + box.size.height, y + tile_height)
                for index, first in enumerate(visible):
                    for second in visible[index + 1:]:
                        self.assertFalse(AppKit.NSIntersectsRect(first.frame(), second.frame()))
                if not cycle.isHidden():
                    tick = cycle.sublayers()[0].frame()
                    self.assertLessEqual(tick.origin.x + tick.size.width, cycle.frame().size.width)
                    self.assertLessEqual(tick.origin.y + tick.size.height, cycle.frame().size.height)

    def test_compact_titles_keep_readable_width_and_separate_number_and_cycle_rows(self):
        from test_map_ticks import canvas_for

        for size in ((260, 260), (200, 260)):
            canvas = canvas_for(size=size)
            for key, tile in canvas._map()[0].items():
                title = canvas.label_for_tile[key].frame()
                self.assertGreaterEqual(title.size.width, min(18, tile[2] - 16))
                self.assertGreaterEqual(title.origin.y, tile[1])
                self.assertLessEqual(title.origin.y + title.size.height, tile[1] + tile[3])
                cycle = canvas.cycle_for_tile[key]
                for badge in canvas.display_number_layers[key]:
                    self.assertFalse(AppKit.NSIntersectsRect(title, badge.frame()))
                    if not cycle.isHidden():
                        self.assertFalse(AppKit.NSIntersectsRect(cycle.frame(), badge.frame()))

    def test_display_badges_match_overlay_labels_including_single_display(self):
        canvas = diagram.AtlasCanvas.alloc().init().setup()
        canvas.setFrame_(((0, 0), (600, 300)))
        tiles = {OWN: dict(x=0, y=0, w=320, h=100, displays=DISPLAYS),
                 PEER: dict(x=320, y=0, w=160, h=100)}
        canvas.show_layout(tiles, {}, {OWN: "This Mac", PEER: "Peer"}, OWN, OWN)
        canvas._draw(False)
        for peer, tile in tiles.items():
            expected = [str(value) for value in identify_screens.display_numbers(tile).values()]
            self.assertEqual([str(layer.string()) for layer in canvas.display_number_layers[peer]], expected)

    def test_numbers_do_not_overlap_name_status_or_footer_on_stacked_or_split_displays(self):
        for displays in (DISPLAYS, {"0": dict(x=0, y=0, w=1920, h=1080),
                                    "1": dict(x=0, y=1080, w=1920, h=1080)}):
            canvas = diagram.AtlasCanvas.alloc().init().setup()
            canvas.setFrame_(((0, 0), (600, 300)))
            tile = dict(x=0, y=0, w=320, h=100, displays=displays)
            canvas.show_layout({OWN: tile}, {OWN: {"platform": "macOS"}}, {OWN: "This Mac"}, OWN, OWN)
            canvas._draw(False)
            for badge in canvas.display_number_layers[OWN]:
                for text in (canvas.label_for_tile[OWN], canvas.state_for_tile[OWN], canvas.outcome_for_tile[OWN]):
                    if not text.isHidden():
                        self.assertFalse(AppKit.NSIntersectsRect(text.frame(), badge.frame()))


class ButtonTests(Page):
    def test_crossing_button_runs_identify_without_modifying_settings(self):
        with mock.patch.object(bridge.KVMController, "identify_screens") as identify:
            window = self.build([])
            before = self.store.current()
            button = window.identify_screens_button
            self.assertEqual(button.title, "Identify screens")
            self.assertTrue(button.view.isEnabled())
            button.target.fire_(button.view)
            identify.assert_called_once_with()
            self.assertEqual(self.store.current(), before)


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