1091 lines
49 KiB
Python
1091 lines
49 KiB
Python
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()
|