Debian Codegraph @

tests/unit_tests/test_learn_mode_presenter.py

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