Debian Codegraph @

tests/unit_tests/test_typing_echo_presenter.py

raw
1 # Unit tests for typing_echo_presenter.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=protected-access
24 # pylint: disable=too-many-public-methods
25 # pylint: disable=too-many-arguments
26 # pylint: disable=too-many-positional-arguments
27 # pylint: disable=too-many-lines
28
29 """Unit tests for typing_echo_presenter.py methods."""
30
31 from __future__ import annotations
32
33 from typing import TYPE_CHECKING
34 from unittest.mock import Mock
35
36 import pytest
37
38 if TYPE_CHECKING:
39 from typing import ClassVar
40
41 from .orca_test_context import OrcaTestContext
42
43
44 class _FakeGtkGrid:
45 """Minimal stub used in unit tests."""
46
47 def __init__(self, *_args, **_kwargs):
48 """Initialize fake GTK grid."""
49 self._children = []
50
51 def attach(self, *args, **kwargs):
52 """Attach widget to grid."""
53 self._children.append((args, kwargs))
54
55 def set_border_width(self, *_args, **_kwargs):
56 """Set border width."""
57 return None
58
59 def set_margin_start(self, *_args, **_kwargs):
60 """Set margin start."""
61 return None
62
63 def show_all(self):
64 """Show all widgets."""
65 return None
66
67
68 class _FakeCheckButton:
69 """Minimal stub emulating Gtk.CheckButton for unit tests."""
70
71 def __init__(self, label: str):
72 self.label = label
73 self.name = label
74 self._active = False
75 self._signal_handlers: dict[str, tuple] = {}
76
77 @classmethod
78 def new_with_mnemonic(cls, label: str) -> _FakeCheckButton:
79 """Create new check button with mnemonic."""
80 return cls(label)
81
82 def set_name(self, name: str) -> None:
83 """Set widget name."""
84 self.name = name
85
86 def set_use_underline(self, *_args, **_kwargs) -> None: # pragma: no cover - unused
87 """Set use underline."""
88 return None
89
90 def set_receives_default(self, *_args, **_kwargs) -> None: # pragma: no cover
91 """Set receives default."""
92 return None
93
94 def connect(self, signal: str, handler, data) -> None:
95 """Connect signal handler."""
96 self._signal_handlers[signal] = (handler, data)
97
98 def set_active(self, active: bool) -> None:
99 """Set active state."""
100 self._active = active
101
102 def get_active(self) -> bool: # pragma: no cover - helper when needed
103 """Get active state."""
104 return self._active
105
106 def set_sensitive(self, _sensitive: bool) -> None:
107 """Set sensitive state."""
108 return None
109
110
111 @pytest.mark.unit
112 class TestTypingEchoPresenter:
113 """Test TypingEchoPresenter and TypingEchoPreferencesGrid."""
114
115 _CMDNAME_VALUES: ClassVar[dict[str, str]] = {
116 "STRUCTURAL_NAVIGATION_MODE_CYCLE": "cycle_mode",
117 "BLOCKQUOTE_PREV": "previous_blockquote",
118 "BLOCKQUOTE_NEXT": "next_blockquote",
119 "BLOCKQUOTE_LIST": "list_blockquotes",
120 "BUTTON_PREV": "previous_button",
121 "BUTTON_NEXT": "next_button",
122 "BUTTON_LIST": "list_buttons",
123 "CHECK_BOX_PREV": "previous_checkbox",
124 "CHECK_BOX_NEXT": "next_checkbox",
125 "CHECK_BOX_LIST": "list_checkboxes",
126 "COMBO_BOX_PREV": "previous_combobox",
127 "COMBO_BOX_NEXT": "next_combobox",
128 "COMBO_BOX_LIST": "list_comboboxes",
129 "ENTRY_PREV": "previous_entry",
130 "ENTRY_NEXT": "next_entry",
131 "ENTRY_LIST": "list_entries",
132 "FORM_FIELD_PREV": "previous_form_field",
133 "FORM_FIELD_NEXT": "next_form_field",
134 "FORM_FIELD_LIST": "list_form_fields",
135 "HEADING_PREV": "previous_heading",
136 "HEADING_NEXT": "next_heading",
137 "HEADING_LIST": "list_headings",
138 "HEADING_AT_LEVEL_PREV": "previous_heading_level_%d",
139 "HEADING_AT_LEVEL_NEXT": "next_heading_level_%d",
140 "HEADING_AT_LEVEL_LIST": "list_headings_level_%d",
141 "IFRAME_PREV": "previous_iframe",
142 "IFRAME_NEXT": "next_iframe",
143 "IFRAME_LIST": "list_iframes",
144 "IMAGE_PREV": "previous_image",
145 "IMAGE_NEXT": "next_image",
146 "IMAGE_LIST": "list_images",
147 "LANDMARK_PREV": "previous_landmark",
148 "LANDMARK_NEXT": "next_landmark",
149 "LANDMARK_LIST": "list_landmarks",
150 "LIST_PREV": "previous_list",
151 "LIST_NEXT": "next_list",
152 "LIST_LIST": "list_lists",
153 "LIST_ITEM_PREV": "previous_list_item",
154 "LIST_ITEM_NEXT": "next_list_item",
155 "LIST_ITEM_LIST": "list_list_items",
156 "LIVE_REGION_PREV": "previous_live_region",
157 "LIVE_REGION_NEXT": "next_live_region",
158 "LIVE_REGION_LAST": "last_live_region",
159 "PARAGRAPH_PREV": "previous_paragraph",
160 "PARAGRAPH_NEXT": "next_paragraph",
161 "PARAGRAPH_LIST": "list_paragraphs",
162 "RADIO_BUTTON_PREV": "previous_radio_button",
163 "RADIO_BUTTON_NEXT": "next_radio_button",
164 "RADIO_BUTTON_LIST": "list_radio_buttons",
165 "SEPARATOR_PREV": "previous_separator",
166 "SEPARATOR_NEXT": "next_separator",
167 "TABLE_PREV": "previous_table",
168 "TABLE_NEXT": "next_table",
169 "TABLE_LIST": "list_tables",
170 "UNVISITED_LINK_PREV": "previous_unvisited_link",
171 "UNVISITED_LINK_NEXT": "next_unvisited_link",
172 "UNVISITED_LINK_LIST": "list_unvisited_links",
173 "VISITED_LINK_PREV": "previous_visited_link",
174 "VISITED_LINK_NEXT": "next_visited_link",
175 "VISITED_LINK_LIST": "list_visited_links",
176 "LINK_PREV": "previous_link",
177 "LINK_NEXT": "next_link",
178 "LINK_LIST": "list_links",
179 "CLICKABLE_PREV": "previous_clickable",
180 "CLICKABLE_NEXT": "next_clickable",
181 "CLICKABLE_LIST": "list_clickables",
182 "LARGE_OBJECT_PREV": "previous_large_object",
183 "LARGE_OBJECT_NEXT": "next_large_object",
184 "LARGE_OBJECT_LIST": "list_large_objects",
185 "CONTAINER_START": "container_start",
186 "CONTAINER_END": "container_end",
187 }
188
189 @staticmethod
190 def _setup_cmdnames(cmdnames) -> None:
191 """Set up cmdnames with all required values for structural_navigator."""
192
193 for attr, value in TestTypingEchoPresenter._CMDNAME_VALUES.items():
194 setattr(cmdnames, attr, value)
195
196 @staticmethod
197 def _setup_guilabels(guilabels_mock) -> None:
198 """Set up guilabels mock with typing echo label values."""
199
200 guilabels_mock.ECHO_ENABLE_KEY_ECHO = "Enable _key echo"
201 guilabels_mock.ECHO_ALPHABETIC_KEYS = "Enable _alphabetic keys"
202 guilabels_mock.ECHO_NUMERIC_KEYS = "Enable n_umeric keys"
203 guilabels_mock.ECHO_PUNCTUATION_KEYS = "Enable _punctuation keys"
204 guilabels_mock.ECHO_SPACE = "Enable _space"
205 guilabels_mock.ECHO_MODIFIER_KEYS = "Enable _modifier keys"
206 guilabels_mock.ECHO_FUNCTION_KEYS = "Enable _function keys"
207 guilabels_mock.ECHO_ACTION_KEYS = "Enable ac_tion keys"
208 guilabels_mock.ECHO_NAVIGATION_KEYS = "Enable _navigation keys"
209 guilabels_mock.ECHO_DIACRITICAL_KEYS = "Enable non-spacing _diacritical keys"
210 guilabels_mock.ECHO_CHARACTER = "Enable echo by cha_racter"
211 guilabels_mock.ECHO_WORD = "Enable echo by _word"
212 guilabels_mock.ECHO_SENTENCE = "Enable echo by _sentence"
213
214 @staticmethod
215 def _setup_atspi_patches(test_context: OrcaTestContext) -> None:
216 """Set up Atspi type patches for testing."""
217
218 from gi.repository import Atspi
219
220 test_context.patch_object(Atspi, "Accessible", new=type("Accessible", (), {}))
221 test_context.patch_object(Atspi, "Hyperlink", new=type("Hyperlink", (), {}))
222 test_context.patch_object(
223 Atspi,
224 "Role",
225 new=type("Role", (), {"PASSWORD_TEXT": 42, "PANEL": 36}),
226 )
227 test_context.patch_object(
228 Atspi,
229 "CollectionMatchType",
230 new=type("CollectionMatchType", (), {"ALL": 0, "ANY": 1}),
231 )
232 test_context.patch_object(Atspi, "MatchRule", new=type("MatchRule", (), {}))
233 test_context.patch_object(
234 Atspi,
235 "RelationType",
236 new=type("RelationType", (), {"LABELLED_BY": 0}),
237 )
238 test_context.patch_object(Atspi, "Relation", new=type("Relation", (), {}))
239
240 _ADDITIONAL_MODULES: ClassVar[list[str]] = [
241 "gi",
242 "gi.repository",
243 "orca.cmdnames",
244 "orca.messages",
245 "orca.object_properties",
246 "orca.orca_gui_navlist",
247 "orca.orca_i18n",
248 "orca.AXHypertext",
249 "orca.AXObject",
250 "orca.AXTable",
251 "orca.AXText",
252 "orca.AXUtilities",
253 "orca.input_event",
254 "orca.braille_presenter",
255 "orca.presentation_manager",
256 ]
257
258 _DEFAULT_VALUES: ClassVar[dict[str, bool]] = {
259 "enableKeyEcho": True,
260 "enableAlphabeticKeys": True,
261 "enableNumericKeys": True,
262 "enablePunctuationKeys": True,
263 "enableSpace": True,
264 "enableModifierKeys": True,
265 "enableFunctionKeys": True,
266 "enableActionKeys": True,
267 "enableNavigationKeys": False,
268 "enableDiacriticalKeys": False,
269 "enableEchoByCharacter": False,
270 "enableEchoByWord": False,
271 "enableEchoBySentence": False,
272 }
273
274 @staticmethod
275 def _setup_essential_mocks(test_context: OrcaTestContext, essential_modules: dict) -> None:
276 """Set up essential mock objects for testing."""
277
278 essential_modules["orca.orca_i18n"]._ = lambda x: x
279 essential_modules["orca.debug"].print_message = test_context.Mock()
280 essential_modules["orca.debug"].LEVEL_INFO = 800
281 essential_modules["orca.debug"].LEVEL_SEVERE = 1000
282 essential_modules["orca.debug"].debugLevel = 1000
283
284 controller_mock = test_context.Mock()
285 controller_mock.register_decorated_module.return_value = None
286 essential_modules["orca.dbus_service"].get_remote_controller.return_value = controller_mock
287
288 focus_manager_instance = test_context.Mock()
289 focus_manager_instance.get_locus_of_focus.return_value = None
290 essential_modules["orca.focus_manager"].get_manager.return_value = focus_manager_instance
291
292 essential_modules["orca.AXObject"].supports_collection.return_value = True
293 essential_modules["orca.AXUtilities"].is_heading.return_value = False
294
295 test_context.patch("gi.repository.Gtk.Grid", new=_FakeGtkGrid)
296 test_context.patch("gi.repository.Gtk.CheckButton", new=_FakeCheckButton)
297
298 def _setup_presenter(self, test_context: OrcaTestContext):
299 """Set up presenter and dependencies for testing."""
300
301 essential_modules = test_context.setup_shared_dependencies(self._ADDITIONAL_MODULES)
302
303 self._setup_cmdnames(essential_modules["orca.cmdnames"])
304 self._setup_essential_mocks(test_context, essential_modules)
305 self._setup_guilabels(essential_modules["orca.guilabels"])
306
307 self._setup_atspi_patches(test_context)
308
309 from orca import gsettings_registry
310 from orca.typing_echo_presenter import TypingEchoPresenter
311
312 registry = gsettings_registry.get_registry()
313 registry.clear_runtime_values()
314
315 presenter = TypingEchoPresenter()
316 return presenter
317
318 @pytest.mark.parametrize(
319 "getter_name,setter_name,setting_key,test_value",
320 [
321 ("get_key_echo_enabled", "set_key_echo_enabled", "enableKeyEcho", False),
322 (
323 "get_character_echo_enabled",
324 "set_character_echo_enabled",
325 "enableEchoByCharacter",
326 False,
327 ),
328 ("get_word_echo_enabled", "set_word_echo_enabled", "enableEchoByWord", True),
329 (
330 "get_sentence_echo_enabled",
331 "set_sentence_echo_enabled",
332 "enableEchoBySentence",
333 False,
334 ),
335 (
336 "get_alphabetic_keys_enabled",
337 "set_alphabetic_keys_enabled",
338 "enableAlphabeticKeys",
339 False,
340 ),
341 ("get_numeric_keys_enabled", "set_numeric_keys_enabled", "enableNumericKeys", True),
342 (
343 "get_punctuation_keys_enabled",
344 "set_punctuation_keys_enabled",
345 "enablePunctuationKeys",
346 True,
347 ),
348 ("get_space_enabled", "set_space_enabled", "enableSpace", False),
349 ("get_modifier_keys_enabled", "set_modifier_keys_enabled", "enableModifierKeys", True),
350 ("get_function_keys_enabled", "set_function_keys_enabled", "enableFunctionKeys", False),
351 ("get_action_keys_enabled", "set_action_keys_enabled", "enableActionKeys", True),
352 (
353 "get_navigation_keys_enabled",
354 "set_navigation_keys_enabled",
355 "enableNavigationKeys",
356 False,
357 ),
358 (
359 "get_diacritical_keys_enabled",
360 "set_diacritical_keys_enabled",
361 "enableDiacriticalKeys",
362 True,
363 ),
364 ],
365 )
366 def test_presenter_getters_and_setters(
367 self,
368 test_context: OrcaTestContext,
369 getter_name: str,
370 setter_name: str,
371 setting_key: str,
372 test_value: bool,
373 ) -> None:
374 """Test presenter getter and setter methods."""
375 presenter = self._setup_presenter(test_context)
376
377 getter = getattr(presenter, getter_name)
378 setter = getattr(presenter, setter_name)
379
380 assert getter() is self._DEFAULT_VALUES[setting_key]
381 setter(test_value)
382 assert getter() == test_value
383
384 def test_locking_keys_presented_getter_and_setter(self, test_context: OrcaTestContext) -> None:
385 """Test locking keys presented getter and setter with special logic."""
386 presenter = self._setup_presenter(test_context)
387
388 presenter._present_locking_keys = True
389 assert presenter.get_locking_keys_presented() is True
390
391 presenter._present_locking_keys = False
392 assert presenter.get_locking_keys_presented() is False
393
394 presenter._present_locking_keys = None
395
396 speech_presenter_patch = test_context.patch("orca.speech_presenter.get_presenter")
397 speech_presenter_instance = speech_presenter_patch.return_value
398
399 speech_presenter_instance.get_only_speak_displayed_text.return_value = False
400 assert presenter.get_locking_keys_presented() is True
401
402 speech_presenter_instance.get_only_speak_displayed_text.return_value = True
403 assert presenter.get_locking_keys_presented() is False
404
405 presenter.set_locking_keys_presented(True)
406 assert presenter._present_locking_keys is True
407
408 presenter.set_locking_keys_presented(None)
409 assert presenter._present_locking_keys is None
410
411 def test_cycle_key_echo_basic_transitions(self, test_context: OrcaTestContext) -> None:
412 """Test cycle_key_echo method basic state transitions."""
413 presenter = self._setup_presenter(test_context)
414
415 script_mock = test_context.mocker.MagicMock()
416
417 presenter.set_key_echo_enabled(False)
418
419 result = presenter.cycle_key_echo(script_mock, None, True)
420 assert result is True
421 assert presenter.get_key_echo_enabled() is True
422 assert presenter.get_word_echo_enabled() is False
423 assert presenter.get_sentence_echo_enabled() is False
424
425 result = presenter.cycle_key_echo(script_mock, None, True)
426 assert result is True
427 assert presenter.get_key_echo_enabled() is False
428 assert presenter.get_word_echo_enabled() is True
429 assert presenter.get_sentence_echo_enabled() is False
430
431 def test_cycle_key_echo_advanced_transitions(self, test_context: OrcaTestContext) -> None:
432 """Test cycle_key_echo method advanced state transitions."""
433 presenter = self._setup_presenter(test_context)
434
435 script_mock = test_context.mocker.MagicMock()
436
437 presenter.set_key_echo_enabled(False)
438 presenter.set_word_echo_enabled(True)
439
440 result = presenter.cycle_key_echo(script_mock, None, True)
441 assert result is True
442 assert presenter.get_key_echo_enabled() is False
443 assert presenter.get_word_echo_enabled() is False
444 assert presenter.get_sentence_echo_enabled() is True
445
446 result = presenter.cycle_key_echo(script_mock, None, True)
447 assert result is True
448 assert presenter.get_key_echo_enabled() is True
449 assert presenter.get_word_echo_enabled() is True
450 assert presenter.get_sentence_echo_enabled() is False
451
452 result = presenter.cycle_key_echo(script_mock, None, True)
453 assert result is True
454 assert presenter.get_key_echo_enabled() is False
455 assert presenter.get_word_echo_enabled() is True
456 assert presenter.get_sentence_echo_enabled() is True
457
458 result = presenter.cycle_key_echo(script_mock, None, True)
459 assert result is True
460 assert presenter.get_key_echo_enabled() is False
461 assert presenter.get_word_echo_enabled() is False
462 assert presenter.get_sentence_echo_enabled() is False
463
464 def test_cycle_key_echo_with_script_presentation(self, test_context: OrcaTestContext) -> None:
465 """Test cycle_key_echo calls present_message when script is provided."""
466 presenter = self._setup_presenter(test_context)
467
468 script_mock = test_context.mocker.MagicMock()
469
470 presenter.set_key_echo_enabled(False)
471
472 from orca import presentation_manager
473
474 present_msg = presentation_manager.get_manager().present_message
475 assert isinstance(present_msg, Mock)
476 present_msg.reset_mock() # pylint: disable=no-member
477
478 presenter.cycle_key_echo(script_mock, None, True)
479 assert present_msg.call_count == 1 # pylint: disable=no-member
480
481 present_msg.reset_mock() # pylint: disable=no-member
482 presenter.cycle_key_echo(script_mock, None, False)
483 assert present_msg.call_count == 0 # pylint: disable=no-member
484
485 presenter.cycle_key_echo(None, None, True)
486
487 def test_should_echo_keyboard_event_basic_cases(self, test_context: OrcaTestContext) -> None:
488 """Test should_echo_keyboard_event for basic cases."""
489 presenter = self._setup_presenter(test_context)
490
491 event_mock = test_context.mocker.MagicMock()
492 event_mock.should_obscure.return_value = False
493 event_mock.get_key_name.return_value = "a"
494
495 event_mock.is_pressed_key.return_value = False
496 assert presenter.should_echo_keyboard_event(event_mock) is False
497
498 event_mock.is_pressed_key.return_value = True
499 presenter.set_key_echo_enabled(False)
500 event_mock.is_orca_modifier.return_value = False
501 event_mock.is_alt_control_or_orca_modified.return_value = False
502 event_mock.is_locking_key.return_value = False
503 presenter.is_character_echoable = test_context.mocker.MagicMock(return_value=False)
504 assert presenter.should_echo_keyboard_event(event_mock) is False
505
506 def test_should_echo_keyboard_event_orca_modifier(self, test_context: OrcaTestContext) -> None:
507 """Test should_echo_keyboard_event for Orca modifier keys."""
508 presenter = self._setup_presenter(test_context)
509
510 event_mock = test_context.mocker.MagicMock()
511 event_mock.should_obscure.return_value = False
512 event_mock.get_key_name.return_value = "Insert_L"
513 event_mock.is_pressed_key.return_value = True
514 event_mock.is_orca_modifier.return_value = True
515
516 event_mock.get_click_count.return_value = 2
517 assert presenter.should_echo_keyboard_event(event_mock) is True
518
519 event_mock.get_click_count.return_value = 1
520 assert presenter.should_echo_keyboard_event(event_mock) is True
521
522 presenter.set_modifier_keys_enabled(False)
523 assert presenter.should_echo_keyboard_event(event_mock) is False
524
525 def test_should_echo_keyboard_event_modified_keys(self, test_context: OrcaTestContext) -> None:
526 """Test should_echo_keyboard_event for modified keys."""
527 presenter = self._setup_presenter(test_context)
528
529 event_mock = test_context.mocker.MagicMock()
530 event_mock.should_obscure.return_value = False
531 event_mock.get_key_name.return_value = "a"
532 event_mock.is_pressed_key.return_value = True
533 event_mock.is_orca_modifier.return_value = False
534
535 event_mock.is_alt_control_or_orca_modified.return_value = True
536 assert presenter.should_echo_keyboard_event(event_mock) is False
537
538 def test_should_echo_keyboard_event_character_echoable(
539 self,
540 test_context: OrcaTestContext,
541 ) -> None:
542 """Test should_echo_keyboard_event when character is echoable."""
543 presenter = self._setup_presenter(test_context)
544
545 event_mock = test_context.mocker.MagicMock()
546 event_mock.should_obscure.return_value = False
547 event_mock.get_key_name.return_value = "a"
548 event_mock.is_pressed_key.return_value = True
549 event_mock.is_orca_modifier.return_value = False
550 event_mock.is_alt_control_or_orca_modified.return_value = False
551
552 presenter.is_character_echoable = test_context.mocker.MagicMock(return_value=True)
553 assert presenter.should_echo_keyboard_event(event_mock) is False
554
555 @pytest.mark.parametrize(
556 "key_type,_setting_key,expected_result",
557 [
558 # Standard key types - enabled
559 ("alphabetic", "enableAlphabeticKeys", True),
560 ("numeric", "enableNumericKeys", True),
561 ("punctuation", "enablePunctuationKeys", True),
562 ("modifier", "enableModifierKeys", True),
563 ("function", "enableFunctionKeys", True),
564 ("action", "enableActionKeys", True),
565 ("navigation", "enableNavigationKeys", True),
566 ("diacritical", "enableDiacriticalKeys", True),
567 # Standard key types - disabled
568 ("alphabetic", "enableAlphabeticKeys", False),
569 ("numeric", "enableNumericKeys", False),
570 ("punctuation", "enablePunctuationKeys", False),
571 ("modifier", "enableModifierKeys", False),
572 ("function", "enableFunctionKeys", False),
573 ("action", "enableActionKeys", False),
574 ("navigation", "enableNavigationKeys", False),
575 ("diacritical", "enableDiacriticalKeys", False),
576 ],
577 )
578 def test_should_echo_keyboard_event_key_types(
579 self,
580 test_context: OrcaTestContext,
581 key_type: str,
582 _setting_key: str,
583 expected_result: bool,
584 ) -> None:
585 """Test should_echo_keyboard_event for different key types."""
586 presenter = self._setup_presenter(test_context)
587
588 from orca import gsettings_registry
589
590 event_mock = test_context.mocker.MagicMock()
591 event_mock.should_obscure.return_value = False
592 event_mock.get_key_name.return_value = "test_key"
593 event_mock.is_pressed_key.return_value = True
594 event_mock.is_orca_modifier.return_value = False
595 event_mock.is_alt_control_or_orca_modified.return_value = False
596 event_mock.is_locking_key.return_value = False
597 event_mock.is_space.return_value = False
598 presenter.is_character_echoable = test_context.mocker.MagicMock(return_value=False)
599
600 # Set all key type checks to False first
601 event_mock.is_alphabetic_key.return_value = False
602 event_mock.is_numeric_key.return_value = False
603 event_mock.is_punctuation_key.return_value = False
604 event_mock.is_modifier_key.return_value = False
605 event_mock.is_function_key.return_value = False
606 event_mock.is_action_key.return_value = False
607 event_mock.is_navigation_key.return_value = False
608 event_mock.is_diacritical_key.return_value = False
609
610 # Enable the specific key type being tested
611 setattr(event_mock, f"is_{key_type}_key", lambda: True)
612
613 gs_key = f"{key_type}-keys"
614 gsettings_registry.get_registry().set_runtime_value("typing-echo", gs_key, expected_result)
615
616 result = presenter.should_echo_keyboard_event(event_mock)
617 assert result is expected_result
618
619 def test_should_echo_keyboard_event_space_key_scenarios(
620 self,
621 test_context: OrcaTestContext,
622 ) -> None:
623 """Test should_echo_keyboard_event for space key with different settings."""
624 presenter = self._setup_presenter(test_context)
625
626 event_mock = test_context.mocker.MagicMock()
627 event_mock.should_obscure.return_value = False
628 event_mock.get_key_name.return_value = "space"
629 event_mock.is_pressed_key.return_value = True
630 event_mock.is_orca_modifier.return_value = False
631 event_mock.is_alt_control_or_orca_modified.return_value = False
632 event_mock.is_locking_key.return_value = False
633 event_mock.is_space.return_value = True
634 presenter.is_character_echoable = test_context.mocker.MagicMock(return_value=False)
635
636 # Set all other key types to False
637 event_mock.is_alphabetic_key.return_value = False
638 event_mock.is_numeric_key.return_value = False
639 event_mock.is_punctuation_key.return_value = False
640 event_mock.is_modifier_key.return_value = False
641 event_mock.is_function_key.return_value = False
642 event_mock.is_action_key.return_value = False
643 event_mock.is_navigation_key.return_value = False
644 event_mock.is_diacritical_key.return_value = False
645
646 # Test space key with space setting enabled (default), character echo disabled (default)
647 assert presenter.should_echo_keyboard_event(event_mock) is True
648
649 # Test space key with space disabled but character echo enabled (should echo)
650 presenter.set_space_enabled(False)
651 presenter.set_character_echo_enabled(True)
652 assert presenter.should_echo_keyboard_event(event_mock) is True
653
654 # Test space key with both space and character echo disabled
655 presenter.set_character_echo_enabled(False)
656 assert presenter.should_echo_keyboard_event(event_mock) is False
657
658 def test_should_echo_keyboard_event_locking_keys(self, test_context: OrcaTestContext) -> None:
659 """Test should_echo_keyboard_event for locking keys."""
660 presenter = self._setup_presenter(test_context)
661
662 event_mock = test_context.mocker.MagicMock()
663 event_mock.should_obscure.return_value = False
664 event_mock.get_key_name.return_value = "Caps_Lock"
665 event_mock.is_pressed_key.return_value = True
666 event_mock.is_orca_modifier.return_value = False
667 event_mock.is_alt_control_or_orca_modified.return_value = False
668 event_mock.is_locking_key.return_value = True
669 presenter.is_character_echoable = test_context.mocker.MagicMock(return_value=False)
670
671 # Test locking key when locking keys are presented
672 presenter._present_locking_keys = True
673 assert presenter.should_echo_keyboard_event(event_mock) is True
674
675 # Test locking key when locking keys are not presented
676 presenter._present_locking_keys = False
677 assert presenter.should_echo_keyboard_event(event_mock) is False
678
679 def test_should_echo_keyboard_event_password_text_obscuring(
680 self,
681 test_context: OrcaTestContext,
682 ) -> None:
683 """Test should_echo_keyboard_event with password text that should be obscured."""
684 presenter = self._setup_presenter(test_context)
685
686 event_mock = test_context.mocker.MagicMock()
687 event_mock.get_key_name.return_value = "a"
688 event_mock.is_pressed_key.return_value = True
689 event_mock.is_orca_modifier.return_value = False
690 event_mock.is_alt_control_or_orca_modified.return_value = False
691 event_mock.is_locking_key.return_value = False
692 # Set all other key type checks to False so we get to password text check
693 event_mock.is_navigation_key.return_value = False
694 event_mock.is_action_key.return_value = False
695 event_mock.is_modifier_key.return_value = False
696 event_mock.is_function_key.return_value = False
697 event_mock.is_diacritical_key.return_value = False
698 event_mock.is_alphabetic_key.return_value = True
699 presenter.is_character_echoable = test_context.mocker.MagicMock(return_value=False)
700
701 # Test with password text that should be obscured - should not echo
702 event_mock.should_obscure.return_value = True
703 test_context.patch("orca.ax_utilities.AXUtilities.is_password_text", return_value=True)
704 assert presenter.should_echo_keyboard_event(event_mock) is False
705
706 # Test with password text that should not be obscured - should echo alphabetic
707 event_mock.should_obscure.return_value = False
708 test_context.patch("orca.ax_utilities.AXUtilities.is_password_text", return_value=False)
709 assert presenter.should_echo_keyboard_event(event_mock) is True
710
711 def test_is_character_echoable(self, test_context: OrcaTestContext) -> None:
712 """Test is_character_echoable method."""
713 presenter = self._setup_presenter(test_context)
714
715 event_mock = test_context.mocker.MagicMock()
716
717 assert presenter.is_character_echoable(event_mock) is False
718
719 presenter.set_character_echo_enabled(True)
720
721 event_mock.is_alt_control_or_orca_modified.return_value = True
722 assert presenter.is_character_echoable(event_mock) is False
723
724 event_mock.is_alt_control_or_orca_modified.return_value = False
725 event_mock.is_printable_key.return_value = False
726 assert presenter.is_character_echoable(event_mock) is False
727
728 event_mock.is_printable_key.return_value = True
729 obj_mock = test_context.mocker.MagicMock()
730 event_mock.get_object.return_value = obj_mock
731
732 test_context.patch("orca.ax_utilities.AXUtilities.is_password_text", return_value=True)
733 assert presenter.is_character_echoable(event_mock) is False
734
735 test_context.patch("orca.ax_utilities.AXUtilities.is_password_text", return_value=False)
736 test_context.patch("orca.ax_utilities.AXUtilities.is_editable", return_value=True)
737 test_context.patch("orca.ax_utilities.AXUtilities.is_terminal", return_value=False)
738 assert presenter.is_character_echoable(event_mock) is True
739
740 test_context.patch("orca.ax_utilities.AXUtilities.is_editable", return_value=False)
741 test_context.patch("orca.ax_utilities.AXUtilities.is_terminal", return_value=True)
742 assert presenter.is_character_echoable(event_mock) is True
743
744 test_context.patch("orca.ax_utilities.AXUtilities.is_terminal", return_value=False)
745 assert presenter.is_character_echoable(event_mock) is False
746
747 def test_echo_previous_word(self, test_context: OrcaTestContext) -> None:
748 """Test echo_previous_word method."""
749 presenter = self._setup_presenter(test_context)
750
751 obj_mock = test_context.mocker.MagicMock()
752
753 assert presenter.echo_previous_word(obj_mock) is False
754
755 presenter.set_word_echo_enabled(True)
756
757 test_context.patch("orca.ax_text.AXText.get_caret_offset", return_value=5)
758 test_context.patch("orca.ax_text.AXText.get_character_count", return_value=10)
759
760 test_context.patch("orca.ax_text.AXText.get_caret_offset", return_value=0)
761 assert presenter.echo_previous_word(obj_mock) is False
762
763 test_context.patch("orca.ax_text.AXText.get_caret_offset", return_value=5)
764 char_mock_1 = test_context.patch("orca.ax_text.AXText.get_character_at_offset")
765 char_mock_1.side_effect = [("a", 4, 5), ("b", 3, 4)]
766 assert presenter.echo_previous_word(obj_mock) is False
767
768 char_mock_2 = test_context.patch("orca.ax_text.AXText.get_character_at_offset")
769 char_mock_2.side_effect = [(" ", 4, 5), (" ", 3, 4)]
770 assert presenter.echo_previous_word(obj_mock) is False
771
772 char_mock_3 = test_context.patch("orca.ax_text.AXText.get_character_at_offset")
773 char_mock_3.side_effect = [(" ", 4, 5), ("a", 3, 4)]
774 test_context.patch("orca.ax_text.AXText.get_word_at_offset", return_value=("hello", 0, 5))
775
776 from orca import presentation_manager
777
778 speak_text = presentation_manager.get_manager().speak_accessible_text
779 assert isinstance(speak_text, Mock)
780 speak_text.reset_mock() # pylint: disable=no-member
781
782 result = presenter.echo_previous_word(obj_mock)
783 assert result is True
784 speak_text.assert_called_with(obj_mock, "hello") # pylint: disable=no-member
785
786 char_mock_4 = test_context.patch("orca.ax_text.AXText.get_character_at_offset")
787 char_mock_4.side_effect = [(" ", 4, 5), ("a", 3, 4)]
788 test_context.patch("orca.ax_text.AXText.get_word_at_offset", return_value=("", 0, 0))
789 assert presenter.echo_previous_word(obj_mock) is False
790
791 def test_echo_previous_sentence(self, test_context: OrcaTestContext) -> None:
792 """Test echo_previous_sentence method."""
793 presenter = self._setup_presenter(test_context)
794
795 obj_mock = test_context.mocker.MagicMock()
796
797 assert presenter.echo_previous_sentence(obj_mock) is False
798
799 presenter.set_sentence_echo_enabled(True)
800
801 test_context.patch("orca.ax_text.AXText.get_caret_offset", return_value=10)
802
803 char_mock_1 = test_context.patch("orca.ax_text.AXText.get_character_at_offset")
804 char_mock_1.side_effect = [("a", 9, 10), ("b", 8, 9)]
805 assert presenter.echo_previous_sentence(obj_mock) is False
806
807 char_mock_2 = test_context.patch("orca.ax_text.AXText.get_character_at_offset")
808 char_mock_2.side_effect = [(" ", 9, 10), (".", 8, 9)]
809 test_context.patch(
810 "orca.ax_text.AXText.get_sentence_at_offset",
811 return_value=("Hello world.", 0, 12),
812 )
813
814 from orca import presentation_manager
815
816 speak_text = presentation_manager.get_manager().speak_accessible_text
817 assert isinstance(speak_text, Mock)
818 speak_text.reset_mock() # pylint: disable=no-member
819
820 result = presenter.echo_previous_sentence(obj_mock)
821 assert result is True
822 speak_text.assert_called_with(obj_mock, "Hello world.") # pylint: disable=no-member
823
824 char_mock_3 = test_context.patch("orca.ax_text.AXText.get_character_at_offset")
825 char_mock_3.side_effect = [(" ", 9, 10), (".", 8, 9)]
826 test_context.patch("orca.ax_text.AXText.get_sentence_at_offset", return_value=("", 0, 0))
827 assert presenter.echo_previous_sentence(obj_mock) is False
828
829 def test_commands_and_bindings(self, test_context: OrcaTestContext) -> None:
830 """Test commands are registered in CommandManager."""
831 presenter = self._setup_presenter(test_context)
832 from orca import command_manager
833
834 # Commands are registered during setup()
835 presenter.set_up_commands()
836
837 # Verify commands are registered in CommandManager
838 cmd_manager = command_manager.get_manager()
839 assert cmd_manager.get_keyboard_command("cycleKeyEchoHandler") is not None
840
841 @pytest.mark.parametrize(
842 "getter_name,gs_key,_setting_key",
843 [
844 ("get_key_echo_enabled", "key-echo", "enableKeyEcho"),
845 ("get_character_echo_enabled", "character-echo", "enableEchoByCharacter"),
846 ("get_word_echo_enabled", "word-echo", "enableEchoByWord"),
847 ("get_sentence_echo_enabled", "sentence-echo", "enableEchoBySentence"),
848 ("get_alphabetic_keys_enabled", "alphabetic-keys", "enableAlphabeticKeys"),
849 ("get_numeric_keys_enabled", "numeric-keys", "enableNumericKeys"),
850 ("get_punctuation_keys_enabled", "punctuation-keys", "enablePunctuationKeys"),
851 ("get_space_enabled", "space", "enableSpace"),
852 ("get_modifier_keys_enabled", "modifier-keys", "enableModifierKeys"),
853 ("get_function_keys_enabled", "function-keys", "enableFunctionKeys"),
854 ("get_action_keys_enabled", "action-keys", "enableActionKeys"),
855 ("get_navigation_keys_enabled", "navigation-keys", "enableNavigationKeys"),
856 ("get_diacritical_keys_enabled", "diacritical-keys", "enableDiacriticalKeys"),
857 ],
858 )
859 def test_getter_returns_dconf_value_when_available(
860 self,
861 test_context: OrcaTestContext,
862 getter_name: str,
863 gs_key: str,
864 _setting_key: str,
865 ) -> None:
866 """Test getter returns dconf value when layered_lookup returns a value."""
867 presenter = self._setup_presenter(test_context)
868
869 from orca import gsettings_registry
870 from orca.gsettings_registry import GSettingsSchemaHandle
871
872 registry = gsettings_registry.get_registry()
873
874 mock_handle = test_context.Mock(spec=GSettingsSchemaHandle)
875 mock_handle.get_boolean.return_value = False
876 registry._handles["typing-echo"] = mock_handle
877
878 getter = getattr(presenter, getter_name)
879 assert getter() is False
880 mock_handle.get_boolean.assert_called_with(gs_key, "", None)
881
882 registry._handles.pop("typing-echo", None)
883
884 @pytest.mark.parametrize(
885 "getter_name,setting_key",
886 [
887 ("get_key_echo_enabled", "enableKeyEcho"),
888 ("get_character_echo_enabled", "enableEchoByCharacter"),
889 ("get_word_echo_enabled", "enableEchoByWord"),
890 ("get_sentence_echo_enabled", "enableEchoBySentence"),
891 ("get_alphabetic_keys_enabled", "enableAlphabeticKeys"),
892 ("get_numeric_keys_enabled", "enableNumericKeys"),
893 ("get_punctuation_keys_enabled", "enablePunctuationKeys"),
894 ("get_space_enabled", "enableSpace"),
895 ("get_modifier_keys_enabled", "enableModifierKeys"),
896 ("get_function_keys_enabled", "enableFunctionKeys"),
897 ("get_action_keys_enabled", "enableActionKeys"),
898 ("get_navigation_keys_enabled", "enableNavigationKeys"),
899 ("get_diacritical_keys_enabled", "enableDiacriticalKeys"),
900 ],
901 )
902 def test_getter_returns_default_when_disabled(
903 self,
904 test_context: OrcaTestContext,
905 getter_name: str,
906 setting_key: str,
907 ) -> None:
908 """Test getter returns module-owned default when registry is disabled."""
909 presenter = self._setup_presenter(test_context)
910
911 getter = getattr(presenter, getter_name)
912 assert getter() is self._DEFAULT_VALUES[setting_key]
913
914 def test_get_setting_logs_dconf_layer(self, test_context: OrcaTestContext) -> None:
915 """Test that dconf lookup logs the source layer and value."""
916 presenter = self._setup_presenter(test_context)
917
918 from orca import debug as debug_mock
919 from orca import gsettings_registry
920 from orca.gsettings_registry import GSettingsSchemaHandle
921
922 registry = gsettings_registry.get_registry()
923
924 mock_handle = test_context.Mock(spec=GSettingsSchemaHandle)
925 mock_handle.get_boolean.return_value = False
926 registry._handles["typing-echo"] = mock_handle
927
928 print_msg = debug_mock.print_message
929 assert isinstance(print_msg, Mock)
930 debug_mock.debugLevel = 800
931 print_msg.reset_mock() # pylint: disable=no-member
932
933 assert presenter.get_key_echo_enabled() is False
934
935 registry._handles.pop("typing-echo", None)