Debian Codegraph @

tests/unit_tests/test_speech_presenter.py

raw
1 # Unit tests for speech_presenter.py methods.
2 #
3 # Copyright 2025 Igalia, S.L.
4 # Author: Joanmarie Diggs <[email protected]>
5 #
6 # This library is free software; you can redistribute it and/or
7 # modify it under the terms of the GNU Lesser General Public
8 # License as published by the Free Software Foundation; either
9 # version 2.1 of the License, or (at your option) any later version.
10 #
11 # This library is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 # Lesser General Public License for more details.
15 #
16 # You should have received a copy of the GNU Lesser General Public
17 # License along with this library; if not, write to the
18 # Free Software Foundation, Inc., Franklin Street, Fifth Floor,
19 # Boston MA 02110-1301 USA.
20
21 # pylint: disable=wrong-import-position
22 # pylint: disable=import-outside-toplevel
23 # pylint: disable=too-many-public-methods
24 # pylint: disable=too-many-statements
25 # pylint: disable=too-many-lines
26 # pylint: disable=protected-access
27 # pylint: disable=too-many-arguments
28 # pylint: disable=too-many-positional-arguments
29 # pylint: disable=too-many-locals
30
31 """Unit tests for speech_presenter.py methods."""
32
33 from __future__ import annotations
34
35 from typing import TYPE_CHECKING
36
37 import pytest
38
39 if TYPE_CHECKING:
40 from unittest.mock import MagicMock
41
42 from .orca_test_context import OrcaTestContext
43
44
45 @pytest.mark.unit
46 class TestSpeechPresenter:
47 """Test SpeechPresenter class methods."""
48
49 def _setup_dependencies(self, test_context: OrcaTestContext) -> dict[str, MagicMock]:
50 """Set up mocks for speech_presenter dependencies."""
51
52 additional_modules = [
53 "orca.document_presenter",
54 "orca.mathsymbols",
55 "orca.object_properties",
56 "orca.phonnames",
57 "orca.pronunciation_dictionary_manager",
58 "orca.ax_hypertext",
59 "orca.ax_table",
60 "orca.ax_text",
61 "orca.ax_utilities",
62 "orca.ax_document",
63 "orca.presentation_manager",
64 "orca.preferences_grid_base",
65 "orca.speech",
66 "orca.speech_manager",
67 "orca.speech_monitor",
68 ]
69 essential_modules = test_context.setup_shared_dependencies(additional_modules)
70
71 document_presenter_mock = essential_modules["orca.document_presenter"]
72 document_presenter_instance = test_context.Mock()
73 document_presenter_instance.get_in_focus_mode = test_context.Mock(return_value=False)
74 document_presenter_mock.get_presenter = test_context.Mock(
75 return_value=document_presenter_instance,
76 )
77
78 dbus_service_mock = essential_modules["orca.dbus_service"]
79 dbus_service_mock.get_remote_controller.return_value = test_context.Mock()
80
81 def passthrough_decorator(func):
82 return func
83
84 dbus_service_mock.getter = passthrough_decorator
85 dbus_service_mock.setter = passthrough_decorator
86 dbus_service_mock.command = passthrough_decorator
87 dbus_service_mock.parameterized_command = passthrough_decorator
88
89 debug_mock = essential_modules["orca.debug"]
90 debug_mock.print_message.return_value = None
91 debug_mock.print_tokens.return_value = None
92 debug_mock.LEVEL_INFO = 800
93 debug_mock.LEVEL_WARNING = 900
94
95 ax_hypertext_mock = essential_modules["orca.ax_hypertext"]
96 ax_hypertext_mock.AXHypertext = test_context.Mock()
97 ax_hypertext_mock.AXHypertext.get_all_links_in_range = test_context.Mock(return_value=[])
98 ax_hypertext_mock.AXHypertext.get_link_end_offset = test_context.Mock(return_value=0)
99
100 ax_object_mock = essential_modules["orca.ax_object"]
101 ax_object_mock.AXObject = test_context.Mock()
102
103 ax_text_mock = essential_modules["orca.ax_text"]
104 ax_text_mock.AXText = test_context.Mock()
105 ax_text_mock.AXText.get_character_at_offset = test_context.Mock(return_value=("a", 0))
106
107 ax_utilities_mock = essential_modules["orca.ax_utilities"]
108 ax_utilities_mock.AXUtilities = test_context.Mock()
109 ax_utilities_mock.AXUtilities.find_ancestor_inclusive = test_context.Mock(return_value=None)
110 ax_utilities_mock.AXUtilities.string_has_spelling_error = test_context.Mock(
111 return_value=False,
112 )
113 ax_utilities_mock.AXUtilities.string_has_grammar_error = test_context.Mock(
114 return_value=False,
115 )
116 ax_utilities_mock.AXUtilities.get_table = test_context.Mock(return_value=None)
117 ax_utilities_mock.AXUtilities.is_math_related = test_context.Mock(return_value=False)
118 ax_utilities_mock.AXUtilities.is_text_input_telephone = test_context.Mock(
119 return_value=False,
120 )
121 ax_utilities_mock.AXUtilities.is_code = test_context.Mock(return_value=False)
122
123 ax_document_mock = essential_modules["orca.ax_document"]
124 ax_document_mock.AXDocument = test_context.Mock()
125 ax_document_mock.AXDocument.is_plain_text = test_context.Mock(return_value=False)
126
127 mathsymbols_mock = essential_modules["orca.mathsymbols"]
128 mathsymbols_mock.adjust_for_speech = test_context.Mock(side_effect=lambda x: x)
129
130 object_properties_mock = essential_modules["orca.object_properties"]
131 object_properties_mock.STATE_INVALID_GRAMMAR_SPEECH = "grammar error"
132
133 pronunciation_dict_mock = essential_modules["orca.pronunciation_dictionary_manager"]
134 pron_manager_instance = test_context.Mock()
135 pron_manager_instance.get_pronunciation = test_context.Mock(side_effect=lambda x: x)
136 pronunciation_dict_mock.get_manager = test_context.Mock(return_value=pron_manager_instance)
137
138 from orca import gsettings_registry
139
140 gsettings_registry.get_registry().clear_runtime_values()
141
142 orca_i18n_mock = essential_modules["orca.orca_i18n"]
143 orca_i18n_mock._ = lambda x: x
144 orca_i18n_mock.C_ = lambda c, x: x
145 orca_i18n_mock.ngettext = lambda s, p, n: s if n == 1 else p
146
147 messages_mock = essential_modules["orca.messages"]
148 messages_mock.LINK = "link"
149 messages_mock.MISSPELLED = "misspelled"
150 messages_mock.repeated_char_count = test_context.Mock(
151 side_effect=lambda char, count: f"{char} repeated {count} times",
152 )
153 messages_mock.spaces_count = test_context.Mock(side_effect=lambda count: f"{count} spaces")
154 messages_mock.tabs_count = test_context.Mock(side_effect=lambda count: f"{count} tabs")
155
156 return essential_modules
157
158 def test_init(self, test_context: OrcaTestContext) -> None:
159 """Test presenter initialization and D-Bus registration."""
160
161 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
162 from orca.speech_presenter import SpeechPresenter
163
164 presenter = SpeechPresenter()
165
166 # Verify D-Bus registration occurred
167 controller = essential_modules["orca.dbus_service"].get_remote_controller()
168 controller.register_decorated_module.assert_called_with("SpeechPresenter", presenter)
169
170 # Monitor callbacks are not registered in __init__ (deferred to set_up_commands
171 # to avoid circular imports during module loading).
172
173 def test_set_up_commands(self, test_context: OrcaTestContext) -> None:
174 """Test that set_up_commands registers commands in CommandManager."""
175
176 self._setup_dependencies(test_context)
177 from orca import command_manager
178 from orca.speech_presenter import SpeechPresenter
179
180 presenter = SpeechPresenter()
181 presenter.set_up_commands()
182
183 # Verify commands are registered in CommandManager
184 cmd_manager = command_manager.get_manager()
185 assert cmd_manager.get_command("changeNumberStyleHandler") is not None
186 assert cmd_manager.get_command("toggleSpeechVerbosityHandler") is not None
187 assert cmd_manager.get_command("toggleSpeakingIndentationJustificationHandler") is not None
188 assert cmd_manager.get_command("toggleTableCellReadModeHandler") is not None
189
190 def test_set_up_commands_registers_monitor_callbacks(
191 self,
192 test_context: OrcaTestContext,
193 ) -> None:
194 """Test that set_up_commands registers speech monitor callbacks."""
195
196 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
197 from orca.speech_presenter import SpeechPresenter
198
199 presenter = SpeechPresenter()
200 speech_mock = essential_modules["orca.speech"]
201 speech_mock.set_monitor_callbacks.reset_mock()
202
203 presenter.set_up_commands()
204
205 speech_mock.set_monitor_callbacks.assert_called_once_with(
206 write_text=presenter.write_to_monitor,
207 write_key=presenter.write_key_to_monitor,
208 begin_group=presenter._begin_monitor_group,
209 end_group=presenter._end_monitor_group,
210 )
211
212 @pytest.mark.parametrize(
213 "case",
214 [
215 {"id": "verbose_true", "setting_value": 1, "expected": True},
216 {"id": "verbose_false", "setting_value": 0, "expected": False},
217 ],
218 ids=lambda case: case["id"],
219 )
220 def test_use_verbose_speech(self, test_context: OrcaTestContext, case: dict) -> None:
221 """Test use_verbose_speech method."""
222
223 self._setup_dependencies(test_context)
224
225 from orca import gsettings_registry
226 from orca.speech_presenter import SpeechPresenter
227
228 presenter = SpeechPresenter()
229 nick = "verbose" if case["setting_value"] == 1 else "brief"
230 gsettings_registry.get_registry().set_runtime_value("speech", "verbosity-level", nick)
231
232 result = presenter.use_verbose_speech()
233 assert result == case["expected"]
234
235 @pytest.mark.parametrize(
236 "case",
237 [
238 {"id": "verbosity_brief", "setting_value": 0, "expected": "brief"},
239 {"id": "verbosity_verbose", "setting_value": 1, "expected": "verbose"},
240 ],
241 ids=lambda case: case["id"],
242 )
243 def test_get_verbosity_level(self, test_context: OrcaTestContext, case: dict) -> None:
244 """Test get_verbosity_level method."""
245
246 self._setup_dependencies(test_context)
247
248 from orca import gsettings_registry
249 from orca.speech_presenter import SpeechPresenter
250
251 presenter = SpeechPresenter()
252 nick = "verbose" if case["setting_value"] == 1 else "brief"
253 gsettings_registry.get_registry().set_runtime_value("speech", "verbosity-level", nick)
254
255 result = presenter.get_verbosity_level()
256 assert result == case["expected"]
257
258 @pytest.mark.parametrize(
259 "case",
260 [
261 {
262 "id": "set_verbosity_brief",
263 "input_value": "brief",
264 "expected": True,
265 },
266 {
267 "id": "set_verbosity_verbose",
268 "input_value": "verbose",
269 "expected": True,
270 },
271 {
272 "id": "set_verbosity_invalid",
273 "input_value": "invalid",
274 "expected": False,
275 },
276 ],
277 ids=lambda case: case["id"],
278 )
279 def test_set_verbosity_level(self, test_context: OrcaTestContext, case: dict) -> None:
280 """Test set_verbosity_level method."""
281
282 self._setup_dependencies(test_context)
283
284 from orca.speech_presenter import SpeechPresenter
285
286 presenter = SpeechPresenter()
287
288 result = presenter.set_verbosity_level(case["input_value"])
289 assert result == case["expected"]
290
291 if case["expected"]:
292 assert presenter.get_verbosity_level() == case["input_value"]
293
294 @pytest.mark.parametrize(
295 "case",
296 [
297 {"id": "speak_blank_lines_true", "setting_value": True, "expected": True},
298 {"id": "speak_blank_lines_false", "setting_value": False, "expected": False},
299 ],
300 ids=lambda case: case["id"],
301 )
302 def test_get_speak_blank_lines(self, test_context: OrcaTestContext, case: dict) -> None:
303 """Test get_speak_blank_lines method."""
304
305 self._setup_dependencies(test_context)
306
307 from orca import gsettings_registry
308 from orca.speech_presenter import SpeechPresenter
309
310 presenter = SpeechPresenter()
311 gsettings_registry.get_registry().set_runtime_value(
312 "speech",
313 "speak-blank-lines",
314 case["setting_value"],
315 )
316
317 result = presenter.get_speak_blank_lines()
318 assert result == case["expected"]
319
320 @pytest.mark.parametrize(
321 "case",
322 [
323 {"id": "only_speak_displayed_true", "setting_value": True, "expected": True},
324 {"id": "only_speak_displayed_false", "setting_value": False, "expected": False},
325 ],
326 ids=lambda case: case["id"],
327 )
328 def test_get_only_speak_displayed_text(self, test_context: OrcaTestContext, case: dict) -> None:
329 """Test get_only_speak_displayed_text method."""
330
331 self._setup_dependencies(test_context)
332
333 from orca import gsettings_registry
334 from orca.speech_presenter import SpeechPresenter
335
336 presenter = SpeechPresenter()
337 gsettings_registry.get_registry().set_runtime_value(
338 "speech",
339 "only-speak-displayed-text",
340 case["setting_value"],
341 )
342
343 result = presenter.get_only_speak_displayed_text()
344 assert result == case["expected"]
345
346 @pytest.mark.parametrize(
347 "case",
348 [
349 {"id": "set_only_speak_displayed_true", "input_value": True, "expected": True},
350 {"id": "set_only_speak_displayed_false", "input_value": False, "expected": True},
351 ],
352 ids=lambda case: case["id"],
353 )
354 def test_set_only_speak_displayed_text(self, test_context: OrcaTestContext, case: dict) -> None:
355 """Test set_only_speak_displayed_text method."""
356
357 self._setup_dependencies(test_context)
358
359 from orca.speech_presenter import SpeechPresenter
360
361 presenter = SpeechPresenter()
362
363 result = presenter.set_only_speak_displayed_text(case["input_value"])
364 assert result == case["expected"]
365 assert presenter.get_only_speak_displayed_text() == case["input_value"]
366
367 @pytest.mark.parametrize(
368 "case",
369 [
370 {"id": "speak_indentation_true", "setting_value": True, "expected": True},
371 {"id": "speak_indentation_false", "setting_value": False, "expected": False},
372 ],
373 ids=lambda case: case["id"],
374 )
375 def test_get_speak_indentation_and_justification(
376 self,
377 test_context: OrcaTestContext,
378 case: dict,
379 ) -> None:
380 """Test get_speak_indentation_and_justification method."""
381
382 self._setup_dependencies(test_context)
383
384 from orca import gsettings_registry
385 from orca.speech_presenter import SpeechPresenter
386
387 presenter = SpeechPresenter()
388 gsettings_registry.get_registry().set_runtime_value(
389 "speech",
390 "speak-indentation-and-justification",
391 case["setting_value"],
392 )
393
394 result = presenter.get_speak_indentation_and_justification()
395 assert result == case["expected"]
396
397 @pytest.mark.parametrize(
398 "case",
399 [
400 {"id": "set_speak_indentation_true", "input_value": True, "expected": True},
401 {"id": "set_speak_indentation_false", "input_value": False, "expected": True},
402 ],
403 ids=lambda case: case["id"],
404 )
405 def test_set_speak_indentation_and_justification(
406 self,
407 test_context: OrcaTestContext,
408 case: dict,
409 ) -> None:
410 """Test set_speak_indentation_and_justification method."""
411
412 self._setup_dependencies(test_context)
413
414 from orca.speech_presenter import SpeechPresenter
415
416 presenter = SpeechPresenter()
417
418 result = presenter.set_speak_indentation_and_justification(case["input_value"])
419 assert result == case["expected"]
420 assert presenter.get_speak_indentation_and_justification() == case["input_value"]
421
422 def test_get_indentation_description_disabled(self, test_context: OrcaTestContext) -> None:
423 """Test get_indentation_description method when disabled."""
424
425 self._setup_dependencies(test_context)
426
427 from orca import gsettings_registry
428 from orca.speech_presenter import SpeechPresenter
429
430 registry = gsettings_registry.get_registry()
431 registry.set_runtime_value("speech", "only-speak-displayed-text", True)
432 registry.set_runtime_value("speech", "speak-indentation-and-justification", False)
433
434 presenter = SpeechPresenter()
435 line = " Hello world"
436 result = presenter.get_indentation_description(line)
437 assert result == ""
438
439 def test_get_indentation_description_enabled(self, test_context: OrcaTestContext) -> None:
440 """Test get_indentation_description method when enabled."""
441
442 self._setup_dependencies(test_context)
443
444 from orca import gsettings_registry
445 from orca.speech_presenter import SpeechPresenter
446
447 registry = gsettings_registry.get_registry()
448 registry.set_runtime_value("speech", "only-speak-displayed-text", False)
449 registry.set_runtime_value("speech", "speak-indentation-and-justification", True)
450 registry.set_runtime_value("speech", "speak-indentation-only-if-changed", False)
451
452 presenter = SpeechPresenter()
453 line = " Hello world"
454 result = presenter.get_indentation_description(line)
455 assert result != ""
456
457 def test_get_indentation_description_only_if_changed(
458 self,
459 test_context: OrcaTestContext,
460 ) -> None:
461 """Test get_indentation_description with only-if-changed enabled."""
462
463 self._setup_dependencies(test_context)
464
465 from orca import gsettings_registry
466 from orca.speech_presenter import SpeechPresenter
467
468 registry = gsettings_registry.get_registry()
469 registry.set_runtime_value("speech", "only-speak-displayed-text", False)
470 registry.set_runtime_value("speech", "speak-indentation-and-justification", True)
471 registry.set_runtime_value("speech", "speak-indentation-only-if-changed", True)
472
473 presenter = SpeechPresenter()
474 line = " Hello world"
475
476 # First call should return a description
477 result1 = presenter.get_indentation_description(line)
478 assert result1 != ""
479
480 # Second call with same indentation should return empty
481 result2 = presenter.get_indentation_description(line)
482 assert result2 == ""
483
484 def test_get_error_description_basic(self, test_context: OrcaTestContext) -> None:
485 """Test get_error_description method with basic scenarios."""
486
487 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
488
489 ax_text_mock = essential_modules["orca.ax_text"]
490 ax_text_mock.AXText.get_character_at_offset = test_context.Mock(return_value=("a", 0))
491 ax_utilities_mock = essential_modules["orca.ax_utilities"]
492 ax_utilities_mock.AXUtilities.string_has_spelling_error = test_context.Mock(
493 return_value=True,
494 )
495 ax_utilities_mock.AXUtilities.string_has_grammar_error = test_context.Mock(
496 return_value=False,
497 )
498
499 from orca.speech_presenter import SpeechPresenter
500
501 presenter = SpeechPresenter()
502 mock_obj = test_context.Mock()
503 result = presenter.get_error_description(mock_obj, 0)
504 assert result == "misspelled"
505
506 def test_get_error_description_disabled(self, test_context: OrcaTestContext) -> None:
507 """Test get_error_description method when misspelled indicator is disabled."""
508
509 self._setup_dependencies(test_context)
510
511 from orca import gsettings_registry
512 from orca.speech_presenter import SpeechPresenter
513
514 gsettings_registry.get_registry().set_runtime_value(
515 "speech",
516 "speak-misspelled-indicator",
517 False,
518 )
519
520 presenter = SpeechPresenter()
521 mock_obj = test_context.Mock()
522 result = presenter.get_error_description(mock_obj, 0)
523 assert result == ""
524
525 def test_adjust_for_presentation(self, test_context: OrcaTestContext) -> None:
526 """Test adjust_for_presentation with all sub-adjustments mocked."""
527
528 self._setup_dependencies(test_context)
529 from orca.speech_presenter import SpeechPresenter
530
531 presenter = SpeechPresenter()
532 return_text = "Hello world"
533
534 test_context.patch_object(presenter, "_adjust_for_links", return_value=return_text)
535 test_context.patch_object(presenter, "adjust_for_digits", return_value=return_text)
536 test_context.patch_object(presenter, "_adjust_for_repeats", return_value=return_text)
537 test_context.patch_object(
538 presenter,
539 "_adjust_for_verbalized_punctuation",
540 return_value=return_text,
541 )
542 test_context.patch_object(
543 presenter,
544 "_apply_pronunciation_dictionary",
545 return_value=return_text,
546 )
547
548 mock_obj = test_context.Mock()
549 result = presenter.adjust_for_presentation(mock_obj, "Hello world", start_offset=0)
550 assert result == return_text
551
552 @pytest.mark.parametrize(
553 "case",
554 [
555 {
556 "id": "digits_on",
557 "speak_digits": True,
558 "is_telephone": False,
559 "input_text": "123 Main",
560 "expected": "1 2 3 Main",
561 },
562 {
563 "id": "digits_off",
564 "speak_digits": False,
565 "is_telephone": False,
566 "input_text": "123 Main",
567 "expected": "123 Main",
568 },
569 {
570 "id": "telephone_field",
571 "speak_digits": False,
572 "is_telephone": True,
573 "input_text": "555",
574 "expected": "5 5 5",
575 },
576 ],
577 ids=lambda case: case["id"],
578 )
579 def test_adjust_for_digits(self, test_context: OrcaTestContext, case: dict) -> None:
580 """Test adjust_for_digits method with speakNumbersAsDigits on/off."""
581
582 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
583
584 from orca import gsettings_registry
585
586 gsettings_registry.get_registry().set_runtime_value(
587 "speech",
588 "speak-numbers-as-digits",
589 case["speak_digits"],
590 )
591
592 essential_modules[
593 "orca.ax_utilities"
594 ].AXUtilities.is_text_input_telephone = test_context.Mock(return_value=case["is_telephone"])
595
596 from orca.speech_presenter import SpeechPresenter
597
598 mock_obj = test_context.Mock()
599 result = SpeechPresenter.adjust_for_digits(mock_obj, case["input_text"])
600 assert result == case["expected"]
601
602 def test_adjust_for_repeats(self, test_context: OrcaTestContext) -> None:
603 """Test _adjust_for_repeats with repeated characters."""
604
605 self._setup_dependencies(test_context)
606
607 from orca.speech_presenter import SpeechPresenter
608
609 presenter = SpeechPresenter()
610 text = "----"
611 result = presenter._adjust_for_repeats(text)
612 # Should describe repeated characters
613 assert "repeated" in result or result != text
614
615 def test_adjust_for_repeats_short_text(self, test_context: OrcaTestContext) -> None:
616 """Test _adjust_for_repeats with text shorter than limit."""
617
618 self._setup_dependencies(test_context)
619
620 from orca.speech_presenter import SpeechPresenter
621
622 presenter = SpeechPresenter()
623 text = "hi"
624 result = presenter._adjust_for_repeats(text)
625 # Short text should be returned unchanged
626 assert result == text
627
628 def test_get_speech_preferences(self, test_context: OrcaTestContext) -> None:
629 """Test get_speech_preferences returns correct tuple structure."""
630
631 self._setup_dependencies(test_context)
632 from orca.speech_presenter import SpeechPresenter
633
634 presenter = SpeechPresenter()
635 result = presenter.get_speech_preferences()
636
637 assert isinstance(result, tuple)
638 assert len(result) == 3
639
640 general, object_details, announcements = result
641
642 # general should have 1 preference
643 assert len(general) == 1
644 assert general[0].prefs_key == "messages-are-detailed"
645
646 # object_details should have 5 preferences
647 assert len(object_details) == 5
648 assert object_details[0].prefs_key == "only-speak-displayed-text"
649
650 # announcements should have 6 preferences
651 assert len(announcements) == 6
652 assert announcements[0].prefs_key == "announce-blockquote"
653
654 def test_apply_speech_preferences(self, test_context: OrcaTestContext) -> None:
655 """Test apply_speech_preferences applies values correctly."""
656
657 self._setup_dependencies(test_context)
658 from orca.speech_presenter import SpeechPreference, SpeechPresenter
659
660 presenter = SpeechPresenter()
661
662 mock_setter1 = test_context.Mock(return_value=True)
663 mock_setter2 = test_context.Mock(return_value=True)
664 pref1 = SpeechPreference("key1", "Label 1", lambda: True, mock_setter1)
665 pref2 = SpeechPreference("key2", "Label 2", lambda: False, mock_setter2)
666
667 updates = [(pref1, False), (pref2, True)]
668 result = presenter.apply_speech_preferences(updates)
669
670 assert result == {"key1": False, "key2": True}
671 mock_setter1.assert_called_once_with(False)
672 mock_setter2.assert_called_once_with(True)
673
674 def test_toggle_indentation_and_justification(self, test_context: OrcaTestContext) -> None:
675 """Test toggle_indentation_and_justification method."""
676
677 self._setup_dependencies(test_context)
678 from orca.speech_presenter import SpeechPresenter
679
680 presenter = SpeechPresenter()
681 result = presenter.toggle_indentation_and_justification()
682 assert result is True
683
684 def test_change_number_style(self, test_context: OrcaTestContext) -> None:
685 """Test change_number_style method."""
686
687 self._setup_dependencies(test_context)
688 from orca.speech_presenter import SpeechPresenter
689
690 presenter = SpeechPresenter()
691 result = presenter.change_number_style()
692 assert result is True
693
694 def test_should_verbalize_punctuation_false(self, test_context: OrcaTestContext) -> None:
695 """Test _should_verbalize_punctuation static method returns False."""
696
697 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
698 from orca.speech_presenter import SpeechPresenter
699
700 essential_modules[
701 "orca.ax_utilities"
702 ].AXUtilities.find_ancestor_inclusive.return_value = None
703 mock_obj = test_context.Mock()
704 result = SpeechPresenter._should_verbalize_punctuation(mock_obj)
705 assert result is False
706
707 def test_should_verbalize_punctuation_true(self, test_context: OrcaTestContext) -> None:
708 """Test _should_verbalize_punctuation static method returns True."""
709
710 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
711 from orca.speech_presenter import SpeechPresenter
712
713 mock_code_obj = test_context.Mock()
714 (
715 essential_modules["orca.ax_utilities"].AXUtilities.find_ancestor_inclusive.return_value
716 ) = mock_code_obj
717 essential_modules["orca.ax_document"].AXDocument.is_plain_text.return_value = False
718 mock_obj = test_context.Mock()
719 result = SpeechPresenter._should_verbalize_punctuation(mock_obj)
720 assert result is True
721
722 def test_adjust_for_verbalized_punctuation(self, test_context: OrcaTestContext) -> None:
723 """Test _adjust_for_verbalized_punctuation static method."""
724
725 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
726 from orca.speech_presenter import SpeechPresenter
727
728 mock_code_obj = test_context.Mock()
729 (
730 essential_modules["orca.ax_utilities"].AXUtilities.find_ancestor_inclusive.return_value
731 ) = mock_code_obj
732 essential_modules["orca.ax_document"].AXDocument.is_plain_text.return_value = False
733 mock_obj = test_context.Mock()
734 text = "Hello, world! How are you?"
735 result = SpeechPresenter._adjust_for_verbalized_punctuation(mock_obj, text)
736
737 expected = "Hello , world ! How are you ? "
738 assert result == expected
739
740 @pytest.mark.parametrize(
741 "case",
742 [
743 {"id": "set_speak_blank_lines_true", "input_value": True, "expected": True},
744 {"id": "set_speak_blank_lines_false", "input_value": False, "expected": True},
745 ],
746 ids=lambda case: case["id"],
747 )
748 def test_set_speak_blank_lines(self, test_context: OrcaTestContext, case: dict) -> None:
749 """Test set_speak_blank_lines method."""
750
751 self._setup_dependencies(test_context)
752
753 from orca.speech_presenter import SpeechPresenter
754
755 presenter = SpeechPresenter()
756
757 result = presenter.set_speak_blank_lines(case["input_value"])
758 assert result == case["expected"]
759 assert presenter.get_speak_blank_lines() == case["input_value"]
760
761 def test_get_presenter_singleton(self, test_context: OrcaTestContext) -> None:
762 """Test get_presenter function returns the same instance."""
763
764 self._setup_dependencies(test_context)
765 from orca import speech_presenter
766
767 presenter1 = speech_presenter.get_presenter()
768 presenter2 = speech_presenter.get_presenter()
769
770 assert presenter1 is presenter2
771 assert isinstance(presenter1, speech_presenter.SpeechPresenter)
772
773 def _setup_speech_output_dependencies(
774 self,
775 test_context: OrcaTestContext,
776 ) -> dict[str, MagicMock]:
777 """Set up additional mocks needed for speech output method testing."""
778
779 essential_modules = self._setup_dependencies(test_context)
780
781 # Add speech module mock
782 speech_mock = essential_modules["orca.speech"]
783 speech_mock.speak = test_context.Mock()
784 speech_mock.speak_character = test_context.Mock()
785 speech_mock.speak_key_event = test_context.Mock()
786
787 # Add phonnames module mock
788 phonnames_mock = essential_modules["orca.phonnames"]
789 phonnames_mock.get_phonetic_name = test_context.Mock(side_effect=lambda c: f"phonetic_{c}")
790
791 # Add speech_manager mock
792 speech_manager_mock = essential_modules["orca.speech_manager"]
793 speech_manager_instance = test_context.Mock()
794 speech_manager_instance.get_speech_is_muted = test_context.Mock(return_value=False)
795 speech_manager_instance.get_speech_is_enabled_and_not_muted = test_context.Mock(
796 return_value=True,
797 )
798 speech_manager_instance.get_capitalization_style = test_context.Mock(return_value="icon")
799 speech_manager_instance.set_capitalization_style = test_context.Mock()
800 speech_manager_instance.get_punctuation_level = test_context.Mock(return_value="all")
801 speech_manager_instance.set_punctuation_level = test_context.Mock()
802 speech_manager_mock.get_manager = test_context.Mock(return_value=speech_manager_instance)
803
804 # Add script_manager mock for _get_active_script / _get_voice
805 script_manager_mock = essential_modules["orca.script_manager"]
806 mock_script = test_context.Mock()
807 speech_gen = test_context.Mock()
808 speech_gen.voice = test_context.Mock(return_value=[{"family": "default"}])
809 speech_gen.generate_contents = test_context.Mock(return_value=["generated speech"])
810 mock_script.get_speech_generator = test_context.Mock(return_value=speech_gen)
811 script_manager_instance = test_context.Mock()
812 script_manager_instance.get_active_script = test_context.Mock(return_value=mock_script)
813 script_manager_mock.get_manager = test_context.Mock(return_value=script_manager_instance)
814
815 return essential_modules
816
817 def test_get_voice_with_active_script(self, test_context: OrcaTestContext) -> None:
818 """Test _get_voice returns voice from active script."""
819
820 essential_modules = self._setup_speech_output_dependencies(test_context)
821 from orca.speech_presenter import SpeechPresenter
822
823 presenter = SpeechPresenter()
824 voice = presenter._get_voice(text="test")
825
826 script_manager = essential_modules["orca.script_manager"].get_manager()
827 script = script_manager.get_active_script()
828 script.get_speech_generator().voice.assert_called_once()
829 kwargs = script.get_speech_generator().voice.call_args.kwargs
830 assert kwargs["obj"] is None
831 assert kwargs["string"] == "test"
832 assert kwargs["context"].in_preferences_window is False
833 assert voice == [{"family": "default"}]
834
835 def test_get_voice_no_active_script(self, test_context: OrcaTestContext) -> None:
836 """Test _get_voice returns empty list when no active script."""
837
838 essential_modules = self._setup_speech_output_dependencies(test_context)
839 script_manager = essential_modules["orca.script_manager"].get_manager()
840 script_manager.get_active_script.return_value = None
841
842 from orca.speech_presenter import SpeechPresenter
843
844 presenter = SpeechPresenter()
845 voice = presenter._get_voice(text="test")
846
847 assert voice == []
848
849 def test_speak_message(self, test_context: OrcaTestContext) -> None:
850 """Test speak_message speaks text via speech module."""
851
852 essential_modules = self._setup_speech_output_dependencies(test_context)
853 from orca.speech_presenter import SpeechPresenter
854
855 presenter = SpeechPresenter()
856 presenter.speak_message("Hello world")
857
858 essential_modules["orca.speech"].speak.assert_called()
859
860 def test_speak_message_non_string(self, test_context: OrcaTestContext) -> None:
861 """Test speak_message with non-string returns early."""
862
863 essential_modules = self._setup_speech_output_dependencies(test_context)
864 from orca.speech_presenter import SpeechPresenter
865
866 presenter = SpeechPresenter()
867 presenter.speak_message(123) # type: ignore
868
869 essential_modules["orca.debug"].print_exception.assert_called()
870 essential_modules["orca.speech"].speak.assert_not_called()
871
872 def test_speak_message_only_displayed_text(self, test_context: OrcaTestContext) -> None:
873 """Test speak_message when only_speak_displayed_text is true."""
874
875 essential_modules = self._setup_speech_output_dependencies(test_context)
876
877 from orca import gsettings_registry
878 from orca.speech_presenter import SpeechPresenter
879
880 gsettings_registry.get_registry().set_runtime_value(
881 "speech",
882 "only-speak-displayed-text",
883 True,
884 )
885
886 presenter = SpeechPresenter()
887 presenter.speak_message("Hello world")
888
889 essential_modules["orca.speech"].speak.assert_not_called()
890
891 def test_speak_character(self, test_context: OrcaTestContext) -> None:
892 """Test speak_character speaks a single character."""
893
894 essential_modules = self._setup_speech_output_dependencies(test_context)
895 from orca.speech_presenter import SpeechPresenter
896
897 presenter = SpeechPresenter()
898 presenter.speak_character("a")
899
900 essential_modules["orca.speech"].speak_character.assert_called_once()
901
902 def test_spell_item(self, test_context: OrcaTestContext) -> None:
903 """Test spell_item speaks each character."""
904
905 essential_modules = self._setup_speech_output_dependencies(test_context)
906 from orca.speech_presenter import SpeechPresenter
907
908 presenter = SpeechPresenter()
909 presenter.spell_item("abc")
910
911 assert essential_modules["orca.speech"].speak_character.call_count == 3
912
913 def test_spell_phonetically(self, test_context: OrcaTestContext) -> None:
914 """Test spell_phonetically speaks phonetic names."""
915
916 essential_modules = self._setup_speech_output_dependencies(test_context)
917 from orca.speech_presenter import SpeechPresenter
918
919 presenter = SpeechPresenter()
920 presenter.spell_phonetically("ab")
921
922 essential_modules["orca.phonnames"].get_phonetic_name.assert_called()
923 assert essential_modules["orca.speech"].speak.call_count >= 2
924
925 def test_speak_contents(self, test_context: OrcaTestContext) -> None:
926 """Test speak_contents generates and speaks contents."""
927
928 essential_modules = self._setup_speech_output_dependencies(test_context)
929 from orca.speech_presenter import SpeechPresenter
930
931 presenter = SpeechPresenter()
932 mock_contents = [(test_context.Mock(), 0, 10, "test text")]
933 presenter.speak_contents(mock_contents)
934
935 script_manager = essential_modules["orca.script_manager"].get_manager()
936 script = script_manager.get_active_script()
937 script.get_speech_generator().generate_contents.assert_called_once()
938 essential_modules["orca.speech"].speak.assert_called()
939
940 def test_speak_contents_no_active_script(self, test_context: OrcaTestContext) -> None:
941 """Test speak_contents returns early when no active script."""
942
943 essential_modules = self._setup_speech_output_dependencies(test_context)
944 script_manager = essential_modules["orca.script_manager"].get_manager()
945 script_manager.get_active_script.return_value = None
946
947 from orca.speech_presenter import SpeechPresenter
948
949 presenter = SpeechPresenter()
950 mock_contents = [(test_context.Mock(), 0, 10, "test text")]
951 presenter.speak_contents(mock_contents)
952
953 essential_modules["orca.speech"].speak.assert_not_called()
954
955 def test_present_key_event(self, test_context: OrcaTestContext) -> None:
956 """Test present_key_event speaks key via speech module."""
957
958 essential_modules = self._setup_speech_output_dependencies(test_context)
959 from orca.speech_presenter import SpeechPresenter
960
961 presenter = SpeechPresenter()
962 mock_event = test_context.Mock()
963 mock_event.is_printable_key.return_value = True
964 mock_event.get_key_name.return_value = "a"
965 presenter.present_key_event(mock_event)
966
967 essential_modules["orca.speech"].speak_key_event.assert_called_once()
968
969 def test_get_set_monitor_is_enabled(self, test_context: OrcaTestContext) -> None:
970 """Test getting and setting speech monitor enabled status."""
971
972 self._setup_dependencies(test_context)
973 from orca.speech_presenter import get_presenter
974
975 presenter = get_presenter()
976
977 result = presenter.set_monitor_is_enabled(True)
978 assert result is True
979 assert presenter.get_monitor_is_enabled() is True
980
981 result = presenter.set_monitor_is_enabled(False)
982 assert result is True
983 assert presenter.get_monitor_is_enabled() is False
984
985 def test_ensure_monitor_creates_when_enabled(self, test_context: OrcaTestContext) -> None:
986 """Test _ensure_monitor creates monitor on demand when enabled."""
987
988 essential_modules = self._setup_dependencies(test_context)
989 speech_monitor_mock = essential_modules["orca.speech_monitor"]
990 from orca.speech_presenter import get_presenter
991
992 presenter = get_presenter()
993 presenter.set_monitor_is_enabled(True)
994 mock_monitor = test_context.Mock()
995 speech_monitor_mock.SpeechMonitor.return_value = mock_monitor
996
997 result = presenter._ensure_monitor()
998
999 speech_monitor_mock.SpeechMonitor.assert_called_once()
1000 mock_monitor.show_all.assert_called_once()
1001 assert result is mock_monitor
1002
1003 def test_ensure_monitor_returns_none_when_disabled(self, test_context: OrcaTestContext) -> None:
1004 """Test _ensure_monitor returns None when disabled."""
1005
1006 self._setup_dependencies(test_context)
1007 from orca.speech_presenter import get_presenter
1008
1009 presenter = get_presenter()
1010 presenter.set_monitor_is_enabled(False)
1011 mock_monitor = test_context.Mock()
1012 presenter._monitor = mock_monitor
1013
1014 result = presenter._ensure_monitor()
1015
1016 assert result is None
1017
1018 def test_write_to_monitor(self, test_context: OrcaTestContext) -> None:
1019 """Test write_to_monitor writes text when monitor active and not focused."""
1020
1021 essential_modules = self._setup_dependencies(test_context)
1022 speech_monitor_mock = essential_modules["orca.speech_monitor"]
1023 from orca.speech_presenter import get_presenter
1024
1025 presenter = get_presenter()
1026 presenter.set_monitor_is_enabled(True)
1027 mock_monitor = test_context.Mock()
1028 mock_monitor.has_toplevel_focus.return_value = False
1029 speech_monitor_mock.SpeechMonitor.return_value = mock_monitor
1030
1031 presenter.write_to_monitor("hello world")
1032
1033 mock_monitor.write_text.assert_called_once_with("hello world")
1034
1035 def test_write_to_monitor_skips_when_focused(self, test_context: OrcaTestContext) -> None:
1036 """Test write_to_monitor skips when monitor has focus."""
1037
1038 essential_modules = self._setup_dependencies(test_context)
1039 speech_monitor_mock = essential_modules["orca.speech_monitor"]
1040 from orca.speech_presenter import get_presenter
1041
1042 presenter = get_presenter()
1043 presenter.set_monitor_is_enabled(True)
1044 mock_monitor = test_context.Mock()
1045 mock_monitor.has_toplevel_focus.return_value = True
1046 speech_monitor_mock.SpeechMonitor.return_value = mock_monitor
1047
1048 presenter.write_to_monitor("hello world")
1049
1050 mock_monitor.write_text.assert_not_called()
1051
1052 def test_write_key_to_monitor(self, test_context: OrcaTestContext) -> None:
1053 """Test write_key_to_monitor writes key event."""
1054
1055 essential_modules = self._setup_dependencies(test_context)
1056 speech_monitor_mock = essential_modules["orca.speech_monitor"]
1057 from orca.speech_presenter import get_presenter
1058
1059 presenter = get_presenter()
1060 presenter.set_monitor_is_enabled(True)
1061 mock_monitor = test_context.Mock()
1062 mock_monitor.has_toplevel_focus.return_value = False
1063 speech_monitor_mock.SpeechMonitor.return_value = mock_monitor
1064
1065 presenter.write_key_to_monitor("Return")
1066
1067 mock_monitor.write_key_event.assert_called_once_with("Return")
1068
1069 def test_destroy_monitor(self, test_context: OrcaTestContext) -> None:
1070 """Test destroy_monitor destroys existing speech monitor."""
1071
1072 self._setup_dependencies(test_context)
1073 from orca.speech_presenter import get_presenter
1074
1075 presenter = get_presenter()
1076 mock_monitor = test_context.Mock()
1077 presenter._monitor = mock_monitor
1078
1079 presenter.destroy_monitor()
1080
1081 mock_monitor.destroy.assert_called_once()
1082 assert presenter._monitor is None
1083
1084 def test_destroy_monitor_no_op_when_none(self, test_context: OrcaTestContext) -> None:
1085 """Test destroy_monitor does nothing when no monitor exists."""
1086
1087 self._setup_dependencies(test_context)
1088 from orca.speech_presenter import get_presenter
1089
1090 presenter = get_presenter()
1091 assert presenter._monitor is None
1092
1093 presenter.destroy_monitor()
1094
1095 assert presenter._monitor is None