amd-debug-tools 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

test_prerequisites.py

@@ -500,9 +500,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
         result = self.validator.map_acpi_path()
         self.assertTrue(result)
         self.mock_db.record_debug.assert_called_with(
-            "ACPI name: ACPI path [driver]\n"
-            "│ device1: mocked_path [driver]\n"
-            "└─device2: mocked_path [driver]\n"
+            "ACPI name | ACPI path | Kernel driver\ndevice1 | mocked_path | driver\ndevice2 | mocked_path | driver\n"
         )
 
     @patch("amd_debug.prerequisites.os.path.exists")
@@ -545,7 +543,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
         result = self.validator.map_acpi_path()
         self.assertTrue(result)
         self.mock_db.record_debug.assert_called_with(
-            "ACPI name: ACPI path [driver]\n└─device1: mocked_path [None]\n"
+            "ACPI name | ACPI path | Kernel driver\ndevice1 | mocked_path | None\n"
         )
 
     @patch("amd_debug.prerequisites.read_file")
@@ -569,8 +567,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
 
         self.validator.capture_pci_acpi()
         self.mock_db.record_debug.assert_called_with(
-            "PCI devices\n"
-            "└─0000:00:1f.0 : Intel Corporation ISA bridge [1234abcd] : mocked_acpi_path\n"
+            "PCI Slot | Vendor | Class | ID | ACPI path\n└─0000:00:1f.0 | Intel Corporation | ISA bridge | 1234abcd | mocked_acpi_path\n"
         )
 
     @patch("amd_debug.prerequisites.read_file")
@@ -593,8 +590,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
 
         self.validator.capture_pci_acpi()
         self.mock_db.record_debug.assert_called_with(
-            "PCI devices\n"
-            "└─0000:01:00.0 : NVIDIA Corporation VGA compatible controller [5678efgh]\n"
+            "PCI Slot | Vendor | Class | ID | ACPI path\n└─0000:01:00.0 | NVIDIA Corporation | VGA compatible controller | 5678efgh | \n"
         )
 
     @patch("amd_debug.prerequisites.read_file")
@@ -628,9 +624,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
 
         self.validator.capture_pci_acpi()
         self.mock_db.record_debug.assert_called_with(
-            "PCI devices\n"
-            "│ 0000:00:1f.0 : Intel Corporation ISA bridge [1234abcd] : mocked_acpi_path\n"
-            "└─0000:01:00.0 : NVIDIA Corporation VGA compatible controller [5678efgh] : mocked_acpi_path\n"
+            "PCI Slot | Vendor | Class | ID | ACPI path\n│ 0000:00:1f.0 | Intel Corporation | ISA bridge | 1234abcd | mocked_acpi_path\n└─0000:01:00.0 | NVIDIA Corporation | VGA compatible controller | 5678efgh | mocked_acpi_path\n"
         )
 
     def test_capture_pci_acpi_no_devices(self):
@@ -638,7 +632,9 @@ class TestPrerequisiteValidator(unittest.TestCase):
         self.mock_pyudev.list_devices.return_value = []
 
         self.validator.capture_pci_acpi()
-        self.mock_db.record_debug.assert_called_with("PCI devices\n")
+        self.mock_db.record_debug.assert_called_with(
+            "PCI Slot | Vendor | Class | ID | ACPI path\n"
+        )
 
     @patch("amd_debug.prerequisites.read_file")
     def test_check_aspm_default_policy(self, mock_read_file):
@@ -802,8 +798,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
         self.assertFalse(result)
         self.assertTrue(any(isinstance(f, FadtWrong) for f in self.validator.failures))
 
-    @patch("amd_debug.prerequisites.os.path.exists", return_value=False)
-    def test_check_fadt_file_not_found(self, mock_path_exists):
+    def test_check_fadt_file_not_found(self):
         """Test check_fadt when FADT file is not found"""
         self.mock_kernel_log.match_line.return_value = False
         result = self.validator.check_fadt()
