| 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) |