Debian Codegraph @

tests/unit_tests/test_live_region_presenter.py

raw
1 # Unit tests for live_region_presenter.py methods.
2 #
3 # Copyright 2025 Igalia, S.L.
4 # Author: Joanmarie Diggs <[email protected]>
5 #
6 # This library is free software; you can redistribute it and/or
7 # modify it under the terms of the GNU Lesser General Public
8 # License as published by the Free Software Foundation; either
9 # version 2.1 of the License, or (at your option) any later version.
10 #
11 # This library is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 # Lesser General Public License for more details.
15 #
16 # You should have received a copy of the GNU Lesser General Public
17 # License along with this library; if not, write to the
18 # Free Software Foundation, Inc., Franklin Street, Fifth Floor,
19 # Boston MA 02110-1301 USA.
20
21 # pylint: disable=wrong-import-position
22 # pylint: disable=import-outside-toplevel
23 # pylint: disable=too-many-public-methods
24 # pylint: disable=too-many-statements
25 # pylint: disable=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 live_region_presenter.py methods."""
32
33 from __future__ import annotations
34
35 from typing import TYPE_CHECKING
36
37 import pytest
38
39 if TYPE_CHECKING:
40 from unittest.mock import MagicMock
41
42 from .orca_test_context import OrcaTestContext
43
44
45 class Fake:
46 """Stub used as a stand-in for objects that need an identity."""
47
48
49 @pytest.mark.unit
50 class TestLivePoliteness:
51 """Test LivePoliteness enum."""
52
53 def _setup_dependencies(self, test_context: OrcaTestContext) -> dict[str, MagicMock]:
54 """Set up dependencies for live_region_presenter module testing."""
55
56 additional_modules = [
57 "gi",
58 "gi.repository",
59 "gi.repository.Atspi",
60 "gi.repository.GLib",
61 "orca.braille_presenter",
62 "orca.presentation_manager",
63 ]
64 essential_modules = test_context.setup_shared_dependencies(additional_modules)
65
66 gi_mock = essential_modules["gi"]
67 gi_mock.require_version = test_context.Mock()
68
69 gi_repository_mock = essential_modules["gi.repository"]
70 atspi_mock = essential_modules["gi.repository.Atspi"]
71 atspi_mock.Role = Fake
72 atspi_mock.Accessible = Fake
73 atspi_mock.MatchRule = Fake
74 atspi_mock.Relation = Fake
75 gi_repository_mock.Atspi = atspi_mock
76
77 glib_mock = essential_modules["gi.repository.GLib"]
78 glib_mock.timeout_add = test_context.Mock(return_value=1)
79
80 return essential_modules
81
82 def test_politeness_values(self, test_context: OrcaTestContext) -> None:
83 """Test LivePoliteness enum values and properties."""
84
85 self._setup_dependencies(test_context)
86 from orca.live_region_presenter import LivePoliteness
87
88 assert LivePoliteness.ASSERTIVE.priority == 0
89 assert LivePoliteness.ASSERTIVE.name_str == "assertive"
90 assert LivePoliteness.POLITE.priority == 1
91 assert LivePoliteness.POLITE.name_str == "polite"
92 assert LivePoliteness.OFF.priority == 2
93 assert LivePoliteness.OFF.name_str == "off"
94
95 @pytest.mark.parametrize(
96 "input_str,expected",
97 [
98 pytest.param("assertive", "ASSERTIVE", id="assertive"),
99 pytest.param("polite", "POLITE", id="polite"),
100 pytest.param("off", "OFF", id="off"),
101 pytest.param("invalid", "OFF", id="invalid_defaults_to_off"),
102 pytest.param(None, "OFF", id="none_defaults_to_off"),
103 ],
104 )
105 def test_from_string(self, test_context: OrcaTestContext, input_str, expected) -> None:
106 """Test LivePoliteness.from_string conversion."""
107
108 self._setup_dependencies(test_context)
109 from orca.live_region_presenter import LivePoliteness
110
111 result = LivePoliteness.OFF.from_string(input_str)
112 assert result.name == expected
113
114 @pytest.mark.parametrize(
115 "politeness,expected_str",
116 [
117 pytest.param("ASSERTIVE", "assertive", id="assertive"),
118 pytest.param("POLITE", "polite", id="polite"),
119 pytest.param("OFF", "off", id="off"),
120 ],
121 )
122 def test_to_string(self, test_context: OrcaTestContext, politeness, expected_str) -> None:
123 """Test LivePoliteness.to_string conversion."""
124
125 self._setup_dependencies(test_context)
126 from orca.live_region_presenter import LivePoliteness
127
128 politeness_enum = getattr(LivePoliteness, politeness)
129 assert politeness_enum.to_string() == expected_str
130
131
132 @pytest.mark.unit
133 class TestLiveRegionMessage:
134 """Test LiveRegionMessage class."""
135
136 def _setup_dependencies(self, test_context: OrcaTestContext):
137 """Set up dependencies for live_region_presenter module testing."""
138
139 additional_modules = [
140 "gi",
141 "gi.repository",
142 "gi.repository.Atspi",
143 "gi.repository.GLib",
144 "orca.braille_presenter",
145 "orca.presentation_manager",
146 ]
147 essential_modules = test_context.setup_shared_dependencies(additional_modules)
148
149 gi_mock = essential_modules["gi"]
150 gi_mock.require_version = test_context.Mock()
151
152 gi_repository_mock = essential_modules["gi.repository"]
153 atspi_mock = essential_modules["gi.repository.Atspi"]
154 atspi_mock.Role = Fake
155 atspi_mock.Accessible = Fake
156 atspi_mock.MatchRule = Fake
157 atspi_mock.Relation = Fake
158 gi_repository_mock.Atspi = atspi_mock
159
160 glib_mock = essential_modules["gi.repository.GLib"]
161 glib_mock.timeout_add = test_context.Mock(return_value=1)
162
163 return essential_modules
164
165 def test_message_creation(self, test_context: OrcaTestContext) -> None:
166 """Test LiveRegionMessage creation."""
167
168 self._setup_dependencies(test_context)
169 from orca.live_region_presenter import LivePoliteness, LiveRegionMessage
170
171 mock_obj = test_context.Mock()
172 test_context.patch("time.time", return_value=1234567890.0)
173
174 message = LiveRegionMessage(
175 text="Test message",
176 politeness=LivePoliteness.POLITE,
177 obj=mock_obj,
178 )
179
180 assert message.text == "Test message"
181 assert message.politeness == LivePoliteness.POLITE
182 assert message.obj == mock_obj
183 assert message.timestamp == 1234567890.0
184
185 def test_message_with_explicit_timestamp(self, test_context: OrcaTestContext) -> None:
186 """Test LiveRegionMessage with explicit timestamp."""
187
188 self._setup_dependencies(test_context)
189 from orca.live_region_presenter import LivePoliteness, LiveRegionMessage
190
191 mock_obj = test_context.Mock()
192 message = LiveRegionMessage(
193 text="Test",
194 politeness=LivePoliteness.ASSERTIVE,
195 obj=mock_obj,
196 timestamp=999.0,
197 )
198
199 assert message.timestamp == 999.0
200
201 @pytest.mark.parametrize(
202 "politeness1,politeness2,timestamp1,timestamp2,expected_less_than",
203 [
204 pytest.param("ASSERTIVE", "POLITE", 100.0, 100.0, True, id="assertive_before_polite"),
205 pytest.param("POLITE", "ASSERTIVE", 100.0, 100.0, False, id="polite_after_assertive"),
206 pytest.param("POLITE", "POLITE", 100.0, 200.0, True, id="older_before_newer"),
207 pytest.param("POLITE", "POLITE", 200.0, 100.0, False, id="newer_after_older"),
208 ],
209 )
210 def test_message_comparison(
211 self,
212 test_context: OrcaTestContext,
213 politeness1,
214 politeness2,
215 timestamp1,
216 timestamp2,
217 expected_less_than,
218 ) -> None:
219 """Test LiveRegionMessage comparison for priority queue ordering."""
220
221 self._setup_dependencies(test_context)
222 from orca.live_region_presenter import LivePoliteness, LiveRegionMessage
223
224 mock_obj = test_context.Mock()
225 msg1 = LiveRegionMessage(
226 text="Message 1",
227 politeness=getattr(LivePoliteness, politeness1),
228 obj=mock_obj,
229 timestamp=timestamp1,
230 )
231 msg2 = LiveRegionMessage(
232 text="Message 2",
233 politeness=getattr(LivePoliteness, politeness2),
234 obj=mock_obj,
235 timestamp=timestamp2,
236 )
237
238 assert (msg1 < msg2) == expected_less_than
239
240 @pytest.mark.parametrize(
241 "text1,text2,time_diff,expected_duplicate",
242 [
243 pytest.param("Same", "Same", 0.1, True, id="duplicate_within_window"),
244 pytest.param("Same", "Same", 0.25, True, id="duplicate_at_boundary"),
245 pytest.param("Same", "Same", 0.26, False, id="not_duplicate_outside_window"),
246 pytest.param("Different", "Text", 0.1, False, id="different_text"),
247 ],
248 )
249 def test_is_duplicate_of(
250 self,
251 test_context: OrcaTestContext,
252 text1,
253 text2,
254 time_diff,
255 expected_duplicate,
256 ) -> None:
257 """Test LiveRegionMessage.is_duplicate_of."""
258
259 self._setup_dependencies(test_context)
260 from orca.live_region_presenter import LivePoliteness, LiveRegionMessage
261
262 mock_obj = test_context.Mock()
263 base_time = 1000.0
264
265 msg1 = LiveRegionMessage(
266 text=text1,
267 politeness=LivePoliteness.POLITE,
268 obj=mock_obj,
269 timestamp=base_time,
270 )
271 msg2 = LiveRegionMessage(
272 text=text2,
273 politeness=LivePoliteness.POLITE,
274 obj=mock_obj,
275 timestamp=base_time + time_diff,
276 )
277
278 assert msg2.is_duplicate_of(msg1) == expected_duplicate
279
280 def test_is_duplicate_of_none(self, test_context: OrcaTestContext) -> None:
281 """Test LiveRegionMessage.is_duplicate_of with None."""
282
283 self._setup_dependencies(test_context)
284 from orca.live_region_presenter import LivePoliteness, LiveRegionMessage
285
286 mock_obj = test_context.Mock()
287 message = LiveRegionMessage(text="Test", politeness=LivePoliteness.POLITE, obj=mock_obj)
288
289 assert message.is_duplicate_of(None) is False
290
291
292 @pytest.mark.unit
293 class TestLiveRegionMessageQueue:
294 """Test LiveRegionMessageQueue class."""
295
296 def _setup_dependencies(self, test_context: OrcaTestContext):
297 """Set up dependencies for live_region_presenter module testing."""
298
299 additional_modules = [
300 "gi",
301 "gi.repository",
302 "gi.repository.Atspi",
303 "gi.repository.GLib",
304 "orca.braille_presenter",
305 "orca.presentation_manager",
306 ]
307 essential_modules = test_context.setup_shared_dependencies(additional_modules)
308
309 gi_mock = essential_modules["gi"]
310 gi_mock.require_version = test_context.Mock()
311
312 gi_repository_mock = essential_modules["gi.repository"]
313 atspi_mock = essential_modules["gi.repository.Atspi"]
314 atspi_mock.Role = Fake
315 atspi_mock.Accessible = Fake
316 atspi_mock.MatchRule = Fake
317 atspi_mock.Relation = Fake
318 gi_repository_mock.Atspi = atspi_mock
319
320 glib_mock = essential_modules["gi.repository.GLib"]
321 glib_mock.timeout_add = test_context.Mock(return_value=1)
322
323 return essential_modules
324
325 def test_queue_creation(self, test_context: OrcaTestContext) -> None:
326 """Test LiveRegionMessageQueue creation."""
327
328 self._setup_dependencies(test_context)
329 from orca.live_region_presenter import LiveRegionMessageQueue
330
331 queue = LiveRegionMessageQueue(max_size=5)
332 assert len(queue) == 0
333
334 def test_enqueue_dequeue(self, test_context: OrcaTestContext) -> None:
335 """Test basic enqueue and dequeue operations."""
336
337 self._setup_dependencies(test_context)
338 from orca.live_region_presenter import (
339 LivePoliteness,
340 LiveRegionMessage,
341 LiveRegionMessageQueue,
342 )
343
344 queue = LiveRegionMessageQueue(max_size=5)
345 mock_obj = test_context.Mock()
346
347 msg = LiveRegionMessage("Test", LivePoliteness.POLITE, mock_obj, timestamp=100.0)
348 queue.enqueue(msg)
349
350 assert len(queue) == 1
351 dequeued = queue.dequeue()
352 assert dequeued == msg
353 assert len(queue) == 0
354
355 def test_priority_ordering(self, test_context: OrcaTestContext) -> None:
356 """Test messages are dequeued in priority order."""
357
358 self._setup_dependencies(test_context)
359 from orca.live_region_presenter import (
360 LivePoliteness,
361 LiveRegionMessage,
362 LiveRegionMessageQueue,
363 )
364
365 queue = LiveRegionMessageQueue(max_size=5)
366 mock_obj = test_context.Mock()
367
368 polite_msg = LiveRegionMessage("Polite", LivePoliteness.POLITE, mock_obj, timestamp=100.0)
369 assertive_msg = LiveRegionMessage(
370 "Assertive",
371 LivePoliteness.ASSERTIVE,
372 mock_obj,
373 timestamp=200.0,
374 )
375
376 queue.enqueue(polite_msg)
377 queue.enqueue(assertive_msg)
378
379 # Assertive should come out first
380 first = queue.dequeue()
381 assert first is not None
382 assert first.text == "Assertive"
383 second = queue.dequeue()
384 assert second is not None
385 assert second.text == "Polite"
386
387 def test_max_size_enforcement(self, test_context: OrcaTestContext) -> None:
388 """Test queue enforces max size limit."""
389
390 self._setup_dependencies(test_context)
391 from orca.live_region_presenter import (
392 LivePoliteness,
393 LiveRegionMessage,
394 LiveRegionMessageQueue,
395 )
396
397 queue = LiveRegionMessageQueue(max_size=3)
398 mock_obj = test_context.Mock()
399
400 for i in range(5):
401 msg = LiveRegionMessage(
402 f"Message {i}",
403 LivePoliteness.POLITE,
404 mock_obj,
405 timestamp=float(i),
406 )
407 queue.enqueue(msg)
408
409 assert len(queue) == 3
410
411 def test_clear(self, test_context: OrcaTestContext) -> None:
412 """Test queue clear operation."""
413
414 self._setup_dependencies(test_context)
415 from orca.live_region_presenter import (
416 LivePoliteness,
417 LiveRegionMessage,
418 LiveRegionMessageQueue,
419 )
420
421 queue = LiveRegionMessageQueue(max_size=5)
422 mock_obj = test_context.Mock()
423
424 for i in range(3):
425 msg = LiveRegionMessage(f"Message {i}", LivePoliteness.POLITE, mock_obj)
426 queue.enqueue(msg)
427
428 assert len(queue) == 3
429 queue.clear()
430 assert len(queue) == 0
431
432 def test_dequeue_empty_returns_none(self, test_context: OrcaTestContext) -> None:
433 """Test dequeue on empty queue returns None."""
434
435 self._setup_dependencies(test_context)
436 from orca.live_region_presenter import LiveRegionMessageQueue
437
438 queue = LiveRegionMessageQueue(max_size=5)
439 assert queue.dequeue() is None
440
441 def test_purge_by_keep_alive(self, test_context: OrcaTestContext) -> None:
442 """Test purge_by_keep_alive removes old messages."""
443
444 self._setup_dependencies(test_context)
445 from orca.live_region_presenter import (
446 LivePoliteness,
447 LiveRegionMessage,
448 LiveRegionMessageQueue,
449 )
450
451 queue = LiveRegionMessageQueue(max_size=10)
452 mock_obj = test_context.Mock()
453
454 current_time = 1000.0
455 test_context.patch("time.time", return_value=current_time)
456
457 # Add old message (older than MSG_KEEPALIVE_TIME)
458 old_msg = LiveRegionMessage(
459 "Old",
460 LivePoliteness.POLITE,
461 mock_obj,
462 timestamp=current_time - 50,
463 )
464 queue.enqueue(old_msg)
465
466 # Add recent message
467 new_msg = LiveRegionMessage(
468 "New",
469 LivePoliteness.POLITE,
470 mock_obj,
471 timestamp=current_time - 10,
472 )
473 queue.enqueue(new_msg)
474
475 assert len(queue) == 2
476 queue.purge_by_keep_alive()
477 assert len(queue) == 1
478
479 remaining = queue.dequeue()
480 assert remaining is not None
481 assert remaining.text == "New"
482
483 def test_purge_by_priority(self, test_context: OrcaTestContext) -> None:
484 """Test purge_by_priority removes lower priority messages."""
485
486 self._setup_dependencies(test_context)
487 from orca.live_region_presenter import (
488 LivePoliteness,
489 LiveRegionMessage,
490 LiveRegionMessageQueue,
491 )
492
493 queue = LiveRegionMessageQueue(max_size=10)
494 mock_obj = test_context.Mock()
495
496 assertive_msg = LiveRegionMessage(
497 "Assertive",
498 LivePoliteness.ASSERTIVE,
499 mock_obj,
500 timestamp=100.0,
501 )
502 polite_msg = LiveRegionMessage("Polite", LivePoliteness.POLITE, mock_obj, timestamp=200.0)
503 off_msg = LiveRegionMessage("Off", LivePoliteness.OFF, mock_obj, timestamp=300.0)
504
505 queue.enqueue(assertive_msg)
506 queue.enqueue(polite_msg)
507 queue.enqueue(off_msg)
508
509 assert len(queue) == 3
510
511 # Purge messages with priority >= POLITE (removes POLITE and OFF, keeps ASSERTIVE)
512 queue.purge_by_priority(LivePoliteness.POLITE)
513 assert len(queue) == 1
514
515 remaining = queue.dequeue()
516 assert remaining is not None
517 assert remaining.text == "Assertive"
518
519
520 @pytest.mark.unit
521 class TestLiveRegionPresenter:
522 """Test LiveRegionPresenter class methods."""
523
524 def _setup_dependencies(self, test_context: OrcaTestContext):
525 """Set up dependencies for LiveRegionPresenter testing."""
526
527 additional_modules = [
528 "gi",
529 "gi.repository",
530 "gi.repository.Atspi",
531 "gi.repository.GLib",
532 "orca.cmdnames",
533 "orca.dbus_service",
534 "orca.debug",
535 "orca.focus_manager",
536 "orca.input_event",
537 "orca.keybindings",
538 "orca.messages",
539 "orca.script_manager",
540 "orca.AXObject",
541 "orca.AXUtilities",
542 "orca.braille_presenter",
543 "orca.presentation_manager",
544 ]
545 essential_modules = test_context.setup_shared_dependencies(additional_modules)
546
547 gi_mock = essential_modules["gi"]
548 gi_mock.require_version = test_context.Mock()
549
550 gi_repository_mock = essential_modules["gi.repository"]
551 atspi_mock = essential_modules["gi.repository.Atspi"]
552 atspi_mock.Role = Fake
553 atspi_mock.Accessible = Fake
554 atspi_mock.MatchRule = Fake
555 atspi_mock.Relation = Fake
556 gi_repository_mock.Atspi = atspi_mock
557
558 glib_mock = essential_modules["gi.repository.GLib"]
559 glib_mock.timeout_add = test_context.Mock(return_value=1)
560
561 cmdnames_mock = essential_modules["orca.cmdnames"]
562 cmdnames_mock.LIVE_REGIONS_MONITOR = "toggleLiveRegionMonitoring"
563 cmdnames_mock.LIVE_REGIONS_PREVIOUS = "presentPreviousLiveRegionMessage"
564 cmdnames_mock.LIVE_REGIONS_ADVANCE_POLITENESS = "advanceLivePoliteness"
565 cmdnames_mock.LIVE_REGIONS_ARE_ANNOUNCED = "toggleLiveRegionPresentation"
566 cmdnames_mock.LIVE_REGIONS_NEXT = "presentNextLiveRegionMessage"
567
568 dbus_service_mock = essential_modules["orca.dbus_service"]
569 controller_mock = test_context.Mock()
570 controller_mock.register_decorated_module = test_context.Mock()
571 dbus_service_mock.get_remote_controller = test_context.Mock(return_value=controller_mock)
572
573 debug_mock = essential_modules["orca.debug"]
574 debug_mock.print_message = test_context.Mock()
575 debug_mock.print_tokens = test_context.Mock()
576 debug_mock.LEVEL_INFO = 800
577
578 input_event_mock = essential_modules["orca.input_event"]
579 input_event_handler_class = test_context.Mock()
580 input_event_handler_instance = test_context.Mock()
581 input_event_handler_class.return_value = input_event_handler_instance
582 input_event_mock.InputEventHandler = input_event_handler_class
583
584 keybindings_mock = essential_modules["orca.keybindings"]
585
586 def create_keybindings_instance():
587 instance = test_context.Mock()
588 instance.is_empty = test_context.Mock(return_value=True)
589 instance.remove_key_grabs = test_context.Mock()
590 instance.add = test_context.Mock()
591 instance.remove = test_context.Mock()
592 instance.key_bindings = []
593 return instance
594
595 keybindings_mock.KeyBindings = test_context.Mock(side_effect=create_keybindings_instance)
596 keybinding_instance = test_context.Mock()
597 keybindings_mock.KeyBinding = test_context.Mock(return_value=keybinding_instance)
598 keybindings_mock.DEFAULT_MODIFIER_MASK = 1
599 keybindings_mock.NO_MODIFIER_MASK = 0
600 keybindings_mock.ORCA_MODIFIER_MASK = 8
601
602 messages_mock = essential_modules["orca.messages"]
603 messages_mock.LIVE_REGIONS_SUPPORT_DISABLED = "Live regions support disabled"
604 messages_mock.LIVE_REGIONS_LEVEL_POLITE = "Live regions set to polite"
605 messages_mock.LIVE_REGIONS_LEVEL_ASSERTIVE = "Live regions set to assertive"
606 messages_mock.LIVE_REGIONS_LEVEL_OFF = "Live regions set to off"
607 messages_mock.LIVE_REGIONS_NO_MESSAGES = "No live region messages"
608 messages_mock.LIVE_REGIONS_LIST_TOP = "Top of live region list"
609 messages_mock.LIVE_REGIONS_LIST_BOTTOM = "Bottom of live region list"
610 messages_mock.LIVE_REGIONS_ENABLED = "Live regions monitoring enabled"
611 messages_mock.LIVE_REGIONS_DISABLED = "Live regions monitoring disabled"
612 messages_mock.LIVE_REGIONS_ALL_OFF = "Live regions all off"
613 messages_mock.LIVE_REGIONS_ALL_RESTORED = "Live regions restored"
614
615 focus_manager_mock = essential_modules["orca.focus_manager"]
616 focus_instance = test_context.Mock()
617 focus_instance.get_locus_of_focus = test_context.Mock(return_value=None)
618 focus_manager_mock.get_manager = test_context.Mock(return_value=focus_instance)
619
620 script_manager_mock = essential_modules["orca.script_manager"]
621 script_instance = test_context.Mock()
622 script_instance.present_message = test_context.Mock()
623 script_instance.utilities = test_context.Mock()
624 script_manager_mock.get_manager = test_context.Mock()
625 script_manager_mock.get_manager.return_value.get_active_script = test_context.Mock(
626 return_value=script_instance,
627 )
628
629 axobject_mock = essential_modules["orca.AXObject"]
630 axobject_mock.get_attributes_dict = test_context.Mock(return_value={})
631 axobject_mock.get_name = test_context.Mock(return_value="")
632 axobject_mock.find_ancestor = test_context.Mock(return_value=None)
633 axobject_mock.find_ancestor_inclusive = test_context.Mock(return_value=None)
634
635 axutilities_mock = essential_modules["orca.AXUtilities"]
636 axutilities_mock.is_live_region = test_context.Mock(return_value=True)
637 axutilities_mock.is_aria_alert = test_context.Mock(return_value=False)
638 axutilities_mock.get_focused_object = test_context.Mock(return_value=None)
639 axutilities_mock.find_all_live_regions = test_context.Mock(return_value=[])
640
641 from orca import gsettings_registry
642
643 registry = gsettings_registry.get_registry()
644 registry.clear_runtime_values()
645
646 return essential_modules
647
648 def test_init(self, test_context: OrcaTestContext) -> None:
649 """Test LiveRegionPresenter.__init__."""
650
651 self._setup_dependencies(test_context)
652 from orca.live_region_presenter import LiveRegionPresenter
653
654 presenter = LiveRegionPresenter()
655
656 assert presenter.msg_queue is not None
657 assert len(presenter.msg_queue) == 0
658 assert len(presenter.msg_cache) == 0
659 assert presenter._monitoring is True
660 assert presenter._current_index == 9 # QUEUE_SIZE
661
662 def test_commands_registered(self, test_context: OrcaTestContext) -> None:
663 """Test LiveRegionPresenter commands are registered in CommandManager."""
664
665 self._setup_dependencies(test_context)
666 from orca import command_manager
667 from orca.live_region_presenter import LiveRegionPresenter
668
669 presenter = LiveRegionPresenter()
670 presenter.set_up_commands()
671
672 cmd_manager = command_manager.get_manager()
673 expected_commands = [
674 "toggle_live_region_support",
675 "present_previous_live_region_message",
676 "advance_live_politeness",
677 "toggle_live_region_presentation",
678 "present_next_live_region_message",
679 ]
680 for cmd_name in expected_commands:
681 assert cmd_manager.get_keyboard_command(cmd_name) is not None
682
683 def test_reset(self, test_context: OrcaTestContext) -> None:
684 """Test LiveRegionPresenter.reset."""
685
686 self._setup_dependencies(test_context)
687 from orca.live_region_presenter import LivePoliteness, LiveRegionPresenter
688
689 presenter = LiveRegionPresenter()
690 presenter._politeness_overrides = {123: LivePoliteness.POLITE}
691 presenter.reset()
692 assert not presenter._politeness_overrides
693
694 def test_get_is_enabled(self, test_context: OrcaTestContext) -> None:
695 """Test LiveRegionPresenter.get_is_enabled."""
696
697 self._setup_dependencies(test_context)
698 from orca.live_region_presenter import LiveRegionPresenter
699
700 presenter = LiveRegionPresenter()
701 assert presenter.get_is_enabled() is True
702
703 def test_set_is_enabled(self, test_context: OrcaTestContext) -> None:
704 """Test LiveRegionPresenter.set_is_enabled."""
705
706 self._setup_dependencies(test_context)
707 from orca.live_region_presenter import LiveRegionPresenter
708
709 presenter = LiveRegionPresenter()
710 presenter.set_is_enabled(False)
711 result = presenter.set_is_enabled(True)
712
713 assert result is True
714 assert presenter.get_is_enabled() is True
715
716 def test_toggle_monitoring_enable(self, test_context: OrcaTestContext) -> None:
717 """Test LiveRegionPresenter.toggle_monitoring enables monitoring."""
718
719 essential_modules = self._setup_dependencies(test_context)
720 from orca.live_region_presenter import LiveRegionPresenter
721
722 presenter = LiveRegionPresenter()
723 presenter.set_is_enabled(False)
724 mock_script = test_context.Mock()
725 mock_script.present_message = test_context.Mock()
726 mock_event = test_context.Mock()
727
728 result = presenter.toggle_monitoring(mock_script, mock_event)
729
730 assert result is True
731 pres_manager = essential_modules["orca.presentation_manager"].get_manager()
732 pres_manager.present_message.assert_called_with("Live regions monitoring enabled")
733
734 def test_toggle_monitoring_disable(self, test_context: OrcaTestContext) -> None:
735 """Test LiveRegionPresenter.toggle_monitoring disables monitoring."""
736
737 essential_modules = self._setup_dependencies(test_context)
738 from orca.live_region_presenter import LiveRegionPresenter
739
740 presenter = LiveRegionPresenter()
741 mock_script = test_context.Mock()
742 mock_script.present_message = test_context.Mock()
743 mock_event = test_context.Mock()
744
745 result = presenter.toggle_monitoring(mock_script, mock_event)
746
747 assert result is True
748 pres_manager = essential_modules["orca.presentation_manager"].get_manager()
749 pres_manager.present_message.assert_called_with("Live regions monitoring disabled")
750
751 def test_flush_messages(self, test_context: OrcaTestContext) -> None:
752 """Test LiveRegionPresenter.flush_messages."""
753
754 self._setup_dependencies(test_context)
755 from orca.live_region_presenter import (
756 LivePoliteness,
757 LiveRegionMessage,
758 LiveRegionPresenter,
759 )
760
761 presenter = LiveRegionPresenter()
762 mock_obj = test_context.Mock()
763 msg = LiveRegionMessage("Test", LivePoliteness.POLITE, mock_obj)
764 presenter.msg_queue.enqueue(msg)
765
766 assert len(presenter.msg_queue) > 0
767 presenter.flush_messages()
768 assert len(presenter.msg_queue) == 0
769
770 def test_present_previous_live_region_message_no_messages(
771 self,
772 test_context: OrcaTestContext,
773 ) -> None:
774 """Test present_previous_live_region_message with no messages."""
775
776 essential_modules = self._setup_dependencies(test_context)
777 from orca.live_region_presenter import LiveRegionPresenter
778
779 presenter = LiveRegionPresenter()
780 mock_script = test_context.Mock()
781 mock_script.present_message = test_context.Mock()
782
783 result = presenter.present_previous_live_region_message(mock_script, None)
784
785 assert result is True
786 pres_manager = essential_modules["orca.presentation_manager"].get_manager()
787 pres_manager.present_message.assert_called_with("No live region messages")
788
789 def test_present_previous_live_region_message_disabled(
790 self,
791 test_context: OrcaTestContext,
792 ) -> None:
793 """Test present_previous_live_region_message when disabled."""
794
795 essential_modules = self._setup_dependencies(test_context)
796 from orca.live_region_presenter import LiveRegionPresenter
797
798 presenter = LiveRegionPresenter()
799 presenter.set_is_enabled(False)
800 mock_script = test_context.Mock()
801 mock_script.present_message = test_context.Mock()
802
803 result = presenter.present_previous_live_region_message(mock_script, None)
804
805 assert result is False
806 pres_manager = essential_modules["orca.presentation_manager"].get_manager()
807 pres_manager.present_message.assert_called_with("Live regions support disabled")
808
809 def test_present_next_live_region_message_no_messages(
810 self,
811 test_context: OrcaTestContext,
812 ) -> None:
813 """Test present_next_live_region_message with no messages."""
814
815 essential_modules = self._setup_dependencies(test_context)
816 from orca.live_region_presenter import LiveRegionPresenter
817
818 presenter = LiveRegionPresenter()
819 mock_script = test_context.Mock()
820 mock_script.present_message = test_context.Mock()
821
822 result = presenter.present_next_live_region_message(mock_script, None)
823
824 assert result is True
825 pres_manager = essential_modules["orca.presentation_manager"].get_manager()
826 pres_manager.present_message.assert_called_with("No live region messages")
827
828 def test_go_last_live_region_no_message(self, test_context: OrcaTestContext) -> None:
829 """Test go_last_live_region with no last message."""
830
831 self._setup_dependencies(test_context)
832 from orca.live_region_presenter import LiveRegionPresenter
833
834 presenter = LiveRegionPresenter()
835 mock_script = test_context.Mock()
836
837 result = presenter.go_last_live_region(mock_script, None)
838 assert result is False
839
840 def test_is_presentable_live_region_event_wrong_type(
841 self,
842 test_context: OrcaTestContext,
843 ) -> None:
844 """Test is_presentable_live_region_event with wrong event type."""
845
846 self._setup_dependencies(test_context)
847 from orca.live_region_presenter import LiveRegionPresenter
848
849 presenter = LiveRegionPresenter()
850 mock_script = test_context.Mock()
851 mock_event = test_context.Mock()
852 mock_event.type = "object:state-changed:focused"
853 mock_event.source = test_context.Mock()
854
855 result = presenter.is_presentable_live_region_event(mock_script, mock_event)
856 assert result is False
857
858 def test_is_presentable_live_region_event_disabled(self, test_context: OrcaTestContext) -> None:
859 """Test is_presentable_live_region_event when presenter is disabled."""
860
861 self._setup_dependencies(test_context)
862 from orca.live_region_presenter import LiveRegionPresenter
863
864 presenter = LiveRegionPresenter()
865 presenter.set_is_enabled(False)
866 mock_script = test_context.Mock()
867 mock_event = test_context.Mock()
868 mock_event.type = "object:text-changed:insert"
869 mock_event.source = test_context.Mock()
870
871 result = presenter.is_presentable_live_region_event(mock_script, mock_event)
872 assert result is False
873
874 def test_is_presentable_live_region_event_not_live_region(
875 self,
876 test_context: OrcaTestContext,
877 ) -> None:
878 """Test is_presentable_live_region_event when source is not a live region."""
879
880 self._setup_dependencies(test_context)
881 from orca import ax_utilities
882 from orca.live_region_presenter import LiveRegionPresenter
883
884 presenter = LiveRegionPresenter()
885 test_context.patch_object(ax_utilities.AXUtilities, "is_live_region", return_value=False)
886
887 mock_script = test_context.Mock()
888 mock_event = test_context.Mock()
889 mock_event.type = "object:text-changed:insert"
890 mock_event.source = test_context.Mock()
891
892 result = presenter.is_presentable_live_region_event(mock_script, mock_event)
893 assert result is False
894
895
896 @pytest.mark.unit
897 class TestLiveRegionPresenterModule:
898 """Test module-level functions."""
899
900 def _setup_dependencies(self, test_context: OrcaTestContext):
901 """Set up dependencies for live_region_presenter module testing."""
902
903 additional_modules = [
904 "gi",
905 "gi.repository",
906 "gi.repository.Atspi",
907 "gi.repository.GLib",
908 "orca.cmdnames",
909 "orca.dbus_service",
910 "orca.debug",
911 "orca.focus_manager",
912 "orca.input_event",
913 "orca.keybindings",
914 "orca.messages",
915 "orca.script_manager",
916 "orca.AXObject",
917 "orca.AXUtilities",
918 "orca.braille_presenter",
919 "orca.presentation_manager",
920 ]
921 essential_modules = test_context.setup_shared_dependencies(additional_modules)
922
923 gi_mock = essential_modules["gi"]
924 gi_mock.require_version = test_context.Mock()
925
926 gi_repository_mock = essential_modules["gi.repository"]
927 atspi_mock = essential_modules["gi.repository.Atspi"]
928 atspi_mock.Role = Fake
929 atspi_mock.Accessible = Fake
930 atspi_mock.MatchRule = Fake
931 atspi_mock.Relation = Fake
932 gi_repository_mock.Atspi = atspi_mock
933
934 glib_mock = essential_modules["gi.repository.GLib"]
935 glib_mock.timeout_add = test_context.Mock(return_value=1)
936
937 dbus_service_mock = essential_modules["orca.dbus_service"]
938 controller_mock = test_context.Mock()
939 controller_mock.register_decorated_module = test_context.Mock()
940 dbus_service_mock.get_remote_controller = test_context.Mock(return_value=controller_mock)
941
942 debug_mock = essential_modules["orca.debug"]
943 debug_mock.print_message = test_context.Mock()
944 debug_mock.print_tokens = test_context.Mock()
945 debug_mock.LEVEL_INFO = 800
946
947 essential_modules["orca.cmdnames"].LIVE_REGIONS_MONITOR = "test"
948 essential_modules["orca.cmdnames"].LIVE_REGIONS_PREVIOUS = "test"
949 essential_modules["orca.cmdnames"].LIVE_REGIONS_ADVANCE_POLITENESS = "test"
950 essential_modules["orca.cmdnames"].LIVE_REGIONS_ARE_ANNOUNCED = "test"
951 essential_modules["orca.cmdnames"].LIVE_REGIONS_NEXT = "test"
952
953 input_event_mock = essential_modules["orca.input_event"]
954 input_event_handler_class = test_context.Mock()
955 input_event_handler_instance = test_context.Mock()
956 input_event_handler_class.return_value = input_event_handler_instance
957 input_event_mock.InputEventHandler = input_event_handler_class
958
959 keybindings_mock = essential_modules["orca.keybindings"]
960
961 def create_keybindings_instance():
962 instance = test_context.Mock()
963 instance.is_empty = test_context.Mock(return_value=True)
964 instance.remove_key_grabs = test_context.Mock()
965 instance.add = test_context.Mock()
966 instance.remove = test_context.Mock()
967 instance.key_bindings = []
968 return instance
969
970 keybindings_mock.KeyBindings = test_context.Mock(side_effect=create_keybindings_instance)
971 keybindings_mock.KeyBinding = test_context.Mock()
972 keybindings_mock.DEFAULT_MODIFIER_MASK = 1
973 keybindings_mock.NO_MODIFIER_MASK = 0
974 keybindings_mock.ORCA_MODIFIER_MASK = 8
975
976 essential_modules["orca.messages"].LIVE_REGIONS_SUPPORT_DISABLED = "test"
977
978 focus_manager_mock = essential_modules["orca.focus_manager"]
979 focus_instance = test_context.Mock()
980 focus_instance.get_locus_of_focus = test_context.Mock(return_value=None)
981 focus_manager_mock.get_manager = test_context.Mock(return_value=focus_instance)
982
983 script_manager_mock = essential_modules["orca.script_manager"]
984 script_instance = test_context.Mock()
985 script_manager_mock.get_manager = test_context.Mock()
986 script_manager_mock.get_manager.return_value.get_active_script = test_context.Mock(
987 return_value=script_instance,
988 )
989
990 axobject_mock = essential_modules["orca.AXObject"]
991 axobject_mock.get_attributes_dict = test_context.Mock(return_value={})
992 axobject_mock.get_name = test_context.Mock(return_value="")
993 axobject_mock.find_ancestor = test_context.Mock(return_value=None)
994 axobject_mock.find_ancestor_inclusive = test_context.Mock(return_value=None)
995
996 axutilities_mock = essential_modules["orca.AXUtilities"]
997 axutilities_mock.is_live_region = test_context.Mock(return_value=True)
998 axutilities_mock.is_aria_alert = test_context.Mock(return_value=False)
999 axutilities_mock.get_focused_object = test_context.Mock(return_value=None)
1000 axutilities_mock.find_all_live_regions = test_context.Mock(return_value=[])
1001
1002 from orca import gsettings_registry
1003
1004 registry = gsettings_registry.get_registry()
1005 registry.clear_runtime_values()
1006
1007 return essential_modules
1008
1009 def test_get_presenter(self, test_context: OrcaTestContext) -> None:
1010 """Test get_presenter function returns singleton."""
1011
1012 _ = self._setup_dependencies(test_context)
1013 from orca.live_region_presenter import get_presenter
1014
1015 presenter1 = get_presenter()
1016 assert presenter1 is not None
1017 assert presenter1.msg_queue is not None
1018
1019 presenter2 = get_presenter()
1020 assert presenter1 is presenter2