Debian Codegraph @

tests/unit_tests/test_document_presenter.py

raw
1 # Unit tests for document_presenter.py.
2 #
3 # Copyright 2026 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=protected-access
23 # pylint: disable=import-outside-toplevel
24 # pylint: disable=too-many-public-methods
25 # pylint: disable=too-many-locals
26
27 # pylint: disable=too-many-lines
28 """Unit tests for document_presenter.py."""
29
30 from __future__ import annotations
31
32 from typing import TYPE_CHECKING
33
34 import pytest
35
36 if TYPE_CHECKING:
37 from .orca_test_context import OrcaTestContext
38
39
40 @pytest.mark.unit
41 class TestDocumentPresenter:
42 """Test DocumentPresenter class."""
43
44 def _setup_presenter(self, test_context: OrcaTestContext):
45 """Set up mocks for document_presenter dependencies."""
46
47 additional_modules = [
48 "orca.ax_document",
49 "orca.ax_object",
50 "orca.ax_table",
51 "orca.ax_text",
52 "orca.ax_utilities",
53 "orca.caret_navigator",
54 "orca.focus_manager",
55 "orca.guilabels",
56 "orca.input_event_manager",
57 "orca.live_region_presenter",
58 "orca.preferences_grid_base",
59 "orca.script_manager",
60 "orca.structural_navigator",
61 "orca.table_navigator",
62 "orca.braille_presenter",
63 "orca.presentation_manager",
64 ]
65 essential_modules = test_context.setup_shared_dependencies(additional_modules)
66
67 # Set up guilabels with required constants
68 guilabels = essential_modules["orca.guilabels"]
69 guilabels.DOCUMENTS = "Documents"
70 guilabels.KB_GROUP_CARET_NAVIGATION = "Caret Navigation"
71 guilabels.KB_GROUP_STRUCTURAL_NAVIGATION = "Structural Navigation"
72 guilabels.KB_GROUP_TABLE_NAVIGATION = "Table Navigation"
73 guilabels.NATIVE_NAVIGATION = "Native Navigation"
74 guilabels.AUTOMATIC_FOCUS_MODE = "Automatic focus mode"
75 guilabels.CONTENT_LAYOUT_MODE = "Layout mode"
76 guilabels.TABLE_SKIP_BLANK_CELLS = "Skip blank cells"
77 guilabels.FIND_SPEAK_RESULTS = "Speak find results"
78 guilabels.FIND_ONLY_SPEAK_CHANGED_LINES = "Only speak changed lines"
79 guilabels.FIND_MINIMUM_MATCH_LENGTH = "Minimum match length"
80 guilabels.FIND_OPTIONS = "Find Options"
81 guilabels.READ_PAGE_UPON_LOAD = "Read page upon load"
82 guilabels.PAGE_SUMMARY_UPON_LOAD = "Page summary upon load"
83 guilabels.PAGE_LOAD = "Page Load"
84 guilabels.CARET_NAVIGATION_INFO = "Caret navigation info"
85 guilabels.STRUCTURAL_NAVIGATION_INFO = "Structural navigation info"
86 guilabels.NATIVE_NAVIGATION_INFO = "Native navigation info"
87 guilabels.AUTOMATIC_FOCUS_MODE_INFO = "Auto focus mode info"
88
89 from orca import gsettings_registry
90
91 registry = gsettings_registry.get_registry()
92 registry.clear_runtime_values()
93
94 # Import and return the module
95 from orca import document_presenter
96
97 return document_presenter, essential_modules
98
99 def test_get_presenter_returns_singleton(self, test_context: OrcaTestContext) -> None:
100 """Test get_presenter returns the same instance."""
101
102 module, _mocks = self._setup_presenter(test_context)
103 presenter1 = module.get_presenter()
104 presenter2 = module.get_presenter()
105
106 assert presenter1 is presenter2
107
108 def test_get_native_nav_triggers_focus_mode_default(
109 self,
110 test_context: OrcaTestContext,
111 ) -> None:
112 """Test get_native_nav_triggers_focus_mode returns default value."""
113
114 module, _mocks = self._setup_presenter(test_context)
115
116 presenter = module.get_presenter()
117 result = presenter.get_native_nav_triggers_focus_mode()
118
119 assert result is True
120
121 def test_set_native_nav_triggers_focus_mode(self, test_context: OrcaTestContext) -> None:
122 """Test set_native_nav_triggers_focus_mode updates setting."""
123
124 module, _mocks = self._setup_presenter(test_context)
125
126 presenter = module.get_presenter()
127 result = presenter.set_native_nav_triggers_focus_mode(False)
128
129 assert result is True
130 assert presenter.get_native_nav_triggers_focus_mode() is False
131
132 def test_set_native_nav_triggers_focus_mode_no_change(
133 self,
134 test_context: OrcaTestContext,
135 ) -> None:
136 """Test set_native_nav_triggers_focus_mode returns True when value unchanged."""
137
138 module, _mocks = self._setup_presenter(test_context)
139
140 presenter = module.get_presenter()
141 result = presenter.set_native_nav_triggers_focus_mode(True)
142
143 assert result is True
144
145 def test_get_say_all_on_load_default(self, test_context: OrcaTestContext) -> None:
146 """Test get_say_all_on_load returns default value."""
147
148 module, _mocks = self._setup_presenter(test_context)
149
150 presenter = module.get_presenter()
151 result = presenter.get_say_all_on_load()
152
153 assert result is True
154
155 def test_set_say_all_on_load(self, test_context: OrcaTestContext) -> None:
156 """Test set_say_all_on_load updates setting."""
157
158 module, _mocks = self._setup_presenter(test_context)
159
160 presenter = module.get_presenter()
161 result = presenter.set_say_all_on_load(False)
162
163 assert result is True
164 assert presenter.get_say_all_on_load() is False
165
166 def test_set_say_all_on_load_no_change(self, test_context: OrcaTestContext) -> None:
167 """Test set_say_all_on_load returns True when value unchanged."""
168
169 module, _mocks = self._setup_presenter(test_context)
170
171 presenter = module.get_presenter()
172 result = presenter.set_say_all_on_load(True)
173
174 assert result is True
175
176 def test_get_page_summary_on_load_default(self, test_context: OrcaTestContext) -> None:
177 """Test get_page_summary_on_load returns default value."""
178
179 module, _mocks = self._setup_presenter(test_context)
180
181 presenter = module.get_presenter()
182 result = presenter.get_page_summary_on_load()
183
184 assert result is True
185
186 def test_set_page_summary_on_load(self, test_context: OrcaTestContext) -> None:
187 """Test set_page_summary_on_load updates setting."""
188
189 module, _mocks = self._setup_presenter(test_context)
190
191 presenter = module.get_presenter()
192 result = presenter.set_page_summary_on_load(False)
193
194 assert result is True
195 assert presenter.get_page_summary_on_load() is False
196
197 def test_set_page_summary_on_load_no_change(self, test_context: OrcaTestContext) -> None:
198 """Test set_page_summary_on_load returns True when value unchanged."""
199
200 module, _mocks = self._setup_presenter(test_context)
201
202 presenter = module.get_presenter()
203 result = presenter.set_page_summary_on_load(True)
204
205 assert result is True
206
207 def test_get_speak_find_results_true(self, test_context: OrcaTestContext) -> None:
208 """Test get_speak_find_results returns True when verbosity is not NONE."""
209
210 module, _mocks = self._setup_presenter(test_context)
211
212 presenter = module.get_presenter()
213 result = presenter.get_speak_find_results()
214
215 assert result is True
216
217 def test_get_speak_find_results_false(self, test_context: OrcaTestContext) -> None:
218 """Test get_speak_find_results returns False when verbosity is NONE."""
219
220 module, _mocks = self._setup_presenter(test_context)
221 from orca import gsettings_registry # pylint: disable=import-outside-toplevel
222
223 presenter = module.get_presenter()
224 gsettings_registry.get_registry().set_runtime_value(
225 "document",
226 "find-results-verbosity",
227 "none",
228 )
229 result = presenter.get_speak_find_results()
230
231 assert result is False
232
233 def test_set_speak_find_results_enable(self, test_context: OrcaTestContext) -> None:
234 """Test set_speak_find_results enables speech."""
235
236 module, _mocks = self._setup_presenter(test_context)
237 from orca import gsettings_registry # pylint: disable=import-outside-toplevel
238
239 presenter = module.get_presenter()
240 gsettings_registry.get_registry().set_runtime_value(
241 "document",
242 "find-results-verbosity",
243 "none",
244 )
245 result = presenter.set_speak_find_results(True)
246
247 assert result is True
248 assert presenter.get_speak_find_results() is True
249
250 def test_set_speak_find_results_disable(self, test_context: OrcaTestContext) -> None:
251 """Test set_speak_find_results disables speech."""
252
253 module, _mocks = self._setup_presenter(test_context)
254
255 presenter = module.get_presenter()
256 result = presenter.set_speak_find_results(False)
257
258 assert result is True
259 assert presenter.get_speak_find_results() is False
260
261 def test_get_only_speak_changed_lines_true(self, test_context: OrcaTestContext) -> None:
262 """Test get_only_speak_changed_lines returns True when set."""
263
264 module, _mocks = self._setup_presenter(test_context)
265 from orca import gsettings_registry # pylint: disable=import-outside-toplevel
266
267 presenter = module.get_presenter()
268 gsettings_registry.get_registry().set_runtime_value(
269 "document",
270 "find-results-verbosity",
271 "if-line-changed",
272 )
273 result = presenter.get_only_speak_changed_lines()
274
275 assert result is True
276
277 def test_get_only_speak_changed_lines_false(self, test_context: OrcaTestContext) -> None:
278 """Test get_only_speak_changed_lines returns False when not set."""
279
280 module, _mocks = self._setup_presenter(test_context)
281
282 presenter = module.get_presenter()
283 result = presenter.get_only_speak_changed_lines()
284
285 assert result is False
286
287 def test_set_only_speak_changed_lines_enable(self, test_context: OrcaTestContext) -> None:
288 """Test set_only_speak_changed_lines enables the option."""
289
290 module, _mocks = self._setup_presenter(test_context)
291
292 presenter = module.get_presenter()
293 result = presenter.set_only_speak_changed_lines(True)
294
295 assert result is True
296 assert presenter.get_only_speak_changed_lines() is True
297
298 def test_set_only_speak_changed_lines_disable(self, test_context: OrcaTestContext) -> None:
299 """Test set_only_speak_changed_lines disables the option."""
300
301 module, _mocks = self._setup_presenter(test_context)
302 from orca import gsettings_registry # pylint: disable=import-outside-toplevel
303
304 presenter = module.get_presenter()
305 gsettings_registry.get_registry().set_runtime_value(
306 "document",
307 "find-results-verbosity",
308 "if-line-changed",
309 )
310 result = presenter.set_only_speak_changed_lines(False)
311
312 assert result is True
313 assert presenter.get_only_speak_changed_lines() is False
314
315 def test_get_find_results_minimum_length(self, test_context: OrcaTestContext) -> None:
316 """Test get_find_results_minimum_length returns current value."""
317
318 module, _mocks = self._setup_presenter(test_context)
319
320 presenter = module.get_presenter()
321 presenter.set_find_results_minimum_length(5)
322 result = presenter.get_find_results_minimum_length()
323
324 assert result == 5
325
326 def test_set_find_results_minimum_length(self, test_context: OrcaTestContext) -> None:
327 """Test set_find_results_minimum_length updates setting."""
328
329 module, _mocks = self._setup_presenter(test_context)
330
331 presenter = module.get_presenter()
332 presenter.set_find_results_minimum_length(5)
333 result = presenter.set_find_results_minimum_length(10)
334
335 assert result is True
336 assert presenter.get_find_results_minimum_length() == 10
337
338 def test_set_find_results_minimum_length_no_change(self, test_context: OrcaTestContext) -> None:
339 """Test set_find_results_minimum_length returns True when value unchanged."""
340
341 module, _mocks = self._setup_presenter(test_context)
342
343 presenter = module.get_presenter()
344 presenter.set_find_results_minimum_length(5)
345 result = presenter.set_find_results_minimum_length(5)
346
347 assert result is True
348
349 def test_reset_find_announcement_state(self, test_context: OrcaTestContext) -> None:
350 """Test reset_find_announcement_state resets the internal state."""
351
352 module, _mocks = self._setup_presenter(test_context)
353 presenter = module.get_presenter()
354
355 # Set the internal state to True
356 presenter._made_find_announcement = True
357 assert presenter._made_find_announcement is True
358
359 # Reset and verify
360 presenter.reset_find_announcement_state()
361 assert presenter._made_find_announcement is False
362
363 def test_present_find_results_no_active_script(self, test_context: OrcaTestContext) -> None:
364 """Test present_find_results returns False when no active script."""
365
366 module, mocks = self._setup_presenter(test_context)
367 script_manager = mocks["orca.script_manager"]
368 script_manager.get_manager.return_value.get_active_script.return_value = None
369
370 presenter = module.get_presenter()
371 result = presenter.present_find_results(None, 0)
372
373 assert result is False
374
375 def test_present_find_results_no_document(self, test_context: OrcaTestContext) -> None:
376 """Test present_find_results returns False when no document."""
377
378 from unittest.mock import MagicMock
379
380 module, mocks = self._setup_presenter(test_context)
381
382 # Set up mock script with utilities
383 mock_script = MagicMock()
384 mock_script.utilities.get_document_for_object.return_value = None
385 script_manager = mocks["orca.script_manager"]
386 script_manager.get_manager.return_value.get_active_script.return_value = mock_script
387
388 presenter = module.get_presenter()
389 mock_obj = MagicMock()
390 result = presenter.present_find_results(mock_obj, 0)
391
392 assert result is False
393
394 def test_present_find_results_selection_too_short(self, test_context: OrcaTestContext) -> None:
395 """Test present_find_results returns False when selection is too short."""
396
397 from unittest.mock import MagicMock
398
399 module, mocks = self._setup_presenter(test_context)
400 from orca import gsettings_registry # pylint: disable=import-outside-toplevel
401
402 gsettings_registry.get_registry().set_runtime_value(
403 "document",
404 "find-results-minimum-length",
405 5,
406 )
407
408 # Set up mock script
409 mock_script = MagicMock()
410 mock_script.utilities.get_document_for_object.return_value = MagicMock()
411 mock_script.utilities.get_caret_context.return_value = (None, 0)
412 script_manager = mocks["orca.script_manager"]
413 script_manager.get_manager.return_value.get_active_script.return_value = mock_script
414
415 # Set up AXText mock to return short selection (length 3)
416 ax_utilities = mocks["orca.ax_utilities"]
417 ax_utilities.AXUtilities.get_selection_start_offset.return_value = 0
418 ax_utilities.AXUtilities.get_selection_end_offset.return_value = 3
419
420 presenter = module.get_presenter()
421 mock_obj = MagicMock()
422 result = presenter.present_find_results(mock_obj, 0)
423
424 assert result is False
425
426 def test_present_find_results_speak_disabled(self, test_context: OrcaTestContext) -> None:
427 """Test present_find_results returns False when speak is disabled."""
428
429 from unittest.mock import MagicMock
430
431 module, mocks = self._setup_presenter(test_context)
432 from orca import gsettings_registry # pylint: disable=import-outside-toplevel
433
434 registry = gsettings_registry.get_registry()
435 registry.set_runtime_value("document", "find-results-minimum-length", 3)
436 registry.set_runtime_value("document", "find-results-verbosity", "none")
437
438 # Set up mock script
439 mock_script = MagicMock()
440 mock_script.utilities.get_document_for_object.return_value = MagicMock()
441 mock_script.utilities.get_caret_context.return_value = (None, 0)
442 script_manager = mocks["orca.script_manager"]
443 script_manager.get_manager.return_value.get_active_script.return_value = mock_script
444
445 # Set up AXText mock with valid selection length
446 ax_utilities = mocks["orca.ax_utilities"]
447 ax_utilities.AXUtilities.get_selection_start_offset.return_value = 0
448 ax_utilities.AXUtilities.get_selection_end_offset.return_value = 10
449
450 presenter = module.get_presenter()
451 mock_obj = MagicMock()
452 result = presenter.present_find_results(mock_obj, 0)
453
454 assert result is False
455
456 def test_present_find_results_success(self, test_context: OrcaTestContext) -> None:
457 """Test present_find_results returns True and presents when conditions are met."""
458
459 from unittest.mock import MagicMock
460
461 module, mocks = self._setup_presenter(test_context)
462 from orca import gsettings_registry # pylint: disable=import-outside-toplevel
463
464 gsettings_registry.get_registry().set_runtime_value(
465 "document",
466 "find-results-minimum-length",
467 3,
468 )
469
470 # Set up mock script
471 mock_script = MagicMock()
472 mock_script.utilities.get_document_for_object.return_value = MagicMock()
473 mock_script.utilities.get_caret_context.return_value = (None, 0)
474 mock_script.utilities.get_line_contents_at_offset.return_value = ["test content"]
475 mock_script.utilities.get_find_results_count.return_value = "1 of 5"
476 script_manager = mocks["orca.script_manager"]
477 script_manager.get_manager.return_value.get_active_script.return_value = mock_script
478
479 # Set up AXText mock with valid selection length
480 ax_utilities = mocks["orca.ax_utilities"]
481 ax_utilities.AXUtilities.get_selection_start_offset.return_value = 0
482 ax_utilities.AXUtilities.get_selection_end_offset.return_value = 10
483
484 presenter = module.get_presenter()
485 presenter._made_find_announcement = False
486 pres_manager = mocks["orca.presentation_manager"].get_manager()
487 pres_manager.speak_contents.reset_mock()
488 pres_manager.present_message.reset_mock()
489 mock_obj = MagicMock()
490 result = presenter.present_find_results(mock_obj, 0)
491
492 assert result is True
493 assert presenter._made_find_announcement is True
494 pres_manager.speak_contents.assert_called_once()
495 mock_script.update_braille.assert_called_once()
496 pres_manager.present_message.assert_called_once_with("1 of 5")
497
498 def test_present_find_results_skips_same_line_when_only_changed(
499 self,
500 test_context: OrcaTestContext,
501 ) -> None:
502 """Test present_find_results skips when same line and only_speak_changed_lines."""
503
504 from unittest.mock import MagicMock
505
506 module, mocks = self._setup_presenter(test_context)
507 from orca import gsettings_registry # pylint: disable=import-outside-toplevel
508
509 registry = gsettings_registry.get_registry()
510 registry.set_runtime_value("document", "find-results-minimum-length", 3)
511 registry.set_runtime_value("document", "find-results-verbosity", "if-line-changed")
512
513 # Set up mock script
514 mock_script = MagicMock()
515 mock_script.utilities.get_document_for_object.return_value = MagicMock()
516 mock_script.utilities.get_caret_context.return_value = (MagicMock(), 5)
517 script_manager = mocks["orca.script_manager"]
518 script_manager.get_manager.return_value.get_active_script.return_value = mock_script
519
520 # Set up AXText mock with valid selection length
521 ax_utilities = mocks["orca.ax_utilities"]
522 ax_utilities.AXUtilities.get_selection_start_offset.return_value = 0
523 ax_utilities.AXUtilities.get_selection_end_offset.return_value = 10
524 ax_text = mocks["orca.ax_text"]
525 ax_text.AXText.get_range_rect.return_value = MagicMock()
526
527 ax_utilities.AXUtilities.rects_are_on_same_line = MagicMock(return_value=True)
528
529 presenter = module.get_presenter()
530 presenter._made_find_announcement = True # Already announced
531 pres_manager = mocks["orca.presentation_manager"].get_manager()
532 pres_manager.speak_contents.reset_mock()
533 mock_obj = MagicMock()
534 result = presenter.present_find_results(mock_obj, 5)
535
536 assert result is False
537 pres_manager.speak_contents.assert_not_called()
538
539 def test_use_focus_mode_no_active_script(self, test_context: OrcaTestContext) -> None:
540 """Test use_focus_mode returns False when no active script."""
541
542 from unittest.mock import MagicMock
543
544 module, mocks = self._setup_presenter(test_context)
545 script_manager = mocks["orca.script_manager"]
546 script_manager.get_manager.return_value.get_active_script.return_value = None
547
548 presenter = module.get_presenter()
549 result = presenter.use_focus_mode(MagicMock())
550
551 assert result is False
552
553 def test_use_focus_mode_sticky_focus_mode(self, test_context: OrcaTestContext) -> None:
554 """Test use_focus_mode returns True when focus mode is sticky."""
555
556 from unittest.mock import MagicMock
557
558 module, mocks = self._setup_presenter(test_context)
559
560 mock_app = MagicMock()
561 mock_script = MagicMock()
562 mock_script.app = mock_app
563 script_manager = mocks["orca.script_manager"]
564 script_manager.get_manager.return_value.get_active_script.return_value = mock_script
565
566 presenter = module.get_presenter()
567 presenter._app_states[hash(mock_app)] = module._AppModeState(
568 in_focus_mode=True,
569 focus_mode_is_sticky=True,
570 browse_mode_is_sticky=False,
571 )
572
573 result = presenter.use_focus_mode(MagicMock())
574
575 assert result is True
576
577 def test_use_focus_mode_sticky_browse_mode(self, test_context: OrcaTestContext) -> None:
578 """Test use_focus_mode returns False when browse mode is sticky."""
579
580 from unittest.mock import MagicMock
581
582 module, mocks = self._setup_presenter(test_context)
583
584 mock_app = MagicMock()
585 mock_script = MagicMock()
586 mock_script.app = mock_app
587 script_manager = mocks["orca.script_manager"]
588 script_manager.get_manager.return_value.get_active_script.return_value = mock_script
589
590 presenter = module.get_presenter()
591 presenter._app_states[hash(mock_app)] = module._AppModeState(
592 in_focus_mode=False,
593 focus_mode_is_sticky=False,
594 browse_mode_is_sticky=True,
595 )
596
597 result = presenter.use_focus_mode(MagicMock())
598
599 assert result is False
600
601 def test_use_focus_mode_in_say_all(self, test_context: OrcaTestContext) -> None:
602 """Test use_focus_mode returns False when in say all."""
603
604 from unittest.mock import MagicMock
605
606 module, mocks = self._setup_presenter(test_context)
607
608 mock_app = MagicMock()
609 mock_script = MagicMock()
610 mock_script.app = mock_app
611 script_manager = mocks["orca.script_manager"]
612 script_manager.get_manager.return_value.get_active_script.return_value = mock_script
613
614 focus_manager = mocks["orca.focus_manager"]
615 focus_manager.get_manager.return_value.in_say_all.return_value = True
616
617 presenter = module.get_presenter()
618 # No sticky state set (defaults to browse mode)
619 result = presenter.use_focus_mode(MagicMock())
620
621 assert result is False
622
623 def test_use_focus_mode_struct_nav_prevents(self, test_context: OrcaTestContext) -> None:
624 """Test use_focus_mode returns False when struct nav prevents it."""
625
626 from unittest.mock import MagicMock
627
628 module, mocks = self._setup_presenter(test_context)
629
630 mock_app = MagicMock()
631 mock_script = MagicMock()
632 mock_script.app = mock_app
633 script_manager = mocks["orca.script_manager"]
634 script_manager.get_manager.return_value.get_active_script.return_value = mock_script
635
636 focus_manager = mocks["orca.focus_manager"]
637 focus_manager.get_manager.return_value.in_say_all.return_value = False
638
639 struct_nav = mocks["orca.structural_navigator"]
640 struct_nav.get_navigator.return_value.last_command_prevents_focus_mode.return_value = True
641
642 presenter = module.get_presenter()
643 result = presenter.use_focus_mode(MagicMock())
644
645 assert result is False
646
647 def test_use_focus_mode_table_nav_prevents(self, test_context: OrcaTestContext) -> None:
648 """Test use_focus_mode returns False when table nav was last command."""
649
650 from unittest.mock import MagicMock
651
652 module, mocks = self._setup_presenter(test_context)
653
654 mock_app = MagicMock()
655 mock_script = MagicMock()
656 mock_script.app = mock_app
657 script_manager = mocks["orca.script_manager"]
658 script_manager.get_manager.return_value.get_active_script.return_value = mock_script
659
660 focus_manager = mocks["orca.focus_manager"]
661 focus_manager.get_manager.return_value.in_say_all.return_value = False
662
663 struct_nav = mocks["orca.structural_navigator"]
664 struct_nav.get_navigator.return_value.last_command_prevents_focus_mode.return_value = False
665
666 table_nav = mocks["orca.table_navigator"]
667 nav_mock = table_nav.get_navigator.return_value
668 nav_mock.last_input_event_was_navigation_command.return_value = True
669
670 presenter = module.get_presenter()
671 result = presenter.use_focus_mode(MagicMock())
672
673 assert result is False
674
675 def test_use_focus_mode_caret_nav_prevents(self, test_context: OrcaTestContext) -> None:
676 """Test use_focus_mode returns False when caret nav prevents it."""
677
678 from unittest.mock import MagicMock
679
680 module, mocks = self._setup_presenter(test_context)
681
682 mock_app = MagicMock()
683 mock_script = MagicMock()
684 mock_script.app = mock_app
685 script_manager = mocks["orca.script_manager"]
686 script_manager.get_manager.return_value.get_active_script.return_value = mock_script
687
688 focus_manager = mocks["orca.focus_manager"]
689 focus_manager.get_manager.return_value.in_say_all.return_value = False
690
691 struct_nav = mocks["orca.structural_navigator"]
692 struct_nav.get_navigator.return_value.last_command_prevents_focus_mode.return_value = False
693
694 table_nav = mocks["orca.table_navigator"]
695 nav_mock = table_nav.get_navigator.return_value
696 nav_mock.last_input_event_was_navigation_command.return_value = False
697
698 caret_nav = mocks["orca.caret_navigator"]
699 caret_nav.get_navigator.return_value.last_command_prevents_focus_mode.return_value = True
700
701 ax_object = mocks["orca.ax_object"]
702 ax_object.AXObject.is_dead.return_value = False
703
704 ax_utilities = mocks["orca.ax_utilities"]
705 ax_utilities.AXUtilities.find_ancestor_inclusive.return_value = None
706
707 presenter = module.get_presenter()
708 result = presenter.use_focus_mode(MagicMock(), MagicMock())
709
710 assert result is False
711
712 def test_use_focus_mode_focus_mode_widget(self, test_context: OrcaTestContext) -> None:
713 """Test use_focus_mode returns True for focus mode widget."""
714
715 from unittest.mock import MagicMock, patch
716
717 module, mocks = self._setup_presenter(test_context)
718 mock_app = MagicMock()
719 mock_script = MagicMock()
720 mock_script.app = mock_app
721 script_manager = mocks["orca.script_manager"]
722 script_manager.get_manager.return_value.get_active_script.return_value = mock_script
723
724 focus_manager = mocks["orca.focus_manager"]
725 focus_manager.get_manager.return_value.in_say_all.return_value = False
726
727 struct_nav = mocks["orca.structural_navigator"]
728 struct_nav.get_navigator.return_value.last_command_prevents_focus_mode.return_value = False
729
730 table_nav = mocks["orca.table_navigator"]
731 nav_mock = table_nav.get_navigator.return_value
732 nav_mock.last_input_event_was_navigation_command.return_value = False
733
734 caret_nav = mocks["orca.caret_navigator"]
735 caret_nav.get_navigator.return_value.last_command_prevents_focus_mode.return_value = False
736
737 presenter = module.get_presenter()
738 with patch.object(presenter, "is_focus_mode_widget", return_value=True):
739 result = presenter.use_focus_mode(MagicMock())
740
741 assert result is True
742
743 def test_use_focus_mode_entering_web_app(self, test_context: OrcaTestContext) -> None:
744 """Test use_focus_mode returns True when entering a web application."""
745
746 from unittest.mock import MagicMock, patch
747
748 module, mocks = self._setup_presenter(test_context)
749 mock_app = MagicMock()
750 mock_script = MagicMock()
751 mock_script.app = mock_app
752 script_manager = mocks["orca.script_manager"]
753 script_manager.get_manager.return_value.get_active_script.return_value = mock_script
754
755 focus_manager = mocks["orca.focus_manager"]
756 focus_manager.get_manager.return_value.in_say_all.return_value = False
757
758 struct_nav = mocks["orca.structural_navigator"]
759 struct_nav.get_navigator.return_value.last_command_prevents_focus_mode.return_value = False
760
761 table_nav = mocks["orca.table_navigator"]
762 nav_mock = table_nav.get_navigator.return_value
763 nav_mock.last_input_event_was_navigation_command.return_value = False
764
765 caret_nav = mocks["orca.caret_navigator"]
766 caret_nav.get_navigator.return_value.last_command_prevents_focus_mode.return_value = False
767
768 ax_utilities = mocks["orca.ax_utilities"]
769 ax_utilities.AXUtilities.is_link.return_value = False
770 ax_utilities.AXUtilities.is_radio_button.return_value = False
771 ax_utilities.AXUtilities.is_embedded = MagicMock()
772
773 # prev_obj not in app, obj in app
774 ax_utilities.AXUtilities.find_ancestor.side_effect = [None, MagicMock()]
775
776 presenter = module.get_presenter()
777 with patch.object(presenter, "is_focus_mode_widget", return_value=False):
778 result = presenter.use_focus_mode(MagicMock(), MagicMock())
779
780 assert result is True
781
782 def test_use_focus_mode_default_false(self, test_context: OrcaTestContext) -> None:
783 """Test use_focus_mode returns False by default."""
784
785 from unittest.mock import MagicMock, patch
786
787 module, mocks = self._setup_presenter(test_context)
788 mock_app = MagicMock()
789 mock_script = MagicMock()
790 mock_script.app = mock_app
791 script_manager = mocks["orca.script_manager"]
792 script_manager.get_manager.return_value.get_active_script.return_value = mock_script
793
794 focus_manager = mocks["orca.focus_manager"]
795 focus_manager.get_manager.return_value.in_say_all.return_value = False
796
797 struct_nav = mocks["orca.structural_navigator"]
798 struct_nav.get_navigator.return_value.last_command_prevents_focus_mode.return_value = False
799
800 table_nav = mocks["orca.table_navigator"]
801 nav_mock = table_nav.get_navigator.return_value
802 nav_mock.last_input_event_was_navigation_command.return_value = False
803
804 caret_nav = mocks["orca.caret_navigator"]
805 caret_nav.get_navigator.return_value.last_command_prevents_focus_mode.return_value = False
806
807 ax_utilities = mocks["orca.ax_utilities"]
808 ax_utilities.AXUtilities.is_link.return_value = False
809 ax_utilities.AXUtilities.is_radio_button.return_value = False
810 ax_utilities.AXUtilities.is_embedded = MagicMock()
811
812 ax_utilities.AXUtilities.find_ancestor.return_value = None
813
814 presenter = module.get_presenter()
815 with patch.object(presenter, "is_focus_mode_widget", return_value=False):
816 result = presenter.use_focus_mode(MagicMock())
817
818 assert result is False
819
820 def test_use_focus_mode_native_nav_no_trigger(self, test_context: OrcaTestContext) -> None:
821 """Test use_focus_mode returns current mode when native nav doesn't trigger."""
822
823 from unittest.mock import MagicMock
824
825 module, mocks = self._setup_presenter(test_context)
826
827 mock_app = MagicMock()
828 mock_script = MagicMock()
829 mock_script.app = mock_app
830 script_manager = mocks["orca.script_manager"]
831 script_manager.get_manager.return_value.get_active_script.return_value = mock_script
832
833 focus_manager = mocks["orca.focus_manager"]
834 focus_manager.get_manager.return_value.in_say_all.return_value = False
835
836 struct_nav = mocks["orca.structural_navigator"]
837 struct_nav.get_navigator.return_value.last_command_prevents_focus_mode.return_value = False
838 nav_mock = struct_nav.get_navigator.return_value
839 nav_mock.last_input_event_was_navigation_command.return_value = False
840
841 table_nav = mocks["orca.table_navigator"]
842 nav_mock = table_nav.get_navigator.return_value
843 nav_mock.last_input_event_was_navigation_command.return_value = False
844
845 caret_nav = mocks["orca.caret_navigator"]
846 caret_nav.get_navigator.return_value.last_command_prevents_focus_mode.return_value = False
847 nav_mock = caret_nav.get_navigator.return_value
848 nav_mock.last_input_event_was_navigation_command.return_value = False
849
850 presenter = module.get_presenter()
851 presenter.set_native_nav_triggers_focus_mode(False)
852 presenter._app_states[hash(mock_app)] = module._AppModeState(
853 in_focus_mode=True,
854 focus_mode_is_sticky=False,
855 browse_mode_is_sticky=False,
856 )
857
858 result = presenter.use_focus_mode(MagicMock())
859
860 assert result is True
861
862 def test_in_focus_mode_default_false(self, test_context: OrcaTestContext) -> None:
863 """Test in_focus_mode returns False when no state exists for app."""
864
865 from unittest.mock import MagicMock
866
867 module, _mocks = self._setup_presenter(test_context)
868 presenter = module.get_presenter()
869 mock_app = MagicMock()
870
871 result = presenter.in_focus_mode(mock_app)
872
873 assert result is False
874
875 def test_in_focus_mode_returns_state(self, test_context: OrcaTestContext) -> None:
876 """Test in_focus_mode returns stored state."""
877
878 from unittest.mock import MagicMock
879
880 module, _mocks = self._setup_presenter(test_context)
881 presenter = module.get_presenter()
882 mock_app = MagicMock()
883
884 presenter._app_states[hash(mock_app)] = module._AppModeState(
885 in_focus_mode=True,
886 focus_mode_is_sticky=False,
887 browse_mode_is_sticky=False,
888 )
889
890 result = presenter.in_focus_mode(mock_app)
891
892 assert result is True
893
894 def test_focus_mode_is_sticky_default_false(self, test_context: OrcaTestContext) -> None:
895 """Test focus_mode_is_sticky returns False by default."""
896
897 from unittest.mock import MagicMock
898
899 module, _mocks = self._setup_presenter(test_context)
900 presenter = module.get_presenter()
901 mock_app = MagicMock()
902
903 result = presenter.focus_mode_is_sticky(mock_app)
904
905 assert result is False
906
907 def test_focus_mode_is_sticky_returns_state(self, test_context: OrcaTestContext) -> None:
908 """Test focus_mode_is_sticky returns stored state."""
909
910 from unittest.mock import MagicMock
911
912 module, _mocks = self._setup_presenter(test_context)
913 presenter = module.get_presenter()
914 mock_app = MagicMock()
915
916 presenter._app_states[hash(mock_app)] = module._AppModeState(
917 in_focus_mode=True,
918 focus_mode_is_sticky=True,
919 browse_mode_is_sticky=False,
920 )
921
922 result = presenter.focus_mode_is_sticky(mock_app)
923
924 assert result is True
925
926 def test_browse_mode_is_sticky_default_false(self, test_context: OrcaTestContext) -> None:
927 """Test browse_mode_is_sticky returns False by default."""
928
929 from unittest.mock import MagicMock
930
931 module, _mocks = self._setup_presenter(test_context)
932 presenter = module.get_presenter()
933 mock_app = MagicMock()
934
935 result = presenter.browse_mode_is_sticky(mock_app)
936
937 assert result is False
938
939 def test_browse_mode_is_sticky_returns_state(self, test_context: OrcaTestContext) -> None:
940 """Test browse_mode_is_sticky returns stored state."""
941
942 from unittest.mock import MagicMock
943
944 module, _mocks = self._setup_presenter(test_context)
945 presenter = module.get_presenter()
946 mock_app = MagicMock()
947
948 presenter._app_states[hash(mock_app)] = module._AppModeState(
949 in_focus_mode=False,
950 focus_mode_is_sticky=False,
951 browse_mode_is_sticky=True,
952 )
953
954 result = presenter.browse_mode_is_sticky(mock_app)
955
956 assert result is True
957
958 def test_get_state_for_app_sets_mode(self, test_context: OrcaTestContext) -> None:
959 """Test _get_state_for_app can be used to set mode state."""
960
961 from unittest.mock import MagicMock
962
963 module, _mocks = self._setup_presenter(test_context)
964 presenter = module.get_presenter()
965 mock_app = MagicMock()
966
967 state = presenter._get_state_for_app(mock_app)
968 state.in_focus_mode = True
969
970 assert presenter.in_focus_mode(mock_app) is True
971
972 state = presenter._get_state_for_app(mock_app)
973 state.in_focus_mode = False
974
975 assert presenter.in_focus_mode(mock_app) is False
976
977 def test_clear_state_for_app(self, test_context: OrcaTestContext) -> None:
978 """Test clear_state_for_app removes app state."""
979
980 from unittest.mock import MagicMock
981
982 module, _mocks = self._setup_presenter(test_context)
983 presenter = module.get_presenter()
984 mock_app = MagicMock()
985
986 presenter._app_states[hash(mock_app)] = module._AppModeState(
987 in_focus_mode=False,
988 focus_mode_is_sticky=False,
989 browse_mode_is_sticky=True,
990 )
991
992 presenter.clear_state_for_app(mock_app)
993
994 assert presenter.in_focus_mode(mock_app) is False
995 assert presenter.focus_mode_is_sticky(mock_app) is False
996
997 def test_per_app_state_isolation(self, test_context: OrcaTestContext) -> None:
998 """Test that different apps have isolated mode state."""
999
1000 from unittest.mock import MagicMock
1001
1002 module, _mocks = self._setup_presenter(test_context)
1003 presenter = module.get_presenter()
1004
1005 app1 = MagicMock()
1006 app2 = MagicMock()
1007
1008 presenter._app_states[hash(app1)] = module._AppModeState(
1009 in_focus_mode=True,
1010 focus_mode_is_sticky=True,
1011 browse_mode_is_sticky=False,
1012 )
1013 presenter._app_states[hash(app2)] = module._AppModeState(
1014 in_focus_mode=False,
1015 focus_mode_is_sticky=False,
1016 browse_mode_is_sticky=True,
1017 )
1018
1019 assert presenter.in_focus_mode(app1) is True
1020 assert presenter.focus_mode_is_sticky(app1) is True
1021 assert presenter.browse_mode_is_sticky(app1) is False
1022
1023 assert presenter.in_focus_mode(app2) is False
1024 assert presenter.focus_mode_is_sticky(app2) is False
1025 assert presenter.browse_mode_is_sticky(app2) is True
1026
1027 def test_set_presentation_mode_not_in_document(self, test_context: OrcaTestContext) -> None:
1028 """Test set_presentation_mode returns False when not in document."""
1029
1030 from unittest.mock import MagicMock
1031
1032 module, mocks = self._setup_presenter(test_context)
1033
1034 mock_script = MagicMock()
1035 mock_script.utilities.in_document_content.return_value = False
1036
1037 mocks["orca.messages"] = MagicMock()
1038 mocks["orca.messages"].DOCUMENT_NOT_IN_A = "Not in document"
1039
1040 presenter = module.get_presenter()
1041 pres_manager = mocks["orca.presentation_manager"].get_manager()
1042 pres_manager.present_message.reset_mock()
1043 result = presenter._set_presentation_mode(mock_script, True, obj=MagicMock())
1044
1045 assert result is False
1046 pres_manager.present_message.assert_called_once()
1047
1048 def test_set_presentation_mode_same_mode(self, test_context: OrcaTestContext) -> None:
1049 """Test set_presentation_mode returns False when already in requested mode."""
1050
1051 from unittest.mock import MagicMock
1052
1053 module, _mocks = self._setup_presenter(test_context)
1054
1055 mock_app = MagicMock()
1056 mock_script = MagicMock()
1057 mock_script.app = mock_app
1058 mock_script.utilities.in_document_content.return_value = True
1059
1060 presenter = module.get_presenter()
1061 presenter._app_states[hash(mock_app)] = module._AppModeState(
1062 in_focus_mode=True,
1063 focus_mode_is_sticky=False,
1064 browse_mode_is_sticky=False,
1065 )
1066
1067 result = presenter._set_presentation_mode(mock_script, True, obj=MagicMock())
1068
1069 assert result is False
1070
1071 def test_set_presentation_mode_to_browse(self, test_context: OrcaTestContext) -> None:
1072 """Test set_presentation_mode switches to browse mode."""
1073
1074 from unittest.mock import MagicMock
1075
1076 module, mocks = self._setup_presenter(test_context)
1077
1078 mock_app = MagicMock()
1079 mock_script = MagicMock()
1080 mock_script.app = mock_app
1081 mock_script.utilities.in_document_content.return_value = True
1082 mock_script.utilities.get_caret_context.return_value = (MagicMock(), 0)
1083
1084 struct_nav = mocks["orca.structural_navigator"]
1085 caret_nav = mocks["orca.caret_navigator"]
1086
1087 presenter = module.get_presenter()
1088 presenter._app_states[hash(mock_app)] = module._AppModeState(
1089 in_focus_mode=True,
1090 focus_mode_is_sticky=False,
1091 browse_mode_is_sticky=False,
1092 )
1093
1094 result = presenter._set_presentation_mode(mock_script, False, obj=MagicMock())
1095
1096 assert result is True
1097 assert presenter.in_focus_mode(mock_app) is False
1098 struct_nav.get_navigator.return_value.set_mode.assert_called()
1099 caret_nav.get_navigator.return_value.set_enabled_for_script.assert_called()
1100
1101 def test_set_presentation_mode_to_focus(self, test_context: OrcaTestContext) -> None:
1102 """Test set_presentation_mode switches to focus mode."""
1103
1104 from unittest.mock import MagicMock
1105
1106 module, mocks = self._setup_presenter(test_context)
1107
1108 mock_app = MagicMock()
1109 mock_script = MagicMock()
1110 mock_script.app = mock_app
1111 mock_script.utilities.in_document_content.return_value = True
1112 mock_script.utilities.get_caret_context.return_value = (MagicMock(), 0)
1113
1114 caret_nav = mocks["orca.caret_navigator"]
1115 nav_mock = caret_nav.get_navigator.return_value
1116 nav_mock.last_input_event_was_navigation_command.return_value = False
1117 struct_nav = mocks["orca.structural_navigator"]
1118 nav_mock = struct_nav.get_navigator.return_value
1119 nav_mock.last_input_event_was_navigation_command.return_value = False
1120 table_nav = mocks["orca.table_navigator"]
1121 nav_mock = table_nav.get_navigator.return_value
1122 nav_mock.last_input_event_was_navigation_command.return_value = False
1123
1124 presenter = module.get_presenter()
1125 presenter._app_states[hash(mock_app)] = module._AppModeState(
1126 in_focus_mode=False,
1127 focus_mode_is_sticky=False,
1128 browse_mode_is_sticky=False,
1129 )
1130
1131 result = presenter._set_presentation_mode(mock_script, True, obj=MagicMock())
1132
1133 assert result is True
1134 assert presenter.in_focus_mode(mock_app) is True
1135
1136 def test_set_presentation_mode_dead_obj_fallback(self, test_context: OrcaTestContext) -> None:
1137 """Test set_presentation_mode uses locus of focus when obj is dead."""
1138
1139 from unittest.mock import MagicMock
1140
1141 module, mocks = self._setup_presenter(test_context)
1142
1143 mock_app = MagicMock()
1144 mock_script = MagicMock()
1145 mock_script.app = mock_app
1146 mock_script.utilities.in_document_content.return_value = True
1147 mock_script.utilities.get_caret_context.return_value = (MagicMock(), 0)
1148
1149 caret_nav = mocks["orca.caret_navigator"]
1150 nav_mock = caret_nav.get_navigator.return_value
1151 nav_mock.last_input_event_was_navigation_command.return_value = False
1152 struct_nav = mocks["orca.structural_navigator"]
1153 nav_mock = struct_nav.get_navigator.return_value
1154 nav_mock.last_input_event_was_navigation_command.return_value = False
1155 table_nav = mocks["orca.table_navigator"]
1156 nav_mock = table_nav.get_navigator.return_value
1157 nav_mock.last_input_event_was_navigation_command.return_value = False
1158
1159 ax_object = mocks["orca.ax_object"]
1160 ax_object.AXObject.is_dead.return_value = True
1161
1162 presenter = module.get_presenter()
1163 presenter._app_states[hash(mock_app)] = module._AppModeState(
1164 in_focus_mode=False,
1165 focus_mode_is_sticky=False,
1166 browse_mode_is_sticky=False,
1167 )
1168
1169 dead_obj = MagicMock()
1170 result = presenter._set_presentation_mode(mock_script, True, obj=dead_obj)
1171
1172 assert result is True
1173 mock_script.utilities.in_document_content.assert_called_with(None)
1174
1175 def test_suspend_navigators(self, test_context: OrcaTestContext) -> None:
1176 """Test suspend_navigators suspends all navigators."""
1177
1178 from unittest.mock import MagicMock
1179
1180 module, mocks = self._setup_presenter(test_context)
1181
1182 mock_app = MagicMock()
1183 mock_script = MagicMock()
1184 mock_script.app = mock_app
1185
1186 caret_nav = mocks["orca.caret_navigator"]
1187 struct_nav = mocks["orca.structural_navigator"]
1188
1189 presenter = module.get_presenter()
1190 result = presenter.suspend_navigators(mock_script, True, "test")
1191
1192 assert result is True
1193 caret_nav.get_navigator.return_value.suspend_commands.assert_called_with(
1194 mock_script,
1195 True,
1196 "test",
1197 )
1198 struct_nav.get_navigator.return_value.suspend_commands.assert_called_with(
1199 mock_script,
1200 True,
1201 "test",
1202 )
1203
1204 def test_enable_sticky_focus_mode(self, test_context: OrcaTestContext) -> None:
1205 """Test enable_sticky_focus_mode sets sticky focus mode."""
1206
1207 from unittest.mock import MagicMock
1208
1209 module, mocks = self._setup_presenter(test_context)
1210
1211 mock_app = MagicMock()
1212 mock_script = MagicMock()
1213 mock_script.app = mock_app
1214
1215 presenter = module.get_presenter()
1216 pres_manager = mocks["orca.presentation_manager"].get_manager()
1217 pres_manager.present_message.reset_mock()
1218 result = presenter.enable_sticky_focus_mode(mock_script)
1219
1220 assert result is True
1221 assert presenter.in_focus_mode(mock_app) is True
1222 assert presenter.focus_mode_is_sticky(mock_app) is True
1223 assert presenter.browse_mode_is_sticky(mock_app) is False
1224 pres_manager.present_message.assert_called()
1225
1226 def test_enable_sticky_browse_mode(self, test_context: OrcaTestContext) -> None:
1227 """Test enable_sticky_browse_mode sets sticky browse mode."""
1228
1229 from unittest.mock import MagicMock
1230
1231 module, mocks = self._setup_presenter(test_context)
1232
1233 mock_app = MagicMock()
1234 mock_script = MagicMock()
1235 mock_script.app = mock_app
1236
1237 presenter = module.get_presenter()
1238 pres_manager = mocks["orca.presentation_manager"].get_manager()
1239 pres_manager.present_message.reset_mock()
1240 result = presenter.enable_sticky_browse_mode(mock_script)
1241
1242 assert result is True
1243 assert presenter.in_focus_mode(mock_app) is False
1244 assert presenter.focus_mode_is_sticky(mock_app) is False
1245 assert presenter.browse_mode_is_sticky(mock_app) is True
1246 pres_manager.present_message.assert_called()
1247
1248 def test_toggle_presentation_mode_not_in_document(self, test_context: OrcaTestContext) -> None:
1249 """Test toggle_presentation_mode when not in document."""
1250
1251 from unittest.mock import MagicMock
1252
1253 module, mocks = self._setup_presenter(test_context)
1254
1255 mock_script = MagicMock()
1256 mock_script.utilities.in_document_content.return_value = False
1257
1258 presenter = module.get_presenter()
1259 pres_manager = mocks["orca.presentation_manager"].get_manager()
1260 pres_manager.present_message.reset_mock()
1261 result = presenter.toggle_presentation_mode(mock_script)
1262
1263 assert result is True
1264 pres_manager.present_message.assert_called()
1265
1266 def test_toggle_presentation_mode_to_focus(self, test_context: OrcaTestContext) -> None:
1267 """Test toggle_presentation_mode switches to focus mode."""
1268
1269 from unittest.mock import MagicMock
1270
1271 module, mocks = self._setup_presenter(test_context)
1272
1273 mock_app = MagicMock()
1274 mock_script = MagicMock()
1275 mock_script.app = mock_app
1276 mock_script.utilities.in_document_content.return_value = True
1277 mock_script.utilities.get_caret_context.return_value = (MagicMock(), 0)
1278
1279 caret_nav = mocks["orca.caret_navigator"]
1280 nav_mock = caret_nav.get_navigator.return_value
1281 nav_mock.last_input_event_was_navigation_command.return_value = False
1282 struct_nav = mocks["orca.structural_navigator"]
1283 nav_mock = struct_nav.get_navigator.return_value
1284 nav_mock.last_input_event_was_navigation_command.return_value = False
1285 table_nav = mocks["orca.table_navigator"]
1286 nav_mock = table_nav.get_navigator.return_value
1287 nav_mock.last_input_event_was_navigation_command.return_value = False
1288
1289 presenter = module.get_presenter()
1290 presenter._app_states[hash(mock_app)] = module._AppModeState(
1291 in_focus_mode=False,
1292 focus_mode_is_sticky=False,
1293 browse_mode_is_sticky=False,
1294 )
1295
1296 result = presenter.toggle_presentation_mode(mock_script)
1297
1298 assert result is True
1299 assert presenter.in_focus_mode(mock_app) is True
1300
1301 def test_restore_mode_for_script_no_app(self, test_context: OrcaTestContext) -> None:
1302 """Test restore_mode_for_script with no app does nothing."""
1303
1304 from unittest.mock import MagicMock
1305
1306 module, _mocks = self._setup_presenter(test_context)
1307
1308 mock_script = MagicMock()
1309 mock_script.app = None
1310
1311 presenter = module.get_presenter()
1312 presenter.restore_mode_for_script(mock_script)
1313
1314 def test_restore_mode_for_script_no_state(self, test_context: OrcaTestContext) -> None:
1315 """Test restore_mode_for_script with no existing state does nothing."""
1316
1317 from unittest.mock import MagicMock
1318
1319 module, _mocks = self._setup_presenter(test_context)
1320
1321 mock_script = MagicMock()
1322 mock_script.app = MagicMock()
1323
1324 presenter = module.get_presenter()
1325 presenter.restore_mode_for_script(mock_script)
1326
1327 def test_restore_mode_for_script_with_state(self, test_context: OrcaTestContext) -> None:
1328 """Test restore_mode_for_script restores navigator suspension state."""
1329
1330 from unittest.mock import MagicMock
1331
1332 module, mocks = self._setup_presenter(test_context)
1333
1334 mock_app = MagicMock()
1335 mock_script = MagicMock()
1336 mock_script.app = mock_app
1337
1338 caret_nav = mocks["orca.caret_navigator"]
1339
1340 presenter = module.get_presenter()
1341 presenter._app_states[hash(mock_app)] = module._AppModeState(
1342 in_focus_mode=True,
1343 focus_mode_is_sticky=False,
1344 browse_mode_is_sticky=False,
1345 )
1346
1347 presenter.restore_mode_for_script(mock_script)
1348
1349 caret_nav.get_navigator.return_value.suspend_commands.assert_called()
1350
1351 def test_restore_mode_for_script_browse_mode_enables_navigators(
1352 self,
1353 test_context: OrcaTestContext,
1354 ) -> None:
1355 """Test restore_mode_for_script re-enables navigators when restoring browse mode."""
1356
1357 from unittest.mock import MagicMock
1358
1359 module, mocks = self._setup_presenter(test_context)
1360
1361 mock_app = MagicMock()
1362 mock_script = MagicMock()
1363 mock_script.app = mock_app
1364
1365 struct_nav = mocks["orca.structural_navigator"]
1366 caret_nav = mocks["orca.caret_navigator"]
1367
1368 presenter = module.get_presenter()
1369 presenter._app_states[hash(mock_app)] = module._AppModeState(
1370 in_focus_mode=False,
1371 focus_mode_is_sticky=False,
1372 browse_mode_is_sticky=False,
1373 )
1374
1375 presenter.restore_mode_for_script(mock_script)
1376
1377 struct_nav.get_navigator.return_value.set_mode.assert_called_once()
1378 caret_nav.get_navigator.return_value.set_enabled_for_script.assert_called_once_with(
1379 mock_script,
1380 True,
1381 )
1382
1383 def test_update_mode_if_needed_not_in_doc(self, test_context: OrcaTestContext) -> None:
1384 """Test update_mode_if_needed when neither in document suspends navigators."""
1385
1386 from unittest.mock import MagicMock
1387
1388 module, mocks = self._setup_presenter(test_context)
1389
1390 mock_script = MagicMock()
1391 mock_script.utilities.get_top_level_document_for_object.return_value = None
1392
1393 caret_nav = mocks["orca.caret_navigator"]
1394
1395 presenter = module.get_presenter()
1396 result = presenter.update_mode_if_needed(mock_script, MagicMock(), MagicMock())
1397
1398 # When focus is not in a document, navigators should be suspended
1399 assert result is True
1400 caret_nav.get_navigator.return_value.suspend_commands.assert_called()
1401
1402 def test_update_mode_if_needed_leaving_doc(self, test_context: OrcaTestContext) -> None:
1403 """Test update_mode_if_needed when leaving document."""
1404
1405 from unittest.mock import MagicMock
1406
1407 module, mocks = self._setup_presenter(test_context)
1408
1409 mock_app = MagicMock()
1410 mock_script = MagicMock()
1411 mock_script.app = mock_app
1412 mock_doc = MagicMock()
1413 mock_script.utilities.get_top_level_document_for_object.side_effect = [mock_doc, None]
1414
1415 caret_nav = mocks["orca.caret_navigator"]
1416
1417 presenter = module.get_presenter()
1418 old_focus = MagicMock()
1419 new_focus = MagicMock()
1420 result = presenter.update_mode_if_needed(mock_script, old_focus, new_focus)
1421
1422 assert result is True
1423 caret_nav.get_navigator.return_value.suspend_commands.assert_called()
1424
1425 def test_update_mode_if_needed_sticky_focus(self, test_context: OrcaTestContext) -> None:
1426 """Test update_mode_if_needed with sticky focus mode when entering document."""
1427
1428 from unittest.mock import MagicMock
1429
1430 module, mocks = self._setup_presenter(test_context)
1431
1432 mock_app = MagicMock()
1433 mock_script = MagicMock()
1434 mock_script.app = mock_app
1435 mock_doc = MagicMock()
1436 mock_script.utilities.get_top_level_document_for_object.side_effect = [None, mock_doc]
1437
1438 focus_manager = mocks["orca.focus_manager"]
1439 focus_manager.get_manager.return_value.old_focus_was_dead.return_value = False
1440
1441 presenter = module.get_presenter()
1442 presenter._app_states[hash(mock_app)] = module._AppModeState(
1443 in_focus_mode=True,
1444 focus_mode_is_sticky=True,
1445 browse_mode_is_sticky=False,
1446 )
1447
1448 pres_manager = mocks["orca.presentation_manager"].get_manager()
1449 pres_manager.present_message.reset_mock()
1450 result = presenter.update_mode_if_needed(mock_script, MagicMock(), MagicMock())
1451
1452 assert result is True
1453 pres_manager.present_message.assert_called()
1454
1455 def test_update_mode_if_needed_sticky_browse(self, test_context: OrcaTestContext) -> None:
1456 """Test update_mode_if_needed with sticky browse mode when entering document."""
1457
1458 from unittest.mock import MagicMock
1459
1460 module, mocks = self._setup_presenter(test_context)
1461
1462 mock_app = MagicMock()
1463 mock_script = MagicMock()
1464 mock_script.app = mock_app
1465 mock_doc = MagicMock()
1466 mock_script.utilities.get_top_level_document_for_object.side_effect = [None, mock_doc]
1467
1468 focus_manager = mocks["orca.focus_manager"]
1469 focus_manager.get_manager.return_value.old_focus_was_dead.return_value = False
1470
1471 struct_nav = mocks["orca.structural_navigator"]
1472 caret_nav = mocks["orca.caret_navigator"]
1473
1474 presenter = module.get_presenter()
1475 presenter._app_states[hash(mock_app)] = module._AppModeState(
1476 in_focus_mode=False,
1477 focus_mode_is_sticky=False,
1478 browse_mode_is_sticky=True,
1479 )
1480
1481 pres_manager = mocks["orca.presentation_manager"].get_manager()
1482 pres_manager.present_message.reset_mock()
1483 result = presenter.update_mode_if_needed(mock_script, MagicMock(), MagicMock())
1484
1485 assert result is True
1486 pres_manager.present_message.assert_called()
1487 struct_nav.get_navigator.return_value.set_mode.assert_called()
1488 caret_nav.get_navigator.return_value.set_enabled_for_script.assert_called()
1489
1490 def test_handle_entering_document_refreshes_commands(
1491 self,
1492 test_context: OrcaTestContext,
1493 ) -> None:
1494 """Test entering document refreshes commands even when mode unchanged."""
1495
1496 from unittest.mock import MagicMock, patch
1497
1498 module, mocks = self._setup_presenter(test_context)
1499
1500 mock_app = MagicMock()
1501 mock_script = MagicMock()
1502 mock_script.app = mock_app
1503 mock_doc = MagicMock()
1504 mock_script.utilities.get_top_level_document_for_object.side_effect = [None, mock_doc]
1505
1506 caret_nav = mocks["orca.caret_navigator"]
1507 nav_mock = caret_nav.get_navigator.return_value
1508 nav_mock.last_input_event_was_navigation_command.return_value = False
1509 caret_nav.get_navigator.return_value.last_command_prevents_focus_mode.return_value = False
1510 struct_nav = mocks["orca.structural_navigator"]
1511 nav_mock = struct_nav.get_navigator.return_value
1512 nav_mock.last_input_event_was_navigation_command.return_value = False
1513 struct_nav.get_navigator.return_value.last_command_prevents_focus_mode.return_value = False
1514 table_nav = mocks["orca.table_navigator"]
1515 nav_mock = table_nav.get_navigator.return_value
1516 nav_mock.last_input_event_was_navigation_command.return_value = False
1517 focus_manager = mocks["orca.focus_manager"]
1518 focus_manager.get_manager.return_value.in_say_all.return_value = False
1519 focus_manager.get_manager.return_value.old_focus_was_dead.return_value = False
1520
1521 script_manager = mocks["orca.script_manager"]
1522 script_manager.get_manager.return_value.get_active_script.return_value = mock_script
1523
1524 presenter = module.get_presenter()
1525 # Already in browse mode - entering document should still refresh commands
1526 presenter._app_states[hash(mock_app)] = module._AppModeState(
1527 in_focus_mode=False,
1528 focus_mode_is_sticky=False,
1529 browse_mode_is_sticky=False,
1530 )
1531
1532 with patch.object(presenter, "is_focus_mode_widget", return_value=False):
1533 result = presenter.update_mode_if_needed(mock_script, MagicMock(), MagicMock())
1534
1535 assert result is True
1536 # Verify commands were refreshed (suspend_commands called with suspended=False for browse)
1537 caret_nav.get_navigator.return_value.suspend_commands.assert_called()
1538 struct_nav.get_navigator.return_value.suspend_commands.assert_called()
1539
1540 def test_is_likely_electron_app_true(self, test_context: OrcaTestContext) -> None:
1541 """Test _is_likely_electron_app returns True for Chromium toolkit non-browser."""
1542
1543 from unittest.mock import MagicMock
1544
1545 module, mocks = self._setup_presenter(test_context)
1546
1547 ax_object = mocks["orca.ax_object"]
1548 ax_object.AXObject.get_toolkit_name.return_value = "Chromium"
1549 ax_object.AXObject.get_name.return_value = "code"
1550
1551 mock_app = MagicMock()
1552 presenter = module.get_presenter()
1553 result = presenter._is_likely_electron_app(mock_app)
1554
1555 assert result is True
1556
1557 def test_is_likely_electron_app_false_for_browser(self, test_context: OrcaTestContext) -> None:
1558 """Test _is_likely_electron_app returns False for known browsers."""
1559
1560 from unittest.mock import MagicMock
1561
1562 module, mocks = self._setup_presenter(test_context)
1563
1564 ax_object = mocks["orca.ax_object"]
1565 ax_object.AXObject.get_toolkit_name.return_value = "Chromium"
1566 ax_object.AXObject.get_name.return_value = "google-chrome"
1567
1568 mock_app = MagicMock()
1569 presenter = module.get_presenter()
1570 result = presenter._is_likely_electron_app(mock_app)
1571
1572 assert result is False
1573
1574 def test_is_likely_electron_app_false_for_non_chromium(
1575 self,
1576 test_context: OrcaTestContext,
1577 ) -> None:
1578 """Test _is_likely_electron_app returns False for non-Chromium toolkit."""
1579
1580 from unittest.mock import MagicMock
1581
1582 module, mocks = self._setup_presenter(test_context)
1583
1584 ax_object = mocks["orca.ax_object"]
1585 ax_object.AXObject.get_toolkit_name.return_value = "gtk"
1586 ax_object.AXObject.get_name.return_value = "gedit"
1587
1588 mock_app = MagicMock()
1589 presenter = module.get_presenter()
1590 result = presenter._is_likely_electron_app(mock_app)
1591
1592 assert result is False
1593
1594 def test_update_mode_electron_app_sticky_focus(self, test_context: OrcaTestContext) -> None:
1595 """Test update_mode_if_needed enables sticky focus for Electron apps when entering."""
1596
1597 from unittest.mock import MagicMock, patch
1598
1599 module, mocks = self._setup_presenter(test_context)
1600
1601 mock_app = MagicMock()
1602 mock_script = MagicMock()
1603 mock_script.app = mock_app
1604 mock_doc = MagicMock()
1605 mock_script.utilities.get_top_level_document_for_object.side_effect = [None, mock_doc]
1606 mock_script.utilities.in_document_content.return_value = True
1607
1608 focus_manager = mocks["orca.focus_manager"]
1609 focus_manager.get_manager.return_value.old_focus_was_dead.return_value = False
1610
1611 presenter = module.get_presenter()
1612
1613 with patch.object(presenter, "_is_likely_electron_app", return_value=True):
1614 result = presenter.update_mode_if_needed(mock_script, MagicMock(), MagicMock())
1615
1616 assert result is True
1617 assert presenter.in_focus_mode(mock_app) is True
1618 assert presenter.focus_mode_is_sticky(mock_app) is True
1619
1620 def test_is_top_level_web_app_true(self, test_context: OrcaTestContext) -> None:
1621 """Test _is_top_level_web_app returns True for embedded doc with http URI."""
1622
1623 from unittest.mock import MagicMock
1624
1625 module, mocks = self._setup_presenter(test_context)
1626
1627 mock_doc = MagicMock()
1628 mock_script = MagicMock()
1629 mock_script.utilities.active_document.return_value = mock_doc
1630
1631 ax_utilities = mocks["orca.ax_utilities"]
1632 ax_utilities.AXUtilities.is_embedded.return_value = True
1633
1634 ax_document = mocks["orca.ax_document"]
1635 ax_document.AXDocument.get_uri.return_value = "https://docs.google.com/document"
1636
1637 presenter = module.get_presenter()
1638
1639 result = presenter._is_top_level_web_app(mock_script, MagicMock())
1640
1641 assert result is True
1642
1643 def test_is_top_level_web_app_false_no_http(self, test_context: OrcaTestContext) -> None:
1644 """Test _is_top_level_web_app returns False for non-http URI."""
1645
1646 from unittest.mock import MagicMock
1647
1648 module, mocks = self._setup_presenter(test_context)
1649
1650 mock_doc = MagicMock()
1651 mock_script = MagicMock()
1652 mock_script.utilities.active_document.return_value = mock_doc
1653
1654 ax_utilities = mocks["orca.ax_utilities"]
1655 ax_utilities.AXUtilities.is_embedded.return_value = True
1656
1657 ax_document = mocks["orca.ax_document"]
1658 ax_document.AXDocument.get_uri.return_value = "file:///home/user/doc.html"
1659
1660 presenter = module.get_presenter()
1661
1662 result = presenter._is_top_level_web_app(mock_script, MagicMock())
1663
1664 assert result is False
1665
1666 def test_is_top_level_web_app_false_no_document(self, test_context: OrcaTestContext) -> None:
1667 """Test _is_top_level_web_app returns False when no active document."""
1668
1669 from unittest.mock import MagicMock
1670
1671 module, _mocks = self._setup_presenter(test_context)
1672
1673 mock_script = MagicMock()
1674 mock_script.utilities.active_document.return_value = None
1675
1676 presenter = module.get_presenter()
1677
1678 result = presenter._is_top_level_web_app(mock_script, MagicMock())
1679
1680 assert result is False
1681
1682 def test_is_top_level_web_app_false_not_embedded(self, test_context: OrcaTestContext) -> None:
1683 """Test _is_top_level_web_app returns False when document is not embedded role."""
1684
1685 from unittest.mock import MagicMock
1686
1687 module, mocks = self._setup_presenter(test_context)
1688
1689 mock_doc = MagicMock()
1690 mock_script = MagicMock()
1691 mock_script.utilities.active_document.return_value = mock_doc
1692
1693 ax_utilities = mocks["orca.ax_utilities"]
1694 ax_utilities.AXUtilities.is_embedded.return_value = False
1695
1696 presenter = module.get_presenter()
1697
1698 result = presenter._is_top_level_web_app(mock_script, MagicMock())
1699
1700 assert result is False
1701
1702 def test_update_mode_top_level_web_app_sticky_focus(
1703 self,
1704 test_context: OrcaTestContext,
1705 ) -> None:
1706 """Test update_mode_if_needed enables sticky focus for top-level web apps when entering."""
1707
1708 from unittest.mock import MagicMock, patch
1709
1710 module, mocks = self._setup_presenter(test_context)
1711
1712 mock_app = MagicMock()
1713 mock_script = MagicMock()
1714 mock_script.app = mock_app
1715 mock_doc = MagicMock()
1716 mock_script.utilities.get_top_level_document_for_object.side_effect = [None, mock_doc]
1717 mock_script.utilities.in_document_content.return_value = True
1718
1719 focus_manager = mocks["orca.focus_manager"]
1720 focus_manager.get_manager.return_value.old_focus_was_dead.return_value = False
1721
1722 presenter = module.get_presenter()
1723
1724 with (
1725 patch.object(presenter, "_is_likely_electron_app", return_value=False),
1726 patch.object(presenter, "_is_top_level_web_app", return_value=True),
1727 ):
1728 result = presenter.update_mode_if_needed(mock_script, MagicMock(), MagicMock())
1729
1730 assert result is True
1731 assert presenter.in_focus_mode(mock_app) is True
1732 assert presenter.focus_mode_is_sticky(mock_app) is True
1733
1734 def test_is_focus_mode_widget_editable(self, test_context: OrcaTestContext) -> None:
1735 """Test is_focus_mode_widget returns True for editable objects."""
1736
1737 from unittest.mock import MagicMock
1738
1739 module, mocks = self._setup_presenter(test_context)
1740
1741 ax_utilities = mocks["orca.ax_utilities"]
1742 ax_utilities.AXUtilities.is_editable.return_value = True
1743
1744 mock_script = MagicMock()
1745 mock_obj = MagicMock()
1746
1747 presenter = module.get_presenter()
1748 result = presenter.is_focus_mode_widget(mock_script, mock_obj)
1749
1750 assert result is True
1751
1752 def test_is_focus_mode_widget_combo_box(self, test_context: OrcaTestContext) -> None:
1753 """Test is_focus_mode_widget returns True for combo boxes."""
1754
1755 from unittest.mock import MagicMock
1756
1757 module, mocks = self._setup_presenter(test_context)
1758
1759 ax_utilities = mocks["orca.ax_utilities"]
1760 ax_utilities.AXUtilities.is_editable.return_value = False
1761 ax_utilities.AXUtilities.is_combo_box.return_value = True
1762
1763 mock_script = MagicMock()
1764 mock_obj = MagicMock()
1765
1766 presenter = module.get_presenter()
1767 result = presenter.is_focus_mode_widget(mock_script, mock_obj)
1768
1769 assert result is True
1770
1771 def test_is_focus_mode_widget_expandable_focusable(self, test_context: OrcaTestContext) -> None:
1772 """Test is_focus_mode_widget returns True for expandable focusable non-links."""
1773
1774 from unittest.mock import MagicMock
1775
1776 module, mocks = self._setup_presenter(test_context)
1777
1778 ax_utilities = mocks["orca.ax_utilities"]
1779 ax_utilities.AXUtilities.is_editable.return_value = False
1780 ax_utilities.AXUtilities.is_expandable.return_value = True
1781 ax_utilities.AXUtilities.is_focusable.return_value = True
1782 ax_utilities.AXUtilities.is_link.return_value = False
1783
1784 mock_script = MagicMock()
1785 mock_obj = MagicMock()
1786
1787 presenter = module.get_presenter()
1788 result = presenter.is_focus_mode_widget(mock_script, mock_obj)
1789
1790 assert result is True
1791
1792 def test_is_focus_mode_widget_expandable_link_false(
1793 self,
1794 test_context: OrcaTestContext,
1795 ) -> None:
1796 """Test is_focus_mode_widget returns False for expandable focusable links."""
1797
1798 from unittest.mock import MagicMock
1799
1800 import gi
1801
1802 gi.require_version("Atspi", "2.0")
1803 from gi.repository import Atspi
1804
1805 module, mocks = self._setup_presenter(test_context)
1806
1807 ax_utilities = mocks["orca.ax_utilities"]
1808 ax_utilities.AXUtilities.is_editable.return_value = False
1809 ax_utilities.AXUtilities.is_expandable.return_value = True
1810 ax_utilities.AXUtilities.is_focusable.return_value = True
1811 ax_utilities.AXUtilities.is_link.return_value = True
1812 ax_utilities.AXUtilities.is_list_box_item.return_value = False
1813 ax_utilities.AXUtilities.is_button_with_popup.return_value = False
1814 ax_utilities.AXUtilities.is_grid = MagicMock()
1815 ax_utilities.AXUtilities.is_menu = MagicMock()
1816 ax_utilities.AXUtilities.is_tool_bar = MagicMock()
1817
1818 ax_object = mocks["orca.ax_object"]
1819 ax_object.AXObject.get_role.return_value = Atspi.Role.LINK
1820 ax_utilities.AXUtilities.find_ancestor.return_value = None
1821
1822 mock_script = MagicMock()
1823 mock_script.utilities.is_content_editable_with_embedded_objects.return_value = False
1824 mock_obj = MagicMock()
1825
1826 presenter = module.get_presenter()
1827 result = presenter.is_focus_mode_widget(mock_script, mock_obj)
1828
1829 assert result is False
1830
1831 def test_is_focus_mode_widget_always_focus_role(self, test_context: OrcaTestContext) -> None:
1832 """Test is_focus_mode_widget returns True for always-focus-mode roles."""
1833
1834 from unittest.mock import MagicMock
1835
1836 import gi
1837
1838 gi.require_version("Atspi", "2.0")
1839 from gi.repository import Atspi
1840
1841 module, mocks = self._setup_presenter(test_context)
1842
1843 ax_utilities = mocks["orca.ax_utilities"]
1844 ax_utilities.AXUtilities.is_editable.return_value = False
1845 ax_utilities.AXUtilities.is_expandable.return_value = False
1846
1847 ax_object = mocks["orca.ax_object"]
1848 ax_object.AXObject.get_role.return_value = Atspi.Role.SLIDER
1849
1850 mock_script = MagicMock()
1851 mock_obj = MagicMock()
1852
1853 presenter = module.get_presenter()
1854 result = presenter.is_focus_mode_widget(mock_script, mock_obj)
1855
1856 assert result is True
1857
1858 def test_is_focus_mode_widget_layout_table_false(self, test_context: OrcaTestContext) -> None:
1859 """Test is_focus_mode_widget returns False for layout tables."""
1860
1861 from unittest.mock import MagicMock
1862
1863 import gi
1864
1865 gi.require_version("Atspi", "2.0")
1866 from gi.repository import Atspi
1867
1868 module, mocks = self._setup_presenter(test_context)
1869
1870 ax_utilities = mocks["orca.ax_utilities"]
1871 ax_utilities.AXUtilities.is_editable.return_value = False
1872 ax_utilities.AXUtilities.is_expandable.return_value = False
1873
1874 ax_object = mocks["orca.ax_object"]
1875 ax_object.AXObject.get_role.return_value = Atspi.Role.TABLE_CELL
1876
1877 ax_utilities.AXUtilities.get_table.return_value = MagicMock()
1878 ax_utilities.AXUtilities.is_layout_table.return_value = True
1879
1880 mock_script = MagicMock()
1881 mock_obj = MagicMock()
1882
1883 presenter = module.get_presenter()
1884 result = presenter.is_focus_mode_widget(mock_script, mock_obj)
1885
1886 assert result is False
1887
1888 def test_is_focus_mode_widget_list_box_item(self, test_context: OrcaTestContext) -> None:
1889 """Test is_focus_mode_widget returns True for list box items."""
1890
1891 from unittest.mock import MagicMock
1892
1893 import gi
1894
1895 gi.require_version("Atspi", "2.0")
1896 from gi.repository import Atspi
1897
1898 module, mocks = self._setup_presenter(test_context)
1899
1900 ax_utilities = mocks["orca.ax_utilities"]
1901 ax_utilities.AXUtilities.is_editable.return_value = False
1902 ax_utilities.AXUtilities.is_expandable.return_value = False
1903 ax_utilities.AXUtilities.is_list_box_item.return_value = True
1904
1905 ax_object = mocks["orca.ax_object"]
1906 ax_object.AXObject.get_role.return_value = Atspi.Role.LIST_ITEM
1907
1908 ax_utilities.AXUtilities.is_layout_table.return_value = False
1909
1910 mock_script = MagicMock()
1911 mock_obj = MagicMock()
1912
1913 presenter = module.get_presenter()
1914 result = presenter.is_focus_mode_widget(mock_script, mock_obj)
1915
1916 assert result is True
1917
1918 def test_is_focus_mode_widget_button_with_popup(self, test_context: OrcaTestContext) -> None:
1919 """Test is_focus_mode_widget returns True for buttons with popup."""
1920
1921 from unittest.mock import MagicMock
1922
1923 import gi
1924
1925 gi.require_version("Atspi", "2.0")
1926 from gi.repository import Atspi
1927
1928 module, mocks = self._setup_presenter(test_context)
1929
1930 ax_utilities = mocks["orca.ax_utilities"]
1931 ax_utilities.AXUtilities.is_editable.return_value = False
1932 ax_utilities.AXUtilities.is_expandable.return_value = False
1933 ax_utilities.AXUtilities.is_list_box_item.return_value = False
1934 ax_utilities.AXUtilities.is_button_with_popup.return_value = True
1935
1936 ax_object = mocks["orca.ax_object"]
1937 ax_object.AXObject.get_role.return_value = Atspi.Role.BUTTON
1938
1939 ax_utilities.AXUtilities.is_layout_table.return_value = False
1940
1941 mock_script = MagicMock()
1942 mock_obj = MagicMock()
1943
1944 presenter = module.get_presenter()
1945 result = presenter.is_focus_mode_widget(mock_script, mock_obj)
1946
1947 assert result is True
1948
1949 def test_is_focus_mode_widget_table_cell_not_layout(
1950 self,
1951 test_context: OrcaTestContext,
1952 ) -> None:
1953 """Test is_focus_mode_widget returns True for non-layout table cells."""
1954
1955 from unittest.mock import MagicMock
1956
1957 import gi
1958
1959 gi.require_version("Atspi", "2.0")
1960 from gi.repository import Atspi
1961
1962 module, mocks = self._setup_presenter(test_context)
1963
1964 ax_utilities = mocks["orca.ax_utilities"]
1965 ax_utilities.AXUtilities.is_editable.return_value = False
1966 ax_utilities.AXUtilities.is_expandable.return_value = False
1967 ax_utilities.AXUtilities.is_list_box_item.return_value = False
1968 ax_utilities.AXUtilities.is_button_with_popup.return_value = False
1969
1970 ax_object = mocks["orca.ax_object"]
1971 ax_object.AXObject.get_role.return_value = Atspi.Role.TABLE_CELL
1972
1973 ax_utilities.AXUtilities.get_table.return_value = MagicMock()
1974 ax_utilities.AXUtilities.is_layout_table.return_value = False
1975
1976 ax_document = mocks["orca.ax_document"]
1977 ax_document.AXDocument.is_pdf.return_value = False
1978
1979 mock_script = MagicMock()
1980 mock_script.utilities.is_text_block_element.return_value = False
1981 mock_script.utilities.has_name_and_action_and_no_useful_children.return_value = False
1982 mock_obj = MagicMock()
1983
1984 presenter = module.get_presenter()
1985 result = presenter.is_focus_mode_widget(mock_script, mock_obj)
1986
1987 assert result is True
1988
1989 def test_is_focus_mode_widget_grid_descendant(self, test_context: OrcaTestContext) -> None:
1990 """Test is_focus_mode_widget returns True for grid descendants."""
1991
1992 from unittest.mock import MagicMock
1993
1994 import gi
1995
1996 gi.require_version("Atspi", "2.0")
1997 from gi.repository import Atspi
1998
1999 module, mocks = self._setup_presenter(test_context)
2000
2001 ax_utilities = mocks["orca.ax_utilities"]
2002 ax_utilities.AXUtilities.is_editable.return_value = False
2003 ax_utilities.AXUtilities.is_expandable.return_value = False
2004 ax_utilities.AXUtilities.is_list_box_item.return_value = False
2005 ax_utilities.AXUtilities.is_button_with_popup.return_value = False
2006 ax_utilities.AXUtilities.is_grid = MagicMock()
2007
2008 ax_object = mocks["orca.ax_object"]
2009 ax_object.AXObject.get_role.return_value = Atspi.Role.PARAGRAPH
2010 ax_utilities.AXUtilities.find_ancestor.return_value = MagicMock()
2011
2012 ax_utilities.AXUtilities.is_layout_table.return_value = False
2013
2014 mock_script = MagicMock()
2015 mock_script.utilities.is_text_block_element.return_value = True
2016 mock_obj = MagicMock()
2017
2018 presenter = module.get_presenter()
2019 result = presenter.is_focus_mode_widget(mock_script, mock_obj)
2020
2021 assert result is True
2022
2023 def test_is_focus_mode_widget_menu_descendant(self, test_context: OrcaTestContext) -> None:
2024 """Test is_focus_mode_widget returns True for menu descendants."""
2025
2026 from unittest.mock import MagicMock
2027
2028 import gi
2029
2030 gi.require_version("Atspi", "2.0")
2031 from gi.repository import Atspi
2032
2033 module, mocks = self._setup_presenter(test_context)
2034
2035 ax_utilities = mocks["orca.ax_utilities"]
2036 ax_utilities.AXUtilities.is_editable.return_value = False
2037 ax_utilities.AXUtilities.is_expandable.return_value = False
2038 ax_utilities.AXUtilities.is_list_box_item.return_value = False
2039 ax_utilities.AXUtilities.is_button_with_popup.return_value = False
2040 ax_utilities.AXUtilities.is_grid = MagicMock()
2041 ax_utilities.AXUtilities.is_menu = MagicMock()
2042
2043 ax_object = mocks["orca.ax_object"]
2044 ax_object.AXObject.get_role.return_value = Atspi.Role.PARAGRAPH
2045 ax_utilities.AXUtilities.find_ancestor.side_effect = [None, MagicMock()]
2046
2047 ax_utilities.AXUtilities.is_layout_table.return_value = False
2048
2049 mock_script = MagicMock()
2050 mock_script.utilities.is_text_block_element.return_value = True
2051 mock_obj = MagicMock()
2052
2053 presenter = module.get_presenter()
2054 result = presenter.is_focus_mode_widget(mock_script, mock_obj)
2055
2056 assert result is True
2057
2058 def test_is_focus_mode_widget_toolbar_descendant(self, test_context: OrcaTestContext) -> None:
2059 """Test is_focus_mode_widget returns True for toolbar descendants."""
2060
2061 from unittest.mock import MagicMock
2062
2063 import gi
2064
2065 gi.require_version("Atspi", "2.0")
2066 from gi.repository import Atspi
2067
2068 module, mocks = self._setup_presenter(test_context)
2069
2070 ax_utilities = mocks["orca.ax_utilities"]
2071 ax_utilities.AXUtilities.is_editable.return_value = False
2072 ax_utilities.AXUtilities.is_expandable.return_value = False
2073 ax_utilities.AXUtilities.is_list_box_item.return_value = False
2074 ax_utilities.AXUtilities.is_button_with_popup.return_value = False
2075 ax_utilities.AXUtilities.is_grid = MagicMock()
2076 ax_utilities.AXUtilities.is_menu = MagicMock()
2077 ax_utilities.AXUtilities.is_tool_bar = MagicMock()
2078
2079 ax_object = mocks["orca.ax_object"]
2080 ax_object.AXObject.get_role.return_value = Atspi.Role.PARAGRAPH
2081 ax_utilities.AXUtilities.find_ancestor.side_effect = [None, None, MagicMock()]
2082
2083 ax_utilities.AXUtilities.is_layout_table.return_value = False
2084
2085 mock_script = MagicMock()
2086 mock_script.utilities.is_text_block_element.return_value = True
2087 mock_obj = MagicMock()
2088
2089 presenter = module.get_presenter()
2090 result = presenter.is_focus_mode_widget(mock_script, mock_obj)
2091
2092 assert result is True
2093
2094 def test_is_focus_mode_widget_content_editable(self, test_context: OrcaTestContext) -> None:
2095 """Test is_focus_mode_widget returns True for content editable with embedded."""
2096
2097 from unittest.mock import MagicMock
2098
2099 import gi
2100
2101 gi.require_version("Atspi", "2.0")
2102 from gi.repository import Atspi
2103
2104 module, mocks = self._setup_presenter(test_context)
2105
2106 ax_utilities = mocks["orca.ax_utilities"]
2107 ax_utilities.AXUtilities.is_editable.return_value = False
2108 ax_utilities.AXUtilities.is_expandable.return_value = False
2109 ax_utilities.AXUtilities.is_list_box_item.return_value = False
2110 ax_utilities.AXUtilities.is_button_with_popup.return_value = False
2111 ax_utilities.AXUtilities.is_grid = MagicMock()
2112 ax_utilities.AXUtilities.is_menu = MagicMock()
2113 ax_utilities.AXUtilities.is_tool_bar = MagicMock()
2114
2115 ax_object = mocks["orca.ax_object"]
2116 ax_object.AXObject.get_role.return_value = Atspi.Role.PARAGRAPH
2117 ax_utilities.AXUtilities.find_ancestor.return_value = None
2118
2119 ax_utilities.AXUtilities.is_layout_table.return_value = False
2120
2121 mock_script = MagicMock()
2122 mock_script.utilities.is_text_block_element.return_value = True
2123 mock_script.utilities.is_content_editable_with_embedded_objects.return_value = True
2124 mock_obj = MagicMock()
2125
2126 presenter = module.get_presenter()
2127 result = presenter.is_focus_mode_widget(mock_script, mock_obj)
2128
2129 assert result is True
2130
2131 def test_is_focus_mode_widget_default_false(self, test_context: OrcaTestContext) -> None:
2132 """Test is_focus_mode_widget returns False by default."""
2133
2134 from unittest.mock import MagicMock
2135
2136 import gi
2137
2138 gi.require_version("Atspi", "2.0")
2139 from gi.repository import Atspi
2140
2141 module, mocks = self._setup_presenter(test_context)
2142
2143 ax_utilities = mocks["orca.ax_utilities"]
2144 ax_utilities.AXUtilities.is_editable.return_value = False
2145 ax_utilities.AXUtilities.is_expandable.return_value = False
2146 ax_utilities.AXUtilities.is_list_box_item.return_value = False
2147 ax_utilities.AXUtilities.is_button_with_popup.return_value = False
2148 ax_utilities.AXUtilities.is_grid = MagicMock()
2149 ax_utilities.AXUtilities.is_menu = MagicMock()
2150 ax_utilities.AXUtilities.is_tool_bar = MagicMock()
2151
2152 ax_object = mocks["orca.ax_object"]
2153 ax_object.AXObject.get_role.return_value = Atspi.Role.PARAGRAPH
2154 ax_utilities.AXUtilities.find_ancestor.return_value = None
2155
2156 ax_utilities.AXUtilities.is_layout_table.return_value = False
2157
2158 mock_script = MagicMock()
2159 mock_script.utilities.is_text_block_element.return_value = True
2160 mock_script.utilities.is_content_editable_with_embedded_objects.return_value = False
2161 mock_obj = MagicMock()
2162
2163 presenter = module.get_presenter()
2164 result = presenter.is_focus_mode_widget(mock_script, mock_obj)
2165
2166 assert result is False
2167
2168 def test_is_focus_mode_widget_pdf_table_false(self, test_context: OrcaTestContext) -> None:
2169 """Test is_focus_mode_widget returns False for table cells in PDFs."""
2170
2171 from unittest.mock import MagicMock
2172
2173 import gi
2174
2175 gi.require_version("Atspi", "2.0")
2176 from gi.repository import Atspi
2177
2178 module, mocks = self._setup_presenter(test_context)
2179
2180 ax_utilities = mocks["orca.ax_utilities"]
2181 ax_utilities.AXUtilities.is_editable.return_value = False
2182 ax_utilities.AXUtilities.is_expandable.return_value = False
2183 ax_utilities.AXUtilities.is_list_box_item.return_value = False
2184 ax_utilities.AXUtilities.is_button_with_popup.return_value = False
2185 ax_utilities.AXUtilities.is_grid = MagicMock()
2186 ax_utilities.AXUtilities.is_menu = MagicMock()
2187 ax_utilities.AXUtilities.is_tool_bar = MagicMock()
2188
2189 ax_object = mocks["orca.ax_object"]
2190 ax_object.AXObject.get_role.return_value = Atspi.Role.TABLE_CELL
2191 ax_utilities.AXUtilities.find_ancestor.return_value = None
2192
2193 ax_utilities.AXUtilities.get_table.return_value = MagicMock()
2194 ax_utilities.AXUtilities.is_layout_table.return_value = False
2195
2196 ax_document = mocks["orca.ax_document"]
2197 ax_document.AXDocument.is_pdf.return_value = True
2198
2199 mock_script = MagicMock()
2200 mock_script.utilities.is_text_block_element.return_value = False
2201 mock_script.utilities.has_name_and_action_and_no_useful_children.return_value = False
2202 mock_script.utilities.is_content_editable_with_embedded_objects.return_value = False
2203 mock_obj = MagicMock()
2204
2205 presenter = module.get_presenter()
2206 result = presenter.is_focus_mode_widget(mock_script, mock_obj)
2207
2208 assert result is False
2209
2210 def test_get_in_focus_mode_no_script(self, test_context: OrcaTestContext) -> None:
2211 """Test get_in_focus_mode returns False when no active script."""
2212
2213 module, mocks = self._setup_presenter(test_context)
2214
2215 script_manager = mocks["orca.script_manager"]
2216 script_manager.get_manager.return_value.get_active_script.return_value = None
2217
2218 presenter = module.get_presenter()
2219 result = presenter.get_in_focus_mode()
2220
2221 assert result is False
2222
2223 def test_get_focus_mode_is_sticky_no_script(self, test_context: OrcaTestContext) -> None:
2224 """Test get_focus_mode_is_sticky returns False when no active script."""
2225
2226 module, mocks = self._setup_presenter(test_context)
2227
2228 script_manager = mocks["orca.script_manager"]
2229 script_manager.get_manager.return_value.get_active_script.return_value = None
2230
2231 presenter = module.get_presenter()
2232 result = presenter.get_focus_mode_is_sticky()
2233
2234 assert result is False
2235
2236 def test_get_browse_mode_is_sticky_no_script(self, test_context: OrcaTestContext) -> None:
2237 """Test get_browse_mode_is_sticky returns False when no active script."""
2238
2239 module, mocks = self._setup_presenter(test_context)
2240
2241 script_manager = mocks["orca.script_manager"]
2242 script_manager.get_manager.return_value.get_active_script.return_value = None
2243
2244 presenter = module.get_presenter()
2245 result = presenter.get_browse_mode_is_sticky()
2246
2247 assert result is False
2248
2249 def test_has_state_for_app(self, test_context: OrcaTestContext) -> None:
2250 """Test has_state_for_app returns correct value."""
2251
2252 from unittest.mock import MagicMock
2253
2254 module, _mocks = self._setup_presenter(test_context)
2255
2256 mock_app = MagicMock()
2257 presenter = module.get_presenter()
2258
2259 assert presenter.has_state_for_app(mock_app) is False
2260
2261 presenter._app_states[hash(mock_app)] = module._AppModeState()
2262
2263 assert presenter.has_state_for_app(mock_app) is True
2264
2265 def test_update_mode_if_needed_within_doc(self, test_context: OrcaTestContext) -> None:
2266 """Test update_mode_if_needed when moving within document."""
2267
2268 from unittest.mock import MagicMock, patch
2269
2270 module, mocks = self._setup_presenter(test_context)
2271
2272 mock_app = MagicMock()
2273 mock_script = MagicMock()
2274 mock_script.app = mock_app
2275 mock_doc = MagicMock()
2276 mock_script.utilities.get_top_level_document_for_object.return_value = mock_doc
2277 mock_script.utilities.in_document_content.return_value = True
2278 mock_script.utilities.get_caret_context.return_value = (MagicMock(), 0)
2279
2280 caret_nav = mocks["orca.caret_navigator"]
2281 nav_mock = caret_nav.get_navigator.return_value
2282 nav_mock.last_input_event_was_navigation_command.return_value = False
2283 caret_nav.get_navigator.return_value.last_command_prevents_focus_mode.return_value = False
2284 struct_nav = mocks["orca.structural_navigator"]
2285 nav_mock = struct_nav.get_navigator.return_value
2286 nav_mock.last_input_event_was_navigation_command.return_value = False
2287 struct_nav.get_navigator.return_value.last_command_prevents_focus_mode.return_value = False
2288 table_nav = mocks["orca.table_navigator"]
2289 nav_mock = table_nav.get_navigator.return_value
2290 nav_mock.last_input_event_was_navigation_command.return_value = False
2291 focus_manager = mocks["orca.focus_manager"]
2292 focus_manager.get_manager.return_value.in_say_all.return_value = False
2293
2294 script_manager = mocks["orca.script_manager"]
2295 script_manager.get_manager.return_value.get_active_script.return_value = mock_script
2296
2297 presenter = module.get_presenter()
2298 presenter._app_states[hash(mock_app)] = module._AppModeState(
2299 in_focus_mode=False,
2300 focus_mode_is_sticky=False,
2301 browse_mode_is_sticky=False,
2302 )
2303
2304 with patch.object(presenter, "is_focus_mode_widget", return_value=False):
2305 result = presenter.update_mode_if_needed(mock_script, MagicMock(), MagicMock())
2306
2307 assert result is True
2308
2309 def test_update_mode_if_needed_sticky_within_doc(self, test_context: OrcaTestContext) -> None:
2310 """Test update_mode_if_needed within doc with sticky mode returns False."""
2311
2312 from unittest.mock import MagicMock
2313
2314 module, _mocks = self._setup_presenter(test_context)
2315
2316 mock_app = MagicMock()
2317 mock_script = MagicMock()
2318 mock_script.app = mock_app
2319 mock_doc = MagicMock()
2320 mock_script.utilities.get_top_level_document_for_object.return_value = mock_doc
2321
2322 presenter = module.get_presenter()
2323 presenter._app_states[hash(mock_app)] = module._AppModeState(
2324 in_focus_mode=True,
2325 focus_mode_is_sticky=True,
2326 browse_mode_is_sticky=False,
2327 )
2328
2329 result = presenter.update_mode_if_needed(mock_script, MagicMock(), MagicMock())
2330
2331 assert result is False