@@ -1006,7 +1001,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
             "MockVendor MockProduct (MockFamily)", "💻"
         )
         self.mock_db.record_debug.assert_called_with(
-            "DMI data:\nchassis_type: Desktop\n"
+            "DMI|value\nchassis_type| Desktop\n"
         )
 
     @patch("amd_debug.prerequisites.os.walk")
@@ -1034,7 +1029,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
         self.mock_db.record_prereq.assert_called_with(
             "MockVendor MockProduct (MockFamily)", "💻"
         )
-        self.mock_db.record_debug.assert_called_with("DMI data:\n")
+        self.mock_db.record_debug.assert_called_with("DMI|value\n")
 
     @patch("amd_debug.prerequisites.os.walk")
     @patch("amd_debug.prerequisites.read_file")
@@ -1710,9 +1705,6 @@ class TestPrerequisiteValidator(unittest.TestCase):
         ]
         result = self.validator.check_storage()
         self.assertTrue(result)
-        self.mock_db.record_debug.assert_called_with(
-            "New enough kernel to avoid NVME check"
-        )
 
     def test_check_storage_no_kernel_log(self):
         """Test check_storage when kernel log is unavailable"""

test_s2idle.py

@@ -180,7 +180,7 @@ class TestMainFunction(unittest.TestCase):
             mock_report.assert_called_once_with(
                 "2023-01-01", "2023-02-01", None, "html", False, False
             )
-            self.assertTrue(result)
+            self.assertIsNone(result)
 
     @patch("amd_debug.s2idle.relaunch_sudo")
     @patch("amd_debug.s2idle.run_test_cycle")
@@ -207,7 +207,7 @@ class TestMainFunction(unittest.TestCase):
             mock_test.assert_called_once_with(
                 None, None, "5", "txt", None, False, False, False, False, False
             )
-            self.assertTrue(result)
+            self.assertIsNone(result)
 
     @patch("amd_debug.s2idle.version")
     def test_main_version(self, mock_version):
@@ -220,7 +220,7 @@ class TestMainFunction(unittest.TestCase):
                 result = main()
                 mock_version.assert_called_once()
                 mock_print.assert_called_once_with("1.0.0")
-                self.assertTrue(result)
+                self.assertIsNone(result)
 
     def test_main_no_action(self):
         """Test main function with no action specified"""
@@ -455,12 +455,18 @@ class TestTestFunction(unittest.TestCase):
 
     @patch("amd_debug.s2idle.Installer")
     @patch("amd_debug.s2idle.PrerequisiteValidator")
-    @patch("amd_debug.prerequisites.SleepDatabase")
-    @patch("amd_debug.validator.SleepDatabase")
+    @patch("amd_debug.s2idle.SleepValidator")
+    @patch("amd_debug.s2idle.SleepReport")
+    @patch("amd_debug.s2idle.prompt_test_arguments")
+    @patch("amd_debug.s2idle.prompt_report_arguments")
+    @patch("amd_debug.s2idle.display_report_file")
     def test_test_prerequisite_failure(
         self,
-        _mock_sleep_db,
-        _mock_sleep_db_prerequisite,
+        mock_display_report_file,
+        mock_prompt_report_arguments,
+        mock_prompt_test_arguments,
+        mock_sleep_report,
+        mock_sleep_validator,
         mock_prerequisite_validator,
         mock_installer,
     ):
@@ -471,6 +477,17 @@ class TestTestFunction(unittest.TestCase):
         mock_prerequisite_instance = mock_prerequisite_validator.return_value
         mock_prerequisite_instance.run.return_value = False
 
