| 1 |
# Unit tests for learn_mode_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=too-many-public-methods |
| 24 |
# pylint: disable=too-many-statements |
| 25 |
# pylint: disable=protected-access |
| 26 |
# pylint: disable=too-many-locals |
| 27 |
# pylint: disable=too-many-arguments |
| 28 |
# pylint: disable=too-many-positional-arguments |
| 29 |
|
| 30 |
"""Unit tests for learn_mode_presenter.py methods.""" |
| 31 |
|
| 32 |
from __future__ import annotations |
| 33 |
|
| 34 |
from typing import TYPE_CHECKING |
| 35 |
|
| 36 |
import pytest |
| 37 |
|
| 38 |
if TYPE_CHECKING: |
| 39 |
from unittest.mock import MagicMock |
| 40 |
|
| 41 |
from .orca_test_context import OrcaTestContext |
| 42 |
|
| 43 |
GTK_STOCK_CLOSE = "gtk-close" |
| 44 |
TEST_COMMAND_DESCRIPTION = "Test Command" |
| 45 |
|
| 46 |
|
| 47 |
@pytest.mark.unit |
| 48 |
class TestLearnModePresenter: |
| 49 |
"""Test LearnModePresenter class methods.""" |
| 50 |
|
| 51 |
def _setup_dependencies(self, test_context: OrcaTestContext) -> dict[str, MagicMock]: |
| 52 |
"""Returns all dependencies needed for LearnModePresenter testing.""" |
| 53 |
|
| 54 |
additional_modules = [ |
| 55 |
"gi.repository", |
| 56 |
"orca.command_manager", |
| 57 |
"orca.input_event_manager", |
| 58 |
"time", |
| 59 |
"orca.speech", |
| 60 |
"orca.speech_generator", |
| 61 |
"orca.generator", |
| 62 |
"orca.ax_hypertext", |
| 63 |
"orca.command_manager", |
| 64 |
"orca.braille_presenter", |
| 65 |
"orca.presentation_manager", |
| 66 |
] |
| 67 |
essential_modules = test_context.setup_shared_dependencies(additional_modules) |
| 68 |
|
| 69 |
gi_repository_mock = essential_modules["gi.repository"] |
| 70 |
gdk_mock = test_context.Mock() |
| 71 |
gdk_mock.Screen = test_context.Mock() |
| 72 |
gdk_mock.Screen.get_default = test_context.Mock(return_value=test_context.Mock()) |
| 73 |
|
| 74 |
gtk_mock = test_context.Mock() |
| 75 |
gtk_mock.show_uri = test_context.Mock() |
| 76 |
gtk_mock.Dialog = test_context.Mock() |
| 77 |
gtk_mock.DialogFlags = test_context.Mock() |
| 78 |
gtk_mock.DialogFlags.MODAL = 1 |
| 79 |
gtk_mock.ResponseType = test_context.Mock() |
| 80 |
gtk_mock.ResponseType.CLOSE = -7 |
| 81 |
gtk_mock.STOCK_CLOSE = GTK_STOCK_CLOSE |
| 82 |
gtk_mock.Grid = test_context.Mock() |
| 83 |
gtk_mock.ScrolledWindow = test_context.Mock() |
| 84 |
gtk_mock.TreeView = test_context.Mock() |
| 85 |
gtk_mock.CellRendererText = test_context.Mock() |
| 86 |
gtk_mock.TreeViewColumn = test_context.Mock() |
| 87 |
gtk_mock.TreeStore = test_context.Mock() |
| 88 |
|
| 89 |
gobject_mock = test_context.Mock() |
| 90 |
gobject_mock.TYPE_STRING = str |
| 91 |
|
| 92 |
atspi_mock = test_context.Mock() |
| 93 |
atspi_hyperlink_mock = test_context.Mock() |
| 94 |
atspi_hyperlink_mock.__or__ = test_context.Mock(return_value=type("UnionType", (), {})) |
| 95 |
atspi_mock.Hyperlink = atspi_hyperlink_mock |
| 96 |
atspi_mock.Accessible = test_context.Mock() |
| 97 |
atspi_mock.Hypertext = test_context.Mock() |
| 98 |
glib_mock = test_context.Mock() |
| 99 |
glib_mock.GError = Exception |
| 100 |
|
| 101 |
gi_repository_mock.Gdk = gdk_mock |
| 102 |
gi_repository_mock.Gtk = gtk_mock |
| 103 |
gi_repository_mock.GObject = gobject_mock |
| 104 |
gi_repository_mock.Atspi = atspi_mock |
| 105 |
gi_repository_mock.GLib = glib_mock |
| 106 |
|
| 107 |
cmdnames_mock = essential_modules["orca.cmdnames"] |
| 108 |
cmdnames_mock.ENTER_LEARN_MODE = "enterLearnMode" |
| 109 |
|
| 110 |
guilabels_mock = essential_modules["orca.guilabels"] |
| 111 |
guilabels_mock.KB_GROUP_DEFAULT = "Default Commands" |
| 112 |
guilabels_mock.KB_GROUP_LEARN_MODE = "Learn Mode Commands" |
| 113 |
guilabels_mock.KB_GROUP_WHERE_AM_I = "Where Am I Commands" |
| 114 |
guilabels_mock.KB_GROUP_SPEECH_VERBOSITY = "Speech and Verbosity Commands" |
| 115 |
guilabels_mock.KB_GROUP_SLEEP_MODE = "Sleep Mode Commands" |
| 116 |
guilabels_mock.KB_GROUP_FLAT_REVIEW = "Flat Review Commands" |
| 117 |
guilabels_mock.KB_GROUP_FIND = "Find Commands" |
| 118 |
guilabels_mock.KB_GROUP_OBJECT_NAVIGATION = "Object Navigation Commands" |
| 119 |
guilabels_mock.KB_GROUP_STRUCTURAL_NAVIGATION = "Structural Navigation Commands" |
| 120 |
guilabels_mock.KB_GROUP_TABLE_NAVIGATION = "Table Navigation Commands" |
| 121 |
guilabels_mock.KB_GROUP_SYSTEM_INFORMATION = "System Information Commands" |
| 122 |
guilabels_mock.KB_GROUP_NOTIFICATIONS = "Notification Commands" |
| 123 |
guilabels_mock.KB_GROUP_CLIPBOARD = "Clipboard Commands" |
| 124 |
guilabels_mock.KB_GROUP_BOOKMARKS = "Bookmark Commands" |
| 125 |
guilabels_mock.KB_GROUP_MOUSE_REVIEW = "Mouse Review Commands" |
| 126 |
guilabels_mock.KB_GROUP_ACTIONS = "Action Commands" |
| 127 |
guilabels_mock.KB_GROUP_DEBUGGING_TOOLS = "Debugging Tool Commands" |
| 128 |
guilabels_mock.KB_HEADER_FUNCTION = "Function" |
| 129 |
guilabels_mock.KB_HEADER_KEY_BINDING = "Key Binding" |
| 130 |
|
| 131 |
input_event_mock = essential_modules["orca.input_event"] |
| 132 |
input_event_handler_mock = test_context.Mock() |
| 133 |
|
| 134 |
class MockKeyboardEvent: # pylint: disable=too-many-instance-attributes |
| 135 |
"""Mock keyboard event class for testing.""" |
| 136 |
|
| 137 |
def __init__(self): |
| 138 |
self.is_printable_key = test_context.Mock(return_value=False) |
| 139 |
self.get_click_count = test_context.Mock(return_value=1) |
| 140 |
self.get_handler = test_context.Mock(return_value=None) |
| 141 |
self.get_command = test_context.Mock(return_value=None) |
| 142 |
self.get_command_name = test_context.Mock(return_value="") |
| 143 |
self.get_key_name = test_context.Mock(return_value="a") |
| 144 |
self.keyval_name = "a" |
| 145 |
self.modifiers = 0 |
| 146 |
|
| 147 |
input_event_mock.InputEventHandler = test_context.Mock( |
| 148 |
return_value=input_event_handler_mock, |
| 149 |
) |
| 150 |
input_event_mock.KeyboardEvent = MockKeyboardEvent |
| 151 |
|
| 152 |
input_event_manager_mock = essential_modules["orca.input_event_manager"] |
| 153 |
manager_instance = test_context.Mock() |
| 154 |
mock_device = test_context.Mock() |
| 155 |
manager_instance._device = mock_device |
| 156 |
manager_instance.grab_keyboard = test_context.Mock() |
| 157 |
manager_instance.ungrab_keyboard = test_context.Mock() |
| 158 |
input_event_manager_mock.get_manager = test_context.Mock(return_value=manager_instance) |
| 159 |
input_event_manager_mock.InputEventManager = test_context.Mock( |
| 160 |
return_value=manager_instance, |
| 161 |
) |
| 162 |
|
| 163 |
keybindings_mock = essential_modules["orca.keybindings"] |
| 164 |
key_bindings_instance = test_context.Mock() |
| 165 |
key_bindings_instance.is_empty = test_context.Mock(return_value=True) |
| 166 |
key_bindings_instance.remove_key_grabs = test_context.Mock(return_value=None) |
| 167 |
key_bindings_instance.add = test_context.Mock(return_value=None) |
| 168 |
key_bindings_instance.get_bound_bindings = test_context.Mock(return_value=[]) |
| 169 |
|
| 170 |
key_binding_mock = test_context.Mock() |
| 171 |
key_binding_mock.handler = test_context.Mock() |
| 172 |
key_binding_mock.handler.description = TEST_COMMAND_DESCRIPTION |
| 173 |
key_binding_mock.as_string = test_context.Mock(return_value="Ctrl+t") |
| 174 |
|
| 175 |
keybindings_mock.KeyBindings = test_context.Mock(return_value=key_bindings_instance) |
| 176 |
keybindings_mock.KeyBinding = test_context.Mock(return_value=key_binding_mock) |
| 177 |
keybindings_mock.DEFAULT_MODIFIER_MASK = 0 |
| 178 |
keybindings_mock.ORCA_MODIFIER_MASK = 1 << 26 |
| 179 |
|
| 180 |
messages_mock = essential_modules["orca.messages"] |
| 181 |
messages_mock.VERSION = "Orca Version Information" |
| 182 |
messages_mock.LEARN_MODE_START_SPEECH = "Entering learn mode" |
| 183 |
messages_mock.LEARN_MODE_START_BRAILLE = "Learn mode" |
| 184 |
messages_mock.LEARN_MODE_STOP = "Exiting learn mode" |
| 185 |
messages_mock.APPLICATION_NO_NAME = "application with no name" |
| 186 |
messages_mock.shortcuts_found_orca = test_context.Mock( |
| 187 |
return_value="Found 25 Orca shortcuts", |
| 188 |
) |
| 189 |
messages_mock.shortcuts_found_app = test_context.Mock( |
| 190 |
return_value="Found 5 application shortcuts", |
| 191 |
) |
| 192 |
|
| 193 |
script_manager_mock = essential_modules["orca.script_manager"] |
| 194 |
script_instance = test_context.Mock() |
| 195 |
script_instance.present_message = test_context.Mock() |
| 196 |
script_instance.speak_message = test_context.Mock() |
| 197 |
script_instance.display_message = test_context.Mock() |
| 198 |
script_instance.speak_key_event = test_context.Mock() |
| 199 |
script_instance.phoneticSpellCurrentItem = test_context.Mock() |
| 200 |
script_instance.spell_phonetically = test_context.Mock() |
| 201 |
script_instance.app = test_context.Mock() |
| 202 |
script_instance.getDefaultKeyBindings = test_context.Mock( |
| 203 |
return_value=key_bindings_instance, |
| 204 |
) |
| 205 |
speech_gen = test_context.Mock() |
| 206 |
speech_gen.voice = test_context.Mock(return_value=[test_context.Mock()]) |
| 207 |
script_instance.get_speech_generator = test_context.Mock(return_value=speech_gen) |
| 208 |
|
| 209 |
for method_name in [ |
| 210 |
"get_learn_mode_presenter", |
| 211 |
"get_where_am_i_presenter", |
| 212 |
"get_speech_manager", |
| 213 |
"get_speech_presenter", |
| 214 |
"get_sleep_mode_manager", |
| 215 |
"get_flat_review_presenter", |
| 216 |
"get_flat_review_finder", |
| 217 |
"get_object_navigator", |
| 218 |
"get_caret_navigator", |
| 219 |
"get_structural_navigator", |
| 220 |
"get_table_navigator", |
| 221 |
"get_live_region_presenter", |
| 222 |
"get_system_information_presenter", |
| 223 |
"get_notification_presenter", |
| 224 |
"get_clipboard_presenter", |
| 225 |
"get_mouse_reviewer", |
| 226 |
"get_action_presenter", |
| 227 |
"get_debugging_tools_manager", |
| 228 |
]: |
| 229 |
presenter_mock = test_context.Mock() |
| 230 |
presenter_mock.get_bindings = test_context.Mock(return_value=key_bindings_instance) |
| 231 |
getattr(script_instance, method_name).return_value = presenter_mock |
| 232 |
|
| 233 |
script_instance.get_app_key_bindings = test_context.Mock(return_value=key_bindings_instance) |
| 234 |
|
| 235 |
script_manager_mock.get_manager = test_context.Mock(return_value=test_context.Mock()) |
| 236 |
script_manager_mock.get_manager.return_value.get_active_script = test_context.Mock( |
| 237 |
return_value=script_instance, |
| 238 |
) |
| 239 |
|
| 240 |
debug_mock = essential_modules["orca.debug"] |
| 241 |
debug_mock.print_message = test_context.Mock() |
| 242 |
debug_mock.LEVEL_INFO = 800 |
| 243 |
|
| 244 |
ax_object_mock = essential_modules["orca.ax_object"] |
| 245 |
ax_object_mock.get_name = test_context.Mock(return_value="Test Application") |
| 246 |
|
| 247 |
time_mock = essential_modules["time"] |
| 248 |
time_mock.time = test_context.Mock(return_value=1234567890.0) |
| 249 |
|
| 250 |
speech_mock = essential_modules["orca.speech"] |
| 251 |
speech_mock.speak_key_event = test_context.Mock() |
| 252 |
|
| 253 |
return essential_modules |
| 254 |
|
| 255 |
def test_init(self, test_context: OrcaTestContext) -> None: |
| 256 |
"""Test LearnModePresenter.__init__.""" |
| 257 |
|
| 258 |
self._setup_dependencies(test_context) |
| 259 |
from orca.learn_mode_presenter import LearnModePresenter |
| 260 |
|
| 261 |
presenter = LearnModePresenter() |
| 262 |
assert presenter._is_active is False |
| 263 |
assert presenter._gui is None |
| 264 |
|
| 265 |
def test_setup_commands(self, test_context: OrcaTestContext) -> None: |
| 266 |
"""Test that commands are registered with CommandManager during setup.""" |
| 267 |
|
| 268 |
essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context) |
| 269 |
from orca import command_manager |
| 270 |
from orca.learn_mode_presenter import LearnModePresenter |
| 271 |
|
| 272 |
presenter = LearnModePresenter() |
| 273 |
presenter.set_up_commands() |
| 274 |
cmd_manager = command_manager.get_manager() |
| 275 |
cmd = cmd_manager.get_keyboard_command("enterLearnModeHandler") |
| 276 |
assert cmd is not None |
| 277 |
essential_modules["orca.debug"].print_message.assert_called() |
| 278 |
|
| 279 |
def test_start_when_inactive(self, test_context: OrcaTestContext) -> None: |
| 280 |
"""Test LearnModePresenter.start when learn mode is inactive.""" |
| 281 |
|
| 282 |
essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context) |
| 283 |
from orca.learn_mode_presenter import LearnModePresenter |
| 284 |
|
| 285 |
presenter = LearnModePresenter() |
| 286 |
result = presenter.start() |
| 287 |
assert result is True |
| 288 |
assert presenter._is_active is True |
| 289 |
|
| 290 |
pres_manager = essential_modules["orca.presentation_manager"].get_manager() |
| 291 |
messages = essential_modules["orca.messages"] |
| 292 |
pres_manager.present_message.assert_called_with(messages.VERSION) |
| 293 |
pres_manager.speak_message.assert_called_with(messages.LEARN_MODE_START_SPEECH) |
| 294 |
pres_manager.present_braille_message.assert_called_with(messages.LEARN_MODE_START_BRAILLE) |
| 295 |
input_manager = essential_modules["orca.input_event_manager"].get_manager.return_value |
| 296 |
input_manager.grab_keyboard.assert_called_with("Entering learn mode") |
| 297 |
|
| 298 |
@pytest.mark.parametrize( |
| 299 |
"is_active,script_provided,script_manager_returns_none,expected_debug_called", |
| 300 |
[ |
| 301 |
(True, False, False, True), # Already active |
| 302 |
(False, True, False, False), # With specific script |
| 303 |
(False, False, True, False), # No script from manager |
| 304 |
], |
| 305 |
) |
| 306 |
def test_start_scenarios( |
| 307 |
self, |
| 308 |
test_context: OrcaTestContext, |
| 309 |
is_active: bool, |
| 310 |
script_provided: bool, |
| 311 |
script_manager_returns_none: bool, |
| 312 |
expected_debug_called: bool, |
| 313 |
) -> None: |
| 314 |
"""Test LearnModePresenter.start under different scenarios.""" |
| 315 |
essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context) |
| 316 |
from orca.learn_mode_presenter import LearnModePresenter |
| 317 |
|
| 318 |
if script_manager_returns_none: |
| 319 |
essential_modules[ |
| 320 |
"orca.script_manager" |
| 321 |
].get_manager.return_value.get_active_script.return_value = None |
| 322 |
presenter = LearnModePresenter() |
| 323 |
presenter._is_active = is_active |
| 324 |
script = test_context.Mock() if script_provided else None |
| 325 |
if script_provided and script is not None: |
| 326 |
script.present_message = test_context.Mock() |
| 327 |
script.speak_message = test_context.Mock() |
| 328 |
script.display_message = test_context.Mock() |
| 329 |
result = presenter.start(_script=script) |
| 330 |
assert result is True |
| 331 |
assert presenter._is_active is True |
| 332 |
if expected_debug_called: |
| 333 |
essential_modules["orca.debug"].print_message.assert_called() |
| 334 |
if script_provided and script is not None: |
| 335 |
pres_manager = essential_modules["orca.presentation_manager"].get_manager() |
| 336 |
pres_manager.present_message.assert_called_with( |
| 337 |
essential_modules["orca.messages"].VERSION, |
| 338 |
) |
| 339 |
|
| 340 |
def test_quit_when_active(self, test_context: OrcaTestContext) -> None: |
| 341 |
"""Test LearnModePresenter.quit when learn mode is active.""" |
| 342 |
|
| 343 |
essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context) |
| 344 |
from orca.learn_mode_presenter import LearnModePresenter |
| 345 |
|
| 346 |
presenter = LearnModePresenter() |
| 347 |
presenter._is_active = True |
| 348 |
result = presenter.quit() |
| 349 |
assert result is True |
| 350 |
assert presenter._is_active is False |
| 351 |
pres_manager = essential_modules["orca.presentation_manager"].get_manager() |
| 352 |
messages = essential_modules["orca.messages"] |
| 353 |
pres_manager.present_message.assert_called_with(messages.LEARN_MODE_STOP) |
| 354 |
input_manager = essential_modules["orca.input_event_manager"].get_manager.return_value |
| 355 |
input_manager.ungrab_keyboard.assert_called_with("Exiting learn mode") |
| 356 |
|
| 357 |
@pytest.mark.parametrize( |
| 358 |
"is_active,script_provided,script_manager_returns_none,expected_debug_called", |
| 359 |
[ |
| 360 |
(False, False, False, True), # Already inactive |
| 361 |
(True, True, False, False), # With specific script |
| 362 |
(True, False, True, False), # No script from manager |
| 363 |
], |
| 364 |
) |
| 365 |
def test_quit_scenarios( |
| 366 |
self, |
| 367 |
test_context: OrcaTestContext, |
| 368 |
is_active: bool, |
| 369 |
script_provided: bool, |
| 370 |
script_manager_returns_none: bool, |
| 371 |
expected_debug_called: bool, |
| 372 |
) -> None: |
| 373 |
"""Test LearnModePresenter.quit under different scenarios.""" |
| 374 |
essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context) |
| 375 |
from orca.learn_mode_presenter import LearnModePresenter |
| 376 |
|
| 377 |
if script_manager_returns_none: |
| 378 |
essential_modules[ |
| 379 |
"orca.script_manager" |
| 380 |
].get_manager.return_value.get_active_script.return_value = None |
| 381 |
presenter = LearnModePresenter() |
| 382 |
presenter._is_active = is_active |
| 383 |
script = test_context.Mock() if script_provided else None |
| 384 |
if script_provided and script is not None: |
| 385 |
script.present_message = test_context.Mock() |
| 386 |
result = presenter.quit(_script=script) |
| 387 |
assert result is True |
| 388 |
expected_final_state = False |
| 389 |
assert presenter._is_active == expected_final_state |
| 390 |
if expected_debug_called: |
| 391 |
essential_modules["orca.debug"].print_message.assert_called() |
| 392 |
if script_provided and script is not None: |
| 393 |
pres_manager = essential_modules["orca.presentation_manager"].get_manager() |
| 394 |
pres_manager.present_message.assert_called_with( |
| 395 |
essential_modules["orca.messages"].LEARN_MODE_STOP, |
| 396 |
) |
| 397 |
|
| 398 |
def test_handle_event_no_script(self, test_context: OrcaTestContext) -> None: |
| 399 |
"""Test LearnModePresenter.handle_event when no active script.""" |
| 400 |
|
| 401 |
essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context) |
| 402 |
essential_modules[ |
| 403 |
"orca.script_manager" |
| 404 |
].get_manager.return_value.get_active_script.return_value = None |
| 405 |
from orca.learn_mode_presenter import LearnModePresenter |
| 406 |
|
| 407 |
presenter = LearnModePresenter() |
| 408 |
keyboard_event_cls = essential_modules["orca.input_event"].KeyboardEvent |
| 409 |
event = keyboard_event_cls() |
| 410 |
result = presenter.handle_event(event, None) |
| 411 |
assert result is False |
| 412 |
|
| 413 |
def test_handle_event_basic_key(self, test_context: OrcaTestContext) -> None: |
| 414 |
"""Test LearnModePresenter.handle_event with basic key event.""" |
| 415 |
|
| 416 |
essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context) |
| 417 |
from orca.learn_mode_presenter import LearnModePresenter |
| 418 |
|
| 419 |
presenter = LearnModePresenter() |
| 420 |
keyboard_event_cls = essential_modules["orca.input_event"].KeyboardEvent |
| 421 |
event = keyboard_event_cls() |
| 422 |
event.keyval_name = "a" |
| 423 |
event.modifiers = 0 |
| 424 |
result = presenter.handle_event(event, None) |
| 425 |
assert result is True |
| 426 |
pres_manager = essential_modules["orca.presentation_manager"].get_manager() |
| 427 |
pres_manager.present_key_event.assert_called() |
| 428 |
|
| 429 |
def test_handle_event_printable_double_click(self, test_context: OrcaTestContext) -> None: |
| 430 |
"""Test LearnModePresenter.handle_event with printable key double-click.""" |
| 431 |
|
| 432 |
essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context) |
| 433 |
from orca.learn_mode_presenter import LearnModePresenter |
| 434 |
|
| 435 |
presenter = LearnModePresenter() |
| 436 |
keyboard_event_cls = essential_modules["orca.input_event"].KeyboardEvent |
| 437 |
event = keyboard_event_cls() |
| 438 |
event.keyval_name = "a" |
| 439 |
event.is_printable_key.return_value = True |
| 440 |
event.get_click_count.return_value = 2 |
| 441 |
event.get_key_name.return_value = "a" |
| 442 |
pres_manager = essential_modules["orca.presentation_manager"].get_manager() |
| 443 |
pres_manager.spell_phonetically.reset_mock() |
| 444 |
result = presenter.handle_event(event, None) |
| 445 |
assert result is True |
| 446 |
pres_manager.spell_phonetically.assert_called_with("a") |
| 447 |
|
| 448 |
@pytest.mark.parametrize( |
| 449 |
"key_name,method_name,has_modifiers", |
| 450 |
[ |
| 451 |
("Escape", "quit", False), |
| 452 |
("F1", "show_help", True), |
| 453 |
("F2", "list_orca_shortcuts", True), |
| 454 |
], |
| 455 |
) |
| 456 |
def test_handle_event_special_keys( |
| 457 |
self, |
| 458 |
test_context: OrcaTestContext, |
| 459 |
key_name: str, |
| 460 |
method_name: str, |
| 461 |
has_modifiers: bool, |
| 462 |
) -> None: |
| 463 |
"""Test LearnModePresenter.handle_event with special function keys.""" |
| 464 |
essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context) |
| 465 |
from orca.learn_mode_presenter import LearnModePresenter |
| 466 |
|
| 467 |
presenter = LearnModePresenter() |
| 468 |
keyboard_event_cls = essential_modules["orca.input_event"].KeyboardEvent |
| 469 |
event = keyboard_event_cls() |
| 470 |
event.keyval_name = key_name |
| 471 |
if has_modifiers: |
| 472 |
event.modifiers = 0 |
| 473 |
script_manager = essential_modules["orca.script_manager"] |
| 474 |
script_instance = script_manager.get_manager.return_value.get_active_script.return_value |
| 475 |
mock_method = test_context.patch_object(presenter, method_name, return_value=True) |
| 476 |
result = presenter.handle_event(event, None) |
| 477 |
assert result is True |
| 478 |
mock_method.assert_called_with(script_instance, event) |
| 479 |
|
| 480 |
def test_handle_event_with_command(self, test_context: OrcaTestContext) -> None: |
| 481 |
"""Test LearnModePresenter.handle_event presents command description.""" |
| 482 |
|
| 483 |
essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context) |
| 484 |
from orca.learn_mode_presenter import LearnModePresenter |
| 485 |
|
| 486 |
presenter = LearnModePresenter() |
| 487 |
keyboard_event_cls = essential_modules["orca.input_event"].KeyboardEvent |
| 488 |
event = keyboard_event_cls() |
| 489 |
event.keyval_name = "a" |
| 490 |
command = test_context.Mock() |
| 491 |
command.get_description.return_value = "Test command" |
| 492 |
result = presenter.handle_event(event, command) |
| 493 |
assert result is True |
| 494 |
pres_manager = essential_modules["orca.presentation_manager"].get_manager() |
| 495 |
pres_manager.present_message.assert_called_with("Test command") |
| 496 |
|
| 497 |
def test_handle_event_command_no_description(self, test_context: OrcaTestContext) -> None: |
| 498 |
"""Test LearnModePresenter.handle_event with command without description.""" |
| 499 |
|
| 500 |
essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context) |
| 501 |
from orca.learn_mode_presenter import LearnModePresenter |
| 502 |
|
| 503 |
presenter = LearnModePresenter() |
| 504 |
keyboard_event_cls = essential_modules["orca.input_event"].KeyboardEvent |
| 505 |
event = keyboard_event_cls() |
| 506 |
event.keyval_name = "a" |
| 507 |
command = test_context.Mock() |
| 508 |
command.get_description.return_value = "" |
| 509 |
result = presenter.handle_event(event, command) |
| 510 |
assert result is True |
| 511 |
pres_manager = essential_modules["orca.presentation_manager"].get_manager() |
| 512 |
pres_manager.present_message.assert_not_called() |
| 513 |
|
| 514 |
def test_list_orca_shortcuts_events(self, test_context: OrcaTestContext) -> None: |
| 515 |
"""Test LearnModePresenter.list_orca_shortcuts with F2 event.""" |
| 516 |
essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context) |
| 517 |
from orca.learn_mode_presenter import LearnModePresenter |
| 518 |
|
| 519 |
mock_keybinding = test_context.Mock() |
| 520 |
mock_keybinding.handler = test_context.Mock() |
| 521 |
mock_keybinding.handler.description = "Test command" |
| 522 |
|
| 523 |
mock_command = test_context.Mock() |
| 524 |
mock_command.get_keybinding.return_value = mock_keybinding |
| 525 |
mock_command.get_group_label.return_value = "Test Group" |
| 526 |
|
| 527 |
command_manager_mock = essential_modules["orca.command_manager"] |
| 528 |
command_manager_mock.get_manager.return_value.get_all_keyboard_commands.return_value = ( |
| 529 |
mock_command, |
| 530 |
) |
| 531 |
|
| 532 |
script_manager = essential_modules["orca.script_manager"] |
| 533 |
script = script_manager.get_manager.return_value.get_active_script.return_value |
| 534 |
|
| 535 |
presenter = LearnModePresenter() |
| 536 |
event = test_context.Mock() |
| 537 |
event.keyval_name = "F2" |
| 538 |
mock_quit = test_context.patch_object(presenter, "quit") |
| 539 |
mock_gui = test_context.patch("orca.learn_mode_presenter.CommandListGUI") |
| 540 |
result = presenter.list_orca_shortcuts(script, event) |
| 541 |
assert result is True |
| 542 |
mock_quit.assert_called_with(script, event) |
| 543 |
mock_gui.assert_called() |
| 544 |
|
| 545 |
def test_show_help_default_page(self, test_context: OrcaTestContext) -> None: |
| 546 |
"""Test LearnModePresenter.show_help with default page.""" |
| 547 |
|
| 548 |
essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context) |
| 549 |
from orca.learn_mode_presenter import LearnModePresenter |
| 550 |
|
| 551 |
presenter = LearnModePresenter() |
| 552 |
script_manager = essential_modules["orca.script_manager"] |
| 553 |
script = script_manager.get_manager.return_value.get_active_script.return_value |
| 554 |
event = test_context.Mock() |
| 555 |
mock_quit = test_context.patch_object(presenter, "quit") |
| 556 |
result = presenter.show_help(script, event) |
| 557 |
assert result is True |
| 558 |
mock_quit.assert_called_with(script, event) |
| 559 |
gi_repository = essential_modules["gi.repository"] |
| 560 |
gi_repository.Gtk.show_uri.assert_called() |
| 561 |
|
| 562 |
def test_handle_braille_event_no_command(self, test_context: OrcaTestContext) -> None: |
| 563 |
"""Test handle_braille_event with no command returns True (don't execute).""" |
| 564 |
|
| 565 |
essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context) |
| 566 |
from orca.learn_mode_presenter import LearnModePresenter |
| 567 |
|
| 568 |
presenter = LearnModePresenter() |
| 569 |
script_manager = essential_modules["orca.script_manager"] |
| 570 |
script = script_manager.get_manager.return_value.get_active_script.return_value |
| 571 |
event = test_context.Mock() |
| 572 |
result = presenter.handle_braille_event(script, event, None) |
| 573 |
assert result is True |
| 574 |
|
| 575 |
def test_handle_braille_event_with_command(self, test_context: OrcaTestContext) -> None: |
| 576 |
"""Test handle_braille_event presents description and returns True.""" |
| 577 |
|
| 578 |
essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context) |
| 579 |
from orca.learn_mode_presenter import LearnModePresenter |
| 580 |
|
| 581 |
presenter = LearnModePresenter() |
| 582 |
script_manager = essential_modules["orca.script_manager"] |
| 583 |
script = script_manager.get_manager.return_value.get_active_script.return_value |
| 584 |
event = test_context.Mock() |
| 585 |
command = test_context.Mock() |
| 586 |
command.get_description.return_value = "Pan braille left" |
| 587 |
command.executes_in_learn_mode.return_value = False |
| 588 |
result = presenter.handle_braille_event(script, event, command) |
| 589 |
assert result is True # Don't execute |
| 590 |
pres_manager = essential_modules["orca.presentation_manager"].get_manager() |
| 591 |
pres_manager.present_message.assert_called_with("Pan braille left") |
| 592 |
command.execute.assert_not_called() |
| 593 |
|
| 594 |
def test_handle_braille_event_pan_command_no_flash(self, test_context: OrcaTestContext) -> None: |
| 595 |
"""Test handle_braille_event presents description when no flash is active.""" |
| 596 |
|
| 597 |
essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context) |
| 598 |
from orca.learn_mode_presenter import LearnModePresenter |
| 599 |
|
| 600 |
presenter = LearnModePresenter() |
| 601 |
script_manager = essential_modules["orca.script_manager"] |
| 602 |
script = script_manager.get_manager.return_value.get_active_script.return_value |
| 603 |
event = test_context.Mock() |
| 604 |
command = test_context.Mock() |
| 605 |
command.get_description.return_value = "Pan braille left" |
| 606 |
command.executes_in_learn_mode.return_value = True |
| 607 |
pres_manager = essential_modules["orca.presentation_manager"].get_manager() |
| 608 |
pres_manager.is_flash_message_displayed.return_value = False |
| 609 |
result = presenter.handle_braille_event(script, event, command) |
| 610 |
assert result is True |
| 611 |
pres_manager.present_message.assert_called_with("Pan braille left") |
| 612 |
command.execute.assert_not_called() |
| 613 |
|
| 614 |
def test_handle_braille_event_pan_command_with_flash( |
| 615 |
self, test_context: OrcaTestContext |
| 616 |
) -> None: |
| 617 |
"""Test handle_braille_event executes pan command when flash is active.""" |
| 618 |
|
| 619 |
essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context) |
| 620 |
from orca.learn_mode_presenter import LearnModePresenter |
| 621 |
|
| 622 |
presenter = LearnModePresenter() |
| 623 |
script_manager = essential_modules["orca.script_manager"] |
| 624 |
script = script_manager.get_manager.return_value.get_active_script.return_value |
| 625 |
event = test_context.Mock() |
| 626 |
command = test_context.Mock() |
| 627 |
command.get_description.return_value = "Pan braille left" |
| 628 |
command.executes_in_learn_mode.return_value = True |
| 629 |
pres_manager = essential_modules["orca.presentation_manager"].get_manager() |
| 630 |
pres_manager.is_flash_message_displayed.return_value = True |
| 631 |
result = presenter.handle_braille_event(script, event, command) |
| 632 |
assert result is True |
| 633 |
command.execute.assert_called_once_with(script, event) |
| 634 |
pres_manager.present_message.assert_not_called() |