Debian Codegraph @

tests/unit_tests/test_ax_document.py

raw
1 # Unit tests for ax_document.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=too-many-public-methods
22 # pylint: disable=wrong-import-position
23 # pylint: disable=import-outside-toplevel
24 # pylint: disable=protected-access
25
26 """Unit tests for ax_document.py methods."""
27
28 from __future__ import annotations
29
30 from typing import TYPE_CHECKING
31
32 import gi
33 import pytest
34
35 gi.require_version("Atspi", "2.0")
36 from gi.repository import Atspi, GLib
37
38 if TYPE_CHECKING:
39 from unittest.mock import MagicMock
40
41 from .orca_test_context import OrcaTestContext
42
43
44 @pytest.mark.unit
45 class TestAXDocument:
46 """Test AXDocument class methods."""
47
48 def _setup_dependencies(self, test_context: OrcaTestContext) -> dict[str, MagicMock]:
49 """Set up mocks for ax_document dependencies."""
50
51 additional_modules = [
52 "orca.ax_collection",
53 "orca.ax_object",
54 "orca.ax_utilities_role",
55 "orca.ax_utilities_state",
56 "orca.ax_utilities_table",
57 "orca.messages",
58 ]
59 essential_modules = test_context.setup_shared_dependencies(additional_modules)
60
61 messages_mock = essential_modules["orca.messages"]
62 messages_mock.landmark_count = test_context.Mock(return_value="")
63 messages_mock.heading_count = test_context.Mock(return_value="")
64 messages_mock.form_count = test_context.Mock(return_value="")
65 messages_mock.table_count = test_context.Mock(return_value="")
66 messages_mock.visited_link_count = test_context.Mock(return_value="")
67 messages_mock.unvisited_link_count = test_context.Mock(return_value="")
68 messages_mock.PAGE_SUMMARY_PREFIX = "Page has %s"
69
70 ax_collection_mock = essential_modules["orca.ax_collection"].AXCollection
71 ax_collection_mock.create_match_rule = test_context.Mock(return_value={})
72 ax_collection_mock.get_all_matches = test_context.Mock(return_value=[])
73
74 ax_utilities_table_mock = essential_modules["orca.ax_utilities_table"].AXUtilitiesTable
75 ax_utilities_table_mock.is_layout_table = test_context.Mock(return_value=False)
76
77 ax_utilities_role_mock = essential_modules["orca.ax_utilities_role"].AXUtilitiesRole
78 ax_utilities_role_mock.is_heading = test_context.Mock(return_value=False)
79 ax_utilities_role_mock.is_form = test_context.Mock(return_value=False)
80 ax_utilities_role_mock.is_table = test_context.Mock(return_value=False)
81 ax_utilities_role_mock.is_link = test_context.Mock(return_value=False)
82 ax_utilities_role_mock.is_landmark = test_context.Mock(return_value=False)
83
84 ax_utilities_state_mock = essential_modules["orca.ax_utilities_state"].AXUtilitiesState
85 ax_utilities_state_mock.is_visited = test_context.Mock(return_value=False)
86
87 return essential_modules
88
89 @pytest.mark.parametrize(
90 "method_name,expected_result",
91 [
92 ("did_page_change", False),
93 ("get_page_count", 0),
94 ("get_locale", ""),
95 ],
96 )
97 def test_document_methods_when_not_document(
98 self,
99 test_context: OrcaTestContext,
100 method_name: str,
101 expected_result,
102 ) -> None:
103 """Test AXDocument methods return defaults when object doesn't support document."""
104
105 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
106 from orca.ax_document import AXDocument
107
108 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
109 ax_object_mock = essential_modules["orca.ax_object"].AXObject
110 ax_object_mock.supports_document.return_value = False
111 method = getattr(AXDocument, method_name)
112 result = method(mock_accessible)
113 assert result == expected_result
114 ax_object_mock.supports_document.assert_called_once_with(mock_accessible)
115
116 def test_did_page_change_false_when_page_unchanged(self, test_context: OrcaTestContext) -> None:
117 """Test AXDocument.did_page_change returns False when page hasn't changed."""
118
119 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
120 from orca.ax_document import AXDocument
121
122 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
123 ax_object_mock = essential_modules["orca.ax_object"].AXObject
124 ax_object_mock.supports_document.return_value = True
125 document_hash = hash(mock_accessible)
126 AXDocument.LAST_KNOWN_PAGE[document_hash] = 3
127 mock_get_page = test_context.Mock(return_value=3)
128 test_context.patch_object(AXDocument, "_get_current_page", new=mock_get_page)
129 result = AXDocument.did_page_change(mock_accessible)
130 assert result is False
131 mock_get_page.assert_called_once_with(mock_accessible)
132
133 def test_did_page_change_true_when_page_changed(self, test_context: OrcaTestContext) -> None:
134 """Test AXDocument.did_page_change returns True when page has changed."""
135
136 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
137 from orca.ax_document import AXDocument
138
139 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
140 ax_object_mock = essential_modules["orca.ax_object"].AXObject
141 ax_object_mock.supports_document.return_value = True
142 document_hash = hash(mock_accessible)
143 AXDocument.LAST_KNOWN_PAGE[document_hash] = 3
144 mock_get_page = test_context.Mock(return_value=5)
145 test_context.patch_object(AXDocument, "_get_current_page", new=mock_get_page)
146 result = AXDocument.did_page_change(mock_accessible)
147 assert result is True
148 mock_get_page.assert_called_once_with(mock_accessible)
149
150 def test_get_current_page_zero_when_not_document(self, test_context: OrcaTestContext) -> None:
151 """Test AXDocument._get_current_page returns 0 when object doesn't support document."""
152
153 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
154 from orca.ax_document import AXDocument
155
156 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
157 ax_object_mock = essential_modules["orca.ax_object"].AXObject
158 ax_object_mock.supports_document.return_value = False
159 result = AXDocument._get_current_page(mock_accessible)
160 assert result == 0
161 ax_object_mock.supports_document.assert_called_once_with(mock_accessible)
162
163 def test_get_current_page_success(self, test_context: OrcaTestContext) -> None:
164 """Test AXDocument._get_current_page returns page number on success."""
165
166 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
167 from orca.ax_document import AXDocument
168
169 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
170 ax_object_mock = essential_modules["orca.ax_object"].AXObject
171 ax_object_mock.supports_document.return_value = True
172 mock_get_page = test_context.Mock(return_value=7)
173 test_context.patch(
174 "gi.repository.Atspi.Document.get_current_page_number",
175 new=mock_get_page,
176 )
177 result = AXDocument._get_current_page(mock_accessible)
178 assert result == 7
179 mock_get_page.assert_called_once_with(mock_accessible)
180
181 def test_get_current_page_exception_returns_zero(self, test_context: OrcaTestContext) -> None:
182 """Test AXDocument._get_current_page returns 0 on GLib.GError exception."""
183
184 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
185 from orca.ax_document import AXDocument
186
187 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
188 ax_object_mock = essential_modules["orca.ax_object"].AXObject
189 ax_object_mock.supports_document.return_value = True
190 mock_get_page = test_context.Mock(side_effect=GLib.GError("Test error"))
191 test_context.patch(
192 "gi.repository.Atspi.Document.get_current_page_number",
193 new=mock_get_page,
194 )
195 result = AXDocument._get_current_page(mock_accessible)
196 assert result == 0
197 mock_get_page.assert_called_once_with(mock_accessible)
198
199 def test_get_current_page_public_method_caches_result(
200 self,
201 test_context: OrcaTestContext,
202 ) -> None:
203 """Test AXDocument.get_current_page caches the result in LAST_KNOWN_PAGE."""
204
205 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
206 from orca.ax_document import AXDocument
207
208 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
209 ax_object_mock = essential_modules["orca.ax_object"].AXObject
210 ax_object_mock.supports_document.return_value = True
211 mock_get_page = test_context.Mock(return_value=9)
212 test_context.patch_object(AXDocument, "_get_current_page", new=mock_get_page)
213 result = AXDocument.get_current_page(mock_accessible)
214 assert result == 9
215 document_hash = hash(mock_accessible)
216 assert AXDocument.LAST_KNOWN_PAGE[document_hash] == 9
217
218 def test_get_page_count_success(self, test_context: OrcaTestContext) -> None:
219 """Test AXDocument.get_page_count returns page count on success."""
220
221 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
222 from orca.ax_document import AXDocument
223
224 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
225 ax_object_mock = essential_modules["orca.ax_object"].AXObject
226 ax_object_mock.supports_document.return_value = True
227 mock_get_count = test_context.Mock(return_value=25)
228 test_context.patch("gi.repository.Atspi.Document.get_page_count", new=mock_get_count)
229 result = AXDocument.get_page_count(mock_accessible)
230 assert result == 25
231 mock_get_count.assert_called_once_with(mock_accessible)
232
233 def test_get_locale_success(self, test_context: OrcaTestContext) -> None:
234 """Test AXDocument.get_locale returns locale string on success."""
235
236 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
237 from orca.ax_document import AXDocument
238
239 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
240 ax_object_mock = essential_modules["orca.ax_object"].AXObject
241 ax_object_mock.supports_document.return_value = True
242 mock_get_locale = test_context.Mock(return_value="en_US")
243 test_context.patch("gi.repository.Atspi.Document.get_locale", new=mock_get_locale)
244 result = AXDocument.get_locale(mock_accessible)
245 assert result == "en_US"
246 mock_get_locale.assert_called_once_with(mock_accessible)
247
248 def test_get_attributes_dict_empty_when_not_document(
249 self,
250 test_context: OrcaTestContext,
251 ) -> None:
252 """Test AXDocument._get_attributes_dict returns empty dict when object isn't a document."""
253
254 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
255 from orca.ax_document import AXDocument
256
257 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
258 ax_object_mock = essential_modules["orca.ax_object"].AXObject
259 ax_object_mock.supports_document.return_value = False
260 result = AXDocument._get_attributes_dict(mock_accessible)
261 assert result == {}
262 ax_object_mock.supports_document.assert_called_once_with(mock_accessible)
263
264 def test_get_attributes_dict_success(self, test_context: OrcaTestContext) -> None:
265 """Test AXDocument._get_attributes_dict returns attributes dict on success."""
266
267 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
268 from orca.ax_document import AXDocument
269
270 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
271 ax_object_mock = essential_modules["orca.ax_object"].AXObject
272 ax_object_mock.supports_document.return_value = True
273 test_attributes = {"DocURL": "http://example.com", "MimeType": "text/html"}
274 mock_get_attrs = test_context.Mock(return_value=test_attributes)
275 test_context.patch(
276 "gi.repository.Atspi.Document.get_document_attributes",
277 new=mock_get_attrs,
278 )
279 result = AXDocument._get_attributes_dict(mock_accessible)
280 assert result == test_attributes
281 mock_get_attrs.assert_called_once_with(mock_accessible)
282
283 @pytest.mark.parametrize(
284 "attributes,expected_uri",
285 [
286 ({"DocURL": "http://example.com/doc", "URI": "fallback"}, "http://example.com/doc"),
287 ({"URI": "http://example.com/fallback"}, "http://example.com/fallback"),
288 ({}, ""),
289 ],
290 )
291 def test_get_uri_handling(
292 self,
293 test_context: OrcaTestContext,
294 attributes: dict,
295 expected_uri: str,
296 ) -> None:
297 """Test AXDocument.get_uri with different attribute scenarios."""
298
299 self._setup_dependencies(test_context)
300 from orca.ax_document import AXDocument
301
302 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
303 mock_get_attrs = test_context.Mock(return_value=attributes)
304 test_context.patch_object(AXDocument, "_get_attributes_dict", new=mock_get_attrs)
305 result = AXDocument.get_uri(mock_accessible)
306 assert result == expected_uri
307
308 def test_get_mime_type_returns_mime_type(self, test_context: OrcaTestContext) -> None:
309 """Test AXDocument.get_mime_type returns MimeType from attributes."""
310
311 self._setup_dependencies(test_context)
312 from orca.ax_document import AXDocument
313
314 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
315 test_mime = "application/pdf"
316 mock_get_attrs = test_context.Mock(return_value={"MimeType": test_mime})
317 test_context.patch_object(AXDocument, "_get_attributes_dict", new=mock_get_attrs)
318 result = AXDocument.get_mime_type(mock_accessible)
319 assert result == test_mime
320
321 @pytest.mark.parametrize(
322 "mime_type,expected",
323 [
324 ("text/plain", True),
325 ("text/html", False),
326 ("application/pdf", False),
327 ("", False),
328 ],
329 )
330 def test_is_plain_text(
331 self,
332 test_context: OrcaTestContext,
333 mime_type: str,
334 expected: bool,
335 ) -> None:
336 """Test AXDocument.is_plain_text with various mime types."""
337
338 self._setup_dependencies(test_context)
339 from orca.ax_document import AXDocument
340
341 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
342 mock_get_mime = test_context.Mock(return_value=mime_type)
343 test_context.patch_object(AXDocument, "get_mime_type", new=mock_get_mime)
344 result = AXDocument.is_plain_text(mock_accessible)
345 assert result is expected
346
347 @pytest.mark.parametrize(
348 "mime_type,uri,expected",
349 [
350 ("application/pdf", "http://example.com/document", True),
351 ("text/html", "http://example.com/document.pdf", True),
352 ("text/html", "http://example.com/document.html", False),
353 ("text/plain", "http://example.com/document.pdf", False),
354 ("", "http://example.com/document.pdf", False),
355 ],
356 )
357 def test_is_pdf(
358 self,
359 test_context: OrcaTestContext,
360 mime_type: str,
361 uri: str,
362 expected: bool,
363 ) -> None:
364 """Test AXDocument.is_pdf with various mime types and URIs."""
365
366 self._setup_dependencies(test_context)
367 from orca.ax_document import AXDocument
368
369 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
370 mock_get_mime = test_context.Mock(return_value=mime_type)
371 mock_get_uri = test_context.Mock(return_value=uri)
372 test_context.patch_object(AXDocument, "get_mime_type", new=mock_get_mime)
373 test_context.patch_object(AXDocument, "get_uri", new=mock_get_uri)
374 result = AXDocument.is_pdf(mock_accessible)
375 assert result is expected
376
377 def test_get_document_uri_fragment_returns_fragment(
378 self,
379 test_context: OrcaTestContext,
380 ) -> None:
381 """Test AXDocument.get_document_uri_fragment returns fragment from parsed URI."""
382
383 self._setup_dependencies(test_context)
384 from orca.ax_document import AXDocument
385
386 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
387 mock_get_uri = test_context.Mock(return_value="http://example.com/doc#section1")
388 test_context.patch_object(AXDocument, "get_uri", new=mock_get_uri)
389 result = AXDocument.get_document_uri_fragment(mock_accessible)
390 assert result == "section1"
391
392 def test_get_object_counts_returns_zero_counts_for_empty_document(
393 self,
394 test_context: OrcaTestContext,
395 ) -> None:
396 """Test AXDocument._get_object_counts returns zero counts when no objects found."""
397
398 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
399 from orca.ax_document import AXDocument
400
401 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
402 ax_collection_mock = essential_modules["orca.ax_collection"].AXCollection
403 ax_collection_mock.get_all_matches.return_value = []
404 result = AXDocument._get_object_counts(mock_accessible)
405 expected = {
406 "forms": 0,
407 "landmarks": 0,
408 "headings": 0,
409 "tables": 0,
410 "unvisited_links": 0,
411 "visited_links": 0,
412 }
413 assert result == expected
414
415 def test_get_object_counts_with_various_objects( # pylint: disable=too-many-locals
416 self,
417 test_context: OrcaTestContext,
418 ) -> None:
419 """Test AXDocument._get_object_counts counts different object types correctly."""
420
421 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
422 from orca.ax_document import AXDocument
423
424 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
425
426 heading1 = test_context.Mock(spec=Atspi.Accessible)
427 heading2 = test_context.Mock(spec=Atspi.Accessible)
428 form_obj = test_context.Mock(spec=Atspi.Accessible)
429 table_obj = test_context.Mock(spec=Atspi.Accessible)
430 visited_link = test_context.Mock(spec=Atspi.Accessible)
431 unvisited_link = test_context.Mock(spec=Atspi.Accessible)
432 landmark_obj = test_context.Mock(spec=Atspi.Accessible)
433 layout_table = test_context.Mock(spec=Atspi.Accessible)
434
435 mock_objects = [
436 heading1,
437 heading2,
438 form_obj,
439 table_obj,
440 visited_link,
441 unvisited_link,
442 landmark_obj,
443 layout_table,
444 ]
445 ax_collection_mock = essential_modules["orca.ax_collection"].AXCollection
446 ax_collection_mock.get_all_matches.return_value = mock_objects
447
448 ax_utilities_role_mock = essential_modules["orca.ax_utilities_role"].AXUtilitiesRole
449 ax_utilities_role_mock.is_heading.side_effect = lambda obj: obj in [heading1, heading2]
450 ax_utilities_role_mock.is_form.side_effect = lambda obj: obj == form_obj
451 ax_utilities_role_mock.is_table.side_effect = lambda obj: obj in [table_obj, layout_table]
452 ax_utilities_role_mock.is_link.side_effect = lambda obj: obj in [
453 visited_link,
454 unvisited_link,
455 ]
456 ax_utilities_role_mock.is_landmark.side_effect = lambda obj: obj == landmark_obj
457
458 ax_utilities_state_mock = essential_modules["orca.ax_utilities_state"].AXUtilitiesState
459 ax_utilities_state_mock.is_visited.side_effect = lambda obj: obj == visited_link
460
461 ax_utilities_table_mock = essential_modules["orca.ax_utilities_table"].AXUtilitiesTable
462 ax_utilities_table_mock.is_layout_table.side_effect = lambda obj: obj == layout_table
463
464 result = AXDocument._get_object_counts(mock_accessible)
465
466 expected = {
467 "forms": 1,
468 "landmarks": 1,
469 "headings": 2,
470 "tables": 1,
471 "unvisited_links": 1,
472 "visited_links": 1,
473 }
474 assert result == expected
475
476 ax_collection_mock.create_match_rule.assert_called_once()
477 call_args = ax_collection_mock.create_match_rule.call_args
478 roles_used = call_args.kwargs["roles"]
479 assert Atspi.Role.HEADING in roles_used
480 assert Atspi.Role.LINK in roles_used
481 assert Atspi.Role.TABLE in roles_used
482 assert Atspi.Role.FORM in roles_used
483 assert Atspi.Role.LANDMARK in roles_used
484
485 @pytest.mark.parametrize(
486 "object_counts,expected_summary",
487 [
488 (
489 {
490 "forms": 0,
491 "landmarks": 0,
492 "headings": 0,
493 "tables": 0,
494 "unvisited_links": 0,
495 "visited_links": 0,
496 },
497 "",
498 ),
499 (
500 {
501 "forms": 2,
502 "landmarks": 1,
503 "headings": 3,
504 "tables": 1,
505 "unvisited_links": 5,
506 "visited_links": 2,
507 },
508 (
509 "Page has 1 landmark, 3 headings, 2 forms, 1 table, "
510 "2 visited links, 5 unvisited links"
511 ),
512 ),
513 ],
514 )
515 def test_get_document_summary(
516 self,
517 test_context: OrcaTestContext,
518 object_counts: dict,
519 expected_summary: str,
520 ) -> None:
521 """Test AXDocument.get_document_summary with different object count scenarios."""
522
523 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
524 from orca.ax_document import AXDocument
525
526 mock_accessible = test_context.Mock(spec=Atspi.Accessible)
527 if expected_summary:
528 messages_mock = essential_modules["orca.messages"]
529 messages_mock.landmark_count.return_value = "1 landmark"
530 messages_mock.heading_count.return_value = "3 headings"
531 messages_mock.form_count.return_value = "2 forms"
532 messages_mock.table_count.return_value = "1 table"
533 messages_mock.visited_link_count.return_value = "2 visited links"
534 messages_mock.unvisited_link_count.return_value = "5 unvisited links"
535 mock_get_counts = test_context.Mock(return_value=object_counts)
536 test_context.patch_object(AXDocument, "_get_object_counts", new=mock_get_counts)
537 result = AXDocument.get_document_summary(mock_accessible)
538 assert result == expected_summary