+        mock_prompt_test_arguments.return_value = (10, 5, 3)
+        mock_prompt_report_arguments.return_value = (
+            "2023-01-01",
+            "2023-02-01",
+            "report.html",
+            "html",
+            True,
+        )
+        mock_sleep_validator_instance = mock_sleep_validator.return_value
+        mock_sleep_report_instance = mock_sleep_report.return_value
+
         result = run_test_cycle(
             duration=None,
             wait=None,
@@ -492,7 +509,20 @@ class TestTestFunction(unittest.TestCase):
         mock_prerequisite_validator.assert_called_once_with(True)
         mock_prerequisite_instance.run.assert_called_once()
         mock_prerequisite_instance.report.assert_called_once()
-        self.assertFalse(result)
+        mock_prompt_test_arguments.assert_called_once_with(None, None, None, False)
+        mock_prompt_report_arguments.assert_called_once()
+        mock_sleep_validator_instance.assert_not_called()
+        mock_sleep_report.assert_called_once_with(
+            since=None,
+            until=None,
+            fname="report.html",
+            fmt="html",
+            tool_debug=True,
+            report_debug=True,
+        )
+        mock_sleep_report_instance.run.assert_called_once()
+        mock_display_report_file.assert_called_once_with("report.html", "html")
+        self.assertTrue(result)
 
     @patch("amd_debug.s2idle.Installer")
     @patch("amd_debug.s2idle.PrerequisiteValidator")
@@ -533,9 +563,9 @@ class TestTestFunction(unittest.TestCase):
             "iasl", "ethtool", "edid-decode"
         )
         mock_installer_instance.install_dependencies.assert_called_once()
-        mock_prerequisite_validator.assert_called_once_with(True)
-        mock_prerequisite_instance.run.assert_called_once()
-        mock_prerequisite_instance.report.assert_called_once()
+        mock_prerequisite_validator.assert_not_called()
+        mock_prerequisite_instance.run.assert_not_called()
+        mock_prerequisite_instance.report.assert_not_called()
         mock_prompt_test_arguments.assert_called_once_with(None, None, None, False)
 
 

test_sleep_report.py

@@ -5,6 +5,7 @@
 This module contains unit tests for the s2idle tool in the amd-debug-tools package.
 """
 
+import math
 import unittest
 from datetime import datetime
 from unittest.mock import patch
@@ -165,3 +166,31 @@ class TestSleepReport(unittest.TestCase):
         self.report.build_hw_sleep_chart()
         self.assertIsNotNone(self.report.hwsleep_svg)
         mock_savefig.assert_called_once()
+
+    def test_pre_process_dataframe_zero_duration(self):
+        """Test the pre_process_dataframe method when t0 and t1 are the same."""
+        # Mock the dataframe with t0 and t1 being the same
+        self.report.df = pd.DataFrame(
+            {
+                "t0": [datetime(2023, 10, 10, 12, 0, 0).strftime("%Y%m%d%H%M%S")],
+                "t1": [datetime(2023, 10, 10, 12, 0, 0).strftime("%Y%m%d%H%M%S")],
+                "hw": [50],
+                "requested": [1],
+                "gpio": ["1, 2"],
+                "wake_irq": ["1"],
+                "b0": [90],
+                "b1": [85],
+                "full": [100],
+            }
+        )
+
+        # Call the method
+        self.report.pre_process_dataframe()
+
+        # Verify the dataframe was processed correctly
+        self.assertTrue(
+            self.report.df["Duration"].isna().iloc[0]
+        )  # Duration should be NaN
+        self.assertTrue(
+            math.isnan(self.report.df["Hardware Sleep"].iloc[0])
+        )  # Hardware Sleep should be NaN

test_validator.py

@@ -5,8 +5,9 @@
 This module contains unit tests for the validator functions in the amd-debug-tools package.
 """
 
-from unittest.mock import patch, mock_open
+from unittest.mock import patch, mock_open, Mock
 
+import os
 import logging
 import unittest
 import math
@@ -157,9 +158,8 @@ class TestValidator(unittest.TestCase):
         self.validator.capture_wake_sources()
 
         # Validate debug messages
-        mock_record_debug.assert_any_call("Possible wakeup sources:")
         mock_record_debug.assert_any_call(
-            "└─ [/sys/devices/pci0000:00/0000:00:14.0]: enabled"
+            "Wakeup Source|Linux Device|Status\n|/sys/devices/pci0000:00/0000:00:14.0|enabled\n"
         )
 
         # Stop patches
