Debian Codegraph @

tests/unit_tests/test_gsettings_registry.py

raw
1 # Unit tests for gsettings_registry.py
2 #
3 # Copyright 2026 Igalia, S.L.
4 # Author: Joanmarie Diggs <[email protected]>
5 #
6 # This library is free software; you can redistribute it and/or
7 # modify it under the terms of the GNU Lesser General Public
8 # License as published by the Free Software Foundation; either
9 # version 2.1 of the License, or (at your option) any later version.
10 #
11 # This library is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 # Lesser General Public License for more details.
15 #
16 # You should have received a copy of the GNU Lesser General Public
17 # License along with this library; if not, write to the
18 # Free Software Foundation, Inc., Franklin Street, Fifth Floor,
19 # Boston MA 02110-1301 USA.
20
21 # pylint: disable=wrong-import-position
22 # pylint: disable=import-outside-toplevel
23 # pylint: disable=protected-access
24 # pylint: disable=too-many-lines
25
26 """Unit tests for gsettings_registry.py."""
27
28 from __future__ import annotations
29
30 from typing import TYPE_CHECKING
31
32 import pytest
33
34 if TYPE_CHECKING:
35 from .orca_test_context import OrcaTestContext
36
37
38 @pytest.mark.unit
39 class TestSanitizeGsettingsPath:
40 """Tests for sanitize_gsettings_path."""
41
42 def _setup(self, test_context: OrcaTestContext):
43 """Set up dependencies."""
44
45 additional_modules = [
46 "orca.cmdnames",
47 "orca.messages",
48 "orca.object_properties",
49 "orca.orca_gui_navlist",
50 "orca.orca_i18n",
51 "orca.AXHypertext",
52 "orca.AXObject",
53 "orca.AXTable",
54 "orca.AXText",
55 "orca.AXUtilities",
56 "orca.input_event",
57 ]
58 test_context.setup_shared_dependencies(additional_modules)
59
60 @pytest.mark.parametrize(
61 "input_name,expected",
62 [
63 ("default", "default"),
64 ("Default", "default"),
65 ("MY_PROFILE", "my-profile"),
66 ("Hello World", "hello-world"),
67 ("based_on_italian,_or_is_it?", "based-on-italian-or-is-it"),
68 ("--leading--", "leading"),
69 ("trailing--", "trailing"),
70 (" spaces ", "spaces"),
71 ("a--b---c", "a-b-c"),
72 ("simple", "simple"),
73 ("CamelCase", "camelcase"),
74 ("with.dots.here", "with-dots-here"),
75 ("Firefox", "firefox"),
76 ],
77 )
78 def test_sanitize_gsettings_path(
79 self,
80 test_context: OrcaTestContext,
81 input_name: str,
82 expected: str,
83 ) -> None:
84 """Test sanitize_gsettings_path with various inputs."""
85
86 self._setup(test_context)
87 from orca.gsettings_registry import get_registry
88
89 assert get_registry().sanitize_gsettings_path(input_name) == expected
90
91
92 @pytest.mark.unit
93 class TestActiveState:
94 """Tests for set_active_app/get_active_app and set_active_profile/get_active_profile."""
95
96 def _setup(self, test_context: OrcaTestContext):
97 """Set up dependencies and return essential modules."""
98
99 additional_modules = [
100 "orca.cmdnames",
101 "orca.messages",
102 "orca.object_properties",
103 "orca.orca_gui_navlist",
104 "orca.orca_i18n",
105 "orca.AXHypertext",
106 "orca.AXObject",
107 "orca.AXTable",
108 "orca.AXText",
109 "orca.AXUtilities",
110 "orca.input_event",
111 ]
112 return test_context.setup_shared_dependencies(additional_modules)
113
114 def test_default_profile_is_default(self, test_context: OrcaTestContext) -> None:
115 """Test that the default active profile is 'default'."""
116
117 self._setup(test_context)
118 from orca import gsettings_registry
119
120 assert gsettings_registry.get_registry().get_active_profile() == "default"
121
122 def test_default_app_is_none(self, test_context: OrcaTestContext) -> None:
123 """Test that the default active app is None."""
124
125 self._setup(test_context)
126 from orca import gsettings_registry
127
128 assert gsettings_registry.get_registry().get_active_app() is None
129
130 def test_set_active_profile(self, test_context: OrcaTestContext) -> None:
131 """Test set_active_profile updates the stored profile."""
132
133 self._setup(test_context)
134 from orca import gsettings_registry
135
136 gsettings_registry.get_registry().set_active_profile("spanish")
137 assert gsettings_registry.get_registry().get_active_profile() == "spanish"
138 gsettings_registry.get_registry().set_active_profile("default")
139
140 def test_set_active_app(self, test_context: OrcaTestContext) -> None:
141 """Test set_active_app updates the stored app name."""
142
143 self._setup(test_context)
144 from orca import gsettings_registry
145
146 gsettings_registry.get_registry().set_active_app("Firefox")
147 assert gsettings_registry.get_registry().get_active_app() == "Firefox"
148 gsettings_registry.get_registry().set_active_app(None)
149
150 def test_set_active_app_empty_string_becomes_none(self, test_context: OrcaTestContext) -> None:
151 """Test set_active_app treats empty string as None."""
152
153 self._setup(test_context)
154 from orca import gsettings_registry
155
156 gsettings_registry.get_registry().set_active_app("")
157 assert gsettings_registry.get_registry().get_active_app() is None
158
159
160 @pytest.mark.unit
161 class TestGsettingDecorator:
162 """Tests for the @gsetting decorator and registry."""
163
164 def _setup(self, test_context: OrcaTestContext):
165 """Set up dependencies."""
166
167 additional_modules = [
168 "orca.cmdnames",
169 "orca.messages",
170 "orca.object_properties",
171 "orca.orca_gui_navlist",
172 "orca.orca_i18n",
173 "orca.AXHypertext",
174 "orca.AXObject",
175 "orca.AXTable",
176 "orca.AXText",
177 "orca.AXUtilities",
178 "orca.input_event",
179 ]
180 test_context.setup_shared_dependencies(additional_modules)
181
182 def test_decorator_registers_metadata(self, test_context: OrcaTestContext) -> None:
183 """Test @gsetting decorator populates the registry."""
184
185 self._setup(test_context)
186 from orca.gsettings_registry import get_registry
187
188 registry = get_registry()
189
190 @registry.gsetting(
191 key="test-key",
192 schema="test-schema",
193 gtype="b",
194 default=True,
195 summary="Test",
196 )
197 def some_getter():
198 return True
199
200 assert ("test-schema", "test-key") in registry._descriptors
201 desc = registry._descriptors[("test-schema", "test-key")]
202 assert desc.gsettings_key == "test-key"
203 assert desc.schema == "test-schema"
204 assert desc.gtype == "b"
205 assert desc.default is True
206 assert desc.migration_key is None
207
208 # Clean up
209 del registry._descriptors[("test-schema", "test-key")]
210
211 def test_decorator_registers_migration_key(self, test_context: OrcaTestContext) -> None:
212 """Test @gsetting decorator stores migration_key in the descriptor."""
213
214 self._setup(test_context)
215 from orca.gsettings_registry import get_registry
216
217 registry = get_registry()
218
219 @registry.gsetting(
220 key="test-sk",
221 schema="test",
222 gtype="b",
223 default=True,
224 summary="Test",
225 migration_key="enableTestSetting",
226 )
227 def some_getter():
228 return True
229
230 desc = registry._descriptors[("test", "test-sk")]
231 assert desc.migration_key == "enableTestSetting"
232
233 del registry._descriptors[("test", "test-sk")]
234
235 def test_decorator_migration_key_defaults_to_none(self, test_context: OrcaTestContext) -> None:
236 """Test @gsetting decorator defaults migration_key to None when omitted."""
237
238 self._setup(test_context)
239 from orca.gsettings_registry import get_registry
240
241 registry = get_registry()
242
243 @registry.gsetting(key="test-no-sk", schema="test", gtype="s", default="", summary="Test")
244 def some_getter():
245 return ""
246
247 desc = registry._descriptors[("test", "test-no-sk")]
248 assert desc.migration_key is None
249
250 del registry._descriptors[("test", "test-no-sk")]
251
252 def test_decorator_preserves_function(self, test_context: OrcaTestContext) -> None:
253 """Test @gsetting decorator returns the function unchanged."""
254
255 self._setup(test_context)
256 from orca.gsettings_registry import get_registry
257
258 registry = get_registry()
259
260 @registry.gsetting(key="test-key2", schema="test", gtype="s", default="", summary="Test")
261 def my_func():
262 return "hello"
263
264 assert my_func() == "hello"
265 assert my_func.gsetting_key == "test-key2" # type: ignore[attr-defined]
266
267 del registry._descriptors[("test", "test-key2")]
268
269 def test_decorator_with_voice_type(self, test_context: OrcaTestContext) -> None:
270 """Test @gsetting decorator handles voice_type parameter."""
271
272 self._setup(test_context)
273 from orca.gsettings_registry import get_registry
274
275 registry = get_registry()
276
277 @registry.gsetting(
278 key="test-voice-key",
279 schema="voice",
280 gtype="i",
281 default=50,
282 summary="Test",
283 voice_type="default",
284 )
285 def voice_getter():
286 return 50
287
288 desc = registry._descriptors[("voice", "test-voice-key")]
289 assert desc.voice_type == "default"
290
291 del registry._descriptors[("voice", "test-voice-key")]
292
293
294 @pytest.mark.unit
295 class TestGSettingsSchemaHandle:
296 """Tests for GSettingsSchemaHandle."""
297
298 def _setup(self, test_context: OrcaTestContext):
299 """Set up dependencies."""
300
301 additional_modules = [
302 "orca.cmdnames",
303 "orca.messages",
304 "orca.object_properties",
305 "orca.orca_gui_navlist",
306 "orca.orca_i18n",
307 "orca.AXHypertext",
308 "orca.AXObject",
309 "orca.AXTable",
310 "orca.AXText",
311 "orca.AXUtilities",
312 "orca.input_event",
313 ]
314 return test_context.setup_shared_dependencies(additional_modules)
315
316 def test_get_schema_returns_none_when_source_unavailable(
317 self,
318 test_context: OrcaTestContext,
319 ) -> None:
320 """Test get_schema returns None when GSettings schema source is unavailable."""
321
322 self._setup(test_context)
323 from orca.gsettings_registry import GSettingsSchemaHandle
324
325 handle = GSettingsSchemaHandle("org.gnome.Orca.Test", "test")
326 # Schema won't exist in test environment unless installed
327 # Force it to return None by patching
328 test_context.patch_object(handle, "get_schema", return_value=None)
329 assert handle.get_schema() is None
330
331 def test_has_key_returns_false_without_schema(self, test_context: OrcaTestContext) -> None:
332 """Test has_key returns False when schema unavailable."""
333
334 self._setup(test_context)
335 from orca.gsettings_registry import GSettingsSchemaHandle
336
337 handle = GSettingsSchemaHandle("org.gnome.Orca.Test", "test")
338 test_context.patch_object(handle, "get_schema", return_value=None)
339 assert handle.has_key("some-key") is False
340
341 def test_has_key_delegates_to_schema(self, test_context: OrcaTestContext) -> None:
342 """Test has_key delegates to schema.has_key."""
343
344 self._setup(test_context)
345 from orca.gsettings_registry import GSettingsSchemaHandle
346
347 handle = GSettingsSchemaHandle("org.gnome.Orca.Test", "test")
348 mock_schema = test_context.Mock()
349 mock_schema.has_key.return_value = True
350 test_context.patch_object(handle, "get_schema", return_value=mock_schema)
351 assert handle.has_key("existing-key") is True
352 mock_schema.has_key.assert_called_with("existing-key")
353
354 def test_build_profile_path(self, test_context: OrcaTestContext) -> None:
355 """Test _build_profile_path produces correct dconf path."""
356
357 self._setup(test_context)
358 from orca.gsettings_registry import GSettingsSchemaHandle
359
360 handle = GSettingsSchemaHandle("org.gnome.Orca.TypingEcho", "typing-echo")
361 assert handle._build_profile_path("default") == "/org/gnome/orca/default/typing-echo/"
362 assert handle._build_profile_path("Spanish") == "/org/gnome/orca/spanish/typing-echo/"
363
364 def test_build_profile_path_with_sub_path(self, test_context: OrcaTestContext) -> None:
365 """Test _build_profile_path with sub_path override."""
366
367 self._setup(test_context)
368 from orca.gsettings_registry import GSettingsSchemaHandle
369
370 handle = GSettingsSchemaHandle("org.gnome.Orca.Voice", "voices")
371 path = handle._build_profile_path("default", sub_path="voices/uppercase")
372 assert path == "/org/gnome/orca/default/voices/uppercase/"
373
374 def test_build_app_path(self, test_context: OrcaTestContext) -> None:
375 """Test _build_app_path produces correct dconf path."""
376
377 self._setup(test_context)
378 from orca.gsettings_registry import GSettingsSchemaHandle
379
380 handle = GSettingsSchemaHandle("org.gnome.Orca.Speech", "speech")
381 path = handle._build_app_path("Firefox", "default")
382 assert path == "/org/gnome/orca/default/apps/firefox/speech/"
383
384 def test_build_app_path_with_sub_path(self, test_context: OrcaTestContext) -> None:
385 """Test _build_app_path with sub_path override."""
386
387 self._setup(test_context)
388 from orca.gsettings_registry import GSettingsSchemaHandle
389
390 handle = GSettingsSchemaHandle("org.gnome.Orca.Voice", "voices")
391 path = handle._build_app_path("Firefox", "spanish", sub_path="voices/default")
392 assert path == "/org/gnome/orca/spanish/apps/firefox/voices/default/"
393
394 def test_get_for_profile_returns_none_without_schema(
395 self,
396 test_context: OrcaTestContext,
397 ) -> None:
398 """Test get_for_profile returns None when schema unavailable."""
399
400 self._setup(test_context)
401 from orca.gsettings_registry import GSettingsSchemaHandle
402
403 handle = GSettingsSchemaHandle("org.gnome.Orca.Test", "test")
404 test_context.patch_object(handle, "get_schema", return_value=None)
405 assert handle.get_for_profile("default") is None
406
407 def test_get_boolean_returns_none_without_schema(self, test_context: OrcaTestContext) -> None:
408 """Test get_boolean returns None when schema unavailable."""
409
410 self._setup(test_context)
411 from orca.gsettings_registry import GSettingsSchemaHandle
412
413 handle = GSettingsSchemaHandle("org.gnome.Orca.Test", "test")
414 test_context.patch_object(handle, "get_schema", return_value=None)
415 assert handle.get_boolean("some-key") is None
416
417 def test_set_boolean_returns_false_without_schema(self, test_context: OrcaTestContext) -> None:
418 """Test set_boolean returns False when schema unavailable."""
419
420 self._setup(test_context)
421 from orca.gsettings_registry import GSettingsSchemaHandle
422
423 handle = GSettingsSchemaHandle("org.gnome.Orca.Test", "test")
424 test_context.patch_object(handle, "get_schema", return_value=None)
425 assert handle.set_boolean("some-key", True) is False
426
427 def test_layered_get_app_override_wins(self, test_context: OrcaTestContext) -> None:
428 """Test layered getter returns app-specific value when set."""
429
430 self._setup(test_context)
431
432 from orca import gsettings_registry
433 from orca.gsettings_registry import GSettingsSchemaHandle
434
435 handle = GSettingsSchemaHandle("org.gnome.Orca.Test", "test")
436
437 mock_schema = test_context.Mock()
438 mock_schema.has_key.return_value = True
439 test_context.patch_object(handle, "get_schema", return_value=mock_schema)
440
441 # Set context: app is "Firefox", profile is "default"
442 gsettings_registry.get_registry().set_active_app("Firefox")
443 gsettings_registry.get_registry().set_active_profile("default")
444
445 # App GSettings has the value
446 mock_app_gs = test_context.Mock()
447 mock_app_variant = test_context.Mock()
448 mock_app_gs.get_user_value.return_value = mock_app_variant
449 mock_app_gs.get_boolean.return_value = False
450
451 # Profile GSettings also has a value (should be ignored)
452 mock_profile_gs = test_context.Mock()
453 mock_profile_variant = test_context.Mock()
454 mock_profile_gs.get_user_value.return_value = mock_profile_variant
455 mock_profile_gs.get_boolean.return_value = True
456
457 test_context.patch_object(handle, "get_for_app", return_value=mock_app_gs)
458 test_context.patch_object(handle, "get_for_profile", return_value=mock_profile_gs)
459
460 result = handle.get_boolean("some-key")
461 assert result is False # App value wins
462 gsettings_registry.get_registry().set_active_app(None)
463
464 def test_layered_get_profile_fallback(self, test_context: OrcaTestContext) -> None:
465 """Test layered getter falls back to profile when app has no user value."""
466
467 self._setup(test_context)
468
469 from orca import gsettings_registry
470 from orca.gsettings_registry import GSettingsSchemaHandle
471
472 handle = GSettingsSchemaHandle("org.gnome.Orca.Test", "test")
473
474 mock_schema = test_context.Mock()
475 mock_schema.has_key.return_value = True
476 test_context.patch_object(handle, "get_schema", return_value=mock_schema)
477
478 gsettings_registry.get_registry().set_active_app("Firefox")
479 gsettings_registry.get_registry().set_active_profile("default")
480
481 # App GSettings has no user value
482 mock_app_gs = test_context.Mock()
483 mock_app_gs.get_user_value.return_value = None
484
485 # Profile GSettings has the value
486 mock_profile_gs = test_context.Mock()
487 mock_profile_variant = test_context.Mock()
488 mock_profile_gs.get_user_value.return_value = mock_profile_variant
489 mock_profile_gs.get_boolean.return_value = True
490
491 test_context.patch_object(handle, "get_for_app", return_value=mock_app_gs)
492 test_context.patch_object(handle, "get_for_profile", return_value=mock_profile_gs)
493
494 result = handle.get_boolean("some-key")
495 assert result is True
496 gsettings_registry.get_registry().set_active_app(None)
497
498 def test_layered_get_default_profile_fallback(self, test_context: OrcaTestContext) -> None:
499 """Test layered getter falls back to default profile for non-default profiles."""
500
501 self._setup(test_context)
502
503 from orca import gsettings_registry
504 from orca.gsettings_registry import GSettingsSchemaHandle
505
506 handle = GSettingsSchemaHandle("org.gnome.Orca.Test", "test")
507
508 mock_schema = test_context.Mock()
509 mock_schema.has_key.return_value = True
510 test_context.patch_object(handle, "get_schema", return_value=mock_schema)
511
512 gsettings_registry.get_registry().set_active_app(None)
513 gsettings_registry.get_registry().set_active_profile("spanish")
514
515 # Spanish profile has no user value
516 mock_spanish_gs = test_context.Mock()
517 mock_spanish_gs.get_user_value.return_value = None
518
519 # Default profile has the value
520 mock_default_gs = test_context.Mock()
521 mock_default_variant = test_context.Mock()
522 mock_default_gs.get_user_value.return_value = mock_default_variant
523 mock_default_gs.get_boolean.return_value = True
524
525 def get_for_profile_side_effect(profile, _sub_path=""):
526 if profile == "spanish":
527 return mock_spanish_gs
528 return mock_default_gs
529
530 test_context.patch_object(
531 handle,
532 "get_for_profile",
533 side_effect=get_for_profile_side_effect,
534 )
535
536 result = handle.get_boolean("some-key")
537 assert result is True
538 gsettings_registry.get_registry().set_active_profile("default")
539
540 def test_layered_get_returns_none_when_nothing_set(self, test_context: OrcaTestContext) -> None:
541 """Test layered getter returns None when no layer has a user value."""
542
543 self._setup(test_context)
544
545 from orca import gsettings_registry
546 from orca.gsettings_registry import GSettingsSchemaHandle
547
548 handle = GSettingsSchemaHandle("org.gnome.Orca.Test", "test")
549
550 mock_schema = test_context.Mock()
551 mock_schema.has_key.return_value = True
552 test_context.patch_object(handle, "get_schema", return_value=mock_schema)
553
554 gsettings_registry.get_registry().set_active_app(None)
555 gsettings_registry.get_registry().set_active_profile("default")
556
557 mock_gs = test_context.Mock()
558 mock_gs.get_user_value.return_value = None
559 test_context.patch_object(handle, "get_for_profile", return_value=mock_gs)
560
561 result = handle.get_boolean("some-key")
562 assert result is None
563
564 def test_get_string_layered(self, test_context: OrcaTestContext) -> None:
565 """Test get_string uses layered lookup."""
566
567 self._setup(test_context)
568
569 from orca import gsettings_registry
570 from orca.gsettings_registry import GSettingsSchemaHandle
571
572 handle = GSettingsSchemaHandle("org.gnome.Orca.Test", "test")
573
574 mock_schema = test_context.Mock()
575 mock_schema.has_key.return_value = True
576 test_context.patch_object(handle, "get_schema", return_value=mock_schema)
577
578 gsettings_registry.get_registry().set_active_app(None)
579 gsettings_registry.get_registry().set_active_profile("default")
580
581 mock_gs = test_context.Mock()
582 mock_variant = test_context.Mock()
583 mock_gs.get_user_value.return_value = mock_variant
584 mock_gs.get_string.return_value = "voxin"
585 test_context.patch_object(handle, "get_for_profile", return_value=mock_gs)
586
587 result = handle.get_string("synthesizer")
588 assert result == "voxin"
589
590
591 @pytest.mark.unit
592 class TestSettingsMappings:
593 """Tests for JSON ↔ GSettings conversion functions."""
594
595 def _setup(self, test_context: OrcaTestContext):
596 """Set up dependencies."""
597
598 additional_modules = [
599 "orca.cmdnames",
600 "orca.messages",
601 "orca.object_properties",
602 "orca.orca_gui_navlist",
603 "orca.orca_i18n",
604 "orca.AXHypertext",
605 "orca.AXObject",
606 "orca.AXTable",
607 "orca.AXText",
608 "orca.AXUtilities",
609 "orca.input_event",
610 ]
611 test_context.setup_shared_dependencies(additional_modules)
612
613 def test_register_and_get_mappings(self, test_context: OrcaTestContext) -> None:
614 """Test register_settings_mappings and _get_settings_mappings."""
615
616 self._setup(test_context)
617 from orca.gsettings_registry import SettingsMapping, get_registry
618
619 registry = get_registry()
620
621 mappings = [
622 SettingsMapping("enableFoo", "foo-enabled", "b", True),
623 SettingsMapping("barLevel", "bar-level", "s", "none"),
624 ]
625 registry.register_settings_mappings("test-schema", mappings)
626 assert registry._get_settings_mappings("test-schema") == mappings
627 assert not registry._get_settings_mappings("nonexistent")
628
629 del registry._mappings["test-schema"]
630
631 def test_write_mapped_settings_boolean(self, test_context: OrcaTestContext) -> None:
632 """Test _write_mapped_settings writes boolean values."""
633
634 self._setup(test_context)
635 from orca.gsettings_registry import SettingsMapping, get_registry
636
637 registry = get_registry()
638
639 registry.register_settings_mappings(
640 "test-b",
641 [
642 SettingsMapping("enableFoo", "foo-enabled", "b", True),
643 ],
644 )
645
646 mock_gs = test_context.Mock()
647 # Value differs from default
648 result = registry._write_mapped_settings({"enableFoo": False}, mock_gs, "test-b")
649 assert result is True
650 mock_gs.set_boolean.assert_called_once_with("foo-enabled", False)
651
652 del registry._mappings["test-b"]
653
654 def test_write_mapped_settings_skips_defaults(self, test_context: OrcaTestContext) -> None:
655 """Test _write_mapped_settings skips values matching schema defaults."""
656
657 self._setup(test_context)
658 from orca.gsettings_registry import SettingsMapping, get_registry
659
660 registry = get_registry()
661
662 registry.register_settings_mappings(
663 "test-skip",
664 [
665 SettingsMapping("enableFoo", "foo-enabled", "b", True),
666 ],
667 )
668
669 mock_gs = test_context.Mock()
670 # Value matches default — should be skipped
671 result = registry._write_mapped_settings({"enableFoo": True}, mock_gs, "test-skip")
672 assert result is False
673 mock_gs.set_boolean.assert_not_called()
674
675 del registry._mappings["test-skip"]
676
677 def test_write_mapped_settings_enum(self, test_context: OrcaTestContext) -> None:
678 """Test _write_mapped_settings handles enum (int->string) conversions."""
679
680 self._setup(test_context)
681 from orca.gsettings_registry import SettingsMapping, get_registry
682
683 registry = get_registry()
684
685 registry.register_settings_mappings(
686 "test-enum",
687 [
688 SettingsMapping(
689 "verbLevel",
690 "verbosity-level",
691 "s",
692 1,
693 enum_map={0: "brief", 1: "verbose"},
694 ),
695 ],
696 )
697
698 mock_gs = test_context.Mock()
699 # Value 0 differs from default 1
700 result = registry._write_mapped_settings({"verbLevel": 0}, mock_gs, "test-enum")
701 assert result is True
702 mock_gs.set_string.assert_called_once_with("verbosity-level", "brief")
703
704 del registry._mappings["test-enum"]
705
706 def test_write_mapped_settings_enum_skips_default(self, test_context: OrcaTestContext) -> None:
707 """Test _write_mapped_settings enum skips value matching default int."""
708
709 self._setup(test_context)
710 from orca.gsettings_registry import SettingsMapping, get_registry
711
712 registry = get_registry()
713
714 registry.register_settings_mappings(
715 "test-enum-skip",
716 [
717 SettingsMapping(
718 "verbLevel",
719 "verbosity-level",
720 "s",
721 1,
722 enum_map={0: "brief", 1: "verbose"},
723 ),
724 ],
725 )
726
727 mock_gs = test_context.Mock()
728 result = registry._write_mapped_settings({"verbLevel": 1}, mock_gs, "test-enum-skip")
729 assert result is False
730 mock_gs.set_string.assert_not_called()
731
732 del registry._mappings["test-enum-skip"]
733
734 def test_read_mapped_settings_boolean(self, test_context: OrcaTestContext) -> None:
735 """Test gsettings_to_json reads boolean values."""
736
737 self._setup(test_context)
738 from orca import gsettings_migrator
739 from orca.gsettings_registry import SettingsMapping, get_registry
740
741 registry = get_registry()
742
743 registry.register_settings_mappings(
744 "test-read",
745 [
746 SettingsMapping("enableFoo", "foo-enabled", "b", True),
747 SettingsMapping("enableBar", "bar-enabled", "b", False),
748 ],
749 )
750
751 mock_gs = test_context.Mock()
752
753 mock_variant_foo = test_context.Mock()
754 mock_variant_foo.get_boolean.return_value = False
755
756 def get_user_value_side_effect(key):
757 if key == "foo-enabled":
758 return mock_variant_foo
759 return None # bar-enabled not set
760
761 mock_gs.get_user_value.side_effect = get_user_value_side_effect
762
763 mappings = registry._get_settings_mappings("test-read")
764 result = gsettings_migrator.gsettings_to_json(mock_gs, mappings)
765 assert result == {"enableFoo": False}
766 assert "enableBar" not in result
767
768 del registry._mappings["test-read"]
769
770 def test_read_mapped_settings_enum(self, test_context: OrcaTestContext) -> None:
771 """Test gsettings_to_json reverses enum mapping (string->int)."""
772
773 self._setup(test_context)
774 from orca import gsettings_migrator
775 from orca.gsettings_registry import SettingsMapping, get_registry
776
777 registry = get_registry()
778
779 registry.register_settings_mappings(
780 "test-read-enum",
781 [
782 SettingsMapping(
783 "verbLevel",
784 "verbosity-level",
785 "s",
786 1,
787 enum_map={0: "brief", 1: "verbose"},
788 ),
789 ],
790 )
791
792 mock_gs = test_context.Mock()
793 mock_variant = test_context.Mock()
794 mock_variant.get_string.return_value = "brief"
795 mock_gs.get_user_value.return_value = mock_variant
796
797 mappings = registry._get_settings_mappings("test-read-enum")
798 result = gsettings_migrator.gsettings_to_json(mock_gs, mappings)
799 assert result == {"verbLevel": 0}
800
801 del registry._mappings["test-read-enum"]
802
803 def test_roundtrip(self, test_context: OrcaTestContext) -> None:
804 """Test _write_mapped_settings followed by gsettings_to_json preserves values."""
805
806 self._setup(test_context)
807 from orca import gsettings_migrator
808 from orca.gsettings_registry import SettingsMapping, get_registry
809
810 registry = get_registry()
811
812 registry.register_settings_mappings(
813 "test-rt",
814 [
815 SettingsMapping("enableFoo", "foo-enabled", "b", True),
816 SettingsMapping(
817 "punctStyle",
818 "punctuation-level",
819 "s",
820 1,
821 enum_map={0: "all", 1: "most", 2: "some", 3: "none"},
822 ),
823 ],
824 )
825
826 # Simulate a Gio.Settings object with in-memory storage
827 store: dict[str, tuple] = {}
828
829 mock_gs = test_context.Mock()
830
831 def set_boolean(key, value):
832 store[key] = ("b", value)
833
834 def set_string(key, value):
835 store[key] = ("s", value)
836
837 mock_gs.set_boolean.side_effect = set_boolean
838 mock_gs.set_string.side_effect = set_string
839
840 def get_user_value(key):
841 if key not in store:
842 return None
843 gtype, value = store[key]
844 variant = test_context.Mock()
845 if gtype == "b":
846 variant.get_boolean.return_value = value
847 elif gtype == "s":
848 variant.get_string.return_value = value
849 return variant
850
851 mock_gs.get_user_value.side_effect = get_user_value
852
853 original = {"enableFoo": False, "punctStyle": 2}
854 registry._write_mapped_settings(original, mock_gs, "test-rt")
855
856 mappings = registry._get_settings_mappings("test-rt")
857 recovered = gsettings_migrator.gsettings_to_json(mock_gs, mappings)
858 assert recovered == original
859
860 del registry._mappings["test-rt"]
861
862 def test_write_mapped_settings_missing_keys(self, test_context: OrcaTestContext) -> None:
863 """Test _write_mapped_settings ignores keys not present in json_dict."""
864
865 self._setup(test_context)
866 from orca.gsettings_registry import SettingsMapping, get_registry
867
868 registry = get_registry()
869
870 registry.register_settings_mappings(
871 "test-miss",
872 [
873 SettingsMapping("enableFoo", "foo-enabled", "b", True),
874 SettingsMapping("enableBar", "bar-enabled", "b", False),
875 ],
876 )
877
878 mock_gs = test_context.Mock()
879 # Only enableBar in the dict, and it matches default
880 result = registry._write_mapped_settings({"enableBar": False}, mock_gs, "test-miss")
881 assert result is False
882 mock_gs.set_boolean.assert_not_called()
883
884 del registry._mappings["test-miss"]
885
886 def test_write_mapped_settings_int_and_double(self, test_context: OrcaTestContext) -> None:
887 """Test _write_mapped_settings handles int and double types."""
888
889 self._setup(test_context)
890 from orca.gsettings_registry import SettingsMapping, get_registry
891
892 registry = get_registry()
893
894 registry.register_settings_mappings(
895 "test-id",
896 [
897 SettingsMapping("rate", "rate", "i", 50),
898 SettingsMapping("pitch", "pitch", "d", 5.0),
899 ],
900 )
901
902 mock_gs = test_context.Mock()
903 result = registry._write_mapped_settings({"rate": 75, "pitch": 7.5}, mock_gs, "test-id")
904 assert result is True
905 mock_gs.set_int.assert_called_once_with("rate", 75)
906 mock_gs.set_double.assert_called_once_with("pitch", 7.5)
907
908 del registry._mappings["test-id"]
909
910
911 @pytest.mark.unit
912 class TestBidirectionalConversionMultiKey:
913 """Tests for JSON↔GSettings roundtrip with realistic multi-key mappings."""
914
915 def _setup(self, test_context: OrcaTestContext):
916 """Set up dependencies."""
917
918 additional_modules = [
919 "orca.cmdnames",
920 "orca.messages",
921 "orca.object_properties",
922 "orca.orca_gui_navlist",
923 "orca.orca_i18n",
924 "orca.AXHypertext",
925 "orca.AXObject",
926 "orca.AXTable",
927 "orca.AXText",
928 "orca.AXUtilities",
929 "orca.input_event",
930 ]
931 test_context.setup_shared_dependencies(additional_modules)
932
933 def _make_mock_gs(self, test_context: OrcaTestContext):
934 """Returns a mock Gio.Settings backed by an in-memory dict."""
935
936 store: dict[str, tuple[str, object]] = {}
937 mock_gs = test_context.Mock()
938
939 def set_boolean(key, value):
940 store[key] = ("b", value)
941
942 def set_string(key, value):
943 store[key] = ("s", value)
944
945 def set_int(key, value):
946 store[key] = ("i", value)
947
948 def set_double(key, value):
949 store[key] = ("d", value)
950
951 mock_gs.set_boolean.side_effect = set_boolean
952 mock_gs.set_string.side_effect = set_string
953 mock_gs.set_int.side_effect = set_int
954 mock_gs.set_double.side_effect = set_double
955
956 def get_user_value(key):
957 if key not in store:
958 return None
959 gtype, value = store[key]
960 variant = test_context.Mock()
961 if gtype == "b":
962 variant.get_boolean.return_value = value
963 elif gtype == "s":
964 variant.get_string.return_value = value
965 elif gtype == "i":
966 variant.get_int32.return_value = value
967 elif gtype == "d":
968 variant.get_double.return_value = value
969 return variant
970
971 mock_gs.get_user_value.side_effect = get_user_value
972 return mock_gs, store
973
974 def test_roundtrip_with_mixed_types_and_enums(self, test_context: OrcaTestContext) -> None:
975 """Test roundtrip with booleans, strings, ints, doubles, and enums together."""
976
977 self._setup(test_context)
978 from orca import gsettings_migrator
979 from orca.gsettings_registry import SettingsMapping, get_registry
980
981 registry = get_registry()
982
983 registry.register_settings_mappings(
984 "test-multi",
985 [
986 SettingsMapping("enableSpeech", "enable", "b", True),
987 SettingsMapping("capitalizationStyle", "capitalization-style", "s", "none"),
988 SettingsMapping("rate", "rate", "i", 50),
989 SettingsMapping("pitch", "pitch", "d", 5.0),
990 SettingsMapping(
991 "verbalizePunctuationStyle",
992 "punctuation-level",
993 "s",
994 1,
995 enum_map={0: "all", 1: "most", 2: "some", 3: "none"},
996 ),
997 ],
998 )
999 try:
1000 json_dict = {
1001 "enableSpeech": False,
1002 "capitalizationStyle": "spell",
1003 "rate": 75,
1004 "pitch": 7.5,
1005 "verbalizePunctuationStyle": 2,
1006 }
1007 mock_gs, _ = self._make_mock_gs(test_context)
1008 wrote = registry._write_mapped_settings(json_dict, mock_gs, "test-multi")
1009 assert wrote is True
1010
1011 mappings = registry._get_settings_mappings("test-multi")
1012 recovered = gsettings_migrator.gsettings_to_json(mock_gs, mappings)
1013 assert recovered == json_dict
1014 finally:
1015 registry._mappings.pop("test-multi", None)
1016
1017 def test_defaults_skipped_non_defaults_preserved(self, test_context: OrcaTestContext) -> None:
1018 """Test that default values are skipped and non-defaults roundtrip correctly."""
1019
1020 self._setup(test_context)
1021 from orca import gsettings_migrator
1022 from orca.gsettings_registry import SettingsMapping, get_registry
1023
1024 registry = get_registry()
1025
1026 registry.register_settings_mappings(
1027 "test-defaults",
1028 [
1029 SettingsMapping("enableKeyEcho", "key-echo", "b", True),
1030 SettingsMapping("enableEchoByCharacter", "character-echo", "b", False),
1031 SettingsMapping("enableNavigationKeys", "navigation-keys", "b", False),
1032 SettingsMapping(
1033 "speechVerbosityLevel",
1034 "verbosity-level",
1035 "s",
1036 1,
1037 enum_map={0: "brief", 1: "verbose"},
1038 ),
1039 ],
1040 )
1041 try:
1042 json_dict = {
1043 "enableKeyEcho": False, # non-default (default True)
1044 "enableEchoByCharacter": False, # matches default — should be skipped
1045 "enableNavigationKeys": True, # non-default (default False)
1046 "speechVerbosityLevel": 1, # matches default — should be skipped
1047 }
1048 mock_gs, store = self._make_mock_gs(test_context)
1049 registry._write_mapped_settings(json_dict, mock_gs, "test-defaults")
1050
1051 # Only non-defaults should have been written
1052 assert "key-echo" in store
1053 assert "navigation-keys" in store
1054 assert "character-echo" not in store
1055 assert "verbosity-level" not in store
1056
1057 mappings = registry._get_settings_mappings("test-defaults")
1058 recovered = gsettings_migrator.gsettings_to_json(mock_gs, mappings)
1059 assert recovered == {
1060 "enableKeyEcho": False,
1061 "enableNavigationKeys": True,
1062 }
1063 finally:
1064 registry._mappings.pop("test-defaults", None)
1065
1066 def test_empty_dict_writes_nothing(self, test_context: OrcaTestContext) -> None:
1067 """Test that an empty JSON dict produces no writes and empty recovery."""
1068
1069 self._setup(test_context)
1070 from orca import gsettings_migrator
1071 from orca.gsettings_registry import SettingsMapping, get_registry
1072
1073 registry = get_registry()
1074
1075 registry.register_settings_mappings(
1076 "test-empty",
1077 [
1078 SettingsMapping("enableSpeech", "enable", "b", True),
1079 SettingsMapping("rate", "rate", "i", 50),
1080 ],
1081 )
1082 try:
1083 mock_gs, _ = self._make_mock_gs(test_context)
1084 wrote = registry._write_mapped_settings({}, mock_gs, "test-empty")
1085 assert wrote is False
1086 mappings = registry._get_settings_mappings("test-empty")
1087 assert not gsettings_migrator.gsettings_to_json(mock_gs, mappings)
1088 finally:
1089 registry._mappings.pop("test-empty", None)
1090
1091 def test_unrelated_keys_ignored(self, test_context: OrcaTestContext) -> None:
1092 """Test that JSON keys not in the mapping are ignored."""
1093
1094 self._setup(test_context)
1095 from orca import gsettings_migrator
1096 from orca.gsettings_registry import SettingsMapping, get_registry
1097
1098 registry = get_registry()
1099
1100 registry.register_settings_mappings(
1101 "test-ignore",
1102 [
1103 SettingsMapping("enableKeyEcho", "key-echo", "b", True),
1104 ],
1105 )
1106 try:
1107 json_dict = {
1108 "enableKeyEcho": False,
1109 "caretNavigationEnabled": True,
1110 "brailleFlashTime": 8000,
1111 "voices": {"default": {"rate": 56}},
1112 }
1113 mock_gs, store = self._make_mock_gs(test_context)
1114 registry._write_mapped_settings(json_dict, mock_gs, "test-ignore")
1115
1116 assert len(store) == 1
1117 assert "key-echo" in store
1118
1119 mappings = registry._get_settings_mappings("test-ignore")
1120 recovered = gsettings_migrator.gsettings_to_json(mock_gs, mappings)
1121 assert recovered == {"enableKeyEcho": False}
1122 finally:
1123 registry._mappings.pop("test-ignore", None)
1124
1125 def test_all_enum_values_roundtrip(self, test_context: OrcaTestContext) -> None:
1126 """Test that every enum value roundtrips correctly."""
1127
1128 self._setup(test_context)
1129 from orca import gsettings_migrator
1130 from orca.gsettings_registry import SettingsMapping, get_registry
1131
1132 registry = get_registry()
1133
1134 enum_map = {0: "all", 1: "most", 2: "some", 3: "none"}
1135 registry.register_settings_mappings(
1136 "test-all-enums",
1137 [
1138 SettingsMapping("punctStyle", "punctuation-level", "s", 1, enum_map=enum_map),
1139 ],
1140 )
1141 try:
1142 for int_val in enum_map:
1143 if int_val == 1:
1144 continue # skip default
1145 mock_gs, _ = self._make_mock_gs(test_context)
1146 registry._write_mapped_settings({"punctStyle": int_val}, mock_gs, "test-all-enums")
1147 mappings = registry._get_settings_mappings("test-all-enums")
1148 recovered = gsettings_migrator.gsettings_to_json(mock_gs, mappings)
1149 assert recovered == {"punctStyle": int_val}
1150 finally:
1151 registry._mappings.pop("test-all-enums", None)
1152
1153
1154 @pytest.mark.unit
1155 class TestBuildMappingsFromDescriptors:
1156 """Tests for auto-generating SettingsMapping from @gsetting descriptors."""
1157
1158 def _setup(self, test_context: OrcaTestContext):
1159 """Set up dependencies."""
1160
1161 additional_modules = [
1162 "orca.cmdnames",
1163 "orca.messages",
1164 "orca.object_properties",
1165 "orca.orca_gui_navlist",
1166 "orca.orca_i18n",
1167 "orca.AXHypertext",
1168 "orca.AXObject",
1169 "orca.AXTable",
1170 "orca.AXText",
1171 "orca.AXUtilities",
1172 "orca.input_event",
1173 ]
1174 test_context.setup_shared_dependencies(additional_modules)
1175
1176 def test_builds_mappings_from_descriptors(self, test_context: OrcaTestContext) -> None:
1177 """Test _build_mappings_from_descriptors creates SettingsMapping from descriptors."""
1178
1179 self._setup(test_context)
1180 from orca.gsettings_registry import SettingDescriptor, get_registry
1181
1182 registry = get_registry()
1183
1184 registry._descriptors[("my-schema", "foo-enabled")] = SettingDescriptor(
1185 gsettings_key="foo-enabled",
1186 schema="my-schema",
1187 gtype="b",
1188 default=True,
1189 migration_key="enableFoo",
1190 )
1191 registry._descriptors[("my-schema", "bar-level")] = SettingDescriptor(
1192 gsettings_key="bar-level",
1193 schema="my-schema",
1194 gtype="i",
1195 default=50,
1196 migration_key="barLevel",
1197 )
1198 try:
1199 mappings = registry._build_mappings_from_descriptors("my-schema")
1200 assert len(mappings) == 2
1201
1202 by_gs_key = {m.gs_key: m for m in mappings}
1203 assert "foo-enabled" in by_gs_key
1204 assert by_gs_key["foo-enabled"].migration_key == "enableFoo"
1205 assert by_gs_key["foo-enabled"].gtype == "b"
1206 assert by_gs_key["foo-enabled"].default is True
1207 assert by_gs_key["foo-enabled"].enum_map is None
1208
1209 assert "bar-level" in by_gs_key
1210 assert by_gs_key["bar-level"].migration_key == "barLevel"
1211 assert by_gs_key["bar-level"].gtype == "i"
1212 assert by_gs_key["bar-level"].default == 50
1213 finally:
1214 registry._descriptors.pop(("my-schema", "foo-enabled"), None)
1215 registry._descriptors.pop(("my-schema", "bar-level"), None)
1216
1217 def test_skips_descriptors_without_migration_key(self, test_context: OrcaTestContext) -> None:
1218 """Test _build_mappings_from_descriptors skips descriptors with migration_key=None."""
1219
1220 self._setup(test_context)
1221 from orca.gsettings_registry import SettingDescriptor, get_registry
1222
1223 registry = get_registry()
1224
1225 registry._descriptors[("my-schema", "has-key")] = SettingDescriptor(
1226 gsettings_key="has-key",
1227 schema="my-schema",
1228 gtype="b",
1229 default=True,
1230 migration_key="enableHasKey",
1231 )
1232 registry._descriptors[("my-schema", "no-key")] = SettingDescriptor(
1233 gsettings_key="no-key",
1234 schema="my-schema",
1235 gtype="b",
1236 default=False,
1237 migration_key=None,
1238 )
1239 try:
1240 mappings = registry._build_mappings_from_descriptors("my-schema")
1241 assert len(mappings) == 1
1242 assert mappings[0].migration_key == "enableHasKey"
1243 finally:
1244 registry._descriptors.pop(("my-schema", "has-key"), None)
1245 registry._descriptors.pop(("my-schema", "no-key"), None)
1246
1247 def test_skips_descriptors_from_other_schemas(self, test_context: OrcaTestContext) -> None:
1248 """Test _build_mappings_from_descriptors only includes matching schema."""
1249
1250 self._setup(test_context)
1251 from orca.gsettings_registry import SettingDescriptor, get_registry
1252
1253 registry = get_registry()
1254
1255 registry._descriptors[("schema-a", "enabled")] = SettingDescriptor(
1256 gsettings_key="enabled",
1257 schema="schema-a",
1258 gtype="b",
1259 default=True,
1260 migration_key="enableA",
1261 )
1262 registry._descriptors[("schema-b", "enabled")] = SettingDescriptor(
1263 gsettings_key="enabled",
1264 schema="schema-b",
1265 gtype="b",
1266 default=False,
1267 migration_key="enableB",
1268 )
1269 try:
1270 mappings_a = registry._build_mappings_from_descriptors("schema-a")
1271 assert len(mappings_a) == 1
1272 assert mappings_a[0].migration_key == "enableA"
1273
1274 mappings_b = registry._build_mappings_from_descriptors("schema-b")
1275 assert len(mappings_b) == 1
1276 assert mappings_b[0].migration_key == "enableB"
1277 finally:
1278 registry._descriptors.pop(("schema-a", "enabled"), None)
1279 registry._descriptors.pop(("schema-b", "enabled"), None)
1280
1281 def test_builds_enum_map_from_registered_enum(self, test_context: OrcaTestContext) -> None:
1282 """Test _build_mappings_from_descriptors builds enum_map from registered enums."""
1283
1284 self._setup(test_context)
1285 from orca.gsettings_registry import SettingDescriptor, get_registry
1286
1287 registry = get_registry()
1288
1289 registry._enums["org.gnome.Orca.Verbosity"] = {"brief": 0, "verbose": 1}
1290 registry._descriptors[("my-schema", "verbosity")] = SettingDescriptor(
1291 gsettings_key="verbosity",
1292 schema="my-schema",
1293 gtype="",
1294 default=1,
1295 migration_key="verbosityLevel",
1296 genum="org.gnome.Orca.Verbosity",
1297 )
1298 try:
1299 mappings = registry._build_mappings_from_descriptors("my-schema")
1300 assert len(mappings) == 1
1301 assert mappings[0].enum_map == {0: "brief", 1: "verbose"}
1302 finally:
1303 registry._descriptors.pop(("my-schema", "verbosity"), None)
1304 registry._enums.pop("org.gnome.Orca.Verbosity", None)
1305
1306 def test_returns_empty_list_for_unknown_schema(self, test_context: OrcaTestContext) -> None:
1307 """Test _build_mappings_from_descriptors returns [] for unknown schema."""
1308
1309 self._setup(test_context)
1310 from orca.gsettings_registry import get_registry
1311
1312 registry = get_registry()
1313 mappings = registry._build_mappings_from_descriptors("nonexistent-schema")
1314 assert not mappings
1315
1316
1317 @pytest.mark.unit
1318 class TestGetSettingsMappingsFallback:
1319 """Tests for _get_settings_mappings fallback to descriptors."""
1320
1321 def _setup(self, test_context: OrcaTestContext):
1322 """Set up dependencies."""
1323
1324 additional_modules = [
1325 "orca.cmdnames",
1326 "orca.messages",
1327 "orca.object_properties",
1328 "orca.orca_gui_navlist",
1329 "orca.orca_i18n",
1330 "orca.AXHypertext",
1331 "orca.AXObject",
1332 "orca.AXTable",
1333 "orca.AXText",
1334 "orca.AXUtilities",
1335 "orca.input_event",
1336 ]
1337 test_context.setup_shared_dependencies(additional_modules)
1338
1339 def test_prefers_explicit_mappings(self, test_context: OrcaTestContext) -> None:
1340 """Test _get_settings_mappings prefers explicitly registered mappings."""
1341
1342 self._setup(test_context)
1343 from orca.gsettings_registry import SettingDescriptor, SettingsMapping, get_registry
1344
1345 registry = get_registry()
1346
1347 explicit = [SettingsMapping("enableFoo", "foo-enabled", "b", True)]
1348 registry.register_settings_mappings("test-pref", explicit)
1349
1350 registry._descriptors[("test-pref", "foo-enabled")] = SettingDescriptor(
1351 gsettings_key="foo-enabled",
1352 schema="test-pref",
1353 gtype="b",
1354 default=False,
1355 migration_key="enableFoo",
1356 )
1357 try:
1358 result = registry._get_settings_mappings("test-pref")
1359 assert result is explicit
1360 finally:
1361 registry._mappings.pop("test-pref", None)
1362 registry._descriptors.pop(("test-pref", "foo-enabled"), None)
1363
1364 def test_falls_back_to_descriptors(self, test_context: OrcaTestContext) -> None:
1365 """Test _get_settings_mappings falls back to descriptors when no explicit mappings."""
1366
1367 self._setup(test_context)
1368 from orca.gsettings_registry import SettingDescriptor, get_registry
1369
1370 registry = get_registry()
1371
1372 registry._descriptors[("test-fb", "bar")] = SettingDescriptor(
1373 gsettings_key="bar",
1374 schema="test-fb",
1375 gtype="s",
1376 default="",
1377 migration_key="barSetting",
1378 )
1379 try:
1380 result = registry._get_settings_mappings("test-fb")
1381 assert len(result) == 1
1382 assert result[0].migration_key == "barSetting"
1383 assert result[0].gs_key == "bar"
1384 finally:
1385 registry._descriptors.pop(("test-fb", "bar"), None)
1386
1387
1388 @pytest.mark.unit
1389 class TestDescriptorKeyCollision:
1390 """Tests verifying (schema, key) tuple prevents collisions."""
1391
1392 def _setup(self, test_context: OrcaTestContext):
1393 """Set up dependencies."""
1394
1395 additional_modules = [
1396 "orca.cmdnames",
1397 "orca.messages",
1398 "orca.object_properties",
1399 "orca.orca_gui_navlist",
1400 "orca.orca_i18n",
1401 "orca.AXHypertext",
1402 "orca.AXObject",
1403 "orca.AXTable",
1404 "orca.AXText",
1405 "orca.AXUtilities",
1406 "orca.input_event",
1407 ]
1408 test_context.setup_shared_dependencies(additional_modules)
1409
1410 def test_same_key_different_schemas_coexist(self, test_context: OrcaTestContext) -> None:
1411 """Test that the same gsettings key in different schemas does not collide."""
1412
1413 self._setup(test_context)
1414 from orca.gsettings_registry import get_registry
1415
1416 registry = get_registry()
1417
1418 @registry.gsetting(
1419 key="enabled",
1420 schema="braille",
1421 gtype="b",
1422 default=True,
1423 summary="Test",
1424 migration_key="enableBraille",
1425 )
1426 def get_braille_enabled():
1427 return True
1428
1429 @registry.gsetting(
1430 key="enabled",
1431 schema="sound",
1432 gtype="b",
1433 default=True,
1434 summary="Test",
1435 migration_key="enableSound",
1436 )
1437 def get_sound_enabled():
1438 return True
1439
1440 try:
1441 assert ("braille", "enabled") in registry._descriptors
1442 assert ("sound", "enabled") in registry._descriptors
1443 assert registry._descriptors[("braille", "enabled")].migration_key == "enableBraille"
1444 assert registry._descriptors[("sound", "enabled")].migration_key == "enableSound"
1445 finally:
1446 registry._descriptors.pop(("braille", "enabled"), None)
1447 registry._descriptors.pop(("sound", "enabled"), None)
1448
1449
1450 @pytest.mark.unit
1451 class TestMigrateAll:
1452 """Tests for migrate_all."""
1453
1454 def _setup(self, test_context: OrcaTestContext):
1455 """Set up dependencies."""
1456
1457 additional_modules = [
1458 "orca.cmdnames",
1459 "orca.messages",
1460 "orca.object_properties",
1461 "orca.orca_gui_navlist",
1462 "orca.orca_i18n",
1463 "orca.AXHypertext",
1464 "orca.AXObject",
1465 "orca.AXTable",
1466 "orca.AXText",
1467 "orca.AXUtilities",
1468 "orca.input_event",
1469 ]
1470 test_context.setup_shared_dependencies(additional_modules)
1471
1472 def test_migrate_all_calls_migrate_schema_for_each(self, test_context: OrcaTestContext) -> None:
1473 """Test migrate_all iterates through all registered schemas."""
1474
1475 self._setup(test_context)
1476 from orca.gsettings_registry import get_registry
1477
1478 registry = get_registry()
1479
1480 registry._schemas["test-alpha"] = "org.gnome.Orca.TestAlpha"
1481 registry._schemas["test-beta"] = "org.gnome.Orca.TestBeta"
1482
1483 migrated_schemas: list[str] = []
1484
1485 def tracking_migrate(_handle, schema_name, _prefs_dir, _profiles):
1486 migrated_schemas.append(schema_name)
1487 return False
1488
1489 try:
1490 test_context.patch_object(registry, "_has_dconf_keys", return_value=False)
1491 test_context.patch_object(registry, "_sync_missing_profiles")
1492 test_context.patch_object(registry, "_read_profiles_from_json", return_value=[])
1493 test_context.patch_object(registry, "migrate_schema", side_effect=tracking_migrate)
1494 registry.migrate_all("/tmp/test")
1495 assert "test-alpha" in migrated_schemas
1496 assert "test-beta" in migrated_schemas
1497 finally:
1498 registry._schemas.pop("test-alpha", None)
1499 registry._schemas.pop("test-beta", None)
1500
1501 def test_migrate_all_returns_true_when_any_migrated(
1502 self,
1503 test_context: OrcaTestContext,
1504 ) -> None:
1505 """Test migrate_all returns True when at least one schema was migrated."""
1506
1507 self._setup(test_context)
1508 from orca.gsettings_registry import get_registry
1509
1510 registry = get_registry()
1511
1512 registry._schemas["test-m1"] = "org.gnome.Orca.TestM1"
1513 registry._schemas["test-m2"] = "org.gnome.Orca.TestM2"
1514
1515 def selective_migrate(_handle, schema_name, _prefs_dir, _profiles):
1516 return schema_name == "test-m2"
1517
1518 try:
1519 test_context.patch_object(registry, "_has_dconf_keys", return_value=False)
1520 test_context.patch_object(registry, "_sync_missing_profiles")
1521 test_context.patch_object(registry, "_read_profiles_from_json", return_value=[])
1522 test_context.patch_object(registry, "migrate_schema", side_effect=selective_migrate)
1523 assert registry.migrate_all("/tmp/test") is True
1524 finally:
1525 registry._schemas.pop("test-m1", None)
1526 registry._schemas.pop("test-m2", None)
1527
1528 def test_migrate_all_returns_false_when_none_migrated(
1529 self,
1530 test_context: OrcaTestContext,
1531 ) -> None:
1532 """Test migrate_all returns False when no schemas were migrated."""
1533
1534 self._setup(test_context)
1535 from orca.gsettings_registry import get_registry
1536
1537 registry = get_registry()
1538
1539 registry._schemas["test-n1"] = "org.gnome.Orca.TestN1"
1540
1541 try:
1542 test_context.patch_object(registry, "_has_dconf_keys", return_value=False)
1543 test_context.patch_object(registry, "_sync_missing_profiles")
1544 test_context.patch_object(registry, "_read_profiles_from_json", return_value=[])
1545 test_context.patch_object(registry, "migrate_schema", return_value=False)
1546 assert registry.migrate_all("/tmp/test") is False
1547 finally:
1548 registry._schemas.pop("test-n1", None)
1549
1550 def test_migrate_all_creates_handle_with_correct_ids(
1551 self,
1552 test_context: OrcaTestContext,
1553 ) -> None:
1554 """Test migrate_all creates GSettingsSchemaHandle with correct schema_id and path."""
1555
1556 self._setup(test_context)
1557 from orca.gsettings_registry import get_registry
1558
1559 registry = get_registry()
1560
1561 registry._schemas["typing-echo"] = "org.gnome.Orca.TypingEcho"
1562
1563 captured_handles: list = []
1564
1565 def capture_migrate(handle, schema_name, _prefs_dir, _profiles):
1566 captured_handles.append((handle.get_schema_id(), schema_name))
1567 return False
1568
1569 try:
1570 test_context.patch_object(registry, "_has_dconf_keys", return_value=False)
1571 test_context.patch_object(registry, "_sync_missing_profiles")
1572 test_context.patch_object(registry, "_read_profiles_from_json", return_value=[])
1573 test_context.patch_object(registry, "migrate_schema", side_effect=capture_migrate)
1574 registry.migrate_all("/tmp/test")
1575 assert len(captured_handles) >= 1
1576 found = [h for h in captured_handles if h[1] == "typing-echo"]
1577 assert len(found) == 1
1578 assert found[0][0] == "org.gnome.Orca.TypingEcho"
1579 finally:
1580 registry._schemas.pop("typing-echo", None)
1581
1582 def test_migrate_all_skips_schemas_without_mappings(
1583 self,
1584 test_context: OrcaTestContext,
1585 ) -> None:
1586 """Test migrate_all gracefully handles schemas with no mappable descriptors."""
1587
1588 self._setup(test_context)
1589 from orca.gsettings_registry import SettingDescriptor, get_registry
1590
1591 registry = get_registry()
1592
1593 registry._schemas["test-nomaps"] = "org.gnome.Orca.TestNoMaps"
1594 registry._descriptors[("test-nomaps", "entries")] = SettingDescriptor(
1595 gsettings_key="entries",
1596 schema="test-nomaps",
1597 gtype="a{ss}",
1598 default={},
1599 migration_key=None,
1600 )
1601
1602 try:
1603 mappings = registry._build_mappings_from_descriptors("test-nomaps")
1604 assert not mappings
1605 finally:
1606 registry._schemas.pop("test-nomaps", None)
1607 registry._descriptors.pop(("test-nomaps", "entries"), None)
1608
1609
1610 @pytest.mark.unit
1611 class TestStringArraySupport:
1612 """Tests for string array (as) type support in JSON↔GSettings conversion."""
1613
1614 def _setup(self, test_context: OrcaTestContext):
1615 """Set up dependencies."""
1616
1617 additional_modules = [
1618 "orca.cmdnames",
1619 "orca.messages",
1620 "orca.object_properties",
1621 "orca.orca_gui_navlist",
1622 "orca.orca_i18n",
1623 "orca.AXHypertext",
1624 "orca.AXObject",
1625 "orca.AXTable",
1626 "orca.AXText",
1627 "orca.AXUtilities",
1628 "orca.input_event",
1629 ]
1630 test_context.setup_shared_dependencies(additional_modules)
1631
1632 def test_write_mapped_settings_string_array(self, test_context: OrcaTestContext) -> None:
1633 """Test _write_mapped_settings writes string array values."""
1634
1635 self._setup(test_context)
1636 from orca.gsettings_registry import SettingsMapping, get_registry
1637
1638 registry = get_registry()
1639
1640 registry.register_settings_mappings(
1641 "test-as",
1642 [SettingsMapping("textAttributesToSpeak", "attributes-to-speak", "as", [])],
1643 )
1644
1645 mock_gs = test_context.Mock()
1646 attrs = ["size", "weight", "style"]
1647 try:
1648 result = registry._write_mapped_settings(
1649 {"textAttributesToSpeak": attrs},
1650 mock_gs,
1651 "test-as",
1652 )
1653 assert result is True
1654 mock_gs.set_strv.assert_called_once_with("attributes-to-speak", attrs)
1655 finally:
1656 registry._mappings.pop("test-as", None)
1657
1658 def test_write_mapped_settings_string_array_skips_default(
1659 self,
1660 test_context: OrcaTestContext,
1661 ) -> None:
1662 """Test _write_mapped_settings skips string array when it matches default."""
1663
1664 self._setup(test_context)
1665 from orca.gsettings_registry import SettingsMapping, get_registry
1666
1667 registry = get_registry()
1668
1669 default_attrs = ["size", "weight"]
1670 registry.register_settings_mappings(
1671 "test-as-skip",
1672 [SettingsMapping("textAttributesToSpeak", "attributes-to-speak", "as", default_attrs)],
1673 )
1674
1675 mock_gs = test_context.Mock()
1676 try:
1677 result = registry._write_mapped_settings(
1678 {"textAttributesToSpeak": ["size", "weight"]},
1679 mock_gs,
1680 "test-as-skip",
1681 )
1682 assert result is False
1683 mock_gs.set_strv.assert_not_called()
1684 finally:
1685 registry._mappings.pop("test-as-skip", None)
1686
1687 def test_read_mapped_settings_string_array(self, test_context: OrcaTestContext) -> None:
1688 """Test gsettings_to_json reads string array values."""
1689
1690 self._setup(test_context)
1691 from orca import gsettings_migrator
1692 from orca.gsettings_registry import SettingsMapping, get_registry
1693
1694 registry = get_registry()
1695
1696 registry.register_settings_mappings(
1697 "test-as-read",
1698 [SettingsMapping("textAttributesToSpeak", "attributes-to-speak", "as", [])],
1699 )
1700
1701 mock_gs = test_context.Mock()
1702 mock_variant = test_context.Mock()
1703 mock_variant.unpack.return_value = ["size", "weight", "style"]
1704 mock_gs.get_user_value.return_value = mock_variant
1705
1706 try:
1707 mappings = registry._get_settings_mappings("test-as-read")
1708 result = gsettings_migrator.gsettings_to_json(mock_gs, mappings)
1709 assert result == {"textAttributesToSpeak": ["size", "weight", "style"]}
1710 finally:
1711 registry._mappings.pop("test-as-read", None)
1712
1713
1714 @pytest.mark.unit
1715 class TestRuntimeValues:
1716 """Tests for runtime value storage (set/get/clear)."""
1717
1718 def _setup(self, test_context: OrcaTestContext):
1719 """Set up dependencies."""
1720
1721 additional_modules = [
1722 "orca.cmdnames",
1723 "orca.messages",
1724 "orca.object_properties",
1725 "orca.orca_gui_navlist",
1726 "orca.orca_i18n",
1727 "orca.AXHypertext",
1728 "orca.AXObject",
1729 "orca.AXTable",
1730 "orca.AXText",
1731 "orca.AXUtilities",
1732 "orca.input_event",
1733 ]
1734 test_context.setup_shared_dependencies(additional_modules)
1735
1736 def test_get_returns_false_for_unset_key(self, test_context: OrcaTestContext) -> None:
1737 """Test get_runtime_value returns (False, None) for a key that was never set."""
1738
1739 self._setup(test_context)
1740 from orca.gsettings_registry import GSettingsRegistry
1741
1742 registry = GSettingsRegistry()
1743 found, value = registry.get_runtime_value("speech", "enable")
1744 assert found is False
1745 assert value is None
1746
1747 def test_set_and_get_boolean(self, test_context: OrcaTestContext) -> None:
1748 """Test set_runtime_value stores a boolean retrievable by get_runtime_value."""
1749
1750 self._setup(test_context)
1751 from orca.gsettings_registry import GSettingsRegistry
1752
1753 registry = GSettingsRegistry()
1754 registry.set_runtime_value("speech", "enable", False)
1755 found, value = registry.get_runtime_value("speech", "enable")
1756 assert found is True
1757 assert value is False
1758
1759 def test_set_and_get_int(self, test_context: OrcaTestContext) -> None:
1760 """Test set_runtime_value stores an int value."""
1761
1762 self._setup(test_context)
1763 from orca.gsettings_registry import GSettingsRegistry
1764
1765 registry = GSettingsRegistry()
1766 registry.set_runtime_value("speech", "repeated-character-limit", 4)
1767 found, value = registry.get_runtime_value("speech", "repeated-character-limit")
1768 assert found is True
1769 assert value == 4
1770
1771 def test_set_and_get_string(self, test_context: OrcaTestContext) -> None:
1772 """Test set_runtime_value stores a string value."""
1773
1774 self._setup(test_context)
1775 from orca.gsettings_registry import GSettingsRegistry
1776
1777 registry = GSettingsRegistry()
1778 registry.set_runtime_value("speech", "capitalization-style", "spell")
1779 found, value = registry.get_runtime_value("speech", "capitalization-style")
1780 assert found is True
1781 assert value == "spell"
1782
1783 def test_set_overwrites_previous_value(self, test_context: OrcaTestContext) -> None:
1784 """Test set_runtime_value overwrites a previously stored value."""
1785
1786 self._setup(test_context)
1787 from orca.gsettings_registry import GSettingsRegistry
1788
1789 registry = GSettingsRegistry()
1790 registry.set_runtime_value("speech", "enable", True)
1791 registry.set_runtime_value("speech", "enable", False)
1792 found, value = registry.get_runtime_value("speech", "enable")
1793 assert found is True
1794 assert value is False
1795
1796 def test_clear_removes_all_values(self, test_context: OrcaTestContext) -> None:
1797 """Test clear_runtime_values removes all stored runtime values."""
1798
1799 self._setup(test_context)
1800 from orca.gsettings_registry import GSettingsRegistry
1801
1802 registry = GSettingsRegistry()
1803 registry.set_runtime_value("speech", "enable", False)
1804 registry.set_runtime_value("braille", "enabled", True)
1805 registry.clear_runtime_values()
1806 found_speech, _ = registry.get_runtime_value("speech", "enable")
1807 found_braille, _ = registry.get_runtime_value("braille", "enabled")
1808 assert found_speech is False
1809 assert found_braille is False
1810
1811 def test_different_schemas_are_independent(self, test_context: OrcaTestContext) -> None:
1812 """Test that the same key in different schemas stores independently."""
1813
1814 self._setup(test_context)
1815 from orca.gsettings_registry import GSettingsRegistry
1816
1817 registry = GSettingsRegistry()
1818 registry.set_runtime_value("speech", "enable", True)
1819 registry.set_runtime_value("braille", "enable", False)
1820 _, speech_val = registry.get_runtime_value("speech", "enable")
1821 _, braille_val = registry.get_runtime_value("braille", "enable")
1822 assert speech_val is True
1823 assert braille_val is False
1824
1825 def test_voice_type_specific_values(self, test_context: OrcaTestContext) -> None:
1826 """Test that voice-type-specific runtime values are stored independently."""
1827
1828 self._setup(test_context)
1829 from orca.gsettings_registry import GSettingsRegistry
1830
1831 registry = GSettingsRegistry()
1832 registry.set_runtime_value("voice", "rate", 50, voice_type="default")
1833 registry.set_runtime_value("voice", "rate", 75, voice_type="uppercase")
1834
1835 found_default, val_default = registry.get_runtime_value(
1836 "voice",
1837 "rate",
1838 voice_type="default",
1839 )
1840 found_upper, val_upper = registry.get_runtime_value("voice", "rate", voice_type="uppercase")
1841 found_none, _ = registry.get_runtime_value("voice", "rate")
1842
1843 assert found_default is True
1844 assert val_default == 50
1845 assert found_upper is True
1846 assert val_upper == 75
1847 assert found_none is False
1848
1849 def test_singleton_set_and_get(self, test_context: OrcaTestContext) -> None:
1850 """Test set/get via the global singleton registry."""
1851
1852 self._setup(test_context)
1853 from orca.gsettings_registry import get_registry
1854
1855 registry = get_registry()
1856 registry.set_runtime_value("speech", "test-singleton-key", 42)
1857 found, value = registry.get_runtime_value("speech", "test-singleton-key")
1858 assert found is True
1859 assert value == 42
1860 registry.clear_runtime_values()
1861
1862
1863 @pytest.mark.unit
1864 class TestLayeredLookup:
1865 """Tests for GSettingsRegistry.layered_lookup."""
1866
1867 def _setup(self, test_context: OrcaTestContext):
1868 """Set up dependencies."""
1869
1870 additional_modules = [
1871 "orca.cmdnames",
1872 "orca.messages",
1873 "orca.object_properties",
1874 "orca.orca_gui_navlist",
1875 "orca.orca_i18n",
1876 "orca.AXHypertext",
1877 "orca.AXObject",
1878 "orca.AXTable",
1879 "orca.AXText",
1880 "orca.AXUtilities",
1881 "orca.input_event",
1882 ]
1883 test_context.setup_shared_dependencies(additional_modules)
1884
1885 def test_returns_none_when_schema_missing(self, test_context: OrcaTestContext) -> None:
1886 """Test layered_lookup returns None for an unknown schema."""
1887
1888 self._setup(test_context)
1889 from orca.gsettings_registry import GSettingsRegistry
1890
1891 registry = GSettingsRegistry()
1892 assert registry.layered_lookup("nonexistent", "key", "b") is None
1893
1894 def test_returns_boolean(self, test_context: OrcaTestContext) -> None:
1895 """Test layered_lookup returns boolean from handle."""
1896
1897 self._setup(test_context)
1898 from orca.gsettings_registry import GSettingsRegistry, GSettingsSchemaHandle
1899
1900 registry = GSettingsRegistry()
1901 registry._schemas["speech"] = "org.gnome.Orca.Speech"
1902
1903 mock_handle = test_context.Mock(spec=GSettingsSchemaHandle)
1904 mock_handle.get_boolean.return_value = True
1905 registry._handles["speech"] = mock_handle
1906
1907 result = registry.layered_lookup("speech", "enabled", "b")
1908 assert result is True
1909 mock_handle.get_boolean.assert_called_once_with("enabled", "", None)
1910
1911 def test_returns_string(self, test_context: OrcaTestContext) -> None:
1912 """Test layered_lookup returns string from handle."""
1913
1914 self._setup(test_context)
1915 from orca.gsettings_registry import GSettingsRegistry, GSettingsSchemaHandle
1916
1917 registry = GSettingsRegistry()
1918 registry._schemas["speech"] = "org.gnome.Orca.Speech"
1919
1920 mock_handle = test_context.Mock(spec=GSettingsSchemaHandle)
1921 mock_handle.get_string.return_value = "voxin"
1922 registry._handles["speech"] = mock_handle
1923
1924 result = registry.layered_lookup("speech", "synthesizer", "s")
1925 assert result == "voxin"
1926 mock_handle.get_string.assert_called_once_with("synthesizer", "", None)
1927
1928 def test_returns_int(self, test_context: OrcaTestContext) -> None:
1929 """Test layered_lookup returns int from handle."""
1930
1931 self._setup(test_context)
1932 from orca.gsettings_registry import GSettingsRegistry, GSettingsSchemaHandle
1933
1934 registry = GSettingsRegistry()
1935 registry._schemas["typing-echo"] = "org.gnome.Orca.TypingEcho"
1936
1937 mock_handle = test_context.Mock(spec=GSettingsSchemaHandle)
1938 mock_handle.get_int.return_value = 75
1939 registry._handles["typing-echo"] = mock_handle
1940
1941 result = registry.layered_lookup("typing-echo", "rate", "i")
1942 assert result == 75
1943
1944 def test_returns_double(self, test_context: OrcaTestContext) -> None:
1945 """Test layered_lookup returns double from handle."""
1946
1947 self._setup(test_context)
1948 from orca.gsettings_registry import GSettingsRegistry, GSettingsSchemaHandle
1949
1950 registry = GSettingsRegistry()
1951 registry._schemas["voice"] = "org.gnome.Orca.Voice"
1952
1953 mock_handle = test_context.Mock(spec=GSettingsSchemaHandle)
1954 mock_handle.get_double.return_value = 7.5
1955 registry._handles["voice"] = mock_handle
1956
1957 result = registry.layered_lookup("voice", "pitch", "d", voice_type="default")
1958 assert result == 7.5
1959 mock_handle.get_double.assert_called_once_with("pitch", "voices/default", None)
1960
1961 def test_voice_sub_path(self, test_context: OrcaTestContext) -> None:
1962 """Test layered_lookup uses voices/{voice_type} sub_path for voice schema."""
1963
1964 self._setup(test_context)
1965 from orca.gsettings_registry import GSettingsRegistry, GSettingsSchemaHandle
1966
1967 registry = GSettingsRegistry()
1968 registry._schemas["voice"] = "org.gnome.Orca.Voice"
1969
1970 mock_handle = test_context.Mock(spec=GSettingsSchemaHandle)
1971 mock_handle.get_int.return_value = 56
1972 registry._handles["voice"] = mock_handle
1973
1974 result = registry.layered_lookup("voice", "rate", "i", voice_type="uppercase")
1975 assert result == 56
1976 mock_handle.get_int.assert_called_once_with("rate", "voices/uppercase", None)
1977
1978 def test_enum_returns_string(self, test_context: OrcaTestContext) -> None:
1979 """Test layered_lookup returns string nick for enum settings."""
1980
1981 self._setup(test_context)
1982 from orca.gsettings_registry import GSettingsRegistry, GSettingsSchemaHandle
1983
1984 registry = GSettingsRegistry()
1985 registry._schemas["speech"] = "org.gnome.Orca.Speech"
1986
1987 mock_handle = test_context.Mock(spec=GSettingsSchemaHandle)
1988 mock_handle.get_string.return_value = "verbose"
1989 registry._handles["speech"] = mock_handle
1990
1991 result = registry.layered_lookup(
1992 "speech",
1993 "verbosity-level",
1994 "",
1995 genum="org.gnome.Orca.Verbosity",
1996 )
1997 assert result == "verbose"
1998 mock_handle.get_string.assert_called_once_with("verbosity-level", "", None)
1999
2000 def test_passes_app_name_to_handle(self, test_context: OrcaTestContext) -> None:
2001 """Test layered_lookup checks app dconf first for explicit app_name."""
2002
2003 self._setup(test_context)
2004 from orca.gsettings_registry import GSettingsRegistry, GSettingsSchemaHandle
2005
2006 registry = GSettingsRegistry()
2007 registry._schemas["chat"] = "org.gnome.Orca.Chat"
2008
2009 mock_handle = test_context.Mock(spec=GSettingsSchemaHandle)
2010 mock_app_gs = mock_handle.get_for_app.return_value
2011 mock_app_gs.get_user_value.return_value = test_context.Mock()
2012 mock_app_gs.get_boolean.return_value = True
2013 registry._handles["chat"] = mock_handle
2014
2015 result = registry.layered_lookup("chat", "speak-room-name", "b", app_name="Firefox")
2016 assert result is True
2017 mock_handle.get_for_app.assert_called_once_with(
2018 "Firefox",
2019 registry.get_active_profile(),
2020 "",
2021 )
2022
2023 def test_app_name_none_uses_active_app(self, test_context: OrcaTestContext) -> None:
2024 """Test layered_lookup with app_name=None passes None (active app fallback)."""
2025
2026 self._setup(test_context)
2027 from orca.gsettings_registry import GSettingsRegistry, GSettingsSchemaHandle
2028
2029 registry = GSettingsRegistry()
2030 registry._schemas["chat"] = "org.gnome.Orca.Chat"
2031 registry.set_active_app("Pidgin")
2032
2033 mock_handle = test_context.Mock(spec=GSettingsSchemaHandle)
2034 mock_handle.get_boolean.return_value = False
2035 registry._handles["chat"] = mock_handle
2036
2037 result = registry.layered_lookup("chat", "speak-room-name", "b")
2038 assert result is False
2039 mock_handle.get_boolean.assert_called_once_with("speak-room-name", "", None)
2040
2041
2042 @pytest.mark.unit
2043 class TestLayeredGetDict:
2044 """Tests for GSettingsSchemaHandle._layered_get_dict merge semantics."""
2045
2046 def _setup(self, test_context: OrcaTestContext):
2047 """Set up dependencies."""
2048
2049 additional_modules = [
2050 "orca.cmdnames",
2051 "orca.messages",
2052 "orca.object_properties",
2053 "orca.orca_gui_navlist",
2054 "orca.orca_i18n",
2055 "orca.AXHypertext",
2056 "orca.AXObject",
2057 "orca.AXTable",
2058 "orca.AXText",
2059 "orca.AXUtilities",
2060 "orca.input_event",
2061 ]
2062 test_context.setup_shared_dependencies(additional_modules)
2063
2064 def _make_gs_with_entries(self, test_context, entries):
2065 """Creates a mock Gio.Settings with user_value for 'entries'."""
2066
2067 gs = test_context.Mock()
2068 if entries is None:
2069 gs.get_user_value.return_value = None
2070 else:
2071 variant = test_context.Mock()
2072 variant.unpack.return_value = entries
2073 gs.get_user_value.return_value = variant
2074 return gs
2075
2076 def test_non_default_profile_inherits_default(
2077 self,
2078 test_context: OrcaTestContext,
2079 ) -> None:
2080 """Test that dict lookup merges entries from the default profile as base."""
2081
2082 self._setup(test_context)
2083 from orca import gsettings_registry
2084 from orca.gsettings_registry import GSettingsSchemaHandle
2085
2086 handle = GSettingsSchemaHandle("org.gnome.Orca.Test", "test")
2087 mock_schema = test_context.Mock()
2088 mock_schema.has_key.return_value = True
2089 test_context.patch_object(handle, "get_schema", return_value=mock_schema)
2090
2091 gsettings_registry.get_registry().set_active_app(None)
2092 gsettings_registry.get_registry().set_active_profile("spanish")
2093
2094 default_gs = self._make_gs_with_entries(test_context, {"a": "1", "b": "2"})
2095 spanish_gs = self._make_gs_with_entries(test_context, {"b": "3", "c": "4"})
2096
2097 def get_for_profile(profile, _sub_path=""):
2098 if profile == "default":
2099 return default_gs
2100 return spanish_gs
2101
2102 test_context.patch_object(handle, "get_for_profile", side_effect=get_for_profile)
2103
2104 result = handle.get_dict("entries")
2105 assert result == {"a": "1", "b": "3", "c": "4"}
2106 gsettings_registry.get_registry().set_active_profile("default")
2107
2108 def test_merges_profile_and_app(self, test_context: OrcaTestContext) -> None:
2109 """Test dict merge: profile | app (no default profile layer)."""
2110
2111 self._setup(test_context)
2112 from orca import gsettings_registry
2113 from orca.gsettings_registry import GSettingsSchemaHandle
2114
2115 handle = GSettingsSchemaHandle("org.gnome.Orca.Test", "test")
2116 mock_schema = test_context.Mock()
2117 mock_schema.has_key.return_value = True
2118 test_context.patch_object(handle, "get_schema", return_value=mock_schema)
2119
2120 gsettings_registry.get_registry().set_active_app("Firefox")
2121 gsettings_registry.get_registry().set_active_profile("spanish")
2122
2123 spanish_gs = self._make_gs_with_entries(test_context, {"b": "3"})
2124 app_gs = self._make_gs_with_entries(test_context, {"a": "5"})
2125
2126 test_context.patch_object(handle, "get_for_profile", return_value=spanish_gs)
2127 test_context.patch_object(handle, "get_for_app", return_value=app_gs)
2128
2129 result = handle.get_dict("entries")
2130 assert result == {"a": "5", "b": "3"}
2131
2132 gsettings_registry.get_registry().set_active_app(None)
2133 gsettings_registry.get_registry().set_active_profile("default")
2134
2135 def test_returns_none_when_no_layer_set(self, test_context: OrcaTestContext) -> None:
2136 """Test dict merge returns None when no layer has a value."""
2137
2138 self._setup(test_context)
2139 from orca import gsettings_registry
2140 from orca.gsettings_registry import GSettingsSchemaHandle
2141
2142 handle = GSettingsSchemaHandle("org.gnome.Orca.Test", "test")
2143 mock_schema = test_context.Mock()
2144 mock_schema.has_key.return_value = True
2145 test_context.patch_object(handle, "get_schema", return_value=mock_schema)
2146
2147 gsettings_registry.get_registry().set_active_app(None)
2148 gsettings_registry.get_registry().set_active_profile("default")
2149
2150 empty_gs = self._make_gs_with_entries(test_context, None)
2151 test_context.patch_object(handle, "get_for_profile", return_value=empty_gs)
2152
2153 result = handle.get_dict("entries")
2154 assert result is None
2155
2156 def test_app_layer_wins_over_profile(self, test_context: OrcaTestContext) -> None:
2157 """Test dict merge: app-specific entries override profile entries."""
2158
2159 self._setup(test_context)
2160 from orca import gsettings_registry
2161 from orca.gsettings_registry import GSettingsSchemaHandle
2162
2163 handle = GSettingsSchemaHandle("org.gnome.Orca.Test", "test")
2164 mock_schema = test_context.Mock()
2165 mock_schema.has_key.return_value = True
2166 test_context.patch_object(handle, "get_schema", return_value=mock_schema)
2167
2168 gsettings_registry.get_registry().set_active_app("Firefox")
2169 gsettings_registry.get_registry().set_active_profile("default")
2170
2171 profile_gs = self._make_gs_with_entries(test_context, {"word": "old"})
2172 app_gs = self._make_gs_with_entries(test_context, {"word": "new"})
2173
2174 test_context.patch_object(handle, "get_for_profile", return_value=profile_gs)
2175 test_context.patch_object(handle, "get_for_app", return_value=app_gs)
2176
2177 result = handle.get_dict("entries")
2178 assert result == {"word": "new"}
2179
2180 gsettings_registry.get_registry().set_active_app(None)
2181
2182 def test_default_profile_only(self, test_context: OrcaTestContext) -> None:
2183 """Test dict merge with only default profile having entries."""
2184
2185 self._setup(test_context)
2186 from orca import gsettings_registry
2187 from orca.gsettings_registry import GSettingsSchemaHandle
2188
2189 handle = GSettingsSchemaHandle("org.gnome.Orca.Test", "test")
2190 mock_schema = test_context.Mock()
2191 mock_schema.has_key.return_value = True
2192 test_context.patch_object(handle, "get_schema", return_value=mock_schema)
2193
2194 gsettings_registry.get_registry().set_active_app(None)
2195 gsettings_registry.get_registry().set_active_profile("default")
2196
2197 profile_gs = self._make_gs_with_entries(test_context, {"hello": "hi"})
2198 test_context.patch_object(handle, "get_for_profile", return_value=profile_gs)
2199
2200 result = handle.get_dict("entries")
2201 assert result == {"hello": "hi"}
2202
2203
2204 @pytest.mark.unit
2205 class TestGetPronunciations:
2206 """Tests for GSettingsRegistry.get_pronunciations."""
2207
2208 def _setup(self, test_context: OrcaTestContext):
2209 """Set up dependencies."""
2210
2211 additional_modules = [
2212 "orca.cmdnames",
2213 "orca.messages",
2214 "orca.object_properties",
2215 "orca.orca_gui_navlist",
2216 "orca.orca_i18n",
2217 "orca.AXHypertext",
2218 "orca.AXObject",
2219 "orca.AXTable",
2220 "orca.AXText",
2221 "orca.AXUtilities",
2222 "orca.input_event",
2223 ]
2224 test_context.setup_shared_dependencies(additional_modules)
2225
2226 def test_returns_empty_dict_when_no_schema(self, test_context: OrcaTestContext) -> None:
2227 """Test get_pronunciations returns {} when pronunciations schema is not registered."""
2228
2229 self._setup(test_context)
2230 from orca.gsettings_registry import GSettingsRegistry
2231
2232 registry = GSettingsRegistry()
2233 assert not registry.get_pronunciations("default")
2234
2235 def test_returns_raw_dconf_pronunciations(self, test_context: OrcaTestContext) -> None:
2236 """Test get_pronunciations returns raw dconf format {word: replacement}."""
2237
2238 self._setup(test_context)
2239 from orca.gsettings_registry import get_registry
2240
2241 registry = get_registry()
2242 mock_gs = test_context.Mock()
2243 expected = {"hello": "hi", "world": "earth"}
2244 mock_variant = test_context.Mock()
2245 mock_variant.unpack.return_value = expected
2246 mock_gs.get_user_value.return_value = mock_variant
2247
2248 test_context.patch_object(registry, "get_settings", return_value=mock_gs)
2249
2250 result = registry.get_pronunciations("default")
2251 assert result == expected
2252
2253 def test_uses_active_profile_when_empty(self, test_context: OrcaTestContext) -> None:
2254 """Test get_pronunciations uses active profile when profile arg is empty."""
2255
2256 self._setup(test_context)
2257 from orca.gsettings_registry import get_registry
2258
2259 registry = get_registry()
2260 registry.set_active_profile("spanish")
2261 mock_gs = test_context.Mock()
2262 mock_gs.get_user_value.return_value = None
2263
2264 mockget_settings = test_context.patch_object(registry, "get_settings", return_value=mock_gs)
2265
2266 registry.get_pronunciations()
2267 mockget_settings.assert_called_once_with("pronunciations", "spanish", "pronunciations", "")
2268 registry.set_active_profile("default")
2269
2270 def test_passes_app_name(self, test_context: OrcaTestContext) -> None:
2271 """Test get_pronunciations passes app_name to get_settings."""
2272
2273 self._setup(test_context)
2274 from orca.gsettings_registry import get_registry
2275
2276 registry = get_registry()
2277 mock_gs = test_context.Mock()
2278 mock_gs.get_user_value.return_value = None
2279
2280 mockget_settings = test_context.patch_object(registry, "get_settings", return_value=mock_gs)
2281
2282 registry.get_pronunciations("default", "Firefox")
2283 mockget_settings.assert_called_once_with(
2284 "pronunciations",
2285 "default",
2286 "pronunciations",
2287 "Firefox",
2288 )
2289
2290 def test_returns_empty_when_get_settings_returns_none(
2291 self,
2292 test_context: OrcaTestContext,
2293 ) -> None:
2294 """Test get_pronunciations returns {} when get_settings returns None."""
2295
2296 self._setup(test_context)
2297 from orca.gsettings_registry import get_registry
2298
2299 registry = get_registry()
2300 test_context.patch_object(registry, "get_settings", return_value=None)
2301
2302 result = registry.get_pronunciations("default")
2303 assert not result
2304
2305 def test_returns_empty_when_no_user_value(self, test_context: OrcaTestContext) -> None:
2306 """Test get_pronunciations returns {} when entries have no user value."""
2307
2308 self._setup(test_context)
2309 from orca.gsettings_registry import get_registry
2310
2311 registry = get_registry()
2312 mock_gs = test_context.Mock()
2313 mock_gs.get_user_value.return_value = None
2314 test_context.patch_object(registry, "get_settings", return_value=mock_gs)
2315
2316 result = registry.get_pronunciations("default")
2317 assert not result
2318
2319
2320 @pytest.mark.unit
2321 class TestGetKeybindings:
2322 """Tests for GSettingsRegistry.get_keybindings."""
2323
2324 def _setup(self, test_context: OrcaTestContext):
2325 """Set up dependencies."""
2326
2327 additional_modules = [
2328 "orca.cmdnames",
2329 "orca.messages",
2330 "orca.object_properties",
2331 "orca.orca_gui_navlist",
2332 "orca.orca_i18n",
2333 "orca.AXHypertext",
2334 "orca.AXObject",
2335 "orca.AXTable",
2336 "orca.AXText",
2337 "orca.AXUtilities",
2338 "orca.input_event",
2339 ]
2340 test_context.setup_shared_dependencies(additional_modules)
2341
2342 def test_returns_empty_dict_when_no_schema(self, test_context: OrcaTestContext) -> None:
2343 """Test get_keybindings returns {} when keybindings schema is not registered."""
2344
2345 self._setup(test_context)
2346 from orca.gsettings_registry import GSettingsRegistry
2347
2348 registry = GSettingsRegistry()
2349 assert not registry.get_keybindings("default")
2350
2351 def test_returns_raw_dconf_keybindings(self, test_context: OrcaTestContext) -> None:
2352 """Test get_keybindings returns raw dconf format."""
2353
2354 self._setup(test_context)
2355 from orca.gsettings_registry import get_registry
2356
2357 registry = get_registry()
2358 mock_gs = test_context.Mock()
2359 expected = {
2360 "next_heading": [["h", "269", "0", "1"]],
2361 "prev_heading": [["h", "269", "0", "2"]],
2362 }
2363 mock_variant = test_context.Mock()
2364 mock_variant.unpack.return_value = expected
2365 mock_gs.get_user_value.return_value = mock_variant
2366
2367 test_context.patch_object(registry, "get_settings", return_value=mock_gs)
2368
2369 result = registry.get_keybindings("default")
2370 assert result == expected
2371
2372 def test_uses_active_profile_when_empty(self, test_context: OrcaTestContext) -> None:
2373 """Test get_keybindings uses active profile when profile arg is empty."""
2374
2375 self._setup(test_context)
2376 from orca.gsettings_registry import get_registry
2377
2378 registry = get_registry()
2379 registry.set_active_profile("spanish")
2380 mock_gs = test_context.Mock()
2381 mock_gs.get_user_value.return_value = None
2382
2383 mockget_settings = test_context.patch_object(registry, "get_settings", return_value=mock_gs)
2384
2385 registry.get_keybindings()
2386 mockget_settings.assert_called_once_with("keybindings", "spanish", "keybindings", "")
2387 registry.set_active_profile("default")
2388
2389 def test_passes_app_name(self, test_context: OrcaTestContext) -> None:
2390 """Test get_keybindings passes app_name to get_settings."""
2391
2392 self._setup(test_context)
2393 from orca.gsettings_registry import get_registry
2394
2395 registry = get_registry()
2396 mock_gs = test_context.Mock()
2397 mock_gs.get_user_value.return_value = None
2398
2399 mockget_settings = test_context.patch_object(registry, "get_settings", return_value=mock_gs)
2400
2401 registry.get_keybindings("default", "Firefox")
2402 mockget_settings.assert_called_once_with("keybindings", "default", "keybindings", "Firefox")
2403
2404 def test_returns_empty_when_get_settings_returns_none(
2405 self,
2406 test_context: OrcaTestContext,
2407 ) -> None:
2408 """Test get_keybindings returns {} when get_settings returns None."""
2409
2410 self._setup(test_context)
2411 from orca.gsettings_registry import get_registry
2412
2413 registry = get_registry()
2414 test_context.patch_object(registry, "get_settings", return_value=None)
2415
2416 result = registry.get_keybindings("default")
2417 assert not result
2418
2419 def test_returns_empty_when_no_user_value(self, test_context: OrcaTestContext) -> None:
2420 """Test get_keybindings returns {} when entries have no user value."""
2421
2422 self._setup(test_context)
2423 from orca.gsettings_registry import get_registry
2424
2425 registry = get_registry()
2426 mock_gs = test_context.Mock()
2427 mock_gs.get_user_value.return_value = None
2428 test_context.patch_object(registry, "get_settings", return_value=mock_gs)
2429
2430 result = registry.get_keybindings("default")
2431 assert not result