Debian Codegraph @

tests/unit_tests/test_presentation_manager.py

raw
1 # Unit tests for presentation_manager.py methods.
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=import-outside-toplevel
23 # pylint: disable=protected-access
24 # pylint: disable=too-many-locals
25 # pylint: disable=too-many-public-methods
26 # pylint: disable=too-many-statements
27
28 """Unit tests for presentation_manager.py methods."""
29
30 from __future__ import annotations
31
32 from typing import TYPE_CHECKING
33
34 import pytest
35
36 if TYPE_CHECKING:
37 from unittest.mock import MagicMock
38
39 from .orca_test_context import OrcaTestContext
40
41
42 @pytest.mark.unit
43 class TestPresentationManager:
44 """Test PresentationManager class methods."""
45
46 def _setup_dependencies(self, test_context: OrcaTestContext) -> dict[str, MagicMock]:
47 """Returns dependencies for presentation_manager module testing."""
48
49 additional_modules = [
50 "orca.braille_presenter",
51 "orca.live_region_presenter",
52 "orca.sound_presenter",
53 "orca.speech_manager",
54 "orca.speech_presenter",
55 "orca.typing_echo_presenter",
56 ]
57 essential_modules = test_context.setup_shared_dependencies(additional_modules)
58
59 debug_mock = essential_modules["orca.debug"]
60 debug_mock.print_message = test_context.Mock()
61 debug_mock.print_tokens = test_context.Mock()
62 debug_mock.print_exception = test_context.Mock()
63 debug_mock.debugFile = None
64 debug_mock.LEVEL_INFO = 800
65 debug_mock.LEVEL_WARNING = 600
66
67 braille_mock = essential_modules["orca.braille"]
68 braille_mock.killFlash = test_context.Mock()
69 braille_mock.displayMessage = test_context.Mock()
70 braille_mock.clear = test_context.Mock()
71 mock_line = test_context.Mock()
72 mock_line.regions = []
73 mock_line.add_regions = test_context.Mock(side_effect=mock_line.regions.append)
74 braille_mock.Line = test_context.Mock(return_value=mock_line)
75 braille_mock.add_line = test_context.Mock()
76 braille_mock.setFocus = test_context.Mock()
77 braille_mock.refresh = test_context.Mock()
78
79 braille_presenter_mock = essential_modules["orca.braille_presenter"]
80 braille_presenter_instance = test_context.Mock()
81 braille_presenter_instance.use_braille = test_context.Mock(return_value=True)
82 braille_presenter_instance.get_flash_messages_are_enabled = test_context.Mock(
83 return_value=True,
84 )
85 braille_presenter_instance.get_flash_messages_are_detailed = test_context.Mock(
86 return_value=True,
87 )
88 braille_presenter_instance.get_flashtime_from_settings = test_context.Mock(
89 return_value=5000,
90 )
91 braille_presenter_instance.kill_flash = test_context.Mock()
92 braille_presenter_instance.present_message = test_context.Mock()
93 braille_presenter_instance.present_regions = test_context.Mock()
94 braille_presenter_mock.get_presenter = test_context.Mock(
95 return_value=braille_presenter_instance,
96 )
97
98 live_region_presenter_mock = essential_modules["orca.live_region_presenter"]
99 live_region_instance = test_context.Mock()
100 live_region_instance.flush_messages = test_context.Mock()
101 live_region_presenter_mock.get_presenter = test_context.Mock(
102 return_value=live_region_instance,
103 )
104
105 sound_presenter_mock = essential_modules["orca.sound_presenter"]
106 sound_presenter_instance = test_context.Mock()
107 sound_presenter_instance.play = test_context.Mock()
108 sound_presenter_mock.get_presenter = test_context.Mock(
109 return_value=sound_presenter_instance,
110 )
111
112 speech_manager_mock = essential_modules["orca.speech_manager"]
113 speech_manager_instance = test_context.Mock()
114 speech_manager_instance.interrupt_speech = test_context.Mock()
115 speech_manager_instance.start_speech = test_context.Mock()
116 speech_manager_instance.shutdown_speech = test_context.Mock()
117 speech_manager_instance.refresh_speech = test_context.Mock()
118 speech_manager_instance.get_speech_is_enabled_and_not_muted = test_context.Mock(
119 return_value=True,
120 )
121 speech_manager_instance.get_speech_is_muted = test_context.Mock(return_value=False)
122 speech_manager_mock.get_manager = test_context.Mock(return_value=speech_manager_instance)
123
124 speech_presenter_mock = essential_modules["orca.speech_presenter"]
125 speech_presenter_instance = test_context.Mock()
126 speech_presenter_instance.present_key_event = test_context.Mock()
127 speech_presenter_instance.speak_message = test_context.Mock()
128 speech_presenter_instance.speak_contents = test_context.Mock()
129 speech_presenter_instance.speak_character = test_context.Mock()
130 speech_presenter_instance.spell_item = test_context.Mock()
131 speech_presenter_instance.spell_phonetically = test_context.Mock()
132 speech_presenter_instance.get_messages_are_detailed = test_context.Mock(return_value=True)
133 speech_presenter_mock.get_presenter = test_context.Mock(
134 return_value=speech_presenter_instance,
135 )
136
137 typing_echo_presenter_mock = essential_modules["orca.typing_echo_presenter"]
138 typing_echo_instance = test_context.Mock()
139 typing_echo_instance.echo_keyboard_event = test_context.Mock()
140 typing_echo_presenter_mock.get_presenter = test_context.Mock(
141 return_value=typing_echo_instance,
142 )
143
144 script_manager_mock = essential_modules["orca.script_manager"]
145 mock_script = test_context.Mock()
146 speech_gen = test_context.Mock()
147 speech_gen.voice = test_context.Mock(return_value=[{"family": "default"}])
148 speech_gen.generate_contents = test_context.Mock(return_value=["generated speech"])
149 mock_script.get_speech_generator = test_context.Mock(return_value=speech_gen)
150
151 braille_gen = test_context.Mock()
152 braille_gen.generate_contents = test_context.Mock(
153 return_value=([test_context.Mock()], test_context.Mock()),
154 )
155 mock_script.get_braille_generator = test_context.Mock(return_value=braille_gen)
156 script_manager_instance = test_context.Mock()
157 script_manager_instance.get_active_script = test_context.Mock(return_value=mock_script)
158 script_manager_mock.get_manager = test_context.Mock(return_value=script_manager_instance)
159
160 return essential_modules
161
162 def test_get_manager_returns_singleton(self, test_context: OrcaTestContext) -> None:
163 """Test get_manager returns the same instance."""
164
165 self._setup_dependencies(test_context)
166 from orca.presentation_manager import get_manager
167
168 manager1 = get_manager()
169 manager2 = get_manager()
170
171 assert manager1 is manager2
172 assert manager1.__class__.__name__ == "PresentationManager"
173
174 def test_interrupt_presentation(self, test_context: OrcaTestContext) -> None:
175 """Test interrupt_presentation interrupts speech and braille."""
176
177 essential_modules = self._setup_dependencies(test_context)
178 from orca.presentation_manager import get_manager
179
180 manager = get_manager()
181 manager.interrupt_presentation()
182
183 speech_manager = essential_modules["orca.speech_manager"].get_manager()
184 speech_manager.interrupt_speech.assert_called_once()
185 braille_presenter = essential_modules["orca.braille_presenter"].get_presenter()
186 braille_presenter.kill_flash.assert_called_once()
187 live_region = essential_modules["orca.live_region_presenter"].get_presenter()
188 live_region.flush_messages.assert_called_once()
189
190 def test_interrupt_presentation_without_kill_flash(self, test_context: OrcaTestContext) -> None:
191 """Test interrupt_presentation with kill_flash=False."""
192
193 essential_modules = self._setup_dependencies(test_context)
194 from orca.presentation_manager import get_manager
195
196 manager = get_manager()
197 manager.interrupt_presentation(kill_flash=False)
198
199 speech_manager = essential_modules["orca.speech_manager"].get_manager()
200 speech_manager.interrupt_speech.assert_called_once()
201 essential_modules["orca.braille"].killFlash.assert_not_called()
202
203 def test_present_keyboard_event(self, test_context: OrcaTestContext) -> None:
204 """Test present_keyboard_event delegates to typing_echo_presenter."""
205
206 essential_modules = self._setup_dependencies(test_context)
207 from orca.presentation_manager import get_manager
208
209 manager = get_manager()
210 mock_event = test_context.Mock()
211
212 manager.present_keyboard_event(mock_event)
213
214 typing_echo = essential_modules["orca.typing_echo_presenter"].get_presenter()
215 typing_echo.echo_keyboard_event.assert_called_once_with(mock_event)
216
217 def test_present_key_event_delegates(self, test_context: OrcaTestContext) -> None:
218 """Test present_key_event delegates to speech_presenter."""
219
220 essential_modules = self._setup_dependencies(test_context)
221 from orca.presentation_manager import get_manager
222
223 manager = get_manager()
224 mock_event = test_context.Mock()
225 mock_event.get_key_name.return_value = "BackSpace"
226 manager.present_key_event(mock_event)
227
228 speech_pres = essential_modules["orca.speech_presenter"].get_presenter()
229 speech_pres.present_key_event.assert_called_once_with(mock_event)
230
231 def test_present_message_delegates_speech(self, test_context: OrcaTestContext) -> None:
232 """Test present_message delegates speech to speech_presenter."""
233
234 essential_modules = self._setup_dependencies(test_context)
235 from orca.presentation_manager import get_manager
236
237 manager = get_manager()
238 manager.present_message("This is a full message")
239
240 speech_pres = essential_modules["orca.speech_presenter"].get_presenter()
241 speech_pres.speak_message.assert_called_once_with(
242 "This is a full message",
243 )
244 braille_presenter = essential_modules["orca.braille_presenter"].get_presenter()
245 braille_presenter.present_message.assert_called()
246
247 def test_present_message_with_brief(self, test_context: OrcaTestContext) -> None:
248 """Test present_message uses full when messages_are_detailed is True."""
249
250 essential_modules = self._setup_dependencies(test_context)
251 from orca.presentation_manager import get_manager
252
253 manager = get_manager()
254 manager.present_message("Full message", brief="Brief")
255
256 speech_pres = essential_modules["orca.speech_presenter"].get_presenter()
257 speech_pres.speak_message.assert_called_once_with(
258 "Full message",
259 )
260
261 def test_present_message_empty_string(self, test_context: OrcaTestContext) -> None:
262 """Test present_message with empty string returns early."""
263
264 essential_modules = self._setup_dependencies(test_context)
265 from orca.presentation_manager import get_manager
266
267 manager = get_manager()
268 manager.present_message("")
269
270 speech_pres = essential_modules["orca.speech_presenter"].get_presenter()
271 speech_pres.speak_message.assert_not_called()
272 essential_modules["orca.braille"].displayMessage.assert_not_called()
273
274 def test_present_message_braille_disabled(self, test_context: OrcaTestContext) -> None:
275 """Test present_message when braille is disabled."""
276
277 essential_modules = self._setup_dependencies(test_context)
278 braille_presenter = essential_modules["orca.braille_presenter"].get_presenter()
279 braille_presenter.use_braille.return_value = False
280
281 from orca.presentation_manager import get_manager
282
283 manager = get_manager()
284 manager.present_message("Test message")
285
286 speech_pres = essential_modules["orca.speech_presenter"].get_presenter()
287 speech_pres.speak_message.assert_called()
288 essential_modules["orca.braille"].displayMessage.assert_not_called()
289
290 def test_present_message_uses_brief(self, test_context: OrcaTestContext) -> None:
291 """Test present_message uses brief when messages_are_detailed is False."""
292
293 essential_modules = self._setup_dependencies(test_context)
294 speech_pres = essential_modules["orca.speech_presenter"].get_presenter()
295 speech_pres.get_messages_are_detailed.return_value = False
296
297 from orca.presentation_manager import get_manager
298
299 manager = get_manager()
300 manager.present_message("Full message", brief="Brief")
301
302 speech_pres.speak_message.assert_called_once_with(
303 "Brief",
304 )
305
306 def test_present_message_speech_disabled(self, test_context: OrcaTestContext) -> None:
307 """Test present_message skips speech when speech is disabled."""
308
309 essential_modules = self._setup_dependencies(test_context)
310 speech_mgr = essential_modules["orca.speech_manager"].get_manager()
311 speech_mgr.get_speech_is_enabled_and_not_muted.return_value = False
312
313 from orca.presentation_manager import get_manager
314
315 manager = get_manager()
316 manager.present_message("Test message")
317
318 speech_pres = essential_modules["orca.speech_presenter"].get_presenter()
319 speech_pres.speak_message.assert_not_called()
320
321 def test_speak_message_muted(self, test_context: OrcaTestContext) -> None:
322 """Test speak_message skips speech when muted."""
323
324 essential_modules = self._setup_dependencies(test_context)
325 speech_mgr = essential_modules["orca.speech_manager"].get_manager()
326 speech_mgr.get_speech_is_muted.return_value = True
327
328 from orca.presentation_manager import get_manager
329
330 manager = get_manager()
331 manager.speak_message("Hello world")
332
333 speech_pres = essential_modules["orca.speech_presenter"].get_presenter()
334 speech_pres.speak_message.assert_not_called()
335
336 def test_speak_accessible_text_muted(self, test_context: OrcaTestContext) -> None:
337 """Test speak_accessible_text skips speech when muted."""
338
339 essential_modules = self._setup_dependencies(test_context)
340 speech_mgr = essential_modules["orca.speech_manager"].get_manager()
341 speech_mgr.get_speech_is_muted.return_value = True
342
343 from orca.presentation_manager import get_manager
344
345 manager = get_manager()
346 mock_obj = test_context.Mock()
347 manager.speak_accessible_text(mock_obj, "Hello")
348
349 speech_pres = essential_modules["orca.speech_presenter"].get_presenter()
350 speech_pres.speak_accessible_text.assert_not_called()
351
352 def test_play_sound(self, test_context: OrcaTestContext) -> None:
353 """Test play_sound delegates to sound_presenter."""
354
355 essential_modules = self._setup_dependencies(test_context)
356 from orca.presentation_manager import PresentationManager
357
358 mock_sound = test_context.Mock()
359 PresentationManager.play_sound(mock_sound)
360
361 sound_presenter = essential_modules["orca.sound_presenter"].get_presenter()
362 sound_presenter.play.assert_called_once_with(mock_sound, True)
363
364 def test_play_sound_no_interrupt(self, test_context: OrcaTestContext) -> None:
365 """Test play_sound with interrupt=False."""
366
367 essential_modules = self._setup_dependencies(test_context)
368 from orca.presentation_manager import PresentationManager
369
370 mock_sound = test_context.Mock()
371 PresentationManager.play_sound(mock_sound, interrupt=False)
372
373 sound_presenter = essential_modules["orca.sound_presenter"].get_presenter()
374 sound_presenter.play.assert_called_once_with(mock_sound, False)
375
376 def test_present_braille_message(self, test_context: OrcaTestContext) -> None:
377 """Test present_braille_message shows braille message."""
378
379 essential_modules = self._setup_dependencies(test_context)
380 from orca.presentation_manager import PresentationManager
381
382 PresentationManager.present_braille_message("Test braille", restore_previous=False)
383
384 braille_presenter = essential_modules["orca.braille_presenter"].get_presenter()
385 braille_presenter.present_message.assert_called_once_with(
386 "Test braille",
387 restore_previous=False,
388 )
389
390 def test_present_braille_message_braille_disabled(self, test_context: OrcaTestContext) -> None:
391 """Test present_braille_message delegates even when braille is disabled."""
392
393 essential_modules = self._setup_dependencies(test_context)
394 braille_presenter_instance = essential_modules["orca.braille_presenter"].get_presenter()
395 braille_presenter_instance.use_braille.return_value = False
396
397 from orca.presentation_manager import PresentationManager
398
399 PresentationManager.present_braille_message("Test braille")
400
401 braille_presenter_instance.present_message.assert_called_once()
402
403 def test_spell_item_delegates(self, test_context: OrcaTestContext) -> None:
404 """Test spell_item delegates to speech_presenter."""
405
406 essential_modules = self._setup_dependencies(test_context)
407 from orca.presentation_manager import get_manager
408
409 manager = get_manager()
410 manager.spell_item("abc")
411
412 speech_pres = essential_modules["orca.speech_presenter"].get_presenter()
413 speech_pres.spell_item.assert_called_once_with("abc")
414
415 def test_spell_phonetically_delegates(self, test_context: OrcaTestContext) -> None:
416 """Test spell_phonetically delegates to speech_presenter."""
417
418 essential_modules = self._setup_dependencies(test_context)
419 from orca.presentation_manager import get_manager
420
421 manager = get_manager()
422 manager.spell_phonetically("ab")
423
424 speech_pres = essential_modules["orca.speech_presenter"].get_presenter()
425 speech_pres.spell_phonetically.assert_called_once_with("ab")
426
427 def test_speak_character_delegates(self, test_context: OrcaTestContext) -> None:
428 """Test speak_character delegates to speech_presenter."""
429
430 essential_modules = self._setup_dependencies(test_context)
431 from orca.presentation_manager import get_manager
432
433 manager = get_manager()
434 manager.speak_character("a")
435
436 speech_pres = essential_modules["orca.speech_presenter"].get_presenter()
437 speech_pres.speak_character.assert_called_once_with(
438 "a",
439 voice_from="a",
440 cap_style=None,
441 obj=None,
442 )
443
444 def test_speak_message_delegates(self, test_context: OrcaTestContext) -> None:
445 """Test speak_message delegates to speech_presenter."""
446
447 essential_modules = self._setup_dependencies(test_context)
448 from orca.presentation_manager import get_manager
449
450 manager = get_manager()
451 manager.speak_message("Hello world")
452
453 speech_pres = essential_modules["orca.speech_presenter"].get_presenter()
454 speech_pres.speak_message.assert_called_once_with(
455 "Hello world",
456 )
457
458 def test_speak_contents_delegates(self, test_context: OrcaTestContext) -> None:
459 """Test speak_contents delegates to speech_presenter."""
460
461 essential_modules = self._setup_dependencies(test_context)
462 from orca.presentation_manager import get_manager
463
464 manager = get_manager()
465 mock_contents = [(test_context.Mock(), 0, 10, "test text")]
466 manager.speak_contents(mock_contents)
467
468 speech_pres = essential_modules["orca.speech_presenter"].get_presenter()
469 speech_pres.speak_contents.assert_called_once_with(mock_contents)
470
471 def test_speak_contents_with_kwargs_delegates(self, test_context: OrcaTestContext) -> None:
472 """Test speak_contents passes keyword arguments to speech_presenter."""
473
474 essential_modules = self._setup_dependencies(test_context)
475 from orca.presentation_manager import get_manager
476
477 manager = get_manager()
478 mock_contents = [(test_context.Mock(), 0, 10, "test text")]
479 mock_prior = test_context.Mock()
480 manager.speak_contents(mock_contents, priorObj=mock_prior)
481
482 speech_pres = essential_modules["orca.speech_presenter"].get_presenter()
483 speech_pres.speak_contents.assert_called_once_with(mock_contents, priorObj=mock_prior)
484
485 def test_display_contents(self, test_context: OrcaTestContext) -> None:
486 """Test display_contents delegates to braille presenter."""
487
488 essential_modules = self._setup_dependencies(test_context)
489
490 script_manager = essential_modules["orca.script_manager"].get_manager()
491 script = script_manager.get_active_script()
492
493 from orca.presentation_manager import get_manager
494
495 manager = get_manager()
496 mock_contents = [(test_context.Mock(), 0, 10, "test text")]
497 manager.display_contents(mock_contents)
498
499 braille_presenter_instance = essential_modules["orca.braille_presenter"].get_presenter()
500 braille_presenter_instance.display_generated_contents.assert_called_once_with(
501 script,
502 mock_contents,
503 )
504
505 def test_display_contents_braille_disabled(self, test_context: OrcaTestContext) -> None:
506 """Test display_contents still delegates to braille presenter (which checks internally)."""
507
508 essential_modules = self._setup_dependencies(test_context)
509
510 from orca.presentation_manager import get_manager
511
512 manager = get_manager()
513 mock_contents = [(test_context.Mock(), 0, 10, "test text")]
514 manager.display_contents(mock_contents)
515
516 braille_presenter_instance = essential_modules["orca.braille_presenter"].get_presenter()
517 braille_presenter_instance.display_generated_contents.assert_called_once()
518
519 def test_display_contents_no_active_script(self, test_context: OrcaTestContext) -> None:
520 """Test display_contents returns early when no active script."""
521
522 essential_modules = self._setup_dependencies(test_context)
523 script_manager = essential_modules["orca.script_manager"].get_manager()
524 script_manager.get_active_script.return_value = None
525
526 from orca.presentation_manager import get_manager
527
528 manager = get_manager()
529 mock_contents = [(test_context.Mock(), 0, 10, "test text")]
530 manager.display_contents(mock_contents)
531
532 braille_presenter_instance = essential_modules["orca.braille_presenter"].get_presenter()
533 braille_presenter_instance.display_generated_contents.assert_not_called()
534
535 def test_display_contents_empty_regions(self, test_context: OrcaTestContext) -> None:
536 """Test display_contents delegates even with empty contents."""
537
538 essential_modules = self._setup_dependencies(test_context)
539
540 from orca.presentation_manager import get_manager
541
542 manager = get_manager()
543 mock_contents: list = []
544 manager.display_contents(mock_contents)
545
546 braille_presenter_instance = essential_modules["orca.braille_presenter"].get_presenter()
547 braille_presenter_instance.display_generated_contents.assert_called_once()
548
549 @pytest.mark.parametrize(
550 "flash_enabled,use_braille,expected_flash_called",
551 [
552 pytest.param(True, True, True, id="flash_and_braille_enabled"),
553 pytest.param(False, True, False, id="flash_disabled"),
554 pytest.param(True, False, False, id="braille_disabled"),
555 pytest.param(False, False, False, id="both_disabled"),
556 ],
557 )
558 def test_present_message_braille_conditions(
559 self,
560 test_context: OrcaTestContext,
561 flash_enabled: bool,
562 use_braille: bool,
563 expected_flash_called: bool,
564 ) -> None:
565 """Test present_message braille behavior under various conditions."""
566
567 essential_modules = self._setup_dependencies(test_context)
568 braille_presenter_instance = essential_modules["orca.braille_presenter"].get_presenter()
569 braille_presenter_instance.use_braille.return_value = use_braille
570 braille_presenter_instance.get_flash_messages_are_enabled.return_value = flash_enabled
571
572 from orca.presentation_manager import get_manager
573
574 manager = get_manager()
575 manager.present_message("Test message")
576
577 if expected_flash_called:
578 braille_presenter_instance.present_message.assert_called()
579 else:
580 braille_presenter_instance.present_message.assert_not_called()