Debian Codegraph @

tests/unit_tests/test_where_am_i_presenter.py

raw
1 # Unit tests for where_am_i_presenter.py methods.
2 #
3 # Copyright 2025 Igalia, S.L.
4 # Author: Joanmarie Diggs <[email protected]>
5 #
6 # This program is free software; you can redistribute it and/or modify
7 # it under the terms of the GNU Lesser General Public License as published by
8 # the Free Software Foundation; either version 2.1 of the License, or
9 # (at your option) any later version.
10 #
11 # This program 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
14 # GNU Lesser General Public License for more details.
15 #
16 # You should have received a copy of the GNU Lesser General Public License
17 # along with this program; if not, write to the Free Software Foundation,
18 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19
20 # pylint: disable=wrong-import-position
21 # pylint: disable=import-outside-toplevel
22 # pylint: disable=too-many-public-methods
23 # pylint: disable=too-many-statements
24 # pylint: disable=protected-access
25 # pylint: disable=too-many-arguments
26 # pylint: disable=too-many-positional-arguments
27 # pylint: disable=too-many-locals
28 # pylint: disable=too-many-lines
29
30 """Unit tests for where_am_i_presenter.py methods."""
31
32 from __future__ import annotations
33
34 from typing import TYPE_CHECKING
35
36 import pytest
37
38 if TYPE_CHECKING:
39 from .orca_test_context import OrcaTestContext
40
41 READ_CHAR_ATTRIBUTES_CMD = "readCharAttributesCommand"
42 PRESENT_SIZE_AND_POSITION_CMD = "presentSizeAndPositionCommand"
43 PRESENT_TITLE_CMD = "presentTitleCommand"
44 PRESENT_STATUS_BAR_CMD = "presentStatusBarCommand"
45 PRESENT_DEFAULT_BUTTON_CMD = "presentDefaultButtonCommand"
46 WHERE_AM_I_BASIC_CMD = "whereAmIBasicCommand"
47 WHERE_AM_I_DETAILED_CMD = "whereAmIDetailedCommand"
48 WHERE_AM_I_LINK_CMD = "whereAmILinkCommand"
49 WHERE_AM_I_SELECTION_CMD = "whereAmISelectionCommand"
50 LOCATION_NOT_FOUND_MSG = "Location not found"
51 DEFAULT_BUTTON_NOT_FOUND_MSG = "Default button not found"
52 STATUS_BAR_NOT_FOUND_FULL_MSG = "Status bar not found"
53 STATUS_BAR_NOT_FOUND_BRIEF_MSG = "No status bar"
54
55
56 @pytest.mark.unit
57 class TestWhereAmIPresenter:
58 """Test WhereAmIPresenter class methods."""
59
60 def _setup_dependencies(self, test_context: OrcaTestContext):
61 """Returns all dependencies needed for WhereAmIPresenter testing."""
62
63 additional_modules = [
64 "orca.flat_review_presenter",
65 "orca.speech_presenter",
66 "orca.spellcheck_presenter",
67 "orca.text_attribute_manager",
68 "orca.ax_component",
69 "orca.ax_text",
70 "orca.ax_utilities",
71 "orca.braille_presenter",
72 "orca.presentation_manager",
73 ]
74 essential_modules = test_context.setup_shared_dependencies(additional_modules)
75
76 cmdnames_mock = essential_modules["orca.cmdnames"]
77 cmdnames_mock.READ_CHAR_ATTRIBUTES = READ_CHAR_ATTRIBUTES_CMD
78 cmdnames_mock.PRESENT_SIZE_AND_POSITION = PRESENT_SIZE_AND_POSITION_CMD
79 cmdnames_mock.PRESENT_TITLE = PRESENT_TITLE_CMD
80 cmdnames_mock.PRESENT_STATUS_BAR = PRESENT_STATUS_BAR_CMD
81 cmdnames_mock.PRESENT_DEFAULT_BUTTON = PRESENT_DEFAULT_BUTTON_CMD
82 cmdnames_mock.WHERE_AM_I_BASIC = WHERE_AM_I_BASIC_CMD
83 cmdnames_mock.WHERE_AM_I_DETAILED = WHERE_AM_I_DETAILED_CMD
84 cmdnames_mock.WHERE_AM_I_LINK = WHERE_AM_I_LINK_CMD
85 cmdnames_mock.WHERE_AM_I_SELECTION = WHERE_AM_I_SELECTION_CMD
86
87 keybindings_mock = essential_modules["orca.keybindings"]
88 keybindings_mock.ORCA_MODIFIER_MASK = 2
89 keybindings_mock.NO_MODIFIER_MASK = 0
90
91 messages_mock = essential_modules["orca.messages"]
92 messages_mock.BOLD = "bold"
93 messages_mock.MISSPELLED = "misspelled"
94 messages_mock.LOCATION_NOT_FOUND_FULL = LOCATION_NOT_FOUND_MSG
95 messages_mock.LOCATION_NOT_FOUND_BRIEF = LOCATION_NOT_FOUND_MSG
96 messages_mock.SIZE_AND_POSITION_FULL = "Size: %d by %d pixels, at %d, %d"
97 messages_mock.SIZE_AND_POSITION_BRIEF = "%dx%d at %d,%d"
98 messages_mock.DIALOG_NOT_IN_A = "Not in a dialog"
99 messages_mock.DEFAULT_BUTTON_NOT_FOUND = DEFAULT_BUTTON_NOT_FOUND_MSG
100 messages_mock.DEFAULT_BUTTON_IS_GRAYED = "Default button %s is grayed"
101 messages_mock.DEFAULT_BUTTON_IS = "Default button is %s"
102 messages_mock.STATUS_BAR_NOT_FOUND_FULL = STATUS_BAR_NOT_FOUND_FULL_MSG
103 messages_mock.STATUS_BAR_NOT_FOUND_BRIEF = STATUS_BAR_NOT_FOUND_BRIEF_MSG
104 messages_mock.NOT_ON_A_LINK = "Not on a link"
105 messages_mock.NO_SELECTED_TEXT = "No selected text"
106 messages_mock.SELECTED_TEXT_IS = "Selected text is %s"
107 messages_mock.selected_items_count = test_context.Mock(return_value="2 of 5 items selected")
108
109 handler_mock = test_context.Mock()
110 essential_modules["orca.input_event"].InputEventHandler = test_context.Mock(
111 return_value=handler_mock,
112 )
113 essential_modules["orca.input_event"].InputEvent = test_context.Mock()
114
115 text_attr_mgr = essential_modules["orca.text_attribute_manager"]
116 text_attr_mgr.get_manager.return_value.get_attributes_to_speak.return_value = [
117 "weight",
118 "style",
119 "underline",
120 ]
121
122 speech_verbosity_instance = test_context.Mock()
123 speech_verbosity_instance.get_indentation_description = test_context.Mock(return_value="")
124 speech_verbosity_instance.adjust_for_presentation = test_context.Mock(
125 return_value="adjusted text",
126 )
127 speech_verbosity_instance.adjust_for_digits = test_context.Mock(
128 return_value="adjusted text",
129 )
130 essential_modules["orca.speech_presenter"].get_presenter = test_context.Mock(
131 return_value=speech_verbosity_instance,
132 )
133
134 ax_component_mock = essential_modules["orca.ax_component"]
135 rect_mock = test_context.Mock()
136 rect_mock.width = 100
137 rect_mock.height = 50
138 rect_mock.x = 200
139 rect_mock.y = 150
140 ax_component_mock.AXComponent = test_context.Mock()
141 ax_component_mock.AXComponent.get_rect = test_context.Mock(return_value=rect_mock)
142
143 ax_utilities_mock = essential_modules["orca.ax_utilities"]
144 ax_utilities_mock.AXUtilities.is_empty_rect = test_context.Mock(return_value=False)
145
146 ax_text_mock = essential_modules["orca.ax_text"]
147 ax_text_mock.AXText = test_context.Mock()
148 ax_text_mock.AXText.get_text_attributes_at_offset = test_context.Mock(
149 return_value=({"weight": "bold"}, 0, 5),
150 )
151
152 ax_text_attribute_instance = test_context.Mock()
153 ax_text_attribute_instance.get_localized_name = test_context.Mock(return_value="Weight")
154 ax_text_attribute_instance.get_localized_value = test_context.Mock(return_value="Bold")
155 ax_text_attribute_instance.value_is_default = test_context.Mock(return_value=False)
156 ax_text_attribute_instance.get_attribute_name = test_context.Mock(return_value="weight")
157 ax_text_mock.AXTextAttribute = test_context.Mock()
158 ax_text_mock.AXTextAttribute.from_string = test_context.Mock(
159 return_value=ax_text_attribute_instance,
160 )
161
162 ax_utilities_mock = essential_modules["orca.ax_utilities"]
163 ax_utilities_mock.AXUtilities = test_context.Mock()
164 ax_utilities_mock.AXUtilities.get_default_button = test_context.Mock()
165 ax_utilities_mock.AXUtilities.is_sensitive = test_context.Mock(return_value=True)
166 ax_utilities_mock.AXUtilities.get_status_bar = test_context.Mock()
167 ax_utilities_mock.AXUtilities.get_info_bar = test_context.Mock()
168 ax_utilities_mock.AXUtilities.is_showing = test_context.Mock(return_value=True)
169 ax_utilities_mock.AXUtilities.is_visible = test_context.Mock(return_value=True)
170 ax_utilities_mock.AXUtilities.is_focused = test_context.Mock(return_value=True)
171 ax_utilities_mock.AXUtilities.is_table_cell = test_context.Mock(return_value=False)
172 ax_utilities_mock.AXUtilities.is_table_cell_or_header = test_context.Mock(
173 return_value=False,
174 )
175 ax_utilities_mock.AXUtilities.save_object_info_for_events = test_context.Mock()
176 ax_utilities_mock.AXUtilities.is_list_item = test_context.Mock(return_value=False)
177 ax_utilities_mock.AXUtilities.get_selected_text = test_context.Mock(
178 return_value=("selected text", 0, 5),
179 )
180 ax_utilities_mock.AXUtilities.get_all_supported_text_attributes = test_context.Mock()
181 ax_utilities_mock.AXUtilities.is_layout_only = test_context.Mock(return_value=False)
182
183 return essential_modules
184
185 def test_init(self, test_context: OrcaTestContext) -> None:
186 """Test WhereAmIPresenter.__init__ using OrcaTestContext for simpler mocking."""
187
188 deps = self._setup_dependencies(test_context)
189 from orca import command_manager
190 from orca.where_am_i_presenter import WhereAmIPresenter
191
192 presenter = WhereAmIPresenter()
193 presenter.set_up_commands()
194
195 # Verify commands are registered in CommandManager
196 cmd_manager = command_manager.get_manager()
197 assert cmd_manager.get_keyboard_command("whereAmIBasicHandler") is not None
198 assert cmd_manager.get_keyboard_command("whereAmIDetailedHandler") is not None
199 assert cmd_manager.get_keyboard_command("readCharAttributesHandler") is not None
200
201 dbus_mock = deps["orca.dbus_service"]
202 assert dbus_mock.get_remote_controller.call_count >= 1
203 controller = dbus_mock.get_remote_controller.return_value
204 controller.register_decorated_module.assert_called_with("WhereAmIPresenter", presenter)
205
206 @pytest.mark.parametrize(
207 "_refresh",
208 [
209 pytest.param(True, id="with_refresh"),
210 pytest.param(False, id="without_refresh"),
211 ],
212 )
213 def test_get_handlers(
214 self,
215 test_context: OrcaTestContext,
216 _refresh: bool,
217 ) -> None:
218 """Test WhereAmIPresenter commands are registered in CommandManager."""
219
220 self._setup_dependencies(test_context)
221 from orca import command_manager
222 from orca.where_am_i_presenter import WhereAmIPresenter
223
224 presenter = WhereAmIPresenter()
225 presenter.set_up_commands()
226
227 cmd_manager = command_manager.get_manager()
228 expected_commands = [
229 "readCharAttributesHandler",
230 "presentSizeAndPositionHandler",
231 "getTitleHandler",
232 "getStatusBarHandler",
233 "present_default_button",
234 "present_cell_formula",
235 "whereAmIBasicHandler",
236 "whereAmIDetailedHandler",
237 "whereAmILinkHandler",
238 "whereAmISelectionHandler",
239 ]
240 for cmd_name in expected_commands:
241 assert cmd_manager.get_keyboard_command(cmd_name) is not None
242
243 @pytest.mark.parametrize(
244 "attribute, value, expected",
245 [
246 pytest.param("weight", None, "", id="none_value"),
247 pytest.param("weight", "bold", "bold", id="bold_weight"),
248 pytest.param("weight", "700", "bold", id="numeric_weight"),
249 pytest.param("spelling", "spelling", "misspelled", id="spelling"),
250 pytest.param("style", "italic", "Weight: Bold", id="general"),
251 ],
252 )
253 def test_localize_text_attribute_scenarios(
254 self,
255 test_context: OrcaTestContext,
256 attribute: str,
257 value: str | None,
258 expected: str,
259 ) -> None:
260 """Test WhereAmIPresenter._localize_text_attribute with various attribute scenarios."""
261
262 self._setup_dependencies(test_context)
263 from orca.where_am_i_presenter import WhereAmIPresenter
264
265 presenter = WhereAmIPresenter()
266 result = presenter._localize_text_attribute(attribute, value)
267 assert result == expected
268
269 def test_present_character_attributes(self, test_context: OrcaTestContext) -> None:
270 """Test WhereAmIPresenter.present_character_attributes."""
271
272 deps = self._setup_dependencies(test_context)
273 from orca.where_am_i_presenter import WhereAmIPresenter
274
275 mock_focus = test_context.Mock()
276 deps[
277 "orca.focus_manager"
278 ].get_manager.return_value.get_locus_of_focus.return_value = mock_focus
279
280 deps["orca.ax_text"].AXText.get_text_attributes_at_offset.return_value = (
281 {"weight": "bold", "style": "italic"},
282 0,
283 5,
284 )
285
286 deps[
287 "orca.text_attribute_manager"
288 ].get_manager.return_value.get_attributes_to_speak.return_value = [
289 "weight",
290 "style",
291 "underline",
292 ]
293
294 pres_manager = deps["orca.presentation_manager"].get_manager()
295 pres_manager.speak_message.reset_mock()
296 mock_script = test_context.Mock()
297 presenter = WhereAmIPresenter()
298 result = presenter.present_character_attributes(mock_script)
299 assert result is True
300 pres_manager.speak_message.assert_called()
301 assert pres_manager.speak_message.call_count >= 1
302 call_args = pres_manager.speak_message.call_args_list
303 assert len(call_args) > 0, "Expected at least one call to speak_message for attributes"
304
305 def test_present_character_attributes_no_custom_attributes(
306 self,
307 test_context: OrcaTestContext,
308 ) -> None:
309 """Test WhereAmIPresenter.present_character_attributes with no custom attributes."""
310
311 deps = self._setup_dependencies(test_context)
312 from orca.where_am_i_presenter import WhereAmIPresenter
313
314 deps[
315 "orca.text_attribute_manager"
316 ].get_manager.return_value.get_attributes_to_speak.return_value = []
317
318 default_attr = test_context.Mock()
319 default_attr.get_attribute_name.return_value = "weight"
320 default_attr.value_is_default.return_value = False
321 deps["orca.ax_utilities"].AXUtilities.get_all_supported_text_attributes.return_value = [
322 default_attr
323 ]
324 pres_manager = deps["orca.presentation_manager"].get_manager()
325 pres_manager.speak_message.reset_mock()
326 mock_script = test_context.Mock()
327 presenter = WhereAmIPresenter()
328 result = presenter.present_character_attributes(mock_script)
329 assert result is True
330 pres_manager.speak_message.assert_called()
331 deps["orca.ax_utilities"].AXUtilities.get_all_supported_text_attributes.assert_called_once()
332
333 def test_present_size_and_position_flat_review(self, test_context: OrcaTestContext) -> None:
334 """Test WhereAmIPresenter.present_size_and_position in flat review mode."""
335
336 deps = self._setup_dependencies(test_context)
337 from orca.where_am_i_presenter import WhereAmIPresenter
338
339 mock_script = test_context.Mock()
340 flat_review_presenter_mock = test_context.Mock()
341 flat_review_presenter_mock.is_active.return_value = True
342 current_obj = test_context.Mock()
343 flat_review_presenter_mock.get_current_object.return_value = current_obj
344 deps["orca.flat_review_presenter"].get_presenter.return_value = flat_review_presenter_mock
345
346 rect = test_context.Mock()
347 rect.width = 200
348 rect.height = 100
349 rect.x = 50
350 rect.y = 75
351 deps["orca.ax_component"].AXComponent.get_rect.return_value = rect
352 deps["orca.ax_utilities"].AXUtilities.is_empty_rect.return_value = False
353 pres_manager = deps["orca.presentation_manager"].get_manager()
354 pres_manager.present_message.reset_mock()
355 presenter = WhereAmIPresenter()
356 result = presenter.present_size_and_position(mock_script)
357 assert result is True
358 pres_manager.present_message.assert_called()
359
360 def test_present_size_and_position_empty_rect(self, test_context: OrcaTestContext) -> None:
361 """Test WhereAmIPresenter.present_size_and_position with empty rectangle."""
362
363 deps = self._setup_dependencies(test_context)
364 from orca.where_am_i_presenter import WhereAmIPresenter
365
366 mock_script = test_context.Mock()
367 flat_review_presenter_mock = test_context.Mock()
368 flat_review_presenter_mock.is_active.return_value = False
369 deps["orca.flat_review_presenter"].get_presenter.return_value = flat_review_presenter_mock
370
371 focus_obj = test_context.Mock()
372 deps[
373 "orca.focus_manager"
374 ].get_manager.return_value.get_locus_of_focus.return_value = focus_obj
375
376 deps["orca.ax_utilities"].AXUtilities.is_empty_rect.return_value = True
377 pres_manager = deps["orca.presentation_manager"].get_manager()
378 pres_manager.present_message.reset_mock()
379 presenter = WhereAmIPresenter()
380 result = presenter.present_size_and_position(mock_script)
381 assert result is True
382 pres_manager.present_message.assert_called_with(
383 LOCATION_NOT_FOUND_MSG,
384 LOCATION_NOT_FOUND_MSG,
385 )
386
387 def test_present_title_valid_focus(self, test_context: OrcaTestContext) -> None:
388 """Test WhereAmIPresenter.present_title with valid focus object."""
389
390 deps = self._setup_dependencies(test_context)
391 from orca.where_am_i_presenter import WhereAmIPresenter
392
393 focus_obj = test_context.Mock()
394 deps[
395 "orca.focus_manager"
396 ].get_manager.return_value.get_locus_of_focus.return_value = focus_obj
397
398 deps["orca.ax_object"].AXObject.is_dead.return_value = False
399
400 mock_script = test_context.Mock()
401 speech_gen = test_context.Mock()
402 speech_gen.generate_window_title.return_value = [("Test Window", None)]
403 mock_script.get_speech_generator = test_context.Mock(return_value=speech_gen)
404 pres_manager = deps["orca.presentation_manager"].get_manager()
405 pres_manager.present_message.reset_mock()
406 presenter = WhereAmIPresenter()
407 result = presenter.present_title(mock_script)
408 assert result is True
409 pres_manager.present_window_title.assert_called_once_with(mock_script, focus_obj)
410
411 def test_present_title_dead_focus(self, test_context: OrcaTestContext) -> None:
412 """Test WhereAmIPresenter.present_title with dead focus object."""
413
414 deps = self._setup_dependencies(test_context)
415 from orca.where_am_i_presenter import WhereAmIPresenter
416
417 dead_obj = test_context.Mock()
418 active_window = test_context.Mock()
419 deps[
420 "orca.focus_manager"
421 ].get_manager.return_value.get_locus_of_focus.return_value = dead_obj
422 deps[
423 "orca.focus_manager"
424 ].get_manager.return_value.get_active_window.return_value = active_window
425
426 deps["orca.ax_object"].AXObject.is_dead.side_effect = [True, False]
427
428 mock_script = test_context.Mock()
429 speech_gen = test_context.Mock()
430 speech_gen.generate_window_title.return_value = [("Active Window", None)]
431 mock_script.get_speech_generator = test_context.Mock(return_value=speech_gen)
432 pres_manager = deps["orca.presentation_manager"].get_manager()
433 pres_manager.present_message.reset_mock()
434 presenter = WhereAmIPresenter()
435 result = presenter.present_title(mock_script)
436 assert result is True
437 pres_manager.present_window_title.assert_called_once_with(mock_script, active_window)
438
439 def test_present_title_no_valid_object(self, test_context: OrcaTestContext) -> None:
440 """Test WhereAmIPresenter.present_title with no valid object."""
441
442 deps = self._setup_dependencies(test_context)
443 from orca.where_am_i_presenter import WhereAmIPresenter
444
445 deps["orca.focus_manager"].get_manager.return_value.get_locus_of_focus.return_value = None
446 deps["orca.focus_manager"].get_manager.return_value.get_active_window.return_value = None
447
448 deps["orca.ax_object"].AXObject.is_dead.return_value = True
449 pres_manager = deps["orca.presentation_manager"].get_manager()
450 pres_manager.present_message.reset_mock()
451 mock_script = test_context.Mock()
452 presenter = WhereAmIPresenter()
453 result = presenter.present_title(mock_script)
454 assert result is True
455 pres_manager.present_message.assert_called_with(LOCATION_NOT_FOUND_MSG)
456
457 @pytest.mark.parametrize(
458 "has_dialog, has_button, is_sensitive, button_name, expected_message",
459 [
460 pytest.param(True, True, True, "OK", "Default button is OK", id="button_success"),
461 pytest.param(
462 True,
463 True,
464 False,
465 "OK",
466 "Default button OK is grayed",
467 id="button_grayed",
468 ),
469 pytest.param(False, False, False, None, "Not in a dialog", id="no_dialog"),
470 pytest.param(True, False, False, None, DEFAULT_BUTTON_NOT_FOUND_MSG, id="no_button"),
471 ],
472 )
473 def test_present_default_button_scenarios(
474 self,
475 test_context: OrcaTestContext,
476 has_dialog: bool,
477 has_button: bool,
478 is_sensitive: bool,
479 button_name: str | None,
480 expected_message: str,
481 ) -> None:
482 """Test WhereAmIPresenter.present_default_button for various scenarios."""
483
484 deps = self._setup_dependencies(test_context)
485 from orca.where_am_i_presenter import WhereAmIPresenter
486
487 focus_obj = test_context.Mock()
488 deps[
489 "orca.focus_manager"
490 ].get_manager.return_value.get_locus_of_focus.return_value = focus_obj
491
492 mock_script = test_context.Mock()
493 dialog = test_context.Mock() if has_dialog else None
494 mock_script.utilities.frame_and_dialog.return_value = (None, dialog)
495
496 if has_button:
497 button = test_context.Mock()
498 deps["orca.ax_utilities"].AXUtilities.get_default_button.return_value = button
499 deps["orca.ax_utilities"].AXUtilities.is_sensitive.return_value = is_sensitive
500 deps["orca.ax_object"].AXObject.get_name.return_value = button_name
501 else:
502 deps["orca.ax_utilities"].AXUtilities.get_default_button.return_value = None
503
504 pres_manager = deps["orca.presentation_manager"].get_manager()
505 pres_manager.present_message.reset_mock()
506 presenter = WhereAmIPresenter()
507 result = presenter.present_default_button(mock_script)
508 assert result is True
509 pres_manager.present_message.assert_called_with(expected_message)
510
511 def test_present_status_bar_with_info(self, test_context: OrcaTestContext) -> None:
512 """Test WhereAmIPresenter.present_status_bar with both status bar and info bar."""
513
514 deps = self._setup_dependencies(test_context)
515 from orca.where_am_i_presenter import WhereAmIPresenter
516
517 focus_obj = test_context.Mock()
518 deps[
519 "orca.focus_manager"
520 ].get_manager.return_value.get_locus_of_focus.return_value = focus_obj
521 mock_script = test_context.Mock()
522 frame = test_context.Mock()
523 mock_script.utilities.frame_and_dialog.return_value = (frame, None)
524 mock_script.present_object = test_context.Mock()
525
526 statusbar = test_context.Mock()
527 infobar = test_context.Mock()
528 deps["orca.ax_utilities"].AXUtilities.get_status_bar.return_value = statusbar
529 deps["orca.ax_utilities"].AXUtilities.get_info_bar.return_value = infobar
530 deps["orca.ax_utilities"].AXUtilities.is_showing.return_value = True
531 deps["orca.ax_utilities"].AXUtilities.is_visible.return_value = True
532 presenter = WhereAmIPresenter()
533 result = presenter.present_status_bar(mock_script)
534 assert result is True
535 assert mock_script.present_object.call_count == 2
536
537 def test_present_status_bar_no_status_bar(self, test_context: OrcaTestContext) -> None:
538 """Test WhereAmIPresenter.present_status_bar with no status bar."""
539
540 deps = self._setup_dependencies(test_context)
541 from orca.where_am_i_presenter import WhereAmIPresenter
542
543 focus_obj = test_context.Mock()
544 deps[
545 "orca.focus_manager"
546 ].get_manager.return_value.get_locus_of_focus.return_value = focus_obj
547 mock_script = test_context.Mock()
548 frame = test_context.Mock()
549 mock_script.utilities.frame_and_dialog.return_value = (frame, None)
550 mock_script.present_object = test_context.Mock()
551 deps["orca.ax_utilities"].AXUtilities.get_status_bar.return_value = None
552 deps["orca.ax_utilities"].AXUtilities.get_info_bar.return_value = None
553 pres_manager = deps["orca.presentation_manager"].get_manager()
554 pres_manager.present_message.reset_mock()
555 presenter = WhereAmIPresenter()
556 result = presenter.present_status_bar(mock_script)
557 assert result is True
558 pres_manager.present_message.assert_called_with(
559 STATUS_BAR_NOT_FOUND_FULL_MSG,
560 STATUS_BAR_NOT_FOUND_BRIEF_MSG,
561 )
562
563 def test_present_link_valid_link(self, test_context: OrcaTestContext) -> None:
564 """Test WhereAmIPresenter.present_link with valid link."""
565
566 deps = self._setup_dependencies(test_context)
567 from orca.where_am_i_presenter import WhereAmIPresenter
568
569 link_obj = test_context.Mock()
570 deps[
571 "orca.focus_manager"
572 ].get_manager.return_value.get_locus_of_focus.return_value = link_obj
573 mock_script = test_context.Mock()
574 mock_script.utilities.is_link.return_value = True
575 presenter = WhereAmIPresenter()
576 mock_do_where_am_i = test_context.patch_object(
577 presenter,
578 "_do_where_am_i",
579 return_value=True,
580 )
581 result = presenter.present_link(mock_script)
582 assert result is True
583 mock_do_where_am_i.assert_called_with(mock_script, True, link_obj)
584
585 def test_present_link_not_link(self, test_context: OrcaTestContext) -> None:
586 """Test WhereAmIPresenter.present_link with non-link object."""
587
588 deps = self._setup_dependencies(test_context)
589 from orca.where_am_i_presenter import WhereAmIPresenter
590
591 non_link_obj = test_context.Mock()
592 deps[
593 "orca.focus_manager"
594 ].get_manager.return_value.get_locus_of_focus.return_value = non_link_obj
595 mock_script = test_context.Mock()
596 mock_script.utilities.is_link.return_value = False
597 pres_manager = deps["orca.presentation_manager"].get_manager()
598 pres_manager.present_message.reset_mock()
599 presenter = WhereAmIPresenter()
600 result = presenter.present_link(mock_script)
601 assert result is True
602 pres_manager.present_message.assert_called_with("Not on a link")
603
604 def test_get_all_selected_text_spreadsheet_cell(self, test_context: OrcaTestContext) -> None:
605 """Test WhereAmIPresenter._get_all_selected_text with spreadsheet cell."""
606
607 deps = self._setup_dependencies(test_context)
608 from orca.where_am_i_presenter import WhereAmIPresenter
609
610 cell_obj = test_context.Mock()
611 mock_script = test_context.Mock()
612 deps["orca.ax_utilities"].AXUtilities.is_spreadsheet_cell.return_value = True
613
614 deps["orca.ax_utilities"].AXUtilities.get_selected_text.return_value = (
615 "cell text",
616 0,
617 9,
618 )
619 presenter = WhereAmIPresenter()
620 result = presenter._get_all_selected_text(mock_script, cell_obj)
621 assert result == "cell text"
622
623 def test_get_all_selected_text_with_adjacent(self, test_context: OrcaTestContext) -> None:
624 """Test WhereAmIPresenter._get_all_selected_text with adjacent text objects."""
625
626 deps = self._setup_dependencies(test_context)
627 from orca.where_am_i_presenter import WhereAmIPresenter
628
629 text_obj = test_context.Mock()
630 prev_obj = test_context.Mock()
631 next_obj = test_context.Mock()
632 mock_script = test_context.Mock()
633 deps["orca.ax_utilities"].AXUtilities.is_spreadsheet_cell.return_value = False
634 mock_script.utilities.find_previous_object.side_effect = [prev_obj, None]
635 mock_script.utilities.find_next_object.side_effect = [next_obj, None]
636
637 deps["orca.ax_utilities"].AXUtilities.get_selected_text.side_effect = [
638 ("current text", 0, 12), # current object
639 ("prev text", 0, 9), # previous object
640 ("next text", 0, 9), # next object
641 ]
642 presenter = WhereAmIPresenter()
643 result = presenter._get_all_selected_text(mock_script, text_obj)
644 assert result == "prev text current text next text"
645
646 def test_present_selected_text_no_focus(self, test_context: OrcaTestContext) -> None:
647 """Test WhereAmIPresenter.present_selected_text with no focus."""
648
649 deps = self._setup_dependencies(test_context)
650 from orca.where_am_i_presenter import WhereAmIPresenter
651
652 deps["orca.focus_manager"].get_manager.return_value.get_locus_of_focus.return_value = None
653 pres_manager = deps["orca.presentation_manager"].get_manager()
654 pres_manager.speak_message.reset_mock()
655 mock_script = test_context.Mock()
656 presenter = WhereAmIPresenter()
657 result = presenter.present_selected_text(mock_script)
658 assert result is True
659 pres_manager.speak_message.assert_called_with(LOCATION_NOT_FOUND_MSG)
660
661 def test_present_selected_text_with_text(self, test_context: OrcaTestContext) -> None:
662 """Test WhereAmIPresenter.present_selected_text with selected text."""
663
664 deps = self._setup_dependencies(test_context)
665 from orca.where_am_i_presenter import WhereAmIPresenter
666
667 focus_obj = test_context.Mock()
668 deps["focus_manager_instance"].get_locus_of_focus.return_value = focus_obj
669 mock_script = test_context.Mock()
670
671 presenter = WhereAmIPresenter()
672 test_context.patch_object(presenter, "_get_all_selected_text", return_value="selected text")
673
674 manager = deps["orca.speech_presenter"].get_presenter.return_value
675 manager.get_indentation_description.return_value = "indent: 2"
676
677 def mock_adjust_for_presentation(_obj, text) -> str:
678 return f"processed {text}"
679
680 def mock_adjust_for_digits(_obj, text) -> str:
681 text_str = str(text) if text is not None else ""
682 return text_str
683
684 manager.adjust_for_presentation = mock_adjust_for_presentation
685 manager.adjust_for_digits = mock_adjust_for_digits
686 pres_manager = deps["orca.presentation_manager"].get_manager()
687 pres_manager.speak_message.reset_mock()
688 result = presenter.present_selected_text(mock_script)
689 assert result is True
690 expected_msg = "Selected text is indent: 2 processed selected text"
691 pres_manager.speak_message.assert_called_with(expected_msg)
692
693 def test_present_selection_spreadsheet_handling(self, test_context: OrcaTestContext) -> None:
694 """Test WhereAmIPresenter.present_selection with spreadsheet cell range."""
695
696 deps = self._setup_dependencies(test_context)
697 from orca.where_am_i_presenter import WhereAmIPresenter
698
699 focus_obj = test_context.Mock()
700 deps[
701 "orca.focus_manager"
702 ].get_manager.return_value.get_locus_of_focus.return_value = focus_obj
703
704 spreadsheet = test_context.Mock()
705 deps["orca.ax_utilities"].AXUtilities.find_ancestor.return_value = spreadsheet
706 mock_script = test_context.Mock()
707 mock_script.utilities.speak_selected_cell_range.return_value = True
708 presenter = WhereAmIPresenter()
709 result = presenter.present_selection(mock_script)
710 assert result is True
711 mock_script.utilities.speak_selected_cell_range.assert_called_with(spreadsheet)
712
713 def test_present_selection_container_selection(self, test_context: OrcaTestContext) -> None:
714 """Test WhereAmIPresenter.present_selection with selection container."""
715
716 deps = self._setup_dependencies(test_context)
717 from orca.where_am_i_presenter import WhereAmIPresenter
718
719 focus_obj = test_context.Mock()
720 deps["focus_manager_instance"].get_locus_of_focus.return_value = focus_obj
721
722 deps["orca.ax_utilities"].AXUtilities.find_ancestor.return_value = None
723 deps["orca.ax_object"].AXObject.get_name.side_effect = ["Item 1", "Item 2"]
724
725 container = test_context.Mock()
726 selected_items = [test_context.Mock(), test_context.Mock()]
727 mock_script = test_context.Mock()
728 deps["orca.ax_utilities"].AXUtilities.get_selection_container.return_value = container
729 deps["orca.ax_utilities"].AXUtilities.selected_child_count.return_value = 2
730 deps["orca.ax_utilities"].AXUtilities.selectable_child_count.return_value = 5
731 deps["orca.ax_utilities"].AXUtilities.selected_children.return_value = selected_items
732 pres_manager = deps["orca.presentation_manager"].get_manager()
733 pres_manager.present_message.reset_mock()
734 pres_manager.speak_message.reset_mock()
735 presenter = WhereAmIPresenter()
736 result = presenter.present_selection(mock_script)
737 assert result is True
738 pres_manager.present_message.assert_called_with("2 of 5 items selected")
739 pres_manager.speak_message.assert_called_with("Item 1,Item 2")
740
741 def test_present_selection_no_container(self, test_context: OrcaTestContext) -> None:
742 """Test WhereAmIPresenter.present_selection with no selection container."""
743
744 deps = self._setup_dependencies(test_context)
745 from orca.where_am_i_presenter import WhereAmIPresenter
746
747 focus_obj = test_context.Mock()
748 deps["focus_manager_instance"].get_locus_of_focus.return_value = focus_obj
749
750 deps["orca.ax_utilities"].AXUtilities.find_ancestor.return_value = None
751 mock_script = test_context.Mock()
752 deps["orca.ax_utilities"].AXUtilities.get_selection_container.return_value = None
753 presenter = WhereAmIPresenter()
754 presenter.present_selected_text = test_context.Mock(return_value=True)
755 result = presenter.present_selection(mock_script)
756 assert result is True
757 presenter.present_selected_text.assert_called_with(mock_script, None, focus_obj)
758
759 def test_do_where_am_i_basic(self, test_context: OrcaTestContext) -> None:
760 """Test WhereAmIPresenter._do_where_am_i with basic mode."""
761
762 deps = self._setup_dependencies(test_context)
763 from orca.where_am_i_presenter import WhereAmIPresenter
764
765 focus_obj = test_context.Mock()
766 deps["focus_manager_instance"].get_locus_of_focus.return_value = focus_obj
767
768 deps["orca.ax_object"].AXObject.is_dead.return_value = False
769
770 deps["orca.ax_utilities"].AXUtilities.is_focused.return_value = True
771 deps["orca.ax_utilities"].AXUtilities.is_table_cell_or_header.return_value = False
772 deps["orca.ax_utilities"].AXUtilities.is_list_item.return_value = False
773 deps["orca.ax_utilities"].AXUtilities.is_layout_only.return_value = False
774 mock_script = test_context.Mock()
775 mock_script.spellcheck = None
776 mock_script.present_object = test_context.Mock()
777 presenter = WhereAmIPresenter()
778 result = presenter._do_where_am_i(mock_script, basic_only=True)
779 assert result is True
780 mock_script.present_object.assert_called_once()
781
782 def test_do_where_am_i_detailed(self, test_context: OrcaTestContext) -> None:
783 """Test WhereAmIPresenter._do_where_am_i with detailed mode."""
784
785 deps = self._setup_dependencies(test_context)
786 from orca.where_am_i_presenter import WhereAmIPresenter
787
788 focus_obj = test_context.Mock()
789 deps["focus_manager_instance"].get_locus_of_focus.return_value = focus_obj
790
791 deps["orca.ax_object"].AXObject.is_dead.return_value = False
792
793 deps["orca.ax_utilities"].AXUtilities.is_focused.return_value = True
794 mock_script = test_context.Mock()
795 mock_script.spellcheck = None
796 mock_script.present_object = test_context.Mock()
797 presenter = WhereAmIPresenter()
798 result = presenter._do_where_am_i(mock_script, basic_only=False)
799 assert result is True
800 call_args = mock_script.present_object.call_args
801 from orca.generator import WhereAmI
802
803 assert call_args[1]["where_am_i_type"] == WhereAmI.DETAILED
804
805 def test_do_where_am_i_dead_object(self, test_context: OrcaTestContext) -> None:
806 """Test WhereAmIPresenter._do_where_am_i with dead focus object."""
807
808 deps = self._setup_dependencies(test_context)
809 from orca.where_am_i_presenter import WhereAmIPresenter
810
811 dead_obj = test_context.Mock()
812 active_window = test_context.Mock()
813 deps[
814 "orca.focus_manager"
815 ].get_manager.return_value.get_locus_of_focus.return_value = dead_obj
816 deps[
817 "orca.focus_manager"
818 ].get_manager.return_value.get_active_window.return_value = active_window
819
820 deps["orca.ax_object"].AXObject.is_dead.side_effect = [True, False]
821
822 deps["orca.ax_utilities"].AXUtilities.is_focused.return_value = True
823 mock_script = test_context.Mock()
824 mock_script.spellcheck = None
825 mock_script.present_object = test_context.Mock()
826 presenter = WhereAmIPresenter()
827 result = presenter._do_where_am_i(mock_script)
828 assert result is True
829
830 def test_do_where_am_i_no_object(self, test_context: OrcaTestContext) -> None:
831 """Test WhereAmIPresenter._do_where_am_i with no valid object."""
832
833 deps = self._setup_dependencies(test_context)
834 from orca.where_am_i_presenter import WhereAmIPresenter
835
836 deps["orca.focus_manager"].get_manager.return_value.get_locus_of_focus.return_value = None
837 deps["orca.focus_manager"].get_manager.return_value.get_active_window.return_value = None
838
839 deps["orca.ax_object"].AXObject.is_dead.return_value = True
840 pres_manager = deps["orca.presentation_manager"].get_manager()
841 pres_manager.present_message.reset_mock()
842 mock_script = test_context.Mock()
843 mock_script.spellcheck = None
844 presenter = WhereAmIPresenter()
845 result = presenter._do_where_am_i(mock_script)
846 assert result is True
847 pres_manager.present_message.assert_called_with(LOCATION_NOT_FOUND_MSG)
848
849 def test_do_where_am_i_with_spellcheck(self, test_context: OrcaTestContext) -> None:
850 """Test WhereAmIPresenter._do_where_am_i with active spellcheck."""
851
852 deps = self._setup_dependencies(test_context)
853 from orca.where_am_i_presenter import WhereAmIPresenter
854
855 focus_obj = test_context.Mock()
856 deps["focus_manager_instance"].get_locus_of_focus.return_value = focus_obj
857
858 deps["orca.ax_object"].AXObject.is_dead.return_value = False
859
860 deps["orca.ax_utilities"].AXUtilities.is_focused.return_value = True
861
862 spellcheck_mock = test_context.Mock()
863 spellcheck_mock.is_active.return_value = True
864 spellcheck_mock.present_error_details = test_context.Mock()
865 deps["orca.spellcheck_presenter"].get_presenter.return_value = spellcheck_mock
866
867 mock_script = test_context.Mock()
868 mock_script.present_object = test_context.Mock()
869 presenter = WhereAmIPresenter()
870 result = presenter._do_where_am_i(mock_script, basic_only=False)
871 assert result is True
872 spellcheck_mock.present_error_details.assert_called_with(True, mock_script)
873
874 def test_where_am_i_basic(self, test_context: OrcaTestContext) -> None:
875 """Test WhereAmIPresenter.where_am_i_basic."""
876
877 self._setup_dependencies(test_context)
878 from orca.where_am_i_presenter import WhereAmIPresenter
879
880 mock_script = test_context.Mock()
881 presenter = WhereAmIPresenter()
882 mock_do_where_am_i = test_context.patch_object(
883 presenter,
884 "_do_where_am_i",
885 return_value=True,
886 )
887 result = presenter.where_am_i_basic(mock_script)
888 assert result is True
889 mock_do_where_am_i.assert_called_with(mock_script, notify_user=True)
890
891 def test_where_am_i_detailed(self, test_context: OrcaTestContext) -> None:
892 """Test WhereAmIPresenter.where_am_i_detailed."""
893
894 deps = self._setup_dependencies(test_context)
895 from orca.where_am_i_presenter import WhereAmIPresenter
896
897 pres_manager = deps["orca.presentation_manager"].get_manager()
898 pres_manager.interrupt_presentation.reset_mock()
899 mock_script = test_context.Mock()
900 presenter = WhereAmIPresenter()
901 mock_do_where_am_i = test_context.patch_object(
902 presenter,
903 "_do_where_am_i",
904 return_value=True,
905 )
906 result = presenter.where_am_i_detailed(mock_script)
907 assert result is True
908 pres_manager.interrupt_presentation.assert_called_once()
909 mock_do_where_am_i.assert_called_with(mock_script, False, notify_user=True)
910
911 def test_get_presenter(self, test_context: OrcaTestContext) -> None:
912 """Test get_presenter function."""
913
914 self._setup_dependencies(test_context)
915 from orca.where_am_i_presenter import get_presenter
916
917 presenter = get_presenter()
918 assert presenter is not None
919 presenter2 = get_presenter()
920 assert presenter is presenter2