@@ -694,7 +694,7 @@ class TestValidator(unittest.TestCase):
         # Test case 3: Randomized test
         mock_randint.side_effect = [7, 3]  # Random duration and wait
         self.validator.run(duration=10, count=1, wait=5, rand=True, logind=False)
-        mock_randint.assert_any_call(1, 10)
+        mock_randint.assert_any_call(4, 10)
         mock_randint.assert_any_call(1, 5)
         mock_run_countdown.assert_any_call("Suspending system", math.ceil(3 / 2))
         mock_run_countdown.assert_any_call("Collecting data", math.ceil(3 / 2))
@@ -705,19 +705,128 @@ class TestValidator(unittest.TestCase):
         mock_report_cycle.assert_called()
         mock_unlock_session.assert_called()
 
-        # Test case 4: Multiple cycles
+        # Test case 4: Randomized test, but too short of a duration
+        result = self.validator.run(
+            duration=4, count=1, wait=5, rand=True, logind=False
+        )
+        self.assertFalse(result)
+        mock_report_cycle.assert_called()
+
+        # Test case 5: Multiple cycles
         self.validator.run(duration=10, count=2, wait=5, rand=False, logind=False)
         self.assertEqual(mock_prep.call_count, 4)  # Includes previous calls
         self.assertEqual(mock_program_wakealarm.call_count, 4)
         self.assertEqual(mock_suspend_system.call_count, 4)
         self.assertEqual(mock_post.call_count, 4)
-        self.assertEqual(mock_report_cycle.call_count, 4)
+        self.assertEqual(mock_report_cycle.call_count, 5)
         self.assertEqual(mock_unlock_session.call_count, 3)
 
-        # Test case 5: suspend_system fails
+        # Test case 6: suspend_system fails
         mock_suspend_system.return_value = False
         result = self.validator.run(
             duration=10, count=1, wait=5, rand=False, logind=False
         )
         self.assertFalse(result)
         mock_report_cycle.assert_called()
+
+    @patch("os.path.exists")
+    @patch("builtins.open", new_callable=mock_open, read_data="3")
+    @patch("os.write")
+    @patch("os.open")
+    @patch("os.close")
+    def test_suspend_system_sysfs_success(
+        self,
+        mock_os_close,
+        mock_os_open,
+        mock_os_write,
+        _mock_open_file,
+        mock_path_exists,
+    ):
+        """Test suspend_system method using sysfs interface with success"""
+        # Mock wakeup_count file existence
+        mock_path_exists.side_effect = lambda path: "wakeup_count" in path
+
+        # Mock os.open and os.write
+        mock_os_open.return_value = 3
+        mock_os_write.return_value = None
+
+        # Call the method
+        result = self.validator.suspend_system()
+
+        # Assert the method returned True
+        self.assertTrue(result)
+
+        # Assert os.open and os.write were called
+        mock_os_open.assert_called_once_with(
+            "/sys/power/state", os.O_WRONLY | os.O_SYNC
+        )
+        mock_os_write.assert_called_once_with(3, b"mem")
+        mock_os_close.assert_called_once_with(3)
+
+    @patch("os.path.exists")
+    @patch("builtins.open", new_callable=mock_open, read_data="3")
+    @patch("os.write")
+    @patch("os.open")
+    @patch("os.close")
+    def test_suspend_system_sysfs_failure(
+        self,
+        mock_os_close,
+        mock_os_open,
+        mock_os_write,
+        _mock_open_file,
+        mock_path_exists,
+    ):
+        """Test suspend_system method using sysfs interface with failure"""
+        # Mock wakeup_count file existence
+        mock_path_exists.side_effect = lambda path: "wakeup_count" in path
+
+        # Mock os.open to raise OSError
+        mock_os_open.return_value = 3
+        mock_os_write.side_effect = OSError("Failed to write to state")
+
+        # Call the method
+        result = self.validator.suspend_system()
+
+        # Assert the method returned False
+        self.assertFalse(result)
+
+        # Assert os.open and os.write were called
+        mock_os_open.assert_called_once_with(
+            "/sys/power/state", os.O_WRONLY | os.O_SYNC
+        )
+        mock_os_write.assert_called_once_with(3, b"mem")
+        mock_os_close.assert_called_once_with(3)
+
+    @patch("os.path.exists")
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("os.write")
+    @patch("os.open")
+    @patch("os.close")
+    def test_suspend_system_sysfs_no_wakeup_count(
+        self,
+        mock_os_close,
+        mock_os_open,
+        mock_os_write,
+        _mock_open_file,
+        mock_path_exists,
+    ):
+        """Test suspend_system method using sysfs interface with no wakeup_count file"""
+        # Mock wakeup_count file does not exist
+        mock_path_exists.return_value = False
+
+        # Mock os.open and os.write
+        mock_os_open.return_value = 3
+        mock_os_write.return_value = None
+
+        # Call the method
+        result = self.validator.suspend_system()
+
+        # Assert the method returned True
+        self.assertTrue(result)
+
+        # Assert os.open and os.write were called
+        mock_os_open.assert_called_once_with(
+            "/sys/power/state", os.O_WRONLY | os.O_SYNC
+        )
+        mock_os_write.assert_called_once_with(3, b"mem")
+        mock_os_close.assert_called_once_with(3)

