import sys import unittest from pathlib import Path from unittest import mock sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src")) from cthulhu import input_event_manager from cthulhu import compositor_state_types class InputEventManagerX11FocusRegressionTests(unittest.TestCase): def setUp(self): self.compositorSnapshot = input_event_manager.cthulhu_state.compositorSnapshot input_event_manager.cthulhu_state.compositorSnapshot = None self.addCleanup( setattr, input_event_manager.cthulhu_state, "compositorSnapshot", self.compositorSnapshot, ) def test_active_x11_window_differs_from_cached_atspi_window_by_pid(self): manager = input_event_manager.InputEventManager() cachedWindow = object() with ( mock.patch.object(manager, "_get_active_x11_window_pid", return_value=1002), mock.patch.object(input_event_manager.AXObject, "get_process_id", return_value=1001), mock.patch.object(input_event_manager.debug, "print_tokens"), ): self.assertTrue(manager._active_x11_window_differs_from(cachedWindow)) def test_keyboard_event_clears_stale_context_before_recovering_old_focus_window(self): manager = input_event_manager.InputEventManager() staleWindow = object() staleFocus = object() focusManager = mock.Mock() focusManager.get_active_window.return_value = staleWindow focusManager.get_locus_of_focus.return_value = staleFocus scriptManager = mock.Mock() keyboardEvent = mock.Mock() keyboardEvent.is_modifier_key.return_value = False manager._last_input_event = object() manager._last_non_modifier_key_event = object() with ( mock.patch.object(input_event_manager.cthulhu_state, "capturingKeys", False), mock.patch.object(input_event_manager.focus_manager, "get_manager", return_value=focusManager), mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager), mock.patch.object(input_event_manager.input_event, "KeyboardEvent", return_value=keyboardEvent), mock.patch.object(input_event_manager.AXUtilities, "can_be_active_window", return_value=False), mock.patch.object(input_event_manager.AXUtilities, "find_active_window", return_value=None), mock.patch.object(manager, "_find_active_x11_atspi_window", return_value=None), mock.patch.object(manager, "_get_top_level_window", return_value=staleWindow), mock.patch.object(manager, "_should_pass_through_for_active_xterm", return_value=False), mock.patch.object(manager, "_active_x11_window_differs_from", return_value=True), mock.patch.object(manager, "last_event_was_keyboard", return_value=False), mock.patch.object(input_event_manager.debug, "print_message"), ): result = manager.process_keyboard_event( mock.Mock(), True, 36, 65293, 0, "Return", ) self.assertFalse(result) scriptManager.set_active_script.assert_called_once_with( None, "active X11 window not found in AT-SPI", ) focusManager.clear_state.assert_called_once_with("active X11 window not found in AT-SPI") focusManager.set_active_window.assert_not_called() keyboardEvent.process.assert_not_called() self.assertIsNone(manager._last_input_event) self.assertIsNone(manager._last_non_modifier_key_event) def test_keyboard_event_clears_stale_script_when_cached_context_is_missing(self): manager = input_event_manager.InputEventManager() staleApp = object() staleScript = mock.Mock(app=staleApp) focusManager = mock.Mock() focusManager.get_active_window.return_value = None focusManager.get_locus_of_focus.return_value = None scriptManager = mock.Mock() scriptManager.get_active_script.return_value = staleScript keyboardEvent = mock.Mock() keyboardEvent.is_modifier_key.return_value = False with ( mock.patch.object(input_event_manager.cthulhu_state, "capturingKeys", False), mock.patch.object(input_event_manager.focus_manager, "get_manager", return_value=focusManager), mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager), mock.patch.object(input_event_manager.input_event, "KeyboardEvent", return_value=keyboardEvent), mock.patch.object(input_event_manager.AXUtilities, "can_be_active_window", return_value=False), mock.patch.object(input_event_manager.AXUtilities, "find_active_window", return_value=None), mock.patch.object(manager, "_find_active_x11_atspi_window", return_value=None), mock.patch.object(manager, "_get_top_level_window", return_value=None), mock.patch.object(manager, "_should_pass_through_for_active_xterm", return_value=False), mock.patch.object(manager, "_active_x11_window_differs_from", return_value=True) as differs, mock.patch.object(manager, "last_event_was_keyboard", return_value=False), mock.patch.object(input_event_manager.debug, "print_message"), ): result = manager.process_keyboard_event( mock.Mock(), True, 81, 65434, 0, "KP_Page_Up", ) self.assertFalse(result) differs.assert_called_once_with(staleApp) scriptManager.set_active_script.assert_called_once_with( None, "active X11 window not found in AT-SPI", ) focusManager.clear_state.assert_called_once_with("active X11 window not found in AT-SPI") keyboardEvent.process.assert_not_called() def test_keyboard_event_recovers_focus_window_when_x11_does_not_contradict_it(self): manager = input_event_manager.InputEventManager() cachedWindow = object() staleFocus = object() focusManager = mock.Mock() focusManager.get_active_window.return_value = cachedWindow focusManager.get_locus_of_focus.return_value = staleFocus scriptManager = mock.Mock() keyboardEvent = mock.Mock() keyboardEvent.is_modifier_key.return_value = False with ( mock.patch.object(input_event_manager.cthulhu_state, "capturingKeys", False), mock.patch.object(input_event_manager.focus_manager, "get_manager", return_value=focusManager), mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager), mock.patch.object(input_event_manager.input_event, "KeyboardEvent", return_value=keyboardEvent), mock.patch.object(input_event_manager.AXUtilities, "can_be_active_window", return_value=False), mock.patch.object(input_event_manager.AXUtilities, "find_active_window", return_value=None), mock.patch.object(manager, "_find_active_x11_atspi_window", return_value=None), mock.patch.object(manager, "_get_top_level_window", return_value=cachedWindow), mock.patch.object(manager, "_should_pass_through_for_active_xterm", return_value=False), mock.patch.object(manager, "_active_x11_window_differs_from", return_value=False), mock.patch.object(manager, "last_event_was_keyboard", return_value=False), mock.patch.object(input_event_manager.debug, "print_message"), ): result = manager.process_keyboard_event( mock.Mock(), True, 36, 65293, 0, "Return", ) self.assertTrue(result) focusManager.set_active_window.assert_called_once_with(cachedWindow) scriptManager.set_active_script.assert_not_called() focusManager.clear_state.assert_not_called() keyboardEvent.process.assert_called_once_with() def test_keyboard_press_keeps_cthulhu_commands_when_unknown_window_is_not_xterm(self): manager = input_event_manager.InputEventManager() focusManager = mock.Mock() focusManager.get_active_window.return_value = None focusManager.get_locus_of_focus.return_value = None scriptManager = mock.Mock() activeScript = mock.Mock(app=None) scriptManager.get_active_script.return_value = activeScript keyboardEvent = mock.Mock() with ( mock.patch.object(input_event_manager.cthulhu_state, "capturingKeys", False), mock.patch.object(input_event_manager.cthulhu_state, "pendingSelfHostedFocus", None), mock.patch.object(input_event_manager.focus_manager, "get_manager", return_value=focusManager), mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager), mock.patch.object(input_event_manager.input_event, "KeyboardEvent", return_value=keyboardEvent), mock.patch.object(input_event_manager.AXUtilities, "can_be_active_window", return_value=False), mock.patch.object(input_event_manager.AXUtilities, "find_active_window", return_value=None), mock.patch.object(manager, "_get_top_level_window", return_value=None), mock.patch.object(manager, "_should_pass_through_for_active_xterm", return_value=False), mock.patch.object(manager, "_active_x11_window_differs_from", return_value=False), mock.patch.object(manager, "last_event_was_keyboard", return_value=False), mock.patch.object(input_event_manager.debug, "print_message"), ): result = manager.process_keyboard_event( mock.Mock(), True, 79, 65429, 0, "KP_Home", ) self.assertTrue(result) activeScript.removeKeyGrabs.assert_not_called() keyboardEvent.process.assert_called_once_with() def test_keyboard_press_suspends_grabs_and_passes_through_when_active_xterm_is_focused(self): manager = input_event_manager.InputEventManager() staleWindow = object() staleFocus = object() focusManager = mock.Mock() focusManager.get_active_window.return_value = staleWindow focusManager.get_locus_of_focus.return_value = staleFocus scriptManager = mock.Mock() activeScript = mock.Mock(app=None) scriptManager.get_active_script.return_value = activeScript keyboardEvent = mock.Mock() with ( mock.patch.object(input_event_manager.cthulhu_state, "capturingKeys", False), mock.patch.object(input_event_manager.cthulhu_state, "pendingSelfHostedFocus", None), mock.patch.object(input_event_manager.focus_manager, "get_manager", return_value=focusManager), mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager), mock.patch.object(input_event_manager.input_event, "KeyboardEvent", return_value=keyboardEvent), mock.patch.object(manager, "_should_pass_through_for_active_xterm", return_value=True), mock.patch.object(input_event_manager.AXUtilities, "can_be_active_window") as canBeActiveWindow, mock.patch.object(input_event_manager.AXUtilities, "find_active_window") as findActiveWindow, mock.patch.object(input_event_manager.debug, "print_message"), ): result = manager.process_keyboard_event( mock.Mock(), True, 79, 65429, 0, "KP_Home", ) self.assertFalse(result) activeScript.removeKeyGrabs.assert_called_once_with() canBeActiveWindow.assert_not_called() findActiveWindow.assert_not_called() keyboardEvent.process.assert_not_called() def test_lxterminal_does_not_pass_through_as_xterm(self): manager = input_event_manager.InputEventManager() window = mock.Mock() window.get_class_group_name.return_value = "lxterminal" window.get_class_instance_name.return_value = "lxterminal" window.get_name.return_value = "LXTerminal" window.get_class_group.return_value = None window.get_pid.return_value = -1 with ( mock.patch.object(manager, "_get_active_x11_window", return_value=window), mock.patch.object(input_event_manager.debug, "print_message"), mock.patch.object(input_event_manager.debug, "print_tokens"), ): result = manager._should_pass_through_for_active_xterm(None, None, None) self.assertFalse(result) def test_xterm_pass_through_stays_active_when_window_lookup_temporarily_fails(self): manager = input_event_manager.InputEventManager() focusManager = mock.Mock() focusManager.get_active_window.return_value = None focusManager.get_locus_of_focus.return_value = None scriptManager = mock.Mock() activeScript = mock.Mock(app=None) scriptManager.get_active_script.return_value = activeScript keyboardEvent = mock.Mock() manager._scriptWithSuspendedGrabsForXterm = activeScript with ( mock.patch.object(input_event_manager.cthulhu_state, "capturingKeys", False), mock.patch.object(input_event_manager.cthulhu_state, "pendingSelfHostedFocus", None), mock.patch.object(input_event_manager.focus_manager, "get_manager", return_value=focusManager), mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager), mock.patch.object(input_event_manager.input_event, "KeyboardEvent", return_value=keyboardEvent), mock.patch.object(manager, "_active_x11_window_xterm_match", return_value=None), mock.patch.object(input_event_manager.debug, "print_message"), mock.patch.object(input_event_manager.debug, "print_tokens"), ): result = manager.process_keyboard_event( mock.Mock(), True, 90, 65438, 0, "KP_Insert", ) self.assertFalse(result) self.assertIs(manager._scriptWithSuspendedGrabsForXterm, activeScript) activeScript.addKeyGrabs.assert_not_called() keyboardEvent.process.assert_not_called() def test_xterm_pass_through_ignores_stale_pending_self_hosted_focus(self): manager = input_event_manager.InputEventManager() pendingFocus = object() focusManager = mock.Mock() focusManager.get_active_window.return_value = None focusManager.get_locus_of_focus.return_value = None scriptManager = mock.Mock() activeScript = mock.Mock(app=None) scriptManager.get_active_script.return_value = activeScript keyboardEvent = mock.Mock() with ( mock.patch.object(input_event_manager.cthulhu_state, "capturingKeys", False), mock.patch.object(input_event_manager.cthulhu_state, "pendingSelfHostedFocus", pendingFocus), mock.patch.object(input_event_manager.focus_manager, "get_manager", return_value=focusManager), mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager), mock.patch.object(input_event_manager.input_event, "KeyboardEvent", return_value=keyboardEvent), mock.patch.object(manager, "_active_x11_window_xterm_match", return_value=True), mock.patch.object(input_event_manager.debug, "print_message"), mock.patch.object(input_event_manager.debug, "print_tokens"), ): result = manager.process_keyboard_event( mock.Mock(), True, 90, 65438, 0, "KP_Insert", ) self.assertFalse(result) activeScript.removeKeyGrabs.assert_called_once_with() keyboardEvent.process.assert_not_called() def test_pending_self_hosted_focus_blocks_unknown_xterm_match(self): manager = input_event_manager.InputEventManager() with ( mock.patch.object(manager, "_active_x11_window_xterm_match", return_value=None), mock.patch.object(input_event_manager.debug, "print_message"), mock.patch.object(input_event_manager.debug, "print_tokens"), ): result = manager._should_pass_through_for_active_xterm(None, None, object()) self.assertFalse(result) def test_xterm_grabs_restore_when_active_window_is_positively_not_xterm(self): manager = input_event_manager.InputEventManager() focusManager = mock.Mock() focusManager.get_active_window.return_value = None focusManager.get_locus_of_focus.return_value = None scriptManager = mock.Mock() activeScript = mock.Mock(app=None) scriptManager.get_active_script.return_value = activeScript keyboardEvent = mock.Mock() keyboardEvent.is_modifier_key.return_value = False manager._scriptWithSuspendedGrabsForXterm = activeScript with ( mock.patch.object(input_event_manager.cthulhu_state, "capturingKeys", False), mock.patch.object(input_event_manager.cthulhu_state, "pendingSelfHostedFocus", None), mock.patch.object(input_event_manager.focus_manager, "get_manager", return_value=focusManager), mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager), mock.patch.object(input_event_manager.input_event, "KeyboardEvent", return_value=keyboardEvent), mock.patch.object(manager, "_active_x11_window_xterm_match", return_value=False), mock.patch.object(input_event_manager.AXUtilities, "can_be_active_window", return_value=True), mock.patch.object(manager, "last_event_was_keyboard", return_value=False), mock.patch.object(input_event_manager.debug, "print_message"), mock.patch.object(input_event_manager.debug, "print_tokens"), ): result = manager.process_keyboard_event( mock.Mock(), True, 36, 65293, 0, "Return", ) self.assertTrue(result) self.assertIsNone(manager._scriptWithSuspendedGrabsForXterm) activeScript.addKeyGrabs.assert_called_once_with() keyboardEvent.process.assert_called_once_with() def test_unidentified_active_x11_window_is_unknown_not_non_xterm(self): manager = input_event_manager.InputEventManager() window = mock.Mock() window.get_class_group_name.return_value = None window.get_class_instance_name.return_value = None window.get_name.return_value = None window.get_class_group.return_value = None window.get_pid.return_value = -1 with ( mock.patch.object(manager, "_get_active_x11_window", return_value=window), mock.patch.object(input_event_manager.debug, "print_message"), mock.patch.object(input_event_manager.debug, "print_tokens"), ): result = manager._active_x11_window_xterm_match() self.assertIsNone(result) def test_finds_focused_atspi_window_for_active_x11_pid(self): manager = input_event_manager.InputEventManager() app = object() unfocusedWindow = object() focusedWindow = object() with ( mock.patch.object(manager, "_get_active_x11_window_pid", return_value=23875), mock.patch.object( input_event_manager.AXUtilitiesApplication, "get_application_with_pid", return_value=app, ), mock.patch.object( input_event_manager.AXObject, "iter_children", return_value=iter([unfocusedWindow, focusedWindow]), ), mock.patch.object(input_event_manager.AXUtilities, "is_frame", return_value=True), mock.patch.object(input_event_manager.AXUtilities, "is_window", return_value=False), mock.patch.object(input_event_manager.AXUtilities, "is_dialog_or_alert", return_value=False), mock.patch.object(input_event_manager.AXUtilities, "is_focused", return_value=False), mock.patch.object( input_event_manager.AXUtilities, "get_focused_object", side_effect=[None, object()], ), mock.patch.object(input_event_manager.debug, "print_tokens"), ): result = manager._find_active_x11_atspi_window() self.assertIs(result, focusedWindow) def test_keyboard_event_recovers_context_from_active_x11_pid_window(self): manager = input_event_manager.InputEventManager() recoveredWindow = object() focusManager = mock.Mock() focusManager.get_active_window.return_value = None focusManager.get_locus_of_focus.return_value = None scriptManager = mock.Mock() activeScript = mock.Mock(app=None) scriptManager.get_active_script.return_value = activeScript keyboardEvent = mock.Mock() keyboardEvent.is_modifier_key.return_value = False with ( mock.patch.object(input_event_manager.cthulhu_state, "capturingKeys", False), mock.patch.object(input_event_manager.cthulhu_state, "pendingSelfHostedFocus", None), mock.patch.object(input_event_manager.focus_manager, "get_manager", return_value=focusManager), mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager), mock.patch.object(input_event_manager.input_event, "KeyboardEvent", return_value=keyboardEvent), mock.patch.object(input_event_manager.AXUtilities, "can_be_active_window", return_value=False), mock.patch.object(input_event_manager.AXUtilities, "find_active_window", return_value=None), mock.patch.object(manager, "_find_active_x11_atspi_window", return_value=recoveredWindow), mock.patch.object(manager, "last_event_was_keyboard", return_value=False), mock.patch.object(input_event_manager.debug, "print_message"), mock.patch.object(input_event_manager.debug, "print_tokens"), ): result = manager.process_keyboard_event( mock.Mock(), True, 79, 65429, 0, "KP_Home", ) self.assertTrue(result) focusManager.set_active_window.assert_called_once_with(recoveredWindow) activeScript.removeKeyGrabs.assert_not_called() keyboardEvent.set_window.assert_called_once_with(recoveredWindow) keyboardEvent.process.assert_called_once_with() def test_keyboard_release_suspends_grabs_and_passes_through_when_active_xterm_is_focused(self): manager = input_event_manager.InputEventManager() focusManager = mock.Mock() focusManager.get_active_window.return_value = None focusManager.get_locus_of_focus.return_value = None scriptManager = mock.Mock() activeScript = mock.Mock(app=None) scriptManager.get_active_script.return_value = activeScript keyboardEvent = mock.Mock() with ( mock.patch.object(input_event_manager.cthulhu_state, "capturingKeys", False), mock.patch.object(input_event_manager.cthulhu_state, "pendingSelfHostedFocus", None), mock.patch.object(input_event_manager.focus_manager, "get_manager", return_value=focusManager), mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager), mock.patch.object(input_event_manager.input_event, "KeyboardEvent", return_value=keyboardEvent), mock.patch.object(manager, "_should_pass_through_for_active_xterm", return_value=True), mock.patch.object(input_event_manager.debug, "print_message"), ): result = manager.process_keyboard_event( mock.Mock(), False, 79, 65429, 0, "KP_Home", ) self.assertFalse(result) activeScript.removeKeyGrabs.assert_called_once_with() keyboardEvent.process.assert_not_called() def test_xterm_grab_suspension_is_idempotent(self): manager = input_event_manager.InputEventManager() activeScript = mock.Mock() scriptManager = mock.Mock() scriptManager.get_active_script.return_value = activeScript with mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager): manager._suspend_key_grabs_for_xterm() manager._suspend_key_grabs_for_xterm() activeScript.removeKeyGrabs.assert_called_once_with() def test_xterm_grab_restore_readds_grabs_for_same_active_script(self): manager = input_event_manager.InputEventManager() activeScript = mock.Mock() scriptManager = mock.Mock() scriptManager.get_active_script.return_value = activeScript with mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager): manager._suspend_key_grabs_for_xterm() manager._restore_key_grabs_after_xterm() activeScript.removeKeyGrabs.assert_called_once_with() activeScript.addKeyGrabs.assert_called_once_with() def test_xterm_grab_restore_does_not_readd_grabs_for_inactive_script(self): manager = input_event_manager.InputEventManager() oldScript = mock.Mock() newScript = mock.Mock() scriptManager = mock.Mock() scriptManager.get_active_script.side_effect = [oldScript, newScript] with mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager): manager._suspend_key_grabs_for_xterm() manager._restore_key_grabs_after_xterm() oldScript.removeKeyGrabs.assert_called_once_with() oldScript.addKeyGrabs.assert_not_called() def test_xterm_grabs_restore_on_x11_focus_change_without_keyboard_event(self): manager = input_event_manager.InputEventManager() activeScript = mock.Mock() scriptManager = mock.Mock() scriptManager.get_active_script.return_value = activeScript manager._scriptWithSuspendedGrabsForXterm = activeScript with ( mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager), mock.patch.object(manager, "_active_x11_window_xterm_match", return_value=False) as matcher, mock.patch.object(input_event_manager.debug, "print_tokens"), ): manager._on_active_x11_window_changed(mock.Mock(), None) matcher.assert_called_once_with() activeScript.addKeyGrabs.assert_called_once_with() self.assertIsNone(manager._scriptWithSuspendedGrabsForXterm) def test_active_x11_window_uses_ewmh_id_instead_of_stale_wnck_active_window(self): manager = input_event_manager.InputEventManager() wnck = mock.Mock() screen = mock.Mock() ewmhWindow = object() wnck.Screen.get_default.return_value = screen wnck.Window.get.return_value = ewmhWindow with ( mock.patch.object(manager, "_get_wnck", return_value=wnck), mock.patch.object(manager, "_ensure_xterm_focus_monitor"), mock.patch.object(manager, "_get_ewmh_active_x11_window_id", return_value=0x1400010), ): result = manager._get_active_x11_window() self.assertIs(result, ewmhWindow) wnck.Window.get.assert_called_once_with(0x1400010) screen.get_active_window.assert_not_called() def test_active_x11_window_does_not_fall_back_to_stale_wnck_window_for_known_ewmh_id(self): manager = input_event_manager.InputEventManager() wnck = mock.Mock() screen = mock.Mock() wnck.Screen.get_default.return_value = screen wnck.Window.get.return_value = None with ( mock.patch.object(manager, "_get_wnck", return_value=wnck), mock.patch.object(manager, "_ensure_xterm_focus_monitor"), mock.patch.object(manager, "_get_ewmh_active_x11_window_id", return_value=0x1400010), mock.patch.object(input_event_manager.debug, "print_tokens"), ): result = manager._get_active_x11_window() self.assertIsNone(result) screen.get_active_window.assert_not_called() def test_active_x11_window_falls_back_to_wnck_when_ewmh_is_unavailable(self): manager = input_event_manager.InputEventManager() wnck = mock.Mock() screen = mock.Mock() fallbackWindow = object() wnck.Screen.get_default.return_value = screen screen.get_active_window.return_value = fallbackWindow with ( mock.patch.object(manager, "_get_wnck", return_value=wnck), mock.patch.object(manager, "_ensure_xterm_focus_monitor"), mock.patch.object(manager, "_get_ewmh_active_x11_window_id", return_value=None), ): result = manager._get_active_x11_window() self.assertIs(result, fallbackWindow) def test_xterm_match_reuses_cached_metadata_while_ewmh_window_id_is_unchanged(self): manager = input_event_manager.InputEventManager() with ( mock.patch.object( manager, "_get_ewmh_active_x11_window_id", return_value=0x1400010, ), mock.patch.object( manager, "_x11_window_id_xterm_match", return_value=False, ) as matcher, ): firstResult = manager._active_x11_window_xterm_match() secondResult = manager._active_x11_window_xterm_match() self.assertFalse(firstResult) self.assertFalse(secondResult) matcher.assert_called_once_with(0x1400010) def test_xterm_match_prefers_i3_focused_window_id_over_stale_ewmh_id(self): manager = input_event_manager.InputEventManager() snapshot = compositor_state_types.DesktopContextSnapshot( session_type="x11", backend_name="i3-ipc", focused_window_id=0x2600003, focused_workspace_empty=False, ) with ( mock.patch.object(input_event_manager.cthulhu_state, "compositorSnapshot", snapshot), mock.patch.object( manager, "_get_ewmh_active_x11_window_id", return_value=0x200000C, ) as getEwmhWindowId, mock.patch.object( manager, "_x11_window_id_xterm_match", return_value=False, ) as matcher, ): result = manager._active_x11_window_xterm_match() self.assertFalse(result) matcher.assert_called_once_with(0x2600003) getEwmhWindowId.assert_not_called() def test_xterm_match_refreshes_i3_context_before_reusing_cached_match(self) -> None: manager = input_event_manager.InputEventManager() staleSnapshot = compositor_state_types.DesktopContextSnapshot( session_type="x11", backend_name="i3-ipc", focused_window_id=0x200000C, focused_workspace_empty=False, ) freshSnapshot = compositor_state_types.DesktopContextSnapshot( session_type="x11", backend_name="i3-ipc", focused_window_id=0x2600003, focused_workspace_empty=False, ) adapter = mock.Mock() def refresh_context(_reason: str) -> compositor_state_types.DesktopContextSnapshot: input_event_manager.cthulhu_state.compositorSnapshot = freshSnapshot return freshSnapshot adapter.refresh_workspace_context.side_effect = refresh_context input_event_manager.cthulhu_state.compositorSnapshot = staleSnapshot manager._lastEwmhActiveWindowId = 0x200000C manager._lastEwmhXtermMatch = True manager.set_compositor_state_adapter(adapter) with mock.patch.object( manager, "_x11_window_id_xterm_match", return_value=False, ) as matcher: result = manager._active_x11_window_xterm_match() self.assertFalse(result) adapter.refresh_workspace_context.assert_called_once_with("xterm-handoff-check") matcher.assert_called_once_with(0x2600003) def test_i3_exact_xid_initializes_x11_before_matching_xterm(self): manager = input_event_manager.InputEventManager() snapshot = compositor_state_types.DesktopContextSnapshot( session_type="x11", backend_name="i3-ipc", focused_window_id=0x200000C, focused_workspace_empty=False, ) window = mock.Mock() window.get_wm_class.return_value = ("xterm", "XTerm") window.get_wm_name.return_value = "devel" window.get_full_property.return_value = None display = mock.Mock() display.create_resource_object.return_value = window def initializeX11(): manager._x11Display = display manager._x11AnyPropertyType = object() return True with ( mock.patch.object(input_event_manager.cthulhu_state, "compositorSnapshot", snapshot), mock.patch.object( manager, "_ensure_x11_display", side_effect=initializeX11, ) as ensureX11, mock.patch.object(manager, "_get_ewmh_active_x11_window_id") as getEwmhWindowId, ): result = manager._active_x11_window_xterm_match() self.assertTrue(result) ensureX11.assert_called_once_with() display.create_resource_object.assert_called_once_with("window", 0x200000C) getEwmhWindowId.assert_not_called() def test_confirmed_empty_i3_workspace_is_definitely_not_xterm(self): manager = input_event_manager.InputEventManager() manager._lastEwmhActiveWindowId = 0x200000C manager._lastEwmhXtermMatch = True snapshot = compositor_state_types.DesktopContextSnapshot( session_type="x11", backend_name="i3-ipc", focused_workspace_empty=True, ) with ( mock.patch.object(input_event_manager.cthulhu_state, "compositorSnapshot", snapshot), mock.patch.object(manager, "_get_ewmh_active_x11_window_id") as getEwmhWindowId, mock.patch.object(manager, "_x11_window_id_xterm_match") as matcher, ): result = manager._active_x11_window_xterm_match() self.assertFalse(result) self.assertIsNone(manager._lastEwmhActiveWindowId) self.assertFalse(manager._lastEwmhXtermMatch) getEwmhWindowId.assert_not_called() matcher.assert_not_called() def test_unknown_i3_context_falls_back_to_generic_ewmh_window_id(self): manager = input_event_manager.InputEventManager() snapshot = compositor_state_types.DesktopContextSnapshot( session_type="x11", backend_name="i3-ipc", focused_window_id=None, focused_workspace_empty=None, ) with ( mock.patch.object(input_event_manager.cthulhu_state, "compositorSnapshot", snapshot), mock.patch.object( manager, "_get_ewmh_active_x11_window_id", return_value=0x2600003, ), mock.patch.object( manager, "_x11_window_id_xterm_match", return_value=False, ) as matcher, ): result = manager._active_x11_window_xterm_match() self.assertFalse(result) matcher.assert_called_once_with(0x2600003) def test_ewmh_brave_window_does_not_use_stale_wnck_xterm_metadata(self): manager = input_event_manager.InputEventManager() with ( mock.patch.object( manager, "_get_ewmh_active_x11_window_id", return_value=0x2600003, ), mock.patch.object( manager, "_x11_window_id_xterm_match", return_value=False, ) as directMatcher, mock.patch.object(manager, "_get_active_x11_window") as getWnckWindow, mock.patch.object(manager, "_x11_window_xterm_match") as wnckMatcher, ): result = manager._active_x11_window_xterm_match() self.assertFalse(result) directMatcher.assert_called_once_with(0x2600003) getWnckWindow.assert_not_called() wnckMatcher.assert_not_called() def test_direct_x11_metadata_identifies_brave_as_non_xterm(self): manager = input_event_manager.InputEventManager() with mock.patch.object( manager, "_get_x11_window_metadata", return_value=(["brave-origin", "Brave-origin", "New Tab - Brave Origin"], 1234), ): result = manager._x11_window_id_xterm_match(0x2600003) self.assertFalse(result) def test_direct_x11_metadata_identifies_xterm(self): manager = input_event_manager.InputEventManager() with mock.patch.object( manager, "_get_x11_window_metadata", return_value=(["xterm", "XTerm", "devel"], 1234), ): result = manager._x11_window_id_xterm_match(0x200000C) self.assertTrue(result) def test_xterm_focus_change_suspends_grabs_without_keyboard_event(self): manager = input_event_manager.InputEventManager() activeScript = mock.Mock() scriptManager = mock.Mock() scriptManager.get_active_script.return_value = activeScript with ( mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager), mock.patch.object(manager, "_active_x11_window_xterm_match", return_value=True) as matcher, mock.patch.object(input_event_manager.debug, "print_tokens"), ): manager._on_active_x11_window_changed(mock.Mock(), None) matcher.assert_called_once_with() activeScript.removeKeyGrabs.assert_called_once_with() self.assertIs(manager._scriptWithSuspendedGrabsForXterm, activeScript) def test_initial_xterm_handoff_suspends_grabs(self): manager = input_event_manager.InputEventManager() manager._device = object() with ( mock.patch.object(manager, "_active_x11_window_xterm_match", return_value=True), mock.patch.object(manager, "_suspend_key_grabs_for_xterm") as suspend, mock.patch.object(manager, "_ensure_xterm_recovery_timer") as ensureTimer, mock.patch.object(input_event_manager.debug, "print_tokens"), ): manager._initialize_xterm_handoff() suspend.assert_called_once_with() ensureTimer.assert_called_once_with() def test_xterm_focus_poll_suspends_grabs_after_entering_xterm(self): manager = input_event_manager.InputEventManager() manager._device = object() with ( mock.patch.object(manager, "_active_x11_window_xterm_match", return_value=True), mock.patch.object(manager, "_suspend_key_grabs_for_xterm") as suspend, mock.patch.object(manager, "_restore_key_grabs_after_xterm") as restore, mock.patch.object(input_event_manager.debug, "print_tokens"), ): result = manager._poll_xterm_grab_recovery() self.assertTrue(result) suspend.assert_called_once_with() restore.assert_not_called() def test_xterm_focus_poll_restores_grabs_after_leaving_xterm(self): manager = input_event_manager.InputEventManager() manager._device = object() with ( mock.patch.object(manager, "_active_x11_window_xterm_match", return_value=False), mock.patch.object(manager, "_suspend_key_grabs_for_xterm") as suspend, mock.patch.object(manager, "_restore_key_grabs_after_xterm") as restore, mock.patch.object(input_event_manager.debug, "print_tokens"), ): result = manager._poll_xterm_grab_recovery() self.assertTrue(result) self.assertEqual(manager._xtermRecoveryPollCount, 1) restore.assert_called_once_with() suspend.assert_not_called() def test_xterm_match_records_last_raw_ewmh_window_id(self): manager = input_event_manager.InputEventManager() with ( mock.patch.object( manager, "_get_ewmh_active_x11_window_id", return_value=0x1400010, ), mock.patch.object( manager, "_x11_window_id_xterm_match", return_value=False, ), ): result = manager._active_x11_window_xterm_match() self.assertFalse(result) self.assertEqual(manager._lastEwmhReadWindowId, 0x1400010) def test_xterm_focus_poll_survives_transient_matcher_failure(self): manager = input_event_manager.InputEventManager() manager._device = object() manager._xtermRecoverySourceId = 23 with ( mock.patch.object( manager, "_active_x11_window_xterm_match", side_effect=RuntimeError("transient matcher failure"), ), mock.patch.object(input_event_manager.debug, "print_message") as printMessage, ): result = manager._poll_xterm_grab_recovery() self.assertTrue(result) self.assertEqual(manager._xtermRecoverySourceId, 23) printMessage.assert_called_once() def test_ewmh_read_failure_reconnects_on_next_check(self): manager = input_event_manager.InputEventManager() x11Display = mock.Mock() x11Root = mock.Mock() x11Root.get_full_property.side_effect = RuntimeError("display connection failed") manager._x11Display = x11Display manager._x11Root = x11Root manager._netActiveWindowAtom = object() manager._x11AnyPropertyType = object() manager._didAttemptX11Display = True with mock.patch.object(input_event_manager.debug, "print_message"): result = manager._get_ewmh_active_x11_window_id() self.assertIsNone(result) x11Display.close.assert_called_once_with() self.assertFalse(manager._didAttemptX11Display) def test_xterm_suppression_does_not_check_x11_without_active_handoff(self): manager = input_event_manager.InputEventManager() with mock.patch.object(manager, "_active_x11_window_xterm_match") as matcher: result = manager.should_suppress_atspi_events_for_xterm(refresh=True) self.assertFalse(result) matcher.assert_not_called() def test_xterm_suppression_ignores_background_event_without_x11_refresh(self): manager = input_event_manager.InputEventManager() manager._scriptWithSuspendedGrabsForXterm = object() with mock.patch.object(manager, "_active_x11_window_xterm_match") as matcher: result = manager.should_suppress_atspi_events_for_xterm(refresh=False) self.assertTrue(result) matcher.assert_not_called() def test_xterm_suppression_releases_handoff_for_real_focus_return(self): manager = input_event_manager.InputEventManager() activeScript = mock.Mock() scriptManager = mock.Mock() scriptManager.get_active_script.return_value = activeScript manager._scriptWithSuspendedGrabsForXterm = activeScript with ( mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager), mock.patch.object(manager, "_active_x11_window_xterm_match", return_value=False), mock.patch.object(input_event_manager.debug, "print_tokens"), ): result = manager.should_suppress_atspi_events_for_xterm(refresh=True) self.assertFalse(result) activeScript.addKeyGrabs.assert_called_once_with() self.assertIsNone(manager._scriptWithSuspendedGrabsForXterm) def test_xterm_focus_check_failure_starts_recovery_timer(self): manager = input_event_manager.InputEventManager() manager._device = object() manager._scriptWithSuspendedGrabsForXterm = object() with ( mock.patch.object(manager, "_active_x11_window_xterm_match", return_value=None), mock.patch.object(input_event_manager.GLib, "timeout_add", return_value=23), mock.patch.object(input_event_manager.debug, "print_tokens"), ): manager._on_active_x11_window_changed(mock.Mock(), None) self.assertEqual(manager._xtermRecoverySourceId, 23) def test_xterm_focus_monitor_is_connected_only_once(self): manager = input_event_manager.InputEventManager() screen = mock.Mock() screen.connect.return_value = 17 manager._ensure_xterm_focus_monitor(screen) manager._ensure_xterm_focus_monitor(screen) screen.connect.assert_called_once_with( "active-window-changed", manager._on_active_x11_window_changed, ) def test_xterm_suspension_starts_fallback_when_focus_monitor_is_unavailable(self): manager = input_event_manager.InputEventManager() manager._device = object() activeScript = mock.Mock() scriptManager = mock.Mock() scriptManager.get_active_script.return_value = activeScript with ( mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager), mock.patch.object(input_event_manager.GLib, "timeout_add", return_value=23) as timeoutAdd, mock.patch.object(input_event_manager.debug, "print_tokens"), ): manager._suspend_key_grabs_for_xterm() timeoutAdd.assert_called_once_with(100, manager._poll_xterm_grab_recovery) self.assertEqual(manager._xtermRecoverySourceId, 23) def test_xterm_grab_restore_failure_keeps_retry_state(self): manager = input_event_manager.InputEventManager() manager._device = object() activeScript = mock.Mock() activeScript.addKeyGrabs.side_effect = RuntimeError("grab failed") scriptManager = mock.Mock() scriptManager.get_active_script.return_value = activeScript manager._scriptWithSuspendedGrabsForXterm = activeScript with ( mock.patch.object(input_event_manager.script_manager, "get_manager", return_value=scriptManager), mock.patch.object(input_event_manager.GLib, "timeout_add", return_value=23), mock.patch.object(input_event_manager.debug, "print_message"), mock.patch.object(input_event_manager.debug, "print_tokens"), ): manager._restore_key_grabs_after_xterm() self.assertIs(manager._scriptWithSuspendedGrabsForXterm, activeScript) self.assertEqual(manager._xtermRecoverySourceId, 23) activeScript.removeKeyGrabs.assert_called_once_with() def test_stopping_key_watcher_disconnects_xterm_focus_monitor(self): manager = input_event_manager.InputEventManager() screen = mock.Mock() manager._xtermFocusScreen = screen manager._xtermFocusHandlerId = 17 manager._xtermRecoverySourceId = 23 manager._scriptWithSuspendedGrabsForXterm = object() x11Display = mock.Mock() manager._x11Display = x11Display manager._didAttemptX11Display = True with ( mock.patch.object(input_event_manager.GLib, "source_remove") as sourceRemove, mock.patch.object(input_event_manager.debug, "print_message"), ): manager.stop_key_watcher() screen.disconnect.assert_called_once_with(17) sourceRemove.assert_called_once_with(23) self.assertIsNone(manager._xtermFocusScreen) self.assertEqual(manager._xtermFocusHandlerId, 0) self.assertEqual(manager._xtermRecoverySourceId, 0) self.assertIsNone(manager._scriptWithSuspendedGrabsForXterm) x11Display.close.assert_called_once_with() self.assertFalse(manager._didAttemptX11Display) def test_identifier_is_xterm_matches_exact_xterm_only(self): self.assertTrue(input_event_manager.InputEventManager._identifier_is_xterm("xterm")) self.assertTrue(input_event_manager.InputEventManager._identifier_is_xterm("/usr/bin/xterm")) self.assertFalse(input_event_manager.InputEventManager._identifier_is_xterm("uxterm")) self.assertFalse(input_event_manager.InputEventManager._identifier_is_xterm("gnome-terminal")) if __name__ == "__main__": unittest.main()