Debian Codegraph @

tests/unit_tests/test_orca_modifier_manager.py

raw
1 # Unit tests for orca_modifier_manager.py methods.
2 #
3 # Copyright 2025 Igalia, S.L.
4 # Author: Joanmarie Diggs <[email protected]>
5 #
6 # This library is free software; you can redistribute it and/or
7 # modify it under the terms of the GNU Lesser General Public
8 # License as published by the Free Software Foundation; either
9 # version 2.1 of the License, or (at your option) any later version.
10 #
11 # This library is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 # Lesser General Public License for more details.
15 #
16 # You should have received a copy of the GNU Lesser General Public
17 # License along with this library; if not, write to the
18 # Free Software Foundation, Inc., Franklin Street, Fifth Floor,
19 # Boston MA 02110-1301 USA.
20
21 # pylint: disable=wrong-import-position
22 # pylint: disable=import-outside-toplevel
23 # pylint: disable=too-many-public-methods
24 # pylint: disable=too-many-statements
25 # pylint: disable=protected-access
26 # pylint: disable=too-many-arguments
27 # pylint: disable=too-many-positional-arguments
28 # pylint: disable=too-many-locals
29
30 """Unit tests for orca_modifier_manager.py methods."""
31
32 from __future__ import annotations
33
34 import subprocess
35 from typing import TYPE_CHECKING
36 from unittest.mock import call
37
38 import pytest
39
40 if TYPE_CHECKING:
41 from unittest.mock import MagicMock
42
43 from .orca_test_context import OrcaTestContext
44
45
46 @pytest.mark.unit
47 class TestOrcaModifierManager:
48 """Test OrcaModifierManager class methods."""
49
50 def _setup_dependencies(self, test_context: OrcaTestContext) -> dict[str, MagicMock]:
51 """Returns dependencies for orca_modifier_manager module testing."""
52
53 additional_modules = ["orca.input_event_manager", "gi.repository"]
54 essential_modules = test_context.setup_shared_dependencies(additional_modules)
55
56 debug_mock = essential_modules["orca.debug"]
57 debug_mock.print_message = test_context.Mock()
58 debug_mock.LEVEL_INFO = 800
59
60 keybindings_mock = essential_modules["orca.keybindings"]
61 keybindings_mock.get_keycodes = test_context.Mock(return_value=(0, 0))
62
63 input_event_manager_mock = essential_modules["orca.input_event_manager"]
64 input_manager_instance = test_context.Mock()
65 input_manager_instance.add_grab_for_modifier = test_context.Mock(return_value=123)
66 input_manager_instance.remove_grab_for_modifier = test_context.Mock()
67 input_event_manager_mock.get_manager = test_context.Mock(
68 return_value=input_manager_instance,
69 )
70
71 gi_repository_mock = essential_modules["gi.repository"]
72
73 gdk_mock = test_context.Mock()
74 display_mock = test_context.Mock()
75 device_manager_mock = test_context.Mock()
76 display_mock.get_device_manager = test_context.Mock(return_value=device_manager_mock)
77 gdk_mock.Display = test_context.Mock()
78 gdk_mock.Display.get_default = test_context.Mock(return_value=display_mock)
79 gdk_mock.InputSource = test_context.Mock()
80 gdk_mock.InputSource.KEYBOARD = 4
81 gi_repository_mock.Gdk = gdk_mock
82
83 atspi_mock = test_context.Mock()
84 atspi_mock.generate_keyboard_event = test_context.Mock()
85 atspi_mock.ModifierType = test_context.Mock()
86 atspi_mock.ModifierType.SHIFTLOCK = 1
87 atspi_mock.ModifierType.SHIFT = 0
88 gi_repository_mock.Atspi = atspi_mock
89
90 glib_mock = test_context.Mock()
91 glib_mock.timeout_add = test_context.Mock()
92 gi_repository_mock.GLib = glib_mock
93
94 essential_modules["input_manager_instance"] = input_manager_instance
95 essential_modules["gdk"] = gdk_mock
96 essential_modules["atspi"] = atspi_mock
97 essential_modules["glib"] = glib_mock
98
99 from orca import gsettings_registry
100
101 gsettings_registry.get_registry().clear_runtime_values()
102
103 return essential_modules
104
105 def test_init(self, test_context: OrcaTestContext) -> None:
106 """Test OrcaModifierManager.__init__."""
107
108 self._setup_dependencies(test_context)
109 from orca import orca_modifier_manager
110
111 mock_gdk = test_context.Mock()
112 test_context.patch("orca.orca_modifier_manager.Gdk", new=mock_gdk)
113 mock_display = test_context.Mock()
114 mock_device_manager = test_context.Mock()
115 mock_display.get_device_manager.return_value = mock_device_manager
116 mock_gdk.Display.get_default.return_value = mock_display
117 manager = orca_modifier_manager.OrcaModifierManager()
118 assert not manager._grabbed_modifiers
119 assert manager._is_pressed is False
120 assert manager._original_xmodmap == b""
121 assert manager._caps_lock_cleared is False
122 assert manager._need_to_restore_orca_modifier is False
123
124 assert manager is not None
125
126 def test_init_no_display(self, test_context: OrcaTestContext) -> None:
127 """Test OrcaModifierManager.__init__ with no display available."""
128
129 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
130 from orca import orca_modifier_manager
131
132 mock_gdk = test_context.Mock()
133 test_context.patch("orca.orca_modifier_manager.Gdk", new=mock_gdk)
134 mock_gdk.Display.get_default.return_value = None
135 essential_modules["orca.debug"].reset_mock()
136 manager = orca_modifier_manager.OrcaModifierManager()
137
138 assert not manager._grabbed_modifiers
139 assert manager._is_pressed is False
140 assert manager._original_xmodmap == b""
141 assert manager._caps_lock_cleared is False
142 assert manager._need_to_restore_orca_modifier is False
143
144 @pytest.mark.parametrize(
145 "case",
146 [
147 {
148 "id": "keyboard_device",
149 "device_source": 4,
150 "should_refresh": True,
151 }, # Gdk.InputSource.KEYBOARD = 4
152 {
153 "id": "mouse_device",
154 "device_source": 0,
155 "should_refresh": False,
156 }, # Gdk.InputSource.MOUSE = 0
157 {
158 "id": "touchscreen_device",
159 "device_source": 5,
160 "should_refresh": False,
161 }, # Gdk.InputSource.TOUCHSCREEN = 5
162 ],
163 ids=lambda case: case["id"],
164 )
165 def test_on_device_changed(
166 self,
167 test_context: OrcaTestContext,
168 case: dict,
169 ) -> None:
170 """Test OrcaModifierManager._on_device_changed."""
171
172 self._setup_dependencies(test_context)
173 from orca import orca_modifier_manager
174
175 manager = orca_modifier_manager.OrcaModifierManager()
176
177 mock_device = test_context.Mock()
178 mock_device.get_source.return_value = case["device_source"]
179
180 mock_refresh = test_context.Mock()
181 test_context.patch_object(manager, "refresh_orca_modifiers", new=mock_refresh)
182 test_context.patch("orca.orca_modifier_manager.Gdk.InputSource.KEYBOARD", new=4)
183 manager._on_device_changed(None, mock_device)
184 if case["should_refresh"]:
185 mock_refresh.assert_called_once_with("Keyboard change detected.")
186 else:
187 mock_refresh.assert_not_called()
188
189 @pytest.mark.parametrize(
190 "case",
191 [
192 {
193 "id": "insert_grabbed",
194 "modifier": "Insert",
195 "orca_modifier_keys": ["Insert", "KP_Insert"],
196 "is_grabbed": True,
197 "expected_result": True,
198 },
199 {
200 "id": "insert_not_grabbed",
201 "modifier": "Insert",
202 "orca_modifier_keys": ["Insert", "KP_Insert"],
203 "is_grabbed": False,
204 "expected_result": False,
205 },
206 {
207 "id": "kp_insert_grabbed",
208 "modifier": "KP_Insert",
209 "orca_modifier_keys": ["Insert", "KP_Insert"],
210 "is_grabbed": True,
211 "expected_result": True,
212 },
213 {
214 "id": "kp_insert_not_grabbed",
215 "modifier": "KP_Insert",
216 "orca_modifier_keys": ["Insert", "KP_Insert"],
217 "is_grabbed": False,
218 "expected_result": False,
219 },
220 {
221 "id": "caps_lock_modifiers_set",
222 "modifier": "Caps_Lock",
223 "orca_modifier_keys": ["Caps_Lock"],
224 "is_grabbed": False,
225 "modifiers_are_set": True,
226 "expected_result": True,
227 },
228 {
229 "id": "caps_lock_modifiers_not_set",
230 "modifier": "Caps_Lock",
231 "orca_modifier_keys": ["Caps_Lock"],
232 "is_grabbed": False,
233 "modifiers_are_set": False,
234 "expected_result": False,
235 },
236 {
237 "id": "shift_lock_modifiers_set",
238 "modifier": "Shift_Lock",
239 "orca_modifier_keys": ["Shift_Lock"],
240 "is_grabbed": False,
241 "modifiers_are_set": True,
242 "expected_result": True,
243 },
244 {
245 "id": "shift_lock_modifiers_not_set",
246 "modifier": "Shift_Lock",
247 "orca_modifier_keys": ["Shift_Lock"],
248 "is_grabbed": False,
249 "modifiers_are_set": False,
250 "expected_result": False,
251 },
252 {
253 "id": "not_orca_modifier",
254 "modifier": "Control_L",
255 "orca_modifier_keys": ["Insert"],
256 "is_grabbed": False,
257 "expected_result": False,
258 },
259 ],
260 ids=lambda case: case["id"],
261 )
262 def test_is_orca_modifier(
263 self,
264 test_context,
265 case: dict,
266 ) -> None:
267 """Test OrcaModifierManager.is_orca_modifier."""
268
269 self._setup_dependencies(test_context)
270 from orca import orca_modifier_manager
271
272 manager = orca_modifier_manager.OrcaModifierManager()
273 manager._grabbed_modifiers = {"Insert": 1, "KP_Insert": 2} if case["is_grabbed"] else {}
274 manager._modifiers_are_set = case.get("modifiers_are_set", False)
275
276 manager._modifier_keys_override = case["orca_modifier_keys"]
277 result = manager.is_orca_modifier(case["modifier"])
278 assert result == case["expected_result"]
279
280 @pytest.mark.parametrize(
281 "case",
282 [
283 {
284 "id": "get_initial_false",
285 "test_type": "get",
286 "initial_state": False,
287 "new_state": None,
288 "expected_get": False,
289 "expected_set": None,
290 },
291 {
292 "id": "get_set_true",
293 "test_type": "get",
294 "initial_state": True,
295 "new_state": None,
296 "expected_get": True,
297 "expected_set": None,
298 },
299 {
300 "id": "set_to_true",
301 "test_type": "set",
302 "initial_state": None,
303 "new_state": True,
304 "expected_get": None,
305 "expected_set": True,
306 },
307 {
308 "id": "set_to_false",
309 "test_type": "set",
310 "initial_state": None,
311 "new_state": False,
312 "expected_get": None,
313 "expected_set": False,
314 },
315 ],
316 ids=lambda case: case["id"],
317 )
318 def test_pressed_state_operations(self, test_context, case: dict) -> None:
319 """Test OrcaModifierManager get_pressed_state and set_pressed_state."""
320
321 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
322 from orca import orca_modifier_manager
323
324 manager = orca_modifier_manager.OrcaModifierManager()
325 essential_modules["orca.debug"].reset_mock()
326
327 if case["test_type"] == "get":
328 if case["initial_state"] is not None:
329 manager._is_pressed = case["initial_state"]
330 result = manager.get_pressed_state()
331 assert result == case["expected_get"]
332 else:
333 manager.set_pressed_state(case["new_state"])
334 assert manager._is_pressed == case["expected_set"]
335
336 @pytest.mark.parametrize(
337 "case",
338 [
339 {
340 "id": "modifier_grabbed",
341 "grabbed_modifiers": {"Insert": 1, "KP_Insert": 2},
342 "modifier": "Insert",
343 "expected_result": True,
344 },
345 {
346 "id": "kp_modifier_grabbed",
347 "grabbed_modifiers": {"Insert": 1, "KP_Insert": 2},
348 "modifier": "KP_Insert",
349 "expected_result": True,
350 },
351 {
352 "id": "modifier_not_grabbed",
353 "grabbed_modifiers": {"Insert": 1},
354 "modifier": "KP_Insert",
355 "expected_result": False,
356 },
357 {
358 "id": "no_grabs",
359 "grabbed_modifiers": {},
360 "modifier": "Insert",
361 "expected_result": False,
362 },
363 ],
364 ids=lambda case: case["id"],
365 )
366 def test_is_modifier_grabbed(
367 self,
368 test_context,
369 case: dict,
370 ) -> None:
371 """Test OrcaModifierManager.is_modifier_grabbed."""
372
373 self._setup_dependencies(test_context)
374 from orca import orca_modifier_manager
375
376 manager = orca_modifier_manager.OrcaModifierManager()
377 manager._grabbed_modifiers = case["grabbed_modifiers"]
378 result = manager.is_modifier_grabbed(case["modifier"])
379 assert result == case["expected_result"]
380
381 @pytest.mark.parametrize(
382 "orca_modifier_keys, expected_calls",
383 [
384 pytest.param(["Insert", "KP_Insert"], ["Insert", "KP_Insert"], id="insert_keys"),
385 pytest.param(["Caps_Lock"], [], id="caps_lock_no_grab"),
386 pytest.param(
387 ["Insert", "Caps_Lock", "KP_Insert"],
388 ["Insert", "KP_Insert"],
389 id="mixed_keys",
390 ),
391 pytest.param([], [], id="no_keys"),
392 ],
393 )
394 def test_add_grabs_for_orca_modifiers(
395 self,
396 test_context,
397 orca_modifier_keys,
398 expected_calls,
399 ) -> None:
400 """Test OrcaModifierManager.add_grabs_for_orca_modifiers."""
401
402 self._setup_dependencies(test_context)
403 from orca import orca_modifier_manager
404
405 manager = orca_modifier_manager.OrcaModifierManager()
406 manager._modifier_keys_override = orca_modifier_keys
407
408 mock_add_grab = test_context.Mock()
409 test_context.patch_object(manager, "add_modifier_grab", new=mock_add_grab)
410 manager.add_grabs_for_orca_modifiers()
411 calls = [call(modifier) for modifier in expected_calls]
412 mock_add_grab.assert_has_calls(calls, any_order=True)
413 assert mock_add_grab.call_count == len(expected_calls)
414
415 @pytest.mark.parametrize(
416 "orca_modifier_keys, expected_calls",
417 [
418 pytest.param(["Insert", "KP_Insert"], ["Insert", "KP_Insert"], id="insert_keys"),
419 pytest.param(["Caps_Lock"], [], id="caps_lock_no_ungrab"),
420 pytest.param(
421 ["Insert", "Caps_Lock", "KP_Insert"],
422 ["Insert", "KP_Insert"],
423 id="mixed_keys",
424 ),
425 pytest.param([], [], id="no_keys"),
426 ],
427 )
428 def test_remove_grabs_for_orca_modifiers(
429 self,
430 test_context,
431 orca_modifier_keys,
432 expected_calls,
433 ) -> None:
434 """Test OrcaModifierManager.remove_grabs_for_orca_modifiers."""
435
436 self._setup_dependencies(test_context)
437 from orca import orca_modifier_manager
438
439 manager = orca_modifier_manager.OrcaModifierManager()
440 manager._modifier_keys_override = orca_modifier_keys
441
442 mock_remove_grab = test_context.Mock()
443 test_context.patch_object(manager, "remove_modifier_grab", new=mock_remove_grab)
444 manager.remove_grabs_for_orca_modifiers()
445 calls = [call(modifier) for modifier in expected_calls]
446 mock_remove_grab.assert_has_calls(calls, any_order=True)
447 assert mock_remove_grab.call_count == len(expected_calls)
448 assert manager._is_pressed is False
449
450 @pytest.mark.parametrize(
451 "scenario,has_existing,grab_result,expects_keycodes_call,expects_grab_call,expects_in_dict",
452 [
453 pytest.param("new", False, 123, True, True, True, id="new_modifier"),
454 pytest.param("existing", True, None, False, False, True, id="existing_modifier"),
455 pytest.param("failed", False, -1, True, True, False, id="failed_grab"),
456 ],
457 )
458 def test_add_modifier_grab(
459 self,
460 test_context,
461 scenario: str,
462 has_existing: bool,
463 grab_result: int | None,
464 expects_keycodes_call: bool,
465 expects_grab_call: bool,
466 expects_in_dict: bool,
467 ) -> None:
468 """Test OrcaModifierManager.add_modifier_grab with various scenarios."""
469
470 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
471 from orca import orca_modifier_manager
472
473 manager = orca_modifier_manager.OrcaModifierManager()
474
475 if has_existing:
476 manager._grabbed_modifiers["Insert"] = 123
477
478 if scenario != "existing":
479 mock_get_keycodes = test_context.Mock()
480 test_context.patch(
481 "orca.orca_modifier_manager.keybindings.get_keycodes",
482 new=mock_get_keycodes,
483 )
484 mock_iem = test_context.Mock()
485 test_context.patch(
486 "orca.orca_modifier_manager.input_event_manager.get_manager",
487 new=mock_iem,
488 )
489 mock_get_keycodes.return_value = (65379, 110)
490 mock_input_manager = test_context.Mock()
491 mock_input_manager.add_grab_for_modifier.return_value = grab_result
492 mock_iem.return_value = mock_input_manager
493
494 manager.add_modifier_grab("Insert")
495
496 if expects_keycodes_call:
497 mock_get_keycodes.assert_called_once_with("Insert")
498 elif scenario == "existing":
499 essential_modules["orca.keybindings"].get_keycodes.assert_not_called()
500
501 if expects_grab_call:
502 mock_input_manager.add_grab_for_modifier.assert_called_once_with("Insert", 65379, 110)
503 elif scenario == "existing":
504 essential_modules["input_manager_instance"].add_grab_for_modifier.assert_not_called()
505
506 if expects_in_dict:
507 if scenario in ("new", "existing"):
508 assert manager._grabbed_modifiers["Insert"] == 123
509 else:
510 assert "Insert" not in manager._grabbed_modifiers
511
512 @pytest.mark.parametrize(
513 "has_grabbed,expects_call",
514 [
515 pytest.param(True, True, id="grabbed_modifier"),
516 pytest.param(False, False, id="not_grabbed_modifier"),
517 ],
518 )
519 def test_remove_modifier_grab(
520 self,
521 test_context,
522 has_grabbed: bool,
523 expects_call: bool,
524 ) -> None:
525 """Test OrcaModifierManager.remove_modifier_grab with grabbed and non-grabbed modifiers."""
526
527 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
528 from orca import orca_modifier_manager
529
530 manager = orca_modifier_manager.OrcaModifierManager()
531
532 if has_grabbed:
533 manager._grabbed_modifiers["Insert"] = 123
534 mock_iem = test_context.Mock()
535 test_context.patch(
536 "orca.orca_modifier_manager.input_event_manager.get_manager",
537 new=mock_iem,
538 )
539 mock_input_manager = test_context.Mock()
540 mock_iem.return_value = mock_input_manager
541
542 manager.remove_modifier_grab("Insert")
543
544 if expects_call:
545 mock_input_manager.remove_grab_for_modifier.assert_called_once_with("Insert", 123)
546 assert "Insert" not in manager._grabbed_modifiers
547 else:
548 essential_modules["input_manager_instance"].remove_grab_for_modifier.assert_not_called()
549
550 @pytest.mark.parametrize(
551 "keyval_name, expected_method",
552 [
553 pytest.param("Caps_Lock", "_toggle_modifier_lock", id="caps_lock"),
554 pytest.param("Shift_Lock", "_toggle_modifier_lock", id="shift_lock"),
555 pytest.param("Insert", "_toggle_modifier_grab", id="insert"),
556 pytest.param("KP_Insert", "_toggle_modifier_grab", id="kp_insert"),
557 ],
558 )
559 def test_toggle_modifier(
560 self,
561 test_context,
562 keyval_name,
563 expected_method,
564 ) -> None:
565 """Test OrcaModifierManager.toggle_modifier."""
566
567 self._setup_dependencies(test_context)
568 from orca import orca_modifier_manager
569
570 manager = orca_modifier_manager.OrcaModifierManager()
571 mock_keyboard_event = test_context.Mock()
572 mock_keyboard_event.keyval_name = keyval_name
573 mock_keyboard_event.hw_code = 110
574 mock_keyboard_event.modifiers = 0
575 mock_keyboard_event.is_pressed_key.return_value = False
576 mock_method = test_context.Mock()
577 test_context.patch_object(manager, expected_method, new=mock_method)
578 manager.toggle_modifier(mock_keyboard_event)
579 mock_method.assert_called_once_with(mock_keyboard_event)
580
581 @pytest.mark.parametrize(
582 "is_pressed_key, expects_remove_call, expects_timeout_calls",
583 [
584 pytest.param(True, False, 0, id="pressed_key_no_action"),
585 pytest.param(False, True, 2, id="released_key_full_action"),
586 ],
587 )
588 def test_toggle_modifier_grab(
589 self,
590 test_context: OrcaTestContext,
591 is_pressed_key,
592 expects_remove_call,
593 expects_timeout_calls,
594 ) -> None:
595 """Test OrcaModifierManager._toggle_modifier_grab with pressed and released keys."""
596 self._setup_dependencies(test_context)
597 from orca import orca_modifier_manager
598
599 manager = orca_modifier_manager.OrcaModifierManager()
600 mock_keyboard_event = test_context.Mock()
601 mock_keyboard_event.keyval_name = "Insert"
602 mock_keyboard_event.hw_code = 110
603 mock_keyboard_event.modifiers = 0
604 mock_keyboard_event.is_pressed_key.return_value = is_pressed_key
605 mock_remove = test_context.Mock()
606 test_context.patch_object(manager, "remove_modifier_grab", new=mock_remove)
607 mock_add_grab = test_context.Mock()
608 test_context.patch_object(manager, "add_modifier_grab", new=mock_add_grab)
609 mock_timeout = test_context.Mock()
610 test_context.patch("orca.orca_modifier_manager.GLib.timeout_add", new=mock_timeout)
611 test_context.patch(
612 "orca.orca_modifier_manager.Atspi.generate_keyboard_event",
613 side_effect=lambda *args, **kwargs: None,
614 )
615
616 manager._toggle_modifier_grab(mock_keyboard_event)
617
618 if expects_remove_call:
619 mock_remove.assert_called_once_with("Insert")
620 assert mock_timeout.call_count == expects_timeout_calls
621 if expects_timeout_calls > 0:
622 timeout_calls = mock_timeout.call_args_list
623 assert timeout_calls[0][0][0] == 1
624 assert timeout_calls[0][0][2] == 110 # hw_code
625 if expects_timeout_calls > 1:
626 assert timeout_calls[1][0][0] == 500
627 assert timeout_calls[1][0][2] == "Insert" # modifier name
628 else:
629 mock_remove.assert_not_called()
630 assert mock_timeout.call_count == expects_timeout_calls
631
632 @pytest.mark.parametrize(
633 "keyval_name, is_pressed, expected_modifier",
634 [
635 pytest.param(
636 "Caps_Lock",
637 True,
638 1 << 1,
639 id="caps_lock_pressed", # 1 << Atspi.ModifierType.SHIFTLOCK
640 ),
641 pytest.param(
642 "Shift_Lock",
643 True,
644 1 << 0,
645 id="shift_lock_pressed", # 1 << Atspi.ModifierType.SHIFT
646 ),
647 pytest.param("Caps_Lock", False, None, id="caps_lock_released"),
648 pytest.param("Other_Key", True, None, id="other_key"),
649 ],
650 )
651 def test_toggle_modifier_lock(
652 self,
653 test_context,
654 keyval_name,
655 is_pressed,
656 expected_modifier,
657 ) -> None:
658 """Test OrcaModifierManager._toggle_modifier_lock."""
659
660 self._setup_dependencies(test_context)
661 from orca import orca_modifier_manager
662
663 test_context.patch("orca.orca_modifier_manager.Atspi.ModifierType.SHIFTLOCK", new=1)
664 test_context.patch("orca.orca_modifier_manager.Atspi.ModifierType.SHIFT", new=0)
665 manager = orca_modifier_manager.OrcaModifierManager()
666 mock_keyboard_event = test_context.Mock()
667 mock_keyboard_event.keyval_name = keyval_name
668 mock_keyboard_event.hw_code = 110
669 mock_keyboard_event.modifiers = 0
670 mock_keyboard_event.is_pressed_key.return_value = is_pressed
671 mock_timeout = test_context.Mock()
672 test_context.patch("orca.orca_modifier_manager.GLib.timeout_add", new=mock_timeout)
673 manager._toggle_modifier_lock(mock_keyboard_event)
674 if expected_modifier is not None:
675 mock_timeout.assert_called_once()
676 timeout_call = mock_timeout.call_args_list[0]
677 assert timeout_call[0][0] == 1 # 1ms delay
678 assert timeout_call[0][2] == 0 # modifiers
679 assert timeout_call[0][3] == expected_modifier # modifier value
680 else:
681 mock_timeout.assert_not_called()
682
683 def test_refresh_orca_modifiers(self, test_context: OrcaTestContext) -> None:
684 """Test OrcaModifierManager.refresh_orca_modifiers."""
685
686 self._setup_dependencies(test_context)
687 from orca import orca_modifier_manager
688
689 manager = orca_modifier_manager.OrcaModifierManager()
690 test_context.patch("os.environ", new={"DISPLAY": ":0"})
691 mock_popen = test_context.Mock()
692 test_context.patch("orca.orca_modifier_manager.subprocess.Popen", new=mock_popen)
693 mock_process = test_context.Mock()
694 mock_process.communicate.return_value = (b"xmodmap_content", b"")
695 mock_context_manager = test_context.Mock()
696 mock_context_manager.__enter__ = test_context.Mock(return_value=mock_process)
697 mock_context_manager.__exit__ = test_context.Mock(return_value=None)
698 mock_popen.return_value = mock_context_manager
699 mock_restore = test_context.Mock()
700 test_context.patch_object(manager, "_restore_original_xkbcomp", new=mock_restore)
701 mock_create = test_context.Mock()
702 test_context.patch_object(manager, "_create_orca_xmodmap", new=mock_create)
703 manager.refresh_orca_modifiers("test reason")
704 mock_restore.assert_called_once()
705 mock_popen.assert_called_once_with(
706 ["xkbcomp", ":0", "-"],
707 stdout=subprocess.PIPE,
708 stderr=subprocess.DEVNULL,
709 )
710 assert manager._original_xmodmap == b"xmodmap_content"
711 assert manager._modifiers_are_set is True
712 mock_create.assert_called_once()
713
714 @pytest.mark.parametrize(
715 "caps_lock_orca, shift_lock_orca, caps_cleared, expected_calls",
716 [
717 pytest.param(True, False, False, [("set_caps", True)], id="caps_lock_enable"),
718 pytest.param(False, True, False, [("set_caps", True)], id="shift_lock_enable"),
719 pytest.param(True, True, False, [("set_caps", True)], id="both_enable"),
720 pytest.param(
721 False,
722 False,
723 True,
724 [("set_caps", False)],
725 id="disable_previously_cleared",
726 ),
727 pytest.param(False, False, False, [], id="no_changes"),
728 ],
729 )
730 def test_create_orca_xmodmap(
731 self,
732 test_context,
733 caps_lock_orca,
734 shift_lock_orca,
735 caps_cleared,
736 expected_calls,
737 ) -> None:
738 """Test OrcaModifierManager._create_orca_xmodmap."""
739
740 self._setup_dependencies(test_context)
741 from orca import orca_modifier_manager
742
743 manager = orca_modifier_manager.OrcaModifierManager()
744 manager._caps_lock_cleared = caps_cleared
745
746 orca_modifier_keys: list[str] = []
747 if caps_lock_orca:
748 orca_modifier_keys.append("Caps_Lock")
749 if shift_lock_orca:
750 orca_modifier_keys.append("Shift_Lock")
751 manager._modifier_keys_override = orca_modifier_keys
752 mock_set_caps = test_context.Mock()
753 test_context.patch_object(manager, "set_caps_lock_as_orca_modifier", new=mock_set_caps)
754 manager._create_orca_xmodmap()
755 for call_type, enable in expected_calls:
756 if call_type == "set_caps":
757 mock_set_caps.assert_called_with(enable)
758
759 if caps_lock_orca or shift_lock_orca:
760 assert manager._caps_lock_cleared is True
761 elif caps_cleared and not caps_lock_orca and not shift_lock_orca:
762 assert manager._caps_lock_cleared is False
763
764 @pytest.mark.parametrize(
765 "has_xmodmap, expects_popen_call",
766 [
767 pytest.param(True, True, id="with_xmodmap"),
768 pytest.param(False, False, id="no_xmodmap"),
769 ],
770 )
771 def test_unset_orca_modifiers(
772 self,
773 test_context: OrcaTestContext,
774 has_xmodmap,
775 expects_popen_call,
776 ) -> None:
777 """Test OrcaModifierManager.unset_orca_modifiers with and without xmodmap."""
778 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
779 from orca import orca_modifier_manager
780
781 manager = orca_modifier_manager.OrcaModifierManager()
782 manager._modifiers_are_set = True
783 if has_xmodmap:
784 test_context.patch("os.environ", new={"DISPLAY": ":0"})
785 manager._original_xmodmap = b"original_xmodmap_content"
786 else:
787 manager._original_xmodmap = b""
788
789 essential_modules["orca.debug"].reset_mock()
790 mock_popen = test_context.Mock()
791 test_context.patch("orca.orca_modifier_manager.subprocess.Popen", new=mock_popen)
792
793 mock_unmap = test_context.Mock()
794 mock_iem = test_context.Mock()
795 mock_iem.unmap_all_modifiers = mock_unmap
796 test_context.patch(
797 "orca.orca_modifier_manager.input_event_manager.get_manager",
798 return_value=mock_iem,
799 )
800
801 if has_xmodmap:
802 mock_process = test_context.Mock()
803 mock_context_manager = test_context.Mock()
804 mock_context_manager.__enter__ = test_context.Mock(return_value=mock_process)
805 mock_context_manager.__exit__ = test_context.Mock(return_value=None)
806 mock_popen.return_value = mock_context_manager
807
808 manager.unset_orca_modifiers("test reason" if has_xmodmap else "")
809
810 assert manager._modifiers_are_set is False
811 mock_unmap.assert_called_once()
812 if expects_popen_call:
813 mock_popen.assert_called_once_with(
814 ["xkbcomp", "-w0", "-", ":0"],
815 stdin=subprocess.PIPE,
816 stdout=None,
817 stderr=None,
818 )
819 mock_process.communicate.assert_called_once_with(b"original_xmodmap_content")
820 assert manager._caps_lock_cleared is False
821 else:
822 mock_popen.assert_not_called()
823
824 @pytest.mark.parametrize(
825 "enable, xmodmap_content, expects_popen_call, expected_content",
826 [
827 pytest.param(
828 True,
829 """interpret Caps_Lock+AnyOfOrNone(all) {
830 action= LockMods(modifiers=Lock);
831 };""",
832 True,
833 b"NoAction()",
834 id="enable_caps_lock",
835 ),
836 pytest.param(
837 False,
838 """interpret Caps_Lock+AnyOfOrNone(all) {
839 action= NoAction();
840 };""",
841 True,
842 b"LockMods(modifiers=Lock)",
843 id="disable_caps_lock",
844 ),
845 pytest.param(
846 True,
847 "some other xmodmap content",
848 False,
849 None,
850 id="no_changes_needed",
851 ),
852 ],
853 )
854 def test_set_caps_lock_as_orca_modifier(
855 self,
856 test_context: OrcaTestContext,
857 enable,
858 xmodmap_content,
859 expects_popen_call,
860 expected_content,
861 ) -> None:
862 """Test OrcaModifierManager.set_caps_lock_as_orca_modifier with various scenarios."""
863 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
864 from orca import orca_modifier_manager
865
866 manager = orca_modifier_manager.OrcaModifierManager()
867 if expects_popen_call:
868 test_context.patch("os.environ", new={"DISPLAY": ":0"})
869
870 manager._original_xmodmap = xmodmap_content.encode("UTF-8")
871 essential_modules["orca.debug"].reset_mock()
872 mock_popen = test_context.Mock()
873 test_context.patch("orca.orca_modifier_manager.subprocess.Popen", new=mock_popen)
874
875 if expects_popen_call:
876 mock_process = test_context.Mock()
877 mock_context_manager = test_context.Mock()
878 mock_context_manager.__enter__ = test_context.Mock(return_value=mock_process)
879 mock_context_manager.__exit__ = test_context.Mock(return_value=None)
880 mock_popen.return_value = mock_context_manager
881
882 manager.set_caps_lock_as_orca_modifier(enable)
883
884 if expects_popen_call:
885 mock_popen.assert_called_once_with(
886 ["xkbcomp", "-w0", "-", ":0"],
887 stdin=subprocess.PIPE,
888 stdout=None,
889 stderr=None,
890 )
891 called_data = mock_process.communicate.call_args[0][0]
892 assert expected_content in called_data
893 else:
894 mock_popen.assert_not_called()
895
896 def test_get_manager(
897 self,
898 test_context,
899 ) -> None:
900 """Test orca_modifier_manager.get_manager."""
901
902 self._setup_dependencies(test_context)
903 from orca import orca_modifier_manager
904
905 manager1 = orca_modifier_manager.get_manager()
906 assert manager1 is not None
907 assert isinstance(manager1, orca_modifier_manager.OrcaModifierManager)
908
909 manager2 = orca_modifier_manager.get_manager()
910 assert manager2 is manager1