amd_debug_tools-0.2.2.dist-info/RECORD

@@ -1,45 +0,0 @@
-launcher.py,sha256=_Gs0W8tUB2wkTy5Nz4qEzG0VqQcnO7xuIQj0GwV_KbY,968
-test_acpi.py,sha256=wtS43Rz95h7YEEJBeFa6Mswaeo4syBZrw4hY8i0YbJY,3117
-test_batteries.py,sha256=nN5pfP5El7Whypq3HHEpW8bufdf5EWSTVGbayfNQYP4,3360
-test_bios.py,sha256=GBAXE_rXd2G-JE0XJ8AvYcF9Me6LTyQQQ8h0Ib3cpxQ,8981
-test_common.py,sha256=fb16Oilh5ga6VgF-UgBj6azoYzZnPrS7KpECQ3nCwlg,16335
-test_database.py,sha256=q5ZjI5u20f7ki6iCY5o1iPi0YOvPz1_W0LTDraU8mN4,10040
-test_display.py,sha256=hHggv-zBthF1BlwWWSjzAm7BBw1DWcElwil5xAuz87g,5822
-test_failures.py,sha256=H1UxXeVjhJs9-j9yas4vwAha676GX1Es7Kz8RN2B590,6845
-test_installer.py,sha256=oDMCvaKqqAWjTggltacnasQ-s1gyUvXPDcNrCUGnux4,10216
-test_kernel.py,sha256=RW-eLbae02Bhwfu1cegqA1pTj6AS5IqD5lLe-6T0Rjo,7871
-test_launcher.py,sha256=govYHL0Cpj9d5msteV5SfR7Covft31rJuzRkDeytHcY,1461
-test_prerequisites.py,sha256=4Ltxx7vGU91b9MX1AtdPLS8iyWJBCNuEKCuO0nnEb_g,83381
-test_pstate.py,sha256=a9oAJ9-LANX32XNQhplz6Y75VNYc__QqoSBKIrwvANg,6058
-test_s2idle.py,sha256=-S3yymjprf3_LIgaPGWgzN9FmnyQG55dNc4xqWAF8Z8,32344
-test_sleep_report.py,sha256=R3cUPPT9r9q4q93xk6NFvi4ySgT5laqidk2SASuTWIo,5878
-test_validator.py,sha256=NeiX8kT5DiHiiB5lRSJkjIpV32UzaIrW5ljKLmFtBMk,30490
-test_wake.py,sha256=6zi5GVFHQKU1sTWw3O5-aGriB9uu5713QLn4l2wjhpM,7152
-amd_debug/__init__.py,sha256=aOtpIEKGLUStrh0e4qgilHW7HgF4Od-r9pOoZ87NwAM,1105
-amd_debug/acpi.py,sha256=fkD3Sov8cRT5ryPlakRlT7Z9jiCLT9x_MPWxt3xU_tc,3161
-amd_debug/battery.py,sha256=WN-6ys9PHCZIwg7PdwyBOa62GjBp8WKG0v1YZt5_W5s,3122
-amd_debug/bios.py,sha256=wmPKDsTZeQqsHjWpv-YHdgRNlCtFdzHQ6jJf0H3hjN8,3971
-amd_debug/common.py,sha256=H9tIRlRFOMwe0d3f2-vXQeK2rJl5Z1WJzkpQM9ivpOc,10347
-amd_debug/database.py,sha256=GkRg3cmaNceyQ2_hy0MBAlMbnTDPHo2co2o4ObWpnQg,10621
-amd_debug/display.py,sha256=5L9x9tI_UoulHpIvuxuVASRtdXta7UCW_JjTb5StEB0,953
-amd_debug/failures.py,sha256=Otv3YDu7Je4ljSifVmvjObGoOY4OvLIY20pw-v4Dqkw,22911
-amd_debug/installer.py,sha256=r6r_nVWv8qYdrqAvnAzQhRiS5unBDOkXsqUfHvFK8uM,14249
-amd_debug/kernel.py,sha256=xzAy-sDY5-sd4jxyU7EaBokS7YsvEjoWRuexaTJNRBc,11851
-amd_debug/prerequisites.py,sha256=bKJA9ztyapB8rxrNEgc-hxazw5Uh-sP5X0S7zplGA0c,50413
-amd_debug/pstate.py,sha256=akGdJkIxBp0bx3AeGv6ictNxwv8m0j9vQ2IZB0Jx3dM,9518
-amd_debug/s2idle-hook,sha256=LLiaqPtGd0qetu9n6EYxKHZaIdHpVQDONdOuSc0pfFg,1695
-amd_debug/s2idle.py,sha256=lzxLYZBcQllyqEMZfxYEUvQO3ArgVzwL5FHymzvZvSs,13281
-amd_debug/sleep_report.py,sha256=zgwcmSk7S8GAmPtPZJGP29Mr5bcWUBxwNL8HBubKs6Q,15516
-amd_debug/validator.py,sha256=fgG3D0k6DS9ArgzK1SuPUds1FNGoKf2asPUwWoyCsXE,33205
-amd_debug/wake.py,sha256=xT8WrFrN6voCmXWo5dsn4mQ7iR2QJxHrrYBd3EREG-Q,3936
-amd_debug/bash/amd-s2idle,sha256=g_cle1ElCJpwE4wcLezL6y-BdasDKTnNMhrtzKLE9ks,1142
-amd_debug/templates/html,sha256=tnpqHDZF5FfhC6YNRUfOG6Vn9ZtISFr10kEXSB476Mw,14518
-amd_debug/templates/md,sha256=r8X2aehnH2gzj0WHYTZ5K9wAqC5y39i_3nkDORSC0uM,787
-amd_debug/templates/stdout,sha256=hyoOJ96K2dJfnWRWhyCuariLKbEHXvs9mstV_g5aMdI,469
-amd_debug/templates/txt,sha256=nNdsvbPFOhGdL7VA-_4k5aN3nB-6ouGQt6AsWst7T3w,649
-amd_debug_tools-0.2.2.dist-info/licenses/LICENSE,sha256=RBlZI6r3MRGzymI2VDX2iW__D2APDbMhu_Xg5t6BWeo,1066
-amd_debug_tools-0.2.2.dist-info/METADATA,sha256=oZ5H5dL216bbAqtOF8VmvtqkqctPIf5iPibPCjjc1tQ,6877
-amd_debug_tools-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-amd_debug_tools-0.2.2.dist-info/entry_points.txt,sha256=HC11T2up0pPfroAn6Pg5M2jOZXhkWIipToJ1YPTKqu8,116
-amd_debug_tools-0.2.2.dist-info/top_level.txt,sha256=XYjxExbUTEtiIlag_5iQvZSVOC1EIxhKM4NLklReQ0k,234
-amd_debug_tools-0.2.2.dist-info/RECORD,,