amd-debug-tools 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

test_s2idle.py

@@ -381,6 +381,7 @@ class TestTestFunction(unittest.TestCase):
             "2023-02-01",
             "report.html",
             "html",
+            True,
         )
 
         mock_sleep_validator_instance = mock_sleep_validator.return_value
@@ -454,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,
     ):
@@ -470,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,
@@ -491,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")
@@ -532,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)
 
 
@@ -605,6 +636,7 @@ class TestReportFunction(unittest.TestCase):
             "2023-02-01",
             "report.html",
             "html",
+            True,
         )
         mock_sleep_report_instance = mock_sleep_report.return_value
 
@@ -614,10 +646,12 @@ class TestReportFunction(unittest.TestCase):
             fname=None,
             fmt=None,
             tool_debug=True,
-            report_debug=True,
+            report_debug=None,
         )
 
-        mock_prompt_report_arguments.assert_called_once_with(None, None, None, None)
+        mock_prompt_report_arguments.assert_called_once_with(
+            None, None, None, None, None
+        )
         mock_sleep_report.assert_called_once_with(
             since="2023-01-01",
             until="2023-02-01",
@@ -640,10 +674,12 @@ class TestReportFunction(unittest.TestCase):
                 fname=None,
                 fmt=None,
                 tool_debug=True,
-                report_debug=True,
+                report_debug=None,
             )
 
-        mock_prompt_report_arguments.assert_called_once_with(None, None, None, None)
+        mock_prompt_report_arguments.assert_called_once_with(
+            None, None, None, None, None
+        )
 
     @patch("amd_debug.s2idle.prompt_report_arguments")
     @patch(
@@ -659,6 +695,7 @@ class TestReportFunction(unittest.TestCase):
             "2023-02-01",
             "report.html",
             "html",
+            True,
         )
 
         result = report(
@@ -667,10 +704,12 @@ class TestReportFunction(unittest.TestCase):
             fname=None,
             fmt=None,
             tool_debug=True,
-            report_debug=True,
+            report_debug=None,
         )
 
-        mock_prompt_report_arguments.assert_called_once_with(None, None, None, None)
+        mock_prompt_report_arguments.assert_called_once_with(
+            None, None, None, None, None
+        )
         mock_sleep_report.assert_called_once_with(
             since="2023-01-01",
             until="2023-02-01",
@@ -695,6 +734,7 @@ class TestReportFunction(unittest.TestCase):
             "2023-02-01",
             "report.html",
             "html",
+            True,
         )
 
         result = report(
@@ -703,10 +743,12 @@ class TestReportFunction(unittest.TestCase):
             fname=None,
             fmt=None,
             tool_debug=True,
-            report_debug=True,
+            report_debug=None,
         )
 
-        mock_prompt_report_arguments.assert_called_once_with(None, None, None, None)
+        mock_prompt_report_arguments.assert_called_once_with(
+            None, None, None, None, None
+        )
         mock_sleep_report.assert_called_once_with(
             since="2023-01-01",
             until="2023-02-01",
@@ -729,6 +771,7 @@ class TestReportFunction(unittest.TestCase):
             "2023-02-01",
             "report.html",
             "html",
+            True,
         )
         mock_sleep_report_instance = mock_sleep_report.return_value
         mock_sleep_report_instance.run.side_effect = ValueError("Invalid value")
@@ -739,10 +782,12 @@ class TestReportFunction(unittest.TestCase):
             fname=None,
             fmt=None,
             tool_debug=True,
-            report_debug=True,
+            report_debug=None,
         )
 
