Debian Codegraph @

tests/unit_tests/test_system_information_presenter.py

raw
1 # Unit tests for system_information_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
30 """Unit tests for system_information_presenter.py methods."""
31
32 from __future__ import annotations
33
34 import time
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 @pytest.mark.unit
46 class TestSystemInformationPresenter:
47 """Test SystemInformationPresenter class methods."""
48
49 def _setup_dependencies(self, test_context: OrcaTestContext) -> dict[str, MagicMock]:
50 """Set up mocks for system_information_presenter dependencies."""
51
52 additional_modules = ["psutil", "orca.braille_presenter", "orca.presentation_manager"]
53 essential_modules = test_context.setup_shared_dependencies(additional_modules)
54
55 cmdnames_mock = essential_modules["orca.cmdnames"]
56 cmdnames_mock.PRESENT_CURRENT_TIME = "presentCurrentTime"
57 cmdnames_mock.PRESENT_CURRENT_DATE = "presentCurrentDate"
58 cmdnames_mock.PRESENT_BATTERY_STATUS = "presentBatteryStatus"
59 cmdnames_mock.PRESENT_CPU_AND_MEMORY_USAGE = "presentCpuAndMemoryUsage"
60
61 debug_mock = essential_modules["orca.debug"]
62 debug_mock.print_message = test_context.Mock()
63 debug_mock.print_tokens = test_context.Mock()
64 debug_mock.LEVEL_INFO = 800
65
66 dbus_service_mock = essential_modules["orca.dbus_service"]
67 controller_mock = test_context.Mock()
68 controller_mock.register_decorated_module = test_context.Mock()
69 dbus_service_mock.get_remote_controller = test_context.Mock(return_value=controller_mock)
70 dbus_service_mock.command = lambda func: func
71
72 input_event_mock = essential_modules["orca.input_event"]
73 input_event_handler_class = test_context.Mock()
74 input_event_handler_instance = test_context.Mock()
75 input_event_handler_class.return_value = input_event_handler_instance
76 input_event_mock.InputEventHandler = input_event_handler_class
77 input_event_mock.InputEvent = test_context.Mock
78
79 keybindings_mock = essential_modules["orca.keybindings"]
80 key_bindings_instance = test_context.Mock()
81 key_bindings_instance.is_empty = test_context.Mock(return_value=True)
82 key_bindings_instance.remove_key_grabs = test_context.Mock()
83 key_bindings_instance.add = test_context.Mock()
84 keybindings_mock.KeyBindings = test_context.Mock(return_value=key_bindings_instance)
85 keybinding_instance = test_context.Mock()
86 keybindings_mock.KeyBinding = test_context.Mock(return_value=keybinding_instance)
87 keybindings_mock.DEFAULT_MODIFIER_MASK = 1
88 keybindings_mock.ORCA_MODIFIER_MASK = 2
89
90 messages_mock = essential_modules["orca.messages"]
91 messages_mock.BATTERY_STATUS_UNKNOWN = "Battery status unknown"
92 messages_mock.BATTERY_LEVEL = "Battery: %d%%"
93 messages_mock.BATTERY_PLUGGED_IN_TRUE = "plugged in"
94 messages_mock.BATTERY_PLUGGED_IN_FALSE = "not plugged in"
95 messages_mock.CPU_AND_MEMORY_USAGE_UNKNOWN = "CPU and memory usage unknown"
96 messages_mock.CPU_AND_MEMORY_USAGE_LEVELS = "CPU: %d%%. Memory: %d%%"
97 messages_mock.memory_usage_gb = test_context.Mock(return_value="5.2GB / 16GB")
98 messages_mock.memory_usage_mb = test_context.Mock(return_value="512MB / 1024MB")
99
100 messages_mock.TIME_FORMAT_LOCALE = "%X"
101 messages_mock.TIME_FORMAT_24_HMS = "%H:%M:%S"
102 messages_mock.TIME_FORMAT_24_HM = "%H:%M"
103 messages_mock.TIME_FORMAT_12_HM = "%I:%M %p"
104 messages_mock.TIME_FORMAT_12_HMS = "%I:%M:%S %p"
105 messages_mock.TIME_FORMAT_24_HMS_WITH_WORDS = "%H hours, %M minutes and %S seconds"
106 messages_mock.TIME_FORMAT_24_HM_WITH_WORDS = "%H hours and %M minutes"
107
108 psutil_mock = essential_modules["psutil"]
109 battery_mock = test_context.Mock()
110 battery_mock.percent = 85
111 battery_mock.power_plugged = True
112 psutil_mock.sensors_battery = test_context.Mock(return_value=battery_mock)
113 psutil_mock.cpu_percent = test_context.Mock(return_value=45.7)
114
115 memory_mock = test_context.Mock()
116 memory_mock.percent = 67.3
117 memory_mock.total = 16 * 1024**3
118 memory_mock.used = 8 * 1024**3
119 psutil_mock.virtual_memory = test_context.Mock(return_value=memory_mock)
120
121 essential_modules["controller"] = controller_mock
122 essential_modules["input_event_handler"] = input_event_handler_class
123 essential_modules["battery"] = battery_mock
124 essential_modules["memory"] = memory_mock
125 essential_modules["key_bindings_instance"] = key_bindings_instance
126
127 return essential_modules
128
129 def test_init(self, test_context: OrcaTestContext) -> None:
130 """Test SystemInformationPresenter.__init__."""
131
132 self._setup_dependencies(test_context)
133
134 mock_controller = test_context.Mock()
135 test_context.patch(
136 "orca.system_information_presenter.dbus_service.get_remote_controller",
137 return_value=mock_controller,
138 )
139
140 mock_bindings_instance = test_context.Mock()
141 test_context.patch(
142 "orca.system_information_presenter.keybindings.KeyBindings",
143 return_value=mock_bindings_instance,
144 )
145 from orca import command_manager
146 from orca.system_information_presenter import SystemInformationPresenter
147
148 presenter = SystemInformationPresenter()
149
150 # Commands are registered during setup(), call it explicitly
151 presenter.set_up_commands()
152
153 # Verify commands are registered in CommandManager
154 cmd_manager = command_manager.get_manager()
155 assert cmd_manager.get_keyboard_command("presentTimeHandler") is not None
156 assert cmd_manager.get_keyboard_command("presentDateHandler") is not None
157 assert cmd_manager.get_keyboard_command("present_battery_status") is not None
158 assert cmd_manager.get_keyboard_command("present_cpu_and_memory_usage") is not None
159
160 mock_controller.register_decorated_module.assert_called_with(
161 "SystemInformationPresenter",
162 presenter,
163 )
164
165 def test_commands_registered(self, test_context: OrcaTestContext) -> None:
166 """Test SystemInformationPresenter commands are registered in CommandManager."""
167
168 self._setup_dependencies(test_context)
169 from orca import command_manager
170 from orca.system_information_presenter import SystemInformationPresenter
171
172 presenter = SystemInformationPresenter()
173 presenter.set_up_commands()
174
175 manager = command_manager.get_manager()
176 expected_commands = [
177 "presentTimeHandler",
178 "presentDateHandler",
179 "present_battery_status",
180 "present_cpu_and_memory_usage",
181 ]
182 for command_name in expected_commands:
183 assert manager.get_keyboard_command(command_name) is not None
184
185 def test_setup_commands(self, test_context: OrcaTestContext) -> None:
186 """Test _setup_commands registers with CommandManager."""
187
188 self._setup_dependencies(test_context)
189 from orca import command_manager
190 from orca.system_information_presenter import SystemInformationPresenter
191
192 presenter = SystemInformationPresenter()
193 presenter.set_up_commands()
194
195 # Verify commands are registered in CommandManager
196 cmd_manager = command_manager.get_manager()
197 expected_commands = [
198 "presentTimeHandler",
199 "presentDateHandler",
200 "present_battery_status",
201 "present_cpu_and_memory_usage",
202 ]
203 for cmd_name in expected_commands:
204 assert cmd_manager.get_keyboard_command(cmd_name) is not None
205
206 @pytest.mark.parametrize(
207 "method_name,_setting_key,format_string,expected_output",
208 [
209 ("present_time", "presentTimeFormat", "%I:%M %p", "2:30 PM"),
210 ("present_date", "presentDateFormat", "%A, %B %d, %Y", "Monday, July 28, 2025"),
211 ],
212 )
213 @pytest.mark.parametrize(
214 "has_event,debugging_enabled",
215 [
216 pytest.param(True, True, id="with_event_debug"),
217 pytest.param(False, False, id="no_event_no_debug"),
218 ],
219 )
220 def test_present_time_and_date(
221 self,
222 test_context: OrcaTestContext,
223 method_name: str,
224 _setting_key: str,
225 format_string: str,
226 expected_output: str,
227 has_event: bool,
228 debugging_enabled: bool,
229 ) -> None:
230 """Test SystemInformationPresenter time and date presentation methods."""
231 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
232
233 from orca import gsettings_registry
234 from orca.system_information_presenter import SystemInformationPresenter
235
236 gsettings_key = "time-format" if _setting_key == "presentTimeFormat" else "date-format"
237 gsettings_registry.get_registry().set_runtime_value(
238 "system-information",
239 gsettings_key,
240 format_string,
241 )
242
243 mock_script = test_context.Mock()
244 mock_script.present_message = test_context.Mock()
245 mock_time_tuple = time.struct_time((2025, 7, 28, 14, 30, 0, 0, 209, 0))
246 test_context.patch("time.localtime", return_value=mock_time_tuple)
247 mock_strftime = test_context.patch("time.strftime", return_value=expected_output)
248 presenter = SystemInformationPresenter()
249
250 mock_event = test_context.Mock() if has_event else None
251 method = getattr(presenter, method_name)
252 result = method(mock_script, mock_event, debugging_enabled)
253
254 if has_event and debugging_enabled:
255 essential_modules["orca.debug"].print_tokens.assert_called_once()
256
257 mock_strftime.assert_called_once_with(format_string, mock_time_tuple)
258 pres_manager = essential_modules["orca.presentation_manager"].get_manager()
259 pres_manager.present_message.assert_called_once_with(expected_output)
260 assert result
261
262 @pytest.mark.parametrize(
263 "psutil_available,has_battery,power_plugged,expected_message",
264 [
265 (True, True, True, "Battery: 85% plugged in"),
266 (True, True, False, "Battery: 85% not plugged in"),
267 (True, False, None, "Battery status unknown"),
268 (False, None, None, "Battery status unknown"),
269 ],
270 )
271 def test_present_battery_status(
272 self,
273 test_context: OrcaTestContext,
274 psutil_available: bool,
275 has_battery: bool | None,
276 power_plugged: bool | None,
277 expected_message: str,
278 ) -> None:
279 """Test SystemInformationPresenter.present_battery_status with different scenarios."""
280 if (
281 not psutil_available
282 and "orca.system_information_presenter" in __import__("sys").modules
283 ):
284 del __import__("sys").modules["orca.system_information_presenter"]
285
286 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
287 mock_script = test_context.Mock()
288 mock_script.present_message = test_context.Mock()
289
290 if psutil_available:
291 test_context.patch("orca.system_information_presenter._PSUTIL_AVAILABLE", new=True)
292 if has_battery:
293 if power_plugged is not None:
294 essential_modules["battery"].power_plugged = power_plugged
295 else:
296 essential_modules["psutil"].sensors_battery.return_value = None
297 else:
298 psutil_mock = essential_modules["psutil"]
299 psutil_mock.sensors_battery.return_value = None
300
301 from orca.system_information_presenter import SystemInformationPresenter
302
303 presenter = SystemInformationPresenter()
304 mock_event = test_context.Mock()
305 pres_manager = essential_modules["orca.presentation_manager"].get_manager()
306 pres_manager.present_message.reset_mock()
307 result = presenter.present_battery_status(mock_script, mock_event, True)
308
309 pres_manager.present_message.assert_called_once_with(expected_message)
310 assert result
311
312 @pytest.mark.parametrize(
313 "psutil_available,memory_size,expected_message,check_debug",
314 [
315 (True, "gb", "CPU: 46%. Memory: 67%. 5.2GB / 16GB", False),
316 (True, "mb", "CPU: 46%. Memory: 67%. 512MB / 1024MB", False),
317 (False, None, "CPU and memory usage unknown", True),
318 ],
319 )
320 def test_present_cpu_and_memory_usage(
321 self,
322 test_context: OrcaTestContext,
323 psutil_available: bool,
324 memory_size: str | None,
325 expected_message: str,
326 check_debug: bool,
327 ) -> None:
328 """Test SystemInformationPresenter.present_cpu_and_memory_usage with different scenarios."""
329 if not psutil_available:
330 if "orca.system_information_presenter" in __import__("sys").modules:
331 del __import__("sys").modules["orca.system_information_presenter"]
332 import sys
333
334 if "psutil" in sys.modules:
335 del sys.modules["psutil"]
336 import builtins
337
338 original_import = builtins.__import__
339
340 def mock_import(name, *args, **kwargs):
341 if name == "psutil":
342 raise ModuleNotFoundError("No module named 'psutil'")
343 return original_import(name, *args, **kwargs)
344
345 test_context.patch("builtins.__import__", side_effect=mock_import)
346 essential_modules = test_context.setup_shared_dependencies(
347 ["orca.presentation_manager"],
348 )
349 mock_script = test_context.Mock()
350 messages_mock = essential_modules["orca.messages"]
351 messages_mock.CPU_AND_MEMORY_USAGE_UNKNOWN = "CPU and memory usage unknown"
352 else:
353 essential_modules = self._setup_dependencies(test_context)
354 mock_script = test_context.Mock()
355 mock_script.present_message = test_context.Mock()
356 if memory_size == "mb":
357 essential_modules["memory"].total = 512 * 1024**2
358 essential_modules["memory"].used = 256 * 1024**2
359 test_context.patch("orca.system_information_presenter._PSUTIL_AVAILABLE", new=True)
360
361 from orca.system_information_presenter import SystemInformationPresenter
362
363 presenter = SystemInformationPresenter()
364 mock_event = test_context.Mock()
365 result = presenter.present_cpu_and_memory_usage(mock_script, mock_event, True)
366
367 if psutil_available:
368 essential_modules["psutil"].cpu_percent.assert_called_once()
369 essential_modules["psutil"].virtual_memory.assert_called_once()
370 if memory_size == "gb":
371 essential_modules["orca.messages"].memory_usage_gb.assert_called_once()
372 elif memory_size == "mb":
373 essential_modules["orca.messages"].memory_usage_mb.assert_called_once()
374
375 pres_manager = essential_modules["orca.presentation_manager"].get_manager()
376 pres_manager.present_message.assert_called_once_with(expected_message)
377 assert result
378
379 if check_debug:
380 essential_modules["orca.debug"].print_tokens.assert_called_once()
381
382 def test_get_presenter_singleton(self, test_context: OrcaTestContext) -> None:
383 """Test system_information_presenter.get_presenter singleton functionality."""
384
385 self._setup_dependencies(test_context)
386 test_context.patch("orca.system_information_presenter._PSUTIL_AVAILABLE", new=True)
387 from orca.system_information_presenter import get_presenter
388
389 presenter1 = get_presenter()
390 presenter2 = get_presenter()
391
392 assert presenter1 is presenter2
393 assert presenter1.__class__.__name__ == "SystemInformationPresenter"
394
395 def test_module_level_psutil_detection(self, test_context: OrcaTestContext) -> None:
396 """Test module-level psutil availability detection."""
397
398 import sys
399
400 if "orca.system_information_presenter" in sys.modules:
401 del sys.modules["orca.system_information_presenter"]
402 self._setup_dependencies(test_context)
403 from orca.system_information_presenter import _PSUTIL_AVAILABLE
404
405 assert _PSUTIL_AVAILABLE is True
406
407 if "orca.system_information_presenter" in sys.modules:
408 del sys.modules["orca.system_information_presenter"]
409
410 if "psutil" in sys.modules:
411 del sys.modules["psutil"]
412
413 import builtins
414
415 original_import = builtins.__import__
416
417 def mock_import(name, *args, **kwargs):
418 if name == "psutil":
419 raise ModuleNotFoundError("No module named 'psutil'")
420 return original_import(name, *args, **kwargs)
421
422 test_context.patch("builtins.__import__", side_effect=mock_import)
423
424 test_context.setup_shared_dependencies([])
425
426 import orca.system_information_presenter as presenter_module
427
428 assert presenter_module._PSUTIL_AVAILABLE is False
429
430 @pytest.mark.parametrize(
431 "format_value,expected_name",
432 [
433 ("%x", "locale"),
434 ("%d/%m/%Y", "numbers_dmy"),
435 ("%m/%d/%Y", "numbers_mdy"),
436 ("%A, %-d %B", "full_dm"),
437 ("%A, %B %-d", "full_md"),
438 ("%a, %-d %b, %Y", "abbreviated_dmy"),
439 ],
440 )
441 def test_get_date_format(
442 self,
443 test_context: OrcaTestContext,
444 format_value: str,
445 expected_name: str,
446 ) -> None:
447 """Test SystemInformationPresenter.get_date_format returns correct enum name."""
448
449 self._setup_dependencies(test_context)
450
451 from orca import gsettings_registry
452
453 gsettings_registry.get_registry().set_runtime_value(
454 "system-information",
455 "date-format",
456 format_value,
457 )
458
459 test_context.patch(
460 "orca.system_information_presenter.dbus_service.getter",
461 new=lambda func: func,
462 )
463
464 from orca.system_information_presenter import SystemInformationPresenter
465
466 presenter = SystemInformationPresenter()
467 result = presenter.get_date_format()
468
469 assert result == expected_name
470
471 @pytest.mark.parametrize(
472 "format_name,expected_success,expected_value",
473 [
474 ("locale", True, "%x"),
475 ("LOCALE", True, "%x"),
476 ("numbers_dmy", True, "%d/%m/%Y"),
477 ("full_md", True, "%A, %B %-d"),
478 ("abbreviated_ymd", True, "%Y. %b %-d, %a"),
479 ("invalid_format", False, None),
480 ],
481 )
482 def test_set_date_format(
483 self,
484 test_context: OrcaTestContext,
485 format_name: str,
486 expected_success: bool,
487 expected_value: str | None,
488 ) -> None:
489 """Test SystemInformationPresenter.set_date_format validates and sets format."""
490
491 essential_modules = self._setup_dependencies(test_context)
492
493 test_context.patch(
494 "orca.system_information_presenter.dbus_service.setter",
495 new=lambda func: func,
496 )
497
498 from orca.system_information_presenter import SystemInformationPresenter
499
500 presenter = SystemInformationPresenter()
501 original_format = presenter._get_date_format_string()
502 result = presenter.set_date_format(format_name)
503
504 assert result == expected_success
505
506 if expected_success:
507 assert presenter._get_date_format_string() == expected_value
508 essential_modules["orca.debug"].print_message.assert_any_call(
509 800,
510 f"SYSTEM INFORMATION PRESENTER: Setting date format to {format_name}.",
511 True,
512 )
513 else:
514 assert presenter._get_date_format_string() == original_format
515 debug_mock = essential_modules["orca.debug"].print_message
516 assert any(
517 call[0][1] == f"SYSTEM INFORMATION PRESENTER: Invalid date format: {format_name}"
518 for call in debug_mock.call_args_list
519 )
520
521 @pytest.mark.parametrize(
522 "format_value,expected_name",
523 [
524 ("%X", "locale"),
525 ("%I:%M %p", "twelve_hm"),
526 ("%I:%M:%S %p", "twelve_hms"),
527 ("%H:%M", "twentyfour_hm"),
528 ("%H:%M:%S", "twentyfour_hms"),
529 ],
530 )
531 def test_get_time_format(
532 self,
533 test_context: OrcaTestContext,
534 format_value: str,
535 expected_name: str,
536 ) -> None:
537 """Test SystemInformationPresenter.get_time_format returns correct enum name."""
538
539 self._setup_dependencies(test_context)
540
541 from orca import gsettings_registry
542
543 gsettings_registry.get_registry().set_runtime_value(
544 "system-information",
545 "time-format",
546 format_value,
547 )
548
549 test_context.patch(
550 "orca.system_information_presenter.dbus_service.getter",
551 new=lambda func: func,
552 )
553
554 from orca.system_information_presenter import SystemInformationPresenter
555
556 presenter = SystemInformationPresenter()
557 result = presenter.get_time_format()
558
559 assert result == expected_name
560
561 @pytest.mark.parametrize(
562 "format_name,expected_success,expected_value",
563 [
564 ("locale", True, "%X"),
565 ("LOCALE", True, "%X"),
566 ("twelve_hm", True, "%I:%M %p"),
567 ("twentyfour_hms", True, "%H:%M:%S"),
568 ("twentyfour_hm_with_words", True, "%H hours and %M minutes"),
569 ("invalid_format", False, None),
570 ],
571 )
572 def test_set_time_format(
573 self,
574 test_context: OrcaTestContext,
575 format_name: str,
576 expected_success: bool,
577 expected_value: str | None,
578 ) -> None:
579 """Test SystemInformationPresenter.set_time_format validates and sets format."""
580
581 essential_modules = self._setup_dependencies(test_context)
582
583 test_context.patch(
584 "orca.system_information_presenter.dbus_service.setter",
585 new=lambda func: func,
586 )
587
588 from orca.system_information_presenter import SystemInformationPresenter
589
590 presenter = SystemInformationPresenter()
591 original_format = presenter._get_time_format_string()
592 result = presenter.set_time_format(format_name)
593
594 assert result == expected_success
595
596 if expected_success:
597 assert presenter._get_time_format_string() == expected_value
598 essential_modules["orca.debug"].print_message.assert_any_call(
599 800,
600 f"SYSTEM INFORMATION PRESENTER: Setting time format to {format_name}.",
601 True,
602 )
603 else:
604 assert presenter._get_time_format_string() == original_format
605 debug_mock = essential_modules["orca.debug"].print_message
606 assert any(
607 call[0][1] == f"SYSTEM INFORMATION PRESENTER: Invalid time format: {format_name}"
608 for call in debug_mock.call_args_list
609 )
610
611 def test_get_available_date_formats(self, test_context: OrcaTestContext) -> None:
612 """Test SystemInformationPresenter.get_available_date_formats returns all format names."""
613
614 self._setup_dependencies(test_context)
615
616 test_context.patch(
617 "orca.system_information_presenter.dbus_service.getter",
618 new=lambda func: func,
619 )
620
621 from orca.system_information_presenter import SystemInformationPresenter
622
623 presenter = SystemInformationPresenter()
624 result = presenter.get_available_date_formats()
625
626 assert isinstance(result, list)
627 assert len(result) == 16
628 assert "locale" in result
629 assert "numbers_dmy" in result
630 assert "full_md" in result
631 assert "abbreviated_ymd" in result
632
633 def test_get_available_time_formats(self, test_context: OrcaTestContext) -> None:
634 """Test SystemInformationPresenter.get_available_time_formats returns all format names."""
635
636 self._setup_dependencies(test_context)
637
638 test_context.patch(
639 "orca.system_information_presenter.dbus_service.getter",
640 new=lambda func: func,
641 )
642
643 from orca.system_information_presenter import SystemInformationPresenter
644
645 presenter = SystemInformationPresenter()
646 result = presenter.get_available_time_formats()
647
648 assert isinstance(result, list)
649 assert len(result) == 7
650 assert "locale" in result
651 assert "twelve_hm" in result
652 assert "twentyfour_hms" in result
653 assert "twentyfour_hm_with_words" in result
654
655 def test_internal_get_date_format_string(self, test_context: OrcaTestContext) -> None:
656 """Test SystemInformationPresenter._get_date_format_string returns raw format."""
657
658 self._setup_dependencies(test_context)
659
660 from orca import gsettings_registry
661 from orca.system_information_presenter import SystemInformationPresenter
662
663 expected_format = "%A, %B %-d"
664 gsettings_registry.get_registry().set_runtime_value(
665 "system-information",
666 "date-format",
667 expected_format,
668 )
669
670 presenter = SystemInformationPresenter()
671 result = presenter._get_date_format_string()
672
673 assert result == expected_format
674
675 def test_internal_get_time_format_string(self, test_context: OrcaTestContext) -> None:
676 """Test SystemInformationPresenter._get_time_format_string returns raw format."""
677
678 self._setup_dependencies(test_context)
679
680 from orca import gsettings_registry
681 from orca.system_information_presenter import SystemInformationPresenter
682
683 expected_format = "%I:%M %p"
684 gsettings_registry.get_registry().set_runtime_value(
685 "system-information",
686 "time-format",
687 expected_format,
688 )
689
690 presenter = SystemInformationPresenter()
691 result = presenter._get_time_format_string()
692
693 assert result == expected_format