Debian Codegraph @

tests/unit_tests/test_flat_review_presenter.py

raw
1 # Unit tests for flat_review_presenter.py methods.
2 #
3 # Copyright 2025 Igalia, S.L.
4 # Author: Joanmarie Diggs <[email protected]>
5 #
6 # This program is free software; you can redistribute it and/or modify
7 # it under the terms of the GNU Lesser General Public License as published by
8 # the Free Software Foundation; either version 2.1 of the License, or
9 # (at your option) any later version.
10 #
11 # This program 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
14 # GNU Lesser General Public License for more details.
15 #
16 # You should have received a copy of the GNU Lesser General Public License
17 # along with this program; if not, write to the Free Software Foundation,
18 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19
20 # pylint: disable=wrong-import-position
21 # pylint: disable=import-outside-toplevel
22 # pylint: disable=too-many-public-methods
23 # pylint: disable=too-many-statements
24 # pylint: disable=protected-access
25 # pylint: disable=too-many-locals
26 # pylint: disable=too-many-arguments
27 # pylint: disable=too-many-positional-arguments
28
29 """Unit tests for flat_review_presenter.py methods."""
30
31 from __future__ import annotations
32
33 from typing import TYPE_CHECKING
34
35 import pytest
36
37 if TYPE_CHECKING:
38 from unittest.mock import MagicMock
39
40 from .orca_test_context import OrcaTestContext
41
42
43 class Fake:
44 """Stub used as a stand-in for objects that need an identity."""
45
46
47 @pytest.mark.unit
48 class TestFlatReviewPresenter:
49 """Test FlatReviewPresenter class methods."""
50
51 def _setup_dependencies(self, test_context: OrcaTestContext) -> dict[str, MagicMock]:
52 """Set up mocks for flat_review_presenter dependencies."""
53
54 additional_modules = [
55 "gi",
56 "gi.repository",
57 "gi.repository.Atspi",
58 "gi.repository.Gtk",
59 "gi.repository.GLib",
60 "dasbus",
61 "dasbus.connection",
62 "dasbus.error",
63 "dasbus.client",
64 "dasbus.client.proxy",
65 "orca.flat_review",
66 "orca.speech_presenter",
67 "orca.ax_event_synthesizer",
68 "orca.ax_text",
69 "orca.braille_presenter",
70 "orca.orca_platform",
71 ]
72 essential_modules = test_context.setup_shared_dependencies(additional_modules)
73
74 gi_mock = essential_modules["gi"]
75 gi_mock.require_version = test_context.Mock()
76
77 gi_repository_mock = essential_modules["gi.repository"]
78 atspi_mock = essential_modules["gi.repository.Atspi"]
79 atspi_mock.Role = Fake
80 atspi_mock.Accessible = Fake
81 atspi_mock.MatchRule = Fake
82 atspi_mock.Relation = Fake
83 gi_repository_mock.Atspi = atspi_mock
84
85 gtk_mock = essential_modules["gi.repository.Gtk"]
86 window_mock = test_context.Mock()
87 gtk_mock.Window = test_context.Mock(return_value=window_mock)
88 gtk_mock.VBox = test_context.Mock()
89 gtk_mock.Label = test_context.Mock()
90 gtk_mock.Button = test_context.Mock()
91
92 glib_mock = essential_modules["gi.repository.GLib"]
93 glib_error_mock = type("GError", (Exception,), {})
94 glib_mock.GError = glib_error_mock
95
96 flat_review_mock = essential_modules["orca.flat_review"]
97 flat_review_context_mock = test_context.Mock()
98
99 flat_review_context_mock.get_current_object = test_context.Mock(
100 return_value=test_context.Mock(),
101 )
102 flat_review_context_mock.get_current_word = test_context.Mock(return_value="test word")
103 flat_review_context_mock.get_current_line = test_context.Mock(return_value="test line")
104 flat_review_context_mock.get_current_line_string = test_context.Mock(
105 return_value="test line",
106 )
107 flat_review_context_mock.get_current_char = test_context.Mock(return_value="t")
108 flat_review_context_mock.get_current_character = test_context.Mock(return_value="t")
109 flat_review_context_mock.get_current_item = test_context.Mock(return_value="test item")
110 flat_review_context_mock.get_contents = test_context.Mock(return_value="test content")
111 flat_review_context_mock.get_current_braille_regions = test_context.Mock(
112 return_value=([], None),
113 )
114
115 flat_review_context_mock.go_next_line = test_context.Mock(return_value=True)
116 flat_review_context_mock.go_previous_line = test_context.Mock(return_value=True)
117 flat_review_context_mock.go_next_item = test_context.Mock(return_value=True)
118 flat_review_context_mock.go_previous_item = test_context.Mock(return_value=True)
119 flat_review_context_mock.go_next_character = test_context.Mock(return_value=True)
120 flat_review_context_mock.go_previous_character = test_context.Mock(return_value=True)
121 flat_review_context_mock.go_begin_line = test_context.Mock(return_value=True)
122 flat_review_context_mock.go_end_line = test_context.Mock(return_value=True)
123 flat_review_context_mock.go_top_left = test_context.Mock(return_value=True)
124 flat_review_context_mock.go_bottom_right = test_context.Mock(return_value=True)
125 flat_review_context_mock.go_bottom_left = test_context.Mock(return_value=True)
126 flat_review_context_mock.go_to_start_of = test_context.Mock(return_value=True)
127 flat_review_context_mock.go_to_end_of = test_context.Mock(return_value=True)
128
129 context_class_mock = test_context.Mock(return_value=flat_review_context_mock)
130 context_class_mock.WINDOW = "window"
131 context_class_mock.LINE = "line"
132 flat_review_mock.Context = context_class_mock
133
134 focus_manager_mock = essential_modules["orca.focus_manager"]
135 focus_manager_instance = test_context.Mock()
136 focus_manager_instance.get_active_mode_and_object_of_interest = test_context.Mock(
137 return_value=("focus_tracking", test_context.Mock()),
138 )
139 focus_manager_instance.get_locus_of_focus = test_context.Mock(
140 return_value=test_context.Mock(),
141 )
142 focus_manager_instance.emit_region_changed = test_context.Mock()
143 focus_manager_instance.FLAT_REVIEW = "flat_review"
144 focus_manager_instance.FOCUS_TRACKING = "focus_tracking"
145 focus_manager_mock.get_manager = test_context.Mock(return_value=focus_manager_instance)
146 focus_manager_mock.FLAT_REVIEW = "flat_review"
147 focus_manager_mock.FOCUS_TRACKING = "focus_tracking"
148
149 script_manager_mock = essential_modules["orca.script_manager"]
150 script_manager_instance = test_context.Mock()
151 script_instance = test_context.Mock()
152 script_instance.present_message = test_context.Mock()
153 script_instance.present_object = test_context.Mock()
154 script_instance.update_braille = test_context.Mock()
155 script_instance.speak_message = test_context.Mock()
156
157 speech_generator_mock = test_context.Mock()
158 speech_generator_mock.voice = test_context.Mock(return_value="voice")
159 script_instance.get_speech_generator = test_context.Mock(return_value=speech_generator_mock)
160
161 script_manager_instance.get_active_script = test_context.Mock(return_value=script_instance)
162 script_manager_mock.get_manager = test_context.Mock(return_value=script_manager_instance)
163
164 dbus_service_mock = essential_modules["orca.dbus_service"]
165 controller_mock = test_context.Mock()
166 controller_mock.register_decorated_module = test_context.Mock()
167 dbus_service_mock.get_remote_controller = test_context.Mock(return_value=controller_mock)
168 dbus_service_mock.command = lambda func: func
169
170 keybindings_mock = essential_modules["orca.keybindings"]
171 bindings_instance = test_context.Mock()
172 bindings_instance.add = test_context.Mock()
173 bindings_instance.remove = test_context.Mock()
174 keybindings_mock.KeyBindings = test_context.Mock(return_value=bindings_instance)
175
176 input_event_mock = essential_modules["orca.input_event"]
177 input_event_handler_mock = test_context.Mock()
178 input_event_mock.InputEventHandler = test_context.Mock(
179 return_value=input_event_handler_mock,
180 )
181 input_event_mock.InputEvent = test_context.Mock()
182 braille_event_mock = type("BrailleEvent", (), {})
183 input_event_mock.BrailleEvent = braille_event_mock
184
185 messages_mock = essential_modules["orca.messages"]
186 messages_mock.FLAT_REVIEW_START = "Entering flat review."
187 messages_mock.FLAT_REVIEW_STOP = "Leaving flat review."
188 messages_mock.FLAT_REVIEW_HOME = "Top left."
189 messages_mock.FLAT_REVIEW_END = "Bottom right."
190
191 guilabels_mock = essential_modules["orca.guilabels"]
192 guilabels_mock.FLAT_REVIEW = "Flat Review"
193
194 cmdnames_mock = essential_modules["orca.cmdnames"]
195 cmdnames_mock.TOGGLE_FLAT_REVIEW = "toggleFlatReviewMode"
196 cmdnames_mock.FLAT_REVIEW_HOME = "flatReviewHome"
197 cmdnames_mock.FLAT_REVIEW_END = "flatReviewEnd"
198
199 braille_mock = essential_modules["orca.braille"]
200 braille_mock.refresh = test_context.Mock()
201 braille_mock.present_line = test_context.Mock()
202 braille_mock.present_item = test_context.Mock()
203
204 debug_mock = essential_modules["orca.debug"]
205 debug_mock.print_message = test_context.Mock()
206 debug_mock.LEVEL_INFO = 800
207
208 ax_event_synthesizer_mock = essential_modules["orca.ax_event_synthesizer"]
209 ax_event_synthesizer_class_mock = test_context.Mock()
210 ax_event_synthesizer_mock.AXEventSynthesizer = ax_event_synthesizer_class_mock
211
212 ax_object_mock = essential_modules["orca.ax_object"]
213 ax_object_class_mock = test_context.Mock()
214 ax_object_class_mock.get_name = test_context.Mock(return_value="Test Object")
215 ax_object_class_mock.is_dead = test_context.Mock(return_value=False)
216 ax_object_mock.AXObject = ax_object_class_mock
217
218 ax_text_mock = essential_modules["orca.ax_text"]
219 ax_text_class_mock = test_context.Mock()
220 ax_text_class_mock.get_text = test_context.Mock(return_value="test text")
221 ax_text_mock.AXText = ax_text_class_mock
222
223 speech_verbosity_mock = essential_modules["orca.speech_presenter"]
224 speech_verbosity_instance = test_context.Mock()
225 speech_verbosity_mock.get_presenter = test_context.Mock(
226 return_value=speech_verbosity_instance,
227 )
228
229 braille_presenter_mock = essential_modules["orca.braille_presenter"]
230 braille_presenter_instance = test_context.Mock()
231 braille_presenter_instance.use_braille = test_context.Mock(return_value=True)
232 braille_presenter_mock.get_presenter = test_context.Mock(
233 return_value=braille_presenter_instance,
234 )
235
236 platform_mock = essential_modules["orca.orca_platform"]
237 platform_mock.tablesdir = "/usr/share/liblouis/tables"
238
239 essential_modules["flat_review_context"] = flat_review_context_mock
240 essential_modules["focus_manager_instance"] = focus_manager_instance
241 essential_modules["script_manager_instance"] = script_manager_instance
242 essential_modules["script_instance"] = script_instance
243 essential_modules["controller"] = controller_mock
244 essential_modules["window"] = window_mock
245
246 return essential_modules
247
248 def test_init(self, test_context: OrcaTestContext) -> None:
249 """Test FlatReviewPresenter.__init__."""
250
251 self._setup_dependencies(test_context)
252 from orca.flat_review_presenter import FlatReviewPresenter
253
254 mock_controller = test_context.Mock()
255 test_context.patch(
256 "orca.flat_review_presenter.dbus_service.get_remote_controller",
257 return_value=mock_controller,
258 )
259 presenter = FlatReviewPresenter()
260
261 assert presenter._context is None
262 assert presenter._current_contents == ""
263 assert isinstance(presenter._restrict, bool)
264 assert presenter._gui is None
265
266 # D-Bus registration and bindings setup happens during setup()
267 presenter.set_up_commands()
268 mock_controller.register_decorated_module.assert_called_with(
269 "FlatReviewPresenter",
270 presenter,
271 )
272
273 @pytest.mark.parametrize(
274 "has_context,expected",
275 [
276 (False, False),
277 (True, True),
278 ],
279 )
280 def test_is_active(
281 self,
282 test_context: OrcaTestContext,
283 has_context: bool,
284 expected: bool,
285 ) -> None:
286 """Test FlatReviewPresenter.is_active with various context states."""
287
288 self._setup_dependencies(test_context)
289 from orca.flat_review_presenter import FlatReviewPresenter
290
291 presenter = FlatReviewPresenter()
292 presenter._context = test_context.Mock() if has_context else None
293 result = presenter.is_active()
294 assert result is expected
295
296 def test_get_or_create_context_creates_new_unrestricted(
297 self,
298 test_context: OrcaTestContext,
299 ) -> None:
300 """Test FlatReviewPresenter.get_or_create_context creates context in unrestricted mode."""
301
302 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
303 from orca.flat_review_presenter import FlatReviewPresenter
304
305 presenter = FlatReviewPresenter()
306 presenter._context = None
307 presenter._restrict = False
308 script_mock = test_context.Mock()
309 context = presenter.get_or_create_context(script_mock)
310
311 assert context is not None
312 assert presenter._context is not None
313 essential_modules["orca.flat_review"].Context.assert_called_with(script_mock)
314 essential_modules["focus_manager_instance"].emit_region_changed.assert_called_once()
315
316 def test_get_or_create_context_creates_new_restricted(
317 self,
318 test_context: OrcaTestContext,
319 ) -> None:
320 """Test FlatReviewPresenter.get_or_create_context creates new context in restricted mode."""
321
322 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
323 from orca.flat_review_presenter import FlatReviewPresenter
324
325 presenter = FlatReviewPresenter()
326 presenter._context = None
327 presenter._restrict = True
328 script_mock = test_context.Mock()
329 root_obj = test_context.Mock()
330 essential_modules[
331 "focus_manager_instance"
332 ].get_active_mode_and_object_of_interest.return_value = ("focus_tracking", root_obj)
333 context = presenter.get_or_create_context(script_mock)
334
335 assert context is not None
336 assert presenter._context is not None
337 essential_modules["orca.flat_review"].Context.assert_called_with(script_mock, root=root_obj)
338
339 def test_get_or_create_context_returns_existing(self, test_context: OrcaTestContext) -> None:
340 """Test FlatReviewPresenter.get_or_create_context returns existing context."""
341
342 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
343 from orca.flat_review_presenter import FlatReviewPresenter
344
345 presenter = FlatReviewPresenter()
346 existing_context = test_context.Mock()
347 presenter._context = existing_context
348 presenter._restrict = False
349 script_mock = test_context.Mock()
350 context = presenter.get_or_create_context(script_mock)
351
352 assert context is existing_context
353 assert essential_modules["orca.flat_review"].Context.call_count == 0
354
355 def test_setup_braille_bindings(self, test_context: OrcaTestContext) -> None:
356 """Test FlatReviewPresenter sets up braille bindings during set_up_commands."""
357
358 self._setup_dependencies(test_context)
359 from orca import command_manager
360 from orca.flat_review_presenter import FlatReviewPresenter
361
362 presenter = FlatReviewPresenter()
363 presenter.set_up_commands()
364
365 # Verify that braille commands are registered
366 manager = command_manager.get_manager()
367 braille_cmds = [
368 c for c in manager.get_all_braille_commands() if c.get_name() == "reviewAboveHandler"
369 ]
370 # May be empty if braille is not available in test environment
371 assert len(braille_cmds) == 0 or braille_cmds[0].get_braille_bindings() is not None
372
373 @pytest.mark.parametrize(
374 "_refresh",
375 [
376 pytest.param(False, id="cached"),
377 pytest.param(True, id="refresh"),
378 ],
379 )
380 def test_get_handlers(self, test_context: OrcaTestContext, _refresh: bool) -> None:
381 """Test FlatReviewPresenter.get_handlers returns empty dict (commands in CommandManager)."""
382
383 self._setup_dependencies(test_context)
384 from orca import command_manager
385 from orca.flat_review_presenter import FlatReviewPresenter
386
387 presenter = FlatReviewPresenter()
388 presenter.set_up_commands()
389
390 cmd_manager = command_manager.get_manager()
391 expected_commands = [
392 "toggleFlatReviewModeHandler",
393 "reviewHomeHandler",
394 "reviewEndHandler",
395 "flatReviewSayAllHandler",
396 ]
397 for cmd_name in expected_commands:
398 assert cmd_manager.get_keyboard_command(cmd_name) is not None
399
400 @pytest.mark.parametrize(
401 "has_context,provides_script,provides_event",
402 [
403 (True, False, False),
404 (False, True, False),
405 (False, True, True),
406 ],
407 )
408 def test_start_scenarios(
409 self,
410 test_context: OrcaTestContext,
411 has_context: bool,
412 provides_script: bool,
413 provides_event: bool,
414 ) -> None:
415 """Test FlatReviewPresenter.start under different scenarios."""
416 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
417 from orca.flat_review_presenter import FlatReviewPresenter
418
419 presenter = FlatReviewPresenter()
420 presenter._context = test_context.Mock() if has_context else None
421 script_mock = test_context.Mock() if provides_script else None
422 event_mock = test_context.Mock() if provides_event else None
423 presenter.start(script=script_mock, event=event_mock)
424 if has_context:
425 essential_modules["orca.flat_review"].Context.assert_not_called()
426 else:
427 assert presenter._context is not None
428 essential_modules["orca.flat_review"].Context.assert_called_once()
429
430 @pytest.mark.parametrize("is_active", [False, True])
431 def test_quit_scenarios(self, test_context: OrcaTestContext, is_active: bool) -> None:
432 """Test FlatReviewPresenter.quit when active or inactive."""
433 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
434 from orca.flat_review_presenter import FlatReviewPresenter
435
436 presenter = FlatReviewPresenter()
437 presenter._context = test_context.Mock() if is_active else None
438 if is_active:
439 focus_obj = test_context.Mock()
440 essential_modules["focus_manager_instance"].get_locus_of_focus.return_value = focus_obj
441 presenter.quit()
442 if is_active:
443 assert presenter._context is None
444 essential_modules["focus_manager_instance"].emit_region_changed.assert_called_with(
445 focus_obj,
446 mode=essential_modules["focus_manager_instance"].FOCUS_TRACKING,
447 )
448 else:
449 essential_modules["focus_manager_instance"].emit_region_changed.assert_not_called()
450
451 def test_toggle_flat_review_mode_enter(self, test_context: OrcaTestContext) -> None:
452 """Test FlatReviewPresenter.toggle_flat_review_mode enters flat review."""
453
454 self._setup_dependencies(test_context)
455 from orca.flat_review_presenter import FlatReviewPresenter
456
457 presenter = FlatReviewPresenter()
458 presenter._context = None
459 script_mock = test_context.Mock()
460 event_mock = test_context.Mock()
461 mock_start = test_context.patch_object(presenter, "start")
462 presenter.toggle_flat_review_mode(script_mock, event_mock)
463 mock_start.assert_called_once_with(script_mock, event_mock)
464
465 def test_toggle_flat_review_mode_exit(self, test_context: OrcaTestContext) -> None:
466 """Test FlatReviewPresenter.toggle_flat_review_mode exits flat review."""
467
468 self._setup_dependencies(test_context)
469 from orca.flat_review_presenter import FlatReviewPresenter
470
471 presenter = FlatReviewPresenter()
472 presenter._context = test_context.Mock()
473 script_mock = test_context.Mock()
474 event_mock = test_context.Mock()
475 mock_quit = test_context.patch_object(presenter, "quit")
476 presenter.toggle_flat_review_mode(script_mock, event_mock)
477 mock_quit.assert_called_once_with(script_mock, event_mock)
478
479 @pytest.mark.parametrize(
480 "method_name,context_method,navigation_target",
481 [
482 ("go_home", "go_to_start_of", "WINDOW"),
483 ("go_end", "go_to_end_of", "WINDOW"),
484 ],
485 )
486 def test_navigation_methods(
487 self,
488 test_context: OrcaTestContext,
489 method_name: str,
490 context_method: str,
491 navigation_target: str,
492 ) -> None:
493 """Test FlatReviewPresenter navigation methods (go_home, go_end)."""
494 essential_modules = self._setup_dependencies(test_context)
495 from orca.flat_review_presenter import FlatReviewPresenter
496
497 presenter = FlatReviewPresenter()
498 script_mock = test_context.Mock()
499 event_mock = test_context.Mock()
500 context_mock = test_context.Mock()
501 presenter._context = context_mock
502 mock_present_line = test_context.patch_object(presenter, "present_line")
503 method = getattr(presenter, method_name)
504 result = method(script_mock, event_mock)
505 getattr(context_mock, context_method).assert_called_once_with(
506 getattr(essential_modules["orca.flat_review"].Context, navigation_target),
507 )
508 mock_present_line.assert_called_once_with(script_mock, event_mock)
509 assert result is True
510
511 def test_go_bottom_left(self, test_context: OrcaTestContext) -> None:
512 """Test FlatReviewPresenter.go_bottom_left."""
513
514 essential_modules = self._setup_dependencies(test_context)
515 from orca.flat_review_presenter import FlatReviewPresenter
516
517 presenter = FlatReviewPresenter()
518 script_mock = test_context.Mock()
519 event_mock = test_context.Mock()
520
521 context_mock = test_context.Mock()
522 presenter._context = context_mock
523 mock_present_line = test_context.patch_object(presenter, "present_line")
524
525 result = presenter.go_bottom_left(script_mock, event_mock)
526
527 assert context_mock.go_to_end_of.call_count == 1
528 context_mock.go_to_end_of.assert_called_with(
529 essential_modules["orca.flat_review"].Context.WINDOW,
530 )
531 context_mock.go_to_start_of.assert_called_once_with(
532 essential_modules["orca.flat_review"].Context.LINE,
533 )
534 mock_present_line.assert_called_once_with(script_mock, event_mock)
535 assert result is True
536
537 @pytest.mark.parametrize("navigation_succeeds", [True, False])
538 def test_go_previous_line_scenarios(
539 self,
540 test_context: OrcaTestContext,
541 navigation_succeeds: bool,
542 ) -> None:
543 """Test FlatReviewPresenter.go_previous_line with success and failure."""
544 self._setup_dependencies(test_context)
545 from orca.flat_review_presenter import FlatReviewPresenter
546
547 presenter = FlatReviewPresenter()
548 script_mock = test_context.Mock()
549 event_mock = test_context.Mock()
550 context_mock = test_context.Mock()
551 context_mock.go_previous_line.return_value = navigation_succeeds
552 presenter._context = context_mock
553 mock_present_line = test_context.patch_object(presenter, "present_line")
554 result = presenter.go_previous_line(script_mock, event_mock)
555 context_mock.go_previous_line.assert_called_once()
556 if navigation_succeeds:
557 mock_present_line.assert_called_once_with(script_mock, event_mock)
558 else:
559 mock_present_line.assert_not_called()
560 assert result is True
561
562 def test_get_presenter_singleton(self, test_context: OrcaTestContext) -> None:
563 """Test get_presenter function returns singleton instance."""
564
565 self._setup_dependencies(test_context)
566 from orca.flat_review_presenter import get_presenter
567
568 presenter1 = get_presenter()
569 presenter2 = get_presenter()
570 assert presenter1 is presenter2
571 assert presenter1 is not None
572
573 def test_full_navigation_workflow(self, test_context: OrcaTestContext) -> None:
574 """Test complete flat review navigation workflow."""
575
576 self._setup_dependencies(test_context)
577 from orca.flat_review_presenter import FlatReviewPresenter
578
579 presenter = FlatReviewPresenter()
580 script_mock = test_context.Mock()
581 event_mock = test_context.Mock()
582
583 presenter.start(script_mock, event_mock)
584 assert presenter.is_active()
585
586 presenter.quit(script_mock, event_mock)
587 assert not presenter.is_active()
588
589 def test_restricted_vs_unrestricted_context_creation(
590 self,
591 test_context: OrcaTestContext,
592 ) -> None:
593 """Test context creation in both restricted and unrestricted modes."""
594
595 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
596 from orca.flat_review_presenter import FlatReviewPresenter
597
598 presenter_unrestricted = FlatReviewPresenter()
599 presenter_unrestricted._restrict = False
600 presenter_unrestricted._context = None
601 script_mock = test_context.Mock()
602 presenter_unrestricted.get_or_create_context(script_mock)
603 essential_modules["orca.flat_review"].Context.assert_called_with(script_mock)
604
605 presenter_restricted = FlatReviewPresenter()
606 presenter_restricted._restrict = True
607 presenter_restricted._context = None
608 root_obj = test_context.Mock()
609 essential_modules[
610 "focus_manager_instance"
611 ].get_active_mode_and_object_of_interest.return_value = ("focus_tracking", root_obj)
612 presenter_restricted.get_or_create_context(script_mock)
613
614 assert essential_modules["orca.flat_review"].Context.call_count >= 2
615
616 def test_braille_integration(self, test_context: OrcaTestContext) -> None:
617 """Test flat review integration with braille system."""
618
619 self._setup_dependencies(test_context)
620 from orca import command_manager
621 from orca.flat_review_presenter import FlatReviewPresenter
622
623 presenter = FlatReviewPresenter()
624 presenter.set_up_commands()
625
626 # Verify that braille commands are registered
627 manager = command_manager.get_manager()
628 # Check for braille commands (may not have brlapi available in test environment)
629 braille_commands = list(manager.get_all_braille_commands())
630 # Either braille commands exist or braille isn't available
631 assert braille_commands is not None
632
633 def test_dbus_command_registration(self, test_context: OrcaTestContext) -> None:
634 """Test D-Bus command registration during setup."""
635
636 self._setup_dependencies(test_context)
637 from orca.flat_review_presenter import FlatReviewPresenter
638
639 mock_controller = test_context.Mock()
640 test_context.patch(
641 "orca.flat_review_presenter.dbus_service.get_remote_controller",
642 return_value=mock_controller,
643 )
644 presenter = FlatReviewPresenter()
645 presenter.set_up_commands()
646
647 mock_controller.register_decorated_module.assert_called_with(
648 "FlatReviewPresenter",
649 presenter,
650 )
651
652 def test_focus_manager_integration(self, test_context: OrcaTestContext) -> None:
653 """Test integration with focus manager for region changes."""
654
655 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
656 from orca.flat_review_presenter import FlatReviewPresenter
657
658 presenter = FlatReviewPresenter()
659 focus_manager_instance = essential_modules["focus_manager_instance"]
660
661 script_mock = test_context.Mock()
662 presenter.get_or_create_context(script_mock)
663 focus_manager_instance.emit_region_changed.assert_called()
664
665 presenter._context = test_context.Mock()
666 focus_obj = test_context.Mock()
667 focus_manager_instance.get_locus_of_focus.return_value = focus_obj
668 presenter.quit()
669 focus_manager_instance.emit_region_changed.assert_called_with(
670 focus_obj,
671 mode=focus_manager_instance.FOCUS_TRACKING,
672 )
673
674 def test_error_handling_navigation_failure(self, test_context: OrcaTestContext) -> None:
675 """Test error handling when navigation operations fail."""
676
677 self._setup_dependencies(test_context)
678 from orca.flat_review_presenter import FlatReviewPresenter
679
680 presenter = FlatReviewPresenter()
681 context_mock = test_context.Mock()
682 context_mock.go_next_line.return_value = False
683 presenter._context = context_mock
684 script_mock = test_context.Mock()
685 event_mock = test_context.Mock()
686
687 presenter.go_next_line(script_mock, event_mock)
688 context_mock.go_next_line.assert_called_once()
689
690 def test_gui_lifecycle_management(self, test_context: OrcaTestContext) -> None:
691 """Test GUI-related methods exist."""
692
693 self._setup_dependencies(test_context)
694 from orca.flat_review_presenter import FlatReviewPresenter
695
696 presenter = FlatReviewPresenter()
697
698 assert hasattr(presenter, "show_contents")
699 assert callable(getattr(presenter, "show_contents", None))
700
701 def test_context_caching_behavior(self, test_context: OrcaTestContext) -> None:
702 """Test context caching and reuse behavior."""
703
704 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
705 from orca.flat_review_presenter import FlatReviewPresenter
706
707 presenter = FlatReviewPresenter()
708 script_mock = test_context.Mock()
709
710 essential_modules["orca.flat_review"].Context.reset_mock()
711
712 context1 = presenter.get_or_create_context(script_mock)
713 assert context1 is not None
714
715 context2 = presenter.get_or_create_context(script_mock)
716 assert context1 is context2
717
718 assert essential_modules["orca.flat_review"].Context.call_count == 1
719
720 presenter._context = None
721 context3 = presenter.get_or_create_context(script_mock)
722 assert context3 is not None
723
724 assert essential_modules["orca.flat_review"].Context.call_count == 2