Debian Codegraph @

tests/unit_tests/test_speech_manager.py

raw
1 # Unit tests for speech_manager.py methods.
2 #
3 # Copyright 2025 Igalia, S.L.
4 # Author: Joanmarie Diggs <[email protected]>
5 #
6 # This library is free software; you can redistribute it and/or
7 # modify it under the terms of the GNU Lesser General Public
8 # License as published by the Free Software Foundation; either
9 # version 2.1 of the License, or (at your option) any later version.
10 #
11 # This library is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 # Lesser General Public License for more details.
15 #
16 # You should have received a copy of the GNU Lesser General Public
17 # License along with this library; if not, write to the
18 # Free Software Foundation, Inc., Franklin Street, Fifth Floor,
19 # Boston MA 02110-1301 USA.
20
21 # pylint: disable=wrong-import-position
22 # pylint: disable=import-outside-toplevel
23 # pylint: disable=too-many-public-methods
24 # pylint: disable=too-many-statements
25 # pylint: disable=protected-access
26 # pylint: disable=too-many-arguments
27 # pylint: disable=too-many-positional-arguments
28 # pylint: disable=too-many-locals
29 # pylint: disable=too-many-lines
30
31 """Unit tests for speech_manager.py methods."""
32
33 from __future__ import annotations
34
35 import queue
36 from enum import Enum
37 from typing import TYPE_CHECKING
38
39 import pytest
40
41
42 class PunctuationStyle(Enum):
43 """Test-local copy of PunctuationStyle for mocking."""
44
45 NONE = 3
46 SOME = 2
47 MOST = 1
48 ALL = 0
49
50 @property
51 def string_name(self) -> str:
52 """Returns the lowercase string name for this enum value."""
53
54 return self.name.lower()
55
56
57 class CapitalizationStyle(Enum):
58 """Test-local copy of CapitalizationStyle for mocking."""
59
60 NONE = "none"
61 SPELL = "spell"
62 ICON = "icon"
63
64 @property
65 def string_name(self) -> str:
66 """Returns the lowercase string name for this enum value."""
67
68 return self.name.lower()
69
70
71 if TYPE_CHECKING:
72 from unittest.mock import MagicMock
73
74 from .orca_test_context import OrcaTestContext
75
76
77 @pytest.mark.unit
78 class TestSpeechManager:
79 """Test SpeechManager class methods."""
80
81 def _setup_dependencies(self, test_context: OrcaTestContext) -> dict[str, MagicMock]:
82 """Set up mocks for speech_manager dependencies."""
83
84 additional_modules = [
85 "orca.speech",
86 "orca.speechserver",
87 "orca.acss",
88 "orca.presentation_manager",
89 "orca.preferences_grid_base",
90 ]
91 essential_modules = test_context.setup_shared_dependencies(additional_modules)
92
93 focus_manager_mock = essential_modules["orca.focus_manager"]
94 focus_manager_mock.get_manager.return_value = test_context.Mock()
95
96 dbus_service_mock = essential_modules["orca.dbus_service"]
97 dbus_service_mock.get_remote_controller.return_value = test_context.Mock()
98
99 def passthrough_decorator(func):
100 return func
101
102 dbus_service_mock.getter = passthrough_decorator
103 dbus_service_mock.setter = passthrough_decorator
104 dbus_service_mock.command = passthrough_decorator
105 dbus_service_mock.parameterized_command = passthrough_decorator
106
107 speech_mock = essential_modules["orca.speech"]
108 speech_mock.speak.return_value = None
109 speech_mock.get_mute_speech.return_value = False
110
111 debug_mock = essential_modules["orca.debug"]
112 debug_mock.print_message.return_value = None
113 debug_mock.print_tokens.return_value = None
114 debug_mock.LEVEL_INFO = 800
115 debug_mock.LEVEL_WARNING = 900
116
117 acss_mock = essential_modules["orca.acss"]
118 acss_mock.ACSS = test_context.Mock()
119 acss_mock.ACSS.RATE = "rate"
120 acss_mock.ACSS.AVERAGE_PITCH = "average-pitch"
121 acss_mock.ACSS.GAIN = "gain"
122 acss_mock.ACSS.FAMILY = "family"
123
124 speechserver_mock = essential_modules["orca.speechserver"]
125 speechserver_mock.VoiceFamily = test_context.Mock()
126 speechserver_mock.VoiceFamily.NAME = "name"
127 speechserver_mock.VoiceFamily.LANG = "lang"
128 speechserver_mock.VoiceFamily.DIALECT = "dialect"
129 speechserver_mock.VoiceFamily.VARIANT = "variant"
130 speechserver_mock.PunctuationStyle = PunctuationStyle
131 speechserver_mock.CapitalizationStyle = CapitalizationStyle
132 speechserver_mock.DEFAULT_VOICE = "default"
133 speechserver_mock.UPPERCASE_VOICE = "uppercase"
134 speechserver_mock.HYPERLINK_VOICE = "hyperlink"
135 speechserver_mock.SYSTEM_VOICE = "system"
136
137 orca_i18n_mock = essential_modules["orca.orca_i18n"]
138 orca_i18n_mock._ = lambda x: x
139 orca_i18n_mock.C_ = lambda c, x: x
140 orca_i18n_mock.ngettext = lambda s, p, n: s if n == 1 else p
141
142 from orca import gsettings_registry
143
144 gsettings_registry.get_registry().clear_runtime_values()
145
146 return essential_modules
147
148 def test_init(self, test_context: OrcaTestContext) -> None:
149 """Test manager initialization and D-Bus registration."""
150
151 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
152 from orca.speech_manager import SpeechManager
153
154 manager = SpeechManager()
155
156 # Verify D-Bus registration occurred
157 controller = essential_modules["orca.dbus_service"].get_remote_controller()
158 controller.register_decorated_module.assert_called_with("SpeechManager", manager)
159
160 def test_set_up_commands(self, test_context: OrcaTestContext) -> None:
161 """Test that set_up_commands registers commands in CommandManager."""
162
163 self._setup_dependencies(test_context)
164 from orca import command_manager
165 from orca.speech_manager import SpeechManager
166
167 manager = SpeechManager()
168 manager.set_up_commands()
169
170 # Verify commands are registered in CommandManager
171 cmd_manager = command_manager.get_manager()
172 assert cmd_manager.get_command("toggleSilenceSpeechHandler") is not None
173 assert cmd_manager.get_command("cycleCapitalizationStyleHandler") is not None
174 assert cmd_manager.get_command("cycleSpeakingPunctuationLevelHandler") is not None
175 assert cmd_manager.get_command("cycleSynthesizerHandler") is not None
176
177 @pytest.mark.parametrize(
178 "case",
179 [
180 {"id": "server_none", "scenario": "none_server", "expected_result": None},
181 {"id": "server_timeout", "scenario": "timeout", "expected_result": None},
182 ],
183 ids=lambda case: case["id"],
184 )
185 def test_get_server_scenarios(self, test_context: OrcaTestContext, case: dict) -> None:
186 """Test _get_server method scenarios."""
187 self._setup_dependencies(test_context)
188 from orca.speech_manager import SpeechManager
189
190 manager = SpeechManager()
191
192 if case["scenario"] == "none_server":
193 manager._server = None
194 else: # timeout scenario
195 mock_speech_server = test_context.Mock()
196 manager._server = mock_speech_server
197
198 def mock_queue_constructor():
199 mock_queue = test_context.Mock()
200 mock_queue.get.side_effect = queue.Empty()
201 return mock_queue
202
203 test_context.patch("queue.Queue", new=mock_queue_constructor)
204
205 result = manager._get_server()
206 assert result is case["expected_result"]
207
208 def test_get_server_module_map_import_errors(self, test_context: OrcaTestContext) -> None:
209 """Test _get_server_module_map method with import errors."""
210
211 self._setup_dependencies(test_context)
212 from orca import speech_manager as sm_module
213 from orca.speech_manager import SpeechManager
214
215 test_context.patch_object(sm_module, "SPEECH_FACTORY_MODULES", new=["nonexistent_module"])
216
217 def mock_import_module(name) -> None:
218 raise ImportError("Module not found")
219
220 test_context.patch("importlib.import_module", new=mock_import_module)
221 manager = SpeechManager()
222 result = manager._get_server_module_map()
223 assert not result
224
225 def test_switch_server_invalid(self, test_context: OrcaTestContext) -> None:
226 """Test _switch_server method with invalid server."""
227
228 self._setup_dependencies(test_context)
229 from orca.speech_manager import SpeechManager
230
231 manager = SpeechManager()
232 test_context.patch_object(manager, "_get_server_module_map", return_value={})
233 result = manager._switch_server("Invalid Server")
234 assert result is False
235
236 @pytest.mark.parametrize(
237 "case",
238 [
239 {"id": "none", "server_return": None, "expected_result": ""},
240 {"id": "with_server", "server_return": "mock_server", "expected_result": "Test Server"},
241 ],
242 ids=lambda case: case["id"],
243 )
244 def test_get_current_server_scenarios(self, test_context: OrcaTestContext, case: dict) -> None:
245 """Test get_current_server method with various scenarios."""
246 self._setup_dependencies(test_context)
247 from orca.speech_manager import SpeechManager
248
249 manager = SpeechManager()
250
251 if case["server_return"] == "mock_server":
252 mock_server = test_context.Mock()
253 mock_server.get_factory_name.return_value = "Test Server"
254 test_context.patch_object(manager, "_get_server", return_value=mock_server)
255 else:
256 test_context.patch_object(manager, "_get_server", return_value=case["server_return"])
257
258 result = manager.get_current_server()
259 assert result == case["expected_result"]
260
261 def test_get_current_synthesizer_none(self, test_context: OrcaTestContext) -> None:
262 """Test get_current_synthesizer method when server is None."""
263
264 self._setup_dependencies(test_context)
265 from orca.speech_manager import SpeechManager
266
267 manager = SpeechManager()
268 test_context.patch_object(manager, "_get_server", return_value=None)
269 result = manager.get_current_synthesizer()
270 assert result == ""
271
272 @pytest.mark.parametrize(
273 "case",
274 [
275 {
276 "id": "set_current_synthesizer",
277 "method_name": "set_current_synthesizer",
278 "method_args": ["espeak-ng"],
279 "expected_result": False,
280 },
281 {
282 "id": "get_available_synthesizers",
283 "method_name": "get_available_synthesizers",
284 "method_args": [],
285 "expected_result": [],
286 },
287 {
288 "id": "get_available_voices",
289 "method_name": "get_available_voices",
290 "method_args": [],
291 "expected_result": [],
292 },
293 {
294 "id": "get_voices_for_language",
295 "method_name": "get_voices_for_language",
296 "method_args": ["en"],
297 "expected_result": [],
298 },
299 {
300 "id": "get_current_voice",
301 "method_name": "get_current_voice",
302 "method_args": [],
303 "expected_result": "",
304 },
305 {
306 "id": "set_current_voice",
307 "method_name": "set_current_voice",
308 "method_args": ["en"],
309 "expected_result": False,
310 },
311 {
312 "id": "interrupt_speech",
313 "method_name": "interrupt_speech",
314 "method_args": [],
315 "expected_result": True,
316 },
317 {
318 "id": "shutdown_speech",
319 "method_name": "shutdown_speech",
320 "method_args": [],
321 "expected_result": True,
322 },
323 {
324 "id": "decrease_rate",
325 "method_name": "decrease_rate",
326 "method_args": [],
327 "expected_result": True,
328 },
329 {
330 "id": "increase_rate",
331 "method_name": "increase_rate",
332 "method_args": [],
333 "expected_result": True,
334 },
335 {
336 "id": "decrease_pitch",
337 "method_name": "decrease_pitch",
338 "method_args": [],
339 "expected_result": True,
340 },
341 {
342 "id": "increase_pitch",
343 "method_name": "increase_pitch",
344 "method_args": [],
345 "expected_result": True,
346 },
347 {
348 "id": "decrease_volume",
349 "method_name": "decrease_volume",
350 "method_args": [],
351 "expected_result": True,
352 },
353 {
354 "id": "increase_volume",
355 "method_name": "increase_volume",
356 "method_args": [],
357 "expected_result": True,
358 },
359 {
360 "id": "update_capitalization_style",
361 "method_name": "update_capitalization_style",
362 "method_args": [],
363 "expected_result": True,
364 },
365 {
366 "id": "update_punctuation_level",
367 "method_name": "update_punctuation_level",
368 "method_args": [],
369 "expected_result": True,
370 },
371 {
372 "id": "update_synthesizer",
373 "method_name": "update_synthesizer",
374 "method_args": [],
375 "expected_result": None,
376 },
377 {
378 "id": "cycle_synthesizer",
379 "method_name": "cycle_synthesizer",
380 "method_args": [],
381 "expected_result": True,
382 },
383 ],
384 ids=lambda case: case["id"],
385 )
386 def test_methods_no_server(self, test_context: OrcaTestContext, case: dict) -> None:
387 """Test various methods when speech server is None."""
388 self._setup_dependencies(test_context)
389 from orca.speech_manager import SpeechManager
390
391 manager = SpeechManager()
392 test_context.patch_object(manager, "_get_server", return_value=None)
393
394 method = getattr(manager, case["method_name"])
395 result = method(*case["method_args"])
396
397 if case["expected_result"] is False:
398 assert not result
399 else:
400 assert result == case["expected_result"]
401
402 @pytest.mark.parametrize(
403 "case",
404 [
405 {"id": "get_capitalization_style", "setting_value": "spell", "expected": "spell"},
406 {"id": "get_capitalization_style_none", "setting_value": "none", "expected": "none"},
407 {"id": "get_capitalization_style_icon", "setting_value": "icon", "expected": "icon"},
408 ],
409 ids=lambda case: case["id"],
410 )
411 def test_get_capitalization_style(self, test_context: OrcaTestContext, case: dict) -> None:
412 """Test get_capitalization_style method."""
413
414 self._setup_dependencies(test_context)
415
416 from orca import gsettings_registry
417 from orca.speech_manager import SpeechManager
418
419 manager = SpeechManager()
420 gsettings_registry.get_registry().set_runtime_value(
421 "speech",
422 "capitalization-style",
423 case["setting_value"],
424 )
425
426 result = manager.get_capitalization_style()
427 assert result == case["expected"]
428
429 @pytest.mark.parametrize(
430 "case",
431 [
432 {"id": "set_capitalization_style_valid", "input_value": "spell", "expected": True},
433 {"id": "set_capitalization_style_none", "input_value": "none", "expected": True},
434 {"id": "set_capitalization_style_icon", "input_value": "icon", "expected": True},
435 {"id": "set_capitalization_style_invalid", "input_value": "invalid", "expected": False},
436 ],
437 ids=lambda case: case["id"],
438 )
439 def test_set_capitalization_style(self, test_context: OrcaTestContext, case: dict) -> None:
440 """Test set_capitalization_style method."""
441
442 self._setup_dependencies(test_context)
443
444 from orca.speech_manager import SpeechManager
445
446 manager = SpeechManager()
447 mock_update = test_context.Mock()
448 test_context.patch_object(manager, "update_capitalization_style", new=mock_update)
449
450 result = manager.set_capitalization_style(case["input_value"])
451 assert result == case["expected"]
452
453 if case["expected"]:
454 assert manager.get_capitalization_style() == case["input_value"]
455 mock_update.assert_called_once()
456 else:
457 mock_update.assert_not_called()
458
459 def test_get_punctuation_level_default(self, test_context: OrcaTestContext) -> None:
460 """Test get_punctuation_level returns 'most' as default fallback."""
461
462 self._setup_dependencies(test_context)
463
464 from orca.speech_manager import SpeechManager
465
466 manager = SpeechManager()
467
468 result = manager.get_punctuation_level()
469 assert result == "most"
470
471 @pytest.mark.parametrize(
472 "case",
473 [
474 {"id": "punctuation_none", "lookup_value": "none", "expected": "none"},
475 {"id": "punctuation_some", "lookup_value": "some", "expected": "some"},
476 {"id": "punctuation_most", "lookup_value": "most", "expected": "most"},
477 {"id": "punctuation_all", "lookup_value": "all", "expected": "all"},
478 ],
479 ids=lambda case: case["id"],
480 )
481 def test_get_punctuation_level_from_dconf(
482 self,
483 test_context: OrcaTestContext,
484 case: dict,
485 ) -> None:
486 """Test get_punctuation_level reads from layered_lookup."""
487
488 self._setup_dependencies(test_context)
489
490 from orca import gsettings_registry
491
492 registry = gsettings_registry.get_registry()
493 registry.set_runtime_value("speech", "punctuation-level", case["lookup_value"])
494
495 from orca.speech_manager import SpeechManager
496
497 manager = SpeechManager()
498
499 result = manager.get_punctuation_level()
500 assert result == case["expected"]
501
502 @pytest.mark.parametrize(
503 "case",
504 [
505 {
506 "id": "set_punctuation_none",
507 "input_value": "none",
508 "expected": True,
509 "setting_int": 3,
510 },
511 {
512 "id": "set_punctuation_some",
513 "input_value": "some",
514 "expected": True,
515 "setting_int": 2,
516 },
517 {
518 "id": "set_punctuation_most",
519 "input_value": "most",
520 "expected": True,
521 "setting_int": 1,
522 },
523 {"id": "set_punctuation_all", "input_value": "all", "expected": True, "setting_int": 0},
524 {
525 "id": "set_punctuation_invalid",
526 "input_value": "invalid",
527 "expected": False,
528 "setting_int": None,
529 },
530 ],
531 ids=lambda case: case["id"],
532 )
533 def test_set_punctuation_level(self, test_context: OrcaTestContext, case: dict) -> None:
534 """Test set_punctuation_level method."""
535
536 self._setup_dependencies(test_context)
537
538 from orca.speech_manager import SpeechManager
539
540 manager = SpeechManager()
541 mock_update = test_context.Mock()
542 test_context.patch_object(manager, "update_punctuation_level", new=mock_update)
543
544 result = manager.set_punctuation_level(case["input_value"])
545 assert result == case["expected"]
546
547 if case["expected"]:
548 assert manager.get_punctuation_level() == case["input_value"]
549 mock_update.assert_called_once()
550 else:
551 mock_update.assert_not_called()
552
553 @pytest.mark.parametrize(
554 "case",
555 [
556 {"id": "speech_enabled_true", "setting_value": True, "expected": True},
557 {"id": "speech_enabled_false", "setting_value": False, "expected": False},
558 ],
559 ids=lambda case: case["id"],
560 )
561 def test_get_speech_is_enabled(self, test_context: OrcaTestContext, case: dict) -> None:
562 """Test get_speech_is_enabled method."""
563
564 self._setup_dependencies(test_context)
565
566 from orca import gsettings_registry
567 from orca.speech_manager import SpeechManager
568
569 manager = SpeechManager()
570 gsettings_registry.get_registry().set_runtime_value(
571 "speech",
572 "enable",
573 case["setting_value"],
574 )
575
576 result = manager.get_speech_is_enabled()
577 assert result == case["expected"]
578
579 @pytest.mark.parametrize(
580 "case",
581 [
582 {"id": "speech_muted_true", "setting_value": True, "expected": True},
583 {"id": "speech_muted_false", "setting_value": False, "expected": False},
584 ],
585 ids=lambda case: case["id"],
586 )
587 def test_get_speech_is_muted(self, test_context: OrcaTestContext, case: dict) -> None:
588 """Test get_speech_is_muted method."""
589
590 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
591 essential_modules["orca.speech"].get_mute_speech.return_value = case["setting_value"]
592
593 from orca.speech_manager import SpeechManager
594
595 manager = SpeechManager()
596
597 result = manager.get_speech_is_muted()
598 assert result == case["expected"]
599
600 @pytest.mark.parametrize(
601 "case",
602 [
603 {
604 "id": "enabled_and_not_muted",
605 "enable_speech": True,
606 "silence_speech": False,
607 "expected": True,
608 },
609 {
610 "id": "enabled_and_muted",
611 "enable_speech": True,
612 "silence_speech": True,
613 "expected": False,
614 },
615 {
616 "id": "disabled_and_not_muted",
617 "enable_speech": False,
618 "silence_speech": False,
619 "expected": False,
620 },
621 {
622 "id": "disabled_and_muted",
623 "enable_speech": False,
624 "silence_speech": True,
625 "expected": False,
626 },
627 ],
628 ids=lambda case: case["id"],
629 )
630 def test_get_speech_is_enabled_and_not_muted(
631 self,
632 test_context: OrcaTestContext,
633 case: dict,
634 ) -> None:
635 """Test get_speech_is_enabled_and_not_muted method."""
636
637 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
638 essential_modules["orca.speech"].get_mute_speech.return_value = case["silence_speech"]
639
640 from orca import gsettings_registry
641 from orca.speech_manager import SpeechManager
642
643 manager = SpeechManager()
644 gsettings_registry.get_registry().set_runtime_value(
645 "speech",
646 "enable",
647 case["enable_speech"],
648 )
649
650 result = manager.get_speech_is_enabled_and_not_muted()
651 assert result == case["expected"]
652
653 @pytest.mark.parametrize(
654 "case",
655 [
656 {
657 "id": "speech_disabled",
658 "speech_enabled": False,
659 "expected_method": "shutdown_speech",
660 },
661 {"id": "speech_enabled", "speech_enabled": True, "expected_method": "start_speech"},
662 ],
663 ids=lambda case: case["id"],
664 )
665 def test_check_speech_setting(self, test_context: OrcaTestContext, case: dict) -> None:
666 """Test check_speech_setting method with various speech enabled settings."""
667
668 self._setup_dependencies(test_context)
669
670 from orca import gsettings_registry
671 from orca.speech_manager import SpeechManager
672
673 manager = SpeechManager()
674 gsettings_registry.get_registry().set_runtime_value(
675 "speech",
676 "enable",
677 case["speech_enabled"],
678 )
679 mock_method = test_context.Mock()
680 test_context.patch_object(manager, case["expected_method"], new=mock_method)
681 manager.check_speech_setting()
682 mock_method.assert_called_once()
683
684 def test_refresh_speech(self, test_context: OrcaTestContext) -> None:
685 """Test refresh_speech method."""
686
687 self._setup_dependencies(test_context)
688 from orca.speech_manager import SpeechManager
689
690 manager = SpeechManager()
691 mock_shutdown = test_context.Mock()
692 test_context.patch_object(manager, "shutdown_speech", new=mock_shutdown)
693 mock_start = test_context.Mock()
694 test_context.patch_object(manager, "start_speech", new=mock_start)
695 result = manager.refresh_speech()
696 assert result is True
697 mock_shutdown.assert_called_once()
698 mock_start.assert_called_once()
699
700 def test_get_server_with_valid_server(self, test_context: OrcaTestContext) -> None:
701 """Test _get_server method with valid speech server."""
702
703 self._setup_dependencies(test_context)
704 from orca.speech_manager import SpeechManager
705
706 manager = SpeechManager()
707
708 mock_server = test_context.Mock()
709 mock_server.is_alive.return_value = True
710 manager._server = mock_server
711 result = manager._get_server()
712 assert result is mock_server
713
714 def test_get_current_synthesizer_with_server(self, test_context: OrcaTestContext) -> None:
715 """Test get_current_synthesizer method with valid server."""
716
717 mock_server = test_context.Mock()
718 mock_server.get_output_module.return_value = "espeak-ng"
719 self._setup_dependencies(test_context)
720 from orca.speech_manager import SpeechManager
721
722 manager = SpeechManager()
723 test_context.patch_object(manager, "_get_server", return_value=mock_server)
724 result = manager.get_current_synthesizer()
725 assert result == "espeak-ng"
726
727 def test_cycle_capitalization_style(self, test_context: OrcaTestContext) -> None:
728 """Test cycle_capitalization_style method."""
729
730 self._setup_dependencies(test_context)
731 from orca.speech_manager import SpeechManager
732
733 manager = SpeechManager()
734 test_context.patch_object(manager, "update_capitalization_style", new=test_context.Mock())
735 result = manager.cycle_capitalization_style()
736 assert result is True
737
738 def test_cycle_synthesizer_with_server(self, test_context: OrcaTestContext) -> None:
739 """Test cycle_synthesizer method with current not in available list."""
740
741 mock_server = test_context.Mock()
742 mock_server.list_output_modules.return_value = ["espeak", "festival"]
743 mock_server.get_output_module.return_value = "unknown"
744 mock_server.set_output_module.return_value = True
745 self._setup_dependencies(test_context)
746 from orca.speech_manager import SpeechManager
747
748 manager = SpeechManager()
749 test_context.patch_object(manager, "_get_server", return_value=mock_server)
750 result = manager.cycle_synthesizer()
751 assert result is True
752 mock_server.set_output_module.assert_called_once_with("espeak")
753
754 @pytest.mark.parametrize(
755 "case",
756 [
757 {
758 "id": "decrease_rate",
759 "method_name": "decrease_rate",
760 "server_method": "decrease_speech_rate",
761 },
762 {
763 "id": "increase_rate",
764 "method_name": "increase_rate",
765 "server_method": "increase_speech_rate",
766 },
767 ],
768 ids=lambda case: case["id"],
769 )
770 def test_rate_adjustment_with_server(self, test_context: OrcaTestContext, case: dict) -> None:
771 """Test rate adjustment methods delegate to the speech server."""
772
773 mock_server = test_context.Mock()
774 self._setup_dependencies(test_context)
775 from orca.speech_manager import SpeechManager
776
777 manager = SpeechManager()
778 test_context.patch_object(manager, "_get_server", return_value=mock_server)
779 result = getattr(manager, case["method_name"])()
780 assert result is True
781 getattr(mock_server, case["server_method"]).assert_called_once()
782
783 @pytest.mark.parametrize(
784 "case",
785 [
786 {
787 "id": "decrease_pitch",
788 "method_name": "decrease_pitch",
789 "server_method": "decrease_speech_pitch",
790 },
791 {
792 "id": "increase_pitch",
793 "method_name": "increase_pitch",
794 "server_method": "increase_speech_pitch",
795 },
796 ],
797 ids=lambda case: case["id"],
798 )
799 def test_pitch_adjustment_with_server(self, test_context: OrcaTestContext, case: dict) -> None:
800 """Test pitch adjustment methods delegate to the speech server."""
801
802 mock_server = test_context.Mock()
803 self._setup_dependencies(test_context)
804 from orca.speech_manager import SpeechManager
805
806 manager = SpeechManager()
807 test_context.patch_object(manager, "_get_server", return_value=mock_server)
808 result = getattr(manager, case["method_name"])()
809 assert result is True
810 getattr(mock_server, case["server_method"]).assert_called_once()
811
812 @pytest.mark.parametrize(
813 "case",
814 [
815 {
816 "id": "decrease_volume",
817 "method_name": "decrease_volume",
818 "server_method": "decrease_speech_volume",
819 },
820 {
821 "id": "increase_volume",
822 "method_name": "increase_volume",
823 "server_method": "increase_speech_volume",
824 },
825 ],
826 ids=lambda case: case["id"],
827 )
828 def test_volume_adjustment_with_server(self, test_context: OrcaTestContext, case: dict) -> None:
829 """Test volume adjustment methods delegate to the speech server."""
830
831 mock_server = test_context.Mock()
832 self._setup_dependencies(test_context)
833 from orca.speech_manager import SpeechManager
834
835 manager = SpeechManager()
836 test_context.patch_object(manager, "_get_server", return_value=mock_server)
837 result = getattr(manager, case["method_name"])()
838 assert result is True
839 getattr(mock_server, case["server_method"]).assert_called_once()
840
841 def test_set_rate_valid(self, test_context: OrcaTestContext) -> None:
842 """Test set_rate method with valid value."""
843
844 self._setup_dependencies(test_context)
845 from orca.speech_manager import SpeechManager
846
847 manager = SpeechManager()
848
849 result = manager.set_rate(75)
850 assert result is True
851 assert manager.get_rate() == 75
852
853 def test_set_volume_valid(self, test_context: OrcaTestContext) -> None:
854 """Test set_volume method with valid value."""
855
856 self._setup_dependencies(test_context)
857 from orca.speech_manager import SpeechManager
858
859 manager = SpeechManager()
860
861 result = manager.set_volume(8.0)
862 assert result is True
863 assert manager.get_volume() == 8.0
864
865 def test_update_synthesizer_with_server(self, test_context: OrcaTestContext) -> None:
866 """Test update_synthesizer method with server and different synthesizer ID."""
867
868 mock_server = test_context.Mock()
869 mock_server.get_output_module.return_value = "espeak"
870 mock_server.set_output_module.return_value = True
871 self._setup_dependencies(test_context)
872 from orca.speech_manager import SpeechManager
873
874 manager = SpeechManager()
875
876 test_context.patch_object(manager, "_get_server", return_value=mock_server)
877 from orca import gsettings_registry
878
879 registry = gsettings_registry.get_registry()
880 registry.set_runtime_value("speech", "synthesizer", "espeak-ng")
881 manager.update_synthesizer()
882 mock_server.set_output_module.assert_called_once_with("espeak-ng")
883 registry.clear_runtime_values()
884
885 def test_get_manager_singleton(self, test_context: OrcaTestContext) -> None:
886 """Test get_manager function returns the same instance."""
887
888 self._setup_dependencies(test_context)
889 from orca import speech_manager
890
891 manager1 = speech_manager.get_manager()
892 manager2 = speech_manager.get_manager()
893
894 assert manager1 is manager2
895 assert isinstance(manager1, speech_manager.SpeechManager)
896
897 @pytest.mark.parametrize(
898 "case",
899 [
900 {"id": "speak_numbers_true", "setting_value": True, "expected": True},
901 {"id": "speak_numbers_false", "setting_value": False, "expected": False},
902 ],
903 ids=lambda case: case["id"],
904 )
905 def test_get_speak_numbers_as_digits(self, test_context: OrcaTestContext, case: dict) -> None:
906 """Test get_speak_numbers_as_digits method."""
907
908 self._setup_dependencies(test_context)
909
910 from orca import gsettings_registry
911 from orca.speech_manager import SpeechManager
912
913 manager = SpeechManager()
914 gsettings_registry.get_registry().set_runtime_value(
915 "speech",
916 "speak-numbers-as-digits",
917 case["setting_value"],
918 )
919
920 result = manager.get_speak_numbers_as_digits()
921 assert result == case["expected"]
922
923 @pytest.mark.parametrize(
924 "case",
925 [
926 {"id": "set_speak_numbers_true", "input_value": True, "expected": True},
927 {"id": "set_speak_numbers_false", "input_value": False, "expected": True},
928 ],
929 ids=lambda case: case["id"],
930 )
931 def test_set_speak_numbers_as_digits(self, test_context: OrcaTestContext, case: dict) -> None:
932 """Test set_speak_numbers_as_digits method."""
933
934 self._setup_dependencies(test_context)
935
936 from orca.speech_manager import SpeechManager
937
938 manager = SpeechManager()
939
940 result = manager.set_speak_numbers_as_digits(case["input_value"])
941 assert result == case["expected"]
942 assert manager.get_speak_numbers_as_digits() == case["input_value"]
943
944 @pytest.mark.parametrize(
945 "case",
946 [
947 {"id": "use_pronunciation_dict_true", "setting_value": True, "expected": True},
948 {"id": "use_pronunciation_dict_false", "setting_value": False, "expected": False},
949 ],
950 ids=lambda case: case["id"],
951 )
952 def test_get_use_pronunciation_dictionary(
953 self,
954 test_context: OrcaTestContext,
955 case: dict,
956 ) -> None:
957 """Test get_use_pronunciation_dictionary method."""
958
959 self._setup_dependencies(test_context)
960
961 from orca import gsettings_registry
962 from orca.speech_manager import SpeechManager
963
964 manager = SpeechManager()
965 gsettings_registry.get_registry().set_runtime_value(
966 "speech",
967 "use-pronunciation-dictionary",
968 case["setting_value"],
969 )
970
971 result = manager.get_use_pronunciation_dictionary()
972 assert result == case["expected"]
973
974 @pytest.mark.parametrize(
975 "case",
976 [
977 {"id": "set_pronunciation_dict_true", "input_value": True, "expected": True},
978 {"id": "set_pronunciation_dict_false", "input_value": False, "expected": True},
979 ],
980 ids=lambda case: case["id"],
981 )
982 def test_set_use_pronunciation_dictionary(
983 self,
984 test_context: OrcaTestContext,
985 case: dict,
986 ) -> None:
987 """Test set_use_pronunciation_dictionary method."""
988
989 self._setup_dependencies(test_context)
990
991 from orca.speech_manager import SpeechManager
992
993 manager = SpeechManager()
994
995 result = manager.set_use_pronunciation_dictionary(case["input_value"])
996 assert result == case["expected"]
997 assert manager.get_use_pronunciation_dictionary() == case["input_value"]
998
999 @pytest.mark.parametrize(
1000 "case",
1001 [
1002 {"id": "use_color_names_true", "setting_value": True, "expected": True},
1003 {"id": "use_color_names_false", "setting_value": False, "expected": False},
1004 ],
1005 ids=lambda case: case["id"],
1006 )
1007 def test_get_use_color_names(self, test_context: OrcaTestContext, case: dict) -> None:
1008 """Test get_use_color_names method."""
1009
1010 self._setup_dependencies(test_context)
1011
1012 from orca import gsettings_registry
1013 from orca.speech_manager import SpeechManager
1014
1015 manager = SpeechManager()
1016 gsettings_registry.get_registry().set_runtime_value(
1017 "speech",
1018 "use-color-names",
1019 case["setting_value"],
1020 )
1021
1022 result = manager.get_use_color_names()
1023 assert result == case["expected"]
1024
1025 @pytest.mark.parametrize(
1026 "case",
1027 [
1028 {"id": "set_color_names_true", "input_value": True, "expected": True},
1029 {"id": "set_color_names_false", "input_value": False, "expected": True},
1030 ],
1031 ids=lambda case: case["id"],
1032 )
1033 def test_set_use_color_names(self, test_context: OrcaTestContext, case: dict) -> None:
1034 """Test set_use_color_names method."""
1035
1036 self._setup_dependencies(test_context)
1037
1038 from orca.speech_manager import SpeechManager
1039
1040 manager = SpeechManager()
1041
1042 result = manager.set_use_color_names(case["input_value"])
1043 assert result == case["expected"]
1044 assert manager.get_use_color_names() == case["input_value"]
1045
1046 @pytest.mark.parametrize(
1047 "case",
1048 [
1049 {"id": "insert_pauses_true", "setting_value": True, "expected": True},
1050 {"id": "insert_pauses_false", "setting_value": False, "expected": False},
1051 ],
1052 ids=lambda case: case["id"],
1053 )
1054 def test_get_insert_pauses_between_utterances(
1055 self,
1056 test_context: OrcaTestContext,
1057 case: dict,
1058 ) -> None:
1059 """Test get_insert_pauses_between_utterances method."""
1060
1061 self._setup_dependencies(test_context)
1062
1063 from orca import gsettings_registry
1064 from orca.speech_manager import SpeechManager
1065
1066 manager = SpeechManager()
1067 gsettings_registry.get_registry().set_runtime_value(
1068 "speech",
1069 "insert-pauses-between-utterances",
1070 case["setting_value"],
1071 )
1072
1073 result = manager.get_insert_pauses_between_utterances()
1074 assert result == case["expected"]
1075
1076 @pytest.mark.parametrize(
1077 "case",
1078 [
1079 {"id": "set_pauses_true", "input_value": True, "expected": True},
1080 {"id": "set_pauses_false", "input_value": False, "expected": True},
1081 ],
1082 ids=lambda case: case["id"],
1083 )
1084 def test_set_insert_pauses_between_utterances(
1085 self,
1086 test_context: OrcaTestContext,
1087 case: dict,
1088 ) -> None:
1089 """Test set_insert_pauses_between_utterances method."""
1090
1091 self._setup_dependencies(test_context)
1092
1093 from orca.speech_manager import SpeechManager
1094
1095 manager = SpeechManager()
1096
1097 result = manager.set_insert_pauses_between_utterances(case["input_value"])
1098 assert result == case["expected"]
1099 assert manager.get_insert_pauses_between_utterances() == case["input_value"]
1100
1101 @pytest.mark.parametrize(
1102 "case",
1103 [
1104 {"id": "auto_lang_true", "setting_value": True, "expected": True},
1105 {"id": "auto_lang_false", "setting_value": False, "expected": False},
1106 ],
1107 ids=lambda case: case["id"],
1108 )
1109 def test_get_auto_language_switching(self, test_context: OrcaTestContext, case: dict) -> None:
1110 """Test get_auto_language_switching method."""
1111
1112 self._setup_dependencies(test_context)
1113
1114 from orca import gsettings_registry
1115 from orca.speech_manager import SpeechManager
1116
1117 manager = SpeechManager()
1118 gsettings_registry.get_registry().set_runtime_value(
1119 "speech",
1120 "auto-language-switching",
1121 case["setting_value"],
1122 )
1123
1124 result = manager.get_auto_language_switching()
1125 assert result == case["expected"]
1126
1127 @pytest.mark.parametrize(
1128 "case",
1129 [
1130 {"id": "set_auto_lang_true", "input_value": True, "expected": True},
1131 {"id": "set_auto_lang_false", "input_value": False, "expected": True},
1132 ],
1133 ids=lambda case: case["id"],
1134 )
1135 def test_set_auto_language_switching(self, test_context: OrcaTestContext, case: dict) -> None:
1136 """Test set_auto_language_switching method."""
1137
1138 self._setup_dependencies(test_context)
1139
1140 from orca.speech_manager import SpeechManager
1141
1142 manager = SpeechManager()
1143
1144 result = manager.set_auto_language_switching(case["input_value"])
1145 assert result == case["expected"]
1146 assert manager.get_auto_language_switching() == case["input_value"]
1147
1148 def test_toggle_speech_unmutes_when_muted(self, test_context: OrcaTestContext) -> None:
1149 """Test toggle_speech unmutes when speech is currently muted."""
1150
1151 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1152 speech_mock = essential_modules["orca.speech"]
1153 speech_mock.get_mute_speech.return_value = True
1154
1155 from orca.speech_manager import SpeechManager
1156
1157 manager = SpeechManager()
1158 script = test_context.Mock()
1159 manager.toggle_speech(script)
1160
1161 speech_mock.set_mute_speech.assert_called_with(False)
1162
1163 def test_toggle_speech_enables_when_disabled(self, test_context: OrcaTestContext) -> None:
1164 """Test toggle_speech enables speech when enableSpeech is False."""
1165
1166 self._setup_dependencies(test_context)
1167
1168 from orca import gsettings_registry
1169 from orca.speech_manager import SpeechManager
1170
1171 manager = SpeechManager()
1172 gsettings_registry.get_registry().set_runtime_value("speech", "enable", False)
1173 mock_init = test_context.patch_object(manager, "_init_server")
1174 script = test_context.Mock()
1175 manager.toggle_speech(script)
1176
1177 assert manager.get_speech_is_enabled() is True
1178 mock_init.assert_called()
1179
1180 def test_toggle_speech_mutes_when_app_profile_has_speech_enabled(
1181 self,
1182 test_context: OrcaTestContext,
1183 ) -> None:
1184 """Test toggle_speech mutes when the app profile has enableSpeech=True."""
1185
1186 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1187 speech_mock = essential_modules["orca.speech"]
1188
1189 from orca.speech_manager import SpeechManager
1190
1191 manager = SpeechManager()
1192 script = test_context.Mock()
1193 manager.toggle_speech(script)
1194
1195 speech_mock.set_mute_speech.assert_called_with(True)
1196 assert manager.get_speech_is_enabled() is True
1197
1198 def test_toggle_speech_disables_when_app_profile_has_speech_disabled(
1199 self,
1200 test_context: OrcaTestContext,
1201 ) -> None:
1202 """Test toggle_speech shuts down when underlying setting disables speech."""
1203
1204 self._setup_dependencies(test_context)
1205
1206 from orca import gsettings_registry
1207 from orca.speech_manager import SpeechManager
1208
1209 manager = SpeechManager()
1210 test_context.patch_object(manager, "get_speech_is_enabled", side_effect=[True, False])
1211 mock_shutdown = test_context.patch_object(manager, "shutdown_speech")
1212
1213 script = test_context.Mock()
1214 manager.toggle_speech(script)
1215
1216 found, _value = gsettings_registry.get_registry().get_runtime_value("speech", "enable")
1217 assert found is False
1218 mock_shutdown.assert_called_once()
1219
1220
1221 class TestVoicesPreferencesGridUI:
1222 """Test VoicesPreferencesGrid save behavior."""
1223
1224 def _setup_dependencies(self, test_context: OrcaTestContext) -> dict[str, MagicMock]:
1225 """Set up mocks for VoicesPreferencesGrid dependencies."""
1226
1227 additional_modules = [
1228 "orca.speech",
1229 "orca.speechserver",
1230 "orca.acss",
1231 "orca.presentation_manager",
1232 ]
1233 essential_modules = test_context.setup_shared_dependencies(additional_modules)
1234
1235 speechserver_mock = essential_modules["orca.speechserver"]
1236 speechserver_mock.PunctuationStyle = PunctuationStyle
1237 speechserver_mock.CapitalizationStyle = CapitalizationStyle
1238 speechserver_mock.DEFAULT_VOICE = "default"
1239 speechserver_mock.UPPERCASE_VOICE = "uppercase"
1240 speechserver_mock.HYPERLINK_VOICE = "hyperlink"
1241 speechserver_mock.SYSTEM_VOICE = "system"
1242
1243 from orca import gsettings_registry
1244
1245 gsettings_registry.get_registry().clear_runtime_values()
1246
1247 return essential_modules
1248
1249 def test_save_settings_includes_speech_server_factory(
1250 self,
1251 test_context: OrcaTestContext,
1252 ) -> None:
1253 """Test save_settings includes speech-server-factory."""
1254
1255 self._setup_dependencies(test_context)
1256
1257 from orca import gsettings_registry
1258 from orca.speech_manager import SpeechManager, VoicesPreferencesGrid
1259
1260 gsettings_registry.get_registry().set_runtime_value(
1261 "speech",
1262 "speech-server-factory",
1263 "spiel",
1264 )
1265
1266 manager = SpeechManager()
1267 mock_server = test_context.Mock()
1268 mock_server.get_factory_name.return_value = "Spiel"
1269 mock_server.get_output_module.return_value = "Piper"
1270 test_context.patch_object(manager, "_get_server", return_value=mock_server)
1271
1272 grid_mock = test_context.Mock()
1273 grid_mock._manager = manager
1274 grid_mock._default_voice = {}
1275 grid_mock._uppercase_voice = {}
1276 grid_mock._hyperlink_voice = {}
1277 grid_mock._system_voice = {}
1278 grid_mock._has_unsaved_changes = True
1279 grid_mock._punctuation_combo.get_model.return_value = None
1280 grid_mock._capitalization_combo.get_model.return_value = None
1281 grid_mock._speak_numbers_switch.get_active.return_value = False
1282 grid_mock._use_color_names_switch.get_active.return_value = True
1283 grid_mock._enable_pause_breaks_switch.get_active.return_value = True
1284 grid_mock._use_pronunciation_dict_switch.get_active.return_value = True
1285 grid_mock._auto_language_switching_switch.get_active.return_value = True
1286
1287 result = VoicesPreferencesGrid.save_settings(grid_mock)
1288
1289 assert result["speech-server-factory"] == "spiel"
1290 assert result["speech-server"] == "Spiel"
1291 assert result["synthesizer"] == "Piper"