-        mock_prompt_report_arguments.assert_called_once_with(None, None, None, None)
+        mock_prompt_report_arguments.assert_called_once_with(
+            None, None, None, None, None
+        )
         mock_sleep_report.assert_called_once_with(
             since="2023-01-01",
             until="2023-02-01",
@@ -758,14 +803,14 @@ class TestReportFunction(unittest.TestCase):
 class TestPromptReportArguments(unittest.TestCase):
     """Test prompt_report_arguments function"""
 
-    @patch("builtins.input", side_effect=["2023-01-01", "2023-02-01", "html"])
+    @patch("builtins.input", side_effect=["2023-01-01", "2023-02-01", "html", "true"])
     @patch("amd_debug.s2idle.get_report_file", return_value="report.html")
     @patch("amd_debug.s2idle.get_report_format", return_value="html")
     def test_prompt_report_arguments_success(
         self, mock_get_report_format, mock_get_report_file, _mock_input
     ):
         """Test prompt_report_arguments with valid inputs"""
-        result = prompt_report_arguments(None, None, None, None)
+        result = prompt_report_arguments(None, None, None, None, None)
         self.assertEqual(result[0], datetime(2023, 1, 1))
         self.assertEqual(result[1], datetime(2023, 2, 1))
         self.assertEqual(result[2], "report.html")
@@ -775,33 +820,36 @@ class TestPromptReportArguments(unittest.TestCase):
 
     @patch(
         "builtins.input",
-        side_effect=["invalid-date", "2023-01-01", "2023-02-01", "html"],
+        side_effect=["invalid-date", "2023-01-01", "2023-02-01", "html", "true"],
     )
     @patch("sys.exit")
     def test_prompt_report_arguments_invalid_since_date(self, mock_exit, mock_input):
         """Test prompt_report_arguments with invalid 'since' date"""
         mock_exit.side_effect = SystemExit
         with self.assertRaises(SystemExit):
-            prompt_report_arguments(None, None, None, None)
+            prompt_report_arguments(None, None, None, None, None)
         mock_exit.assert_called_once_with(
             "Invalid date, use YYYY-MM-DD: Invalid isoformat string: 'invalid-date'"
         )
 
     @patch(
         "builtins.input",
-        side_effect=["2023-01-01", "invalid-date", "2023-02-01", "html"],
+        side_effect=["2023-01-01", "invalid-date", "2023-02-01", "html", "true"],
     )
     @patch("sys.exit")
     def test_prompt_report_arguments_invalid_until_date(self, mock_exit, mock_input):
         """Test prompt_report_arguments with invalid 'until' date"""
         mock_exit.side_effect = SystemExit
         with self.assertRaises(SystemExit):
-            prompt_report_arguments(None, None, None, None)
+            prompt_report_arguments(None, None, None, None, None)
         mock_exit.assert_called_once_with(
             "Invalid date, use YYYY-MM-DD: Invalid isoformat string: 'invalid-date'"
         )
 
-    @patch("builtins.input", side_effect=["2023-01-01", "2023-02-01", "invalid-format"])
+    @patch(
+        "builtins.input",
+        side_effect=["2023-01-01", "2023-02-01", "invalid-format", "true"],
+    )
     @patch("amd_debug.s2idle.get_report_format", return_value="html")
     @patch("sys.exit")
     def test_prompt_report_arguments_invalid_format(
@@ -810,11 +858,27 @@ class TestPromptReportArguments(unittest.TestCase):
         """Test prompt_report_arguments with invalid format"""
         mock_exit.side_effect = SystemExit
         with self.assertRaises(SystemExit):
-            prompt_report_arguments(None, None, None, None)
+            prompt_report_arguments(None, None, None, None, None)
         mock_exit.assert_called_once_with("Invalid format: invalid-format")
         mock_get_report_format.assert_called_once()
 
-    @patch("builtins.input", side_effect=["", "", ""])
+    @patch(
+        "builtins.input",
+        side_effect=["2023-01-01", "2023-02-01", "html", "foo_the_bar"],
+    )
+    @patch("amd_debug.s2idle.get_report_format", return_value="html")
+    @patch("sys.exit")
+    def test_prompt_report_arguments_invalid_report(
+        self, mock_exit, mock_get_report_format, mock_input
+    ):
+        """Test prompt_report_arguments with invalid format"""
+        mock_exit.side_effect = SystemExit
+        with self.assertRaises(SystemExit):
+            prompt_report_arguments(None, None, None, None, None)
+        mock_exit.assert_called_once_with("Invalid entry: Foo_the_bar")
+        mock_get_report_format.assert_called_once()
+
+    @patch("builtins.input", side_effect=["", "", "", ""])
     @patch(
         "amd_debug.s2idle.get_report_file",
         return_value="amd-s2idle-report-2023-01-01.html",
@@ -824,10 +888,11 @@ class TestPromptReportArguments(unittest.TestCase):
         self, mock_get_report_format, mock_get_report_file, mock_input
     ):
         """Test prompt_report_arguments with default values"""
-        result = prompt_report_arguments(None, None, None, None)
+        result = prompt_report_arguments(None, None, None, None, None)
         self.assertEqual(datetime.date(result[0]), Defaults.since)
         self.assertEqual(datetime.date(result[1]), Defaults.until)
         self.assertEqual(result[2], "amd-s2idle-report-2023-01-01.html")
         self.assertEqual(result[3], "html")
+        self.assertEqual(result[4], True)
         mock_get_report_file.assert_called_once_with(None, "html")
         mock_get_report_format.assert_called()

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
@@ -321,13 +321,11 @@ class TestValidator(unittest.TestCase):
         self.validator.lockdown = False
         with patch("os.path.exists", return_value=False), patch(
             "amd_debug.validator.read_file", side_effect=FileNotFoundError
-        ), patch.object(
-            self.validator.db, "record_cycle_data"
-        ) as mock_record_cycle_data:
+        ), patch.object(self.validator.db, "record_debug") as mock_record:
             result = self.validator.capture_hw_sleep()
             self.assertFalse(result)
-            mock_record_cycle_data.assert_called_once_with(
-                "HW sleep statistics file missing", "❌"
+            mock_record.assert_called_once_with(
+                "HW sleep statistics file /sys/kernel/debug/amd_pmc/smu_fw_info is missing"
             )
 
     def test_capture_amdgpu_ips_status(self):
@@ -696,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))
@@ -707,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)