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

test_prerequisites.py

@@ -143,6 +143,16 @@ class TestPrerequisiteValidator(unittest.TestCase):
         result = self.validator.check_port_pm_override()
         self.assertTrue(result)
 
+    @patch("amd_debug.prerequisites.version.parse")
+    def test_check_port_pm_override_smu_version_missing(self, mock_version_parse):
+        """Test check_port_pm_override with SMU version undefined"""
+        self.validator.cpu_family = 0x19
+        self.validator.cpu_model = 0x74
+        mock_version_parse.side_effect = lambda v: v if isinstance(v, str) else None
+        self.validator.smu_version = ""
+        result = self.validator.check_port_pm_override()
+        self.assertTrue(result)
+
     @patch("amd_debug.prerequisites.version.parse")
     def test_check_port_pm_override_smu_version_too_low(self, mock_version_parse):
         """Test check_port_pm_override with SMU version < 76.18.0"""
@@ -185,15 +195,18 @@ class TestPrerequisiteValidator(unittest.TestCase):
         new_callable=unittest.mock.mock_open,
         read_data=b"\x00" * 45,
     )
-    def test_check_iommu_no_dma_protection(self, _mock_open):
-        """Test check_iommu when DMA protection is not enabled"""
+    @patch("amd_debug.prerequisites.os.path.exists", return_value=True)
+    def test_check_iommu_no_dma_protection_no_msft0201(self, _mock_open, _mock_exists):
+        """Test check_iommu when DMA protection is not enabled and no MSFT0201 in IVRS"""
         self.validator.cpu_family = 0x1A
         self.validator.cpu_model = 0x20
         iommu_device = MagicMock(sys_path="/sys/devices/iommu")
+        acpi_device = MagicMock(sys_path="/sys/devices/acpi/MSFT0201")
+        platform_device = MagicMock(sys_path="/sys/devices/platform/MSFT0201")
         self.mock_pyudev.list_devices.side_effect = [
             [iommu_device],
-            [],
-            [],
+            [acpi_device],
+            [platform_device],
         ]
         result = self.validator.check_iommu()
         self.assertFalse(result)
@@ -204,6 +217,27 @@ class TestPrerequisiteValidator(unittest.TestCase):
             "IOMMU is misconfigured: Pre-boot DMA protection not enabled", "❌"
         )
 
+    @patch(
+        "amd_debug.prerequisites.open",
+        new_callable=unittest.mock.mock_open,
+        read_data=b"\x00" * 45 + "MSFT0201".encode("utf-8"),
+    )
+    @patch("amd_debug.prerequisites.os.path.exists", return_value=True)
+    def test_check_iommu_no_dma_protection_BUT_msft0201(self, _mock_open, _mock_exists):
+        """Test check_iommu when DMA protection is not enabled BUT MSFT0201 is in IVRS"""
+        self.validator.cpu_family = 0x1A
+        self.validator.cpu_model = 0x20
+        iommu_device = MagicMock(sys_path="/sys/devices/iommu")
+        acpi_device = MagicMock(sys_path="/sys/devices/acpi/MSFT0201")
+        platform_device = MagicMock(sys_path="/sys/devices/platform/MSFT0201")
+        self.mock_pyudev.list_devices.side_effect = [
+            [iommu_device],
+            [acpi_device],
+            [platform_device],
+        ]
+        result = self.validator.check_iommu()
+        self.assertTrue(result)
+
     @patch(
         "amd_debug.prerequisites.open",
         new_callable=unittest.mock.mock_open,
@@ -292,7 +326,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
             BIT(9) | 1
         )  # Kernel warnings ignored, other taint present
         result = self.validator.check_taint()
-        self.assertFalse(result)
+        self.assertTrue(result)
         self.assertTrue(
             any(isinstance(f, TaintedKernel) for f in self.validator.failures)
         )
@@ -1925,3 +1959,79 @@ class TestPrerequisiteValidator(unittest.TestCase):
         result = self.validator.check_dpia_pg_dmcub()
         self.assertTrue(result)
         self.mock_db.record_prereq.assert_not_called()
+
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_capture_nvidia_version_file_missing(self, mock_exists):
+        """Test capture_nvidia when /proc/driver/nvidia/version does not exist"""
+        mock_exists.side_effect = lambda p: False if "version" in p else True
+        result = self.validator.capture_nvidia()
+        self.assertTrue(result)
+        self.mock_db.record_debug_file.assert_not_called()
+        self.mock_db.record_prereq.assert_not_called()
+
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_capture_nvidia_gpus_dir_missing(self, mock_exists):
+        """Test capture_nvidia when /proc/driver/nvidia/gpus does not exist"""
+
+        def exists_side_effect(path):
+            if "version" in path:
+                return True
+            if "gpus" in path:
+                return False
+            return True
+
+        mock_exists.side_effect = exists_side_effect
+        result = self.validator.capture_nvidia()
+        self.assertTrue(result)
+        self.mock_db.record_debug_file.assert_called_once_with(
+            "/proc/driver/nvidia/version"
+        )
+        self.mock_db.record_prereq.assert_not_called()
+
+    @patch("amd_debug.prerequisites.os.walk")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_capture_nvidia_success(self, mock_exists, mock_walk):
+        """Test capture_nvidia when NVIDIA GPU files are present and readable"""
+        mock_exists.side_effect = lambda p: True
+        mock_walk.return_value = [
+            ("/proc/driver/nvidia/gpus/0000:01:00.0", [], ["info", "power"])
+        ]
+        result = self.validator.capture_nvidia()
+        self.assertTrue(result)
+        self.mock_db.record_debug_file.assert_any_call("/proc/driver/nvidia/version")
+        self.mock_db.record_debug.assert_any_call("NVIDIA info")
+        self.mock_db.record_debug_file.assert_any_call(
+            "/proc/driver/nvidia/gpus/0000:01:00.0/info"
+        )
+        self.mock_db.record_debug.assert_any_call("NVIDIA power")
+        self.mock_db.record_debug_file.assert_any_call(
+            "/proc/driver/nvidia/gpus/0000:01:00.0/power"
+        )
+
+    @patch("amd_debug.prerequisites.os.walk")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_capture_nvidia_permission_error_on_version(self, mock_exists, mock_walk):
+        """Test capture_nvidia when PermissionError occurs reading version file"""
+        mock_exists.side_effect = lambda p: True if "version" in p else False
+        self.mock_db.record_debug_file.side_effect = PermissionError
+        result = self.validator.capture_nvidia()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_called_with(
+            "NVIDIA GPU version not readable", "👀"
+        )
+
+    @patch("amd_debug.prerequisites.os.walk")
+    @patch("amd_debug.prerequisites.os.path.exists")
+    def test_capture_nvidia_permission_error_on_gpu_file(self, mock_exists, mock_walk):
+        """Test capture_nvidia when PermissionError occurs reading a GPU file"""
+        mock_exists.side_effect = lambda p: True
+        mock_walk.return_value = [
+            ("/proc/driver/nvidia/gpus/0000:01:00.0", [], ["info"])
+        ]
+        self.mock_db.record_debug_file.side_effect = [None, PermissionError]
+        result = self.validator.capture_nvidia()
+        self.assertTrue(result)
+        self.mock_db.record_debug.assert_any_call("NVIDIA info")
+        self.mock_db.record_prereq.assert_called_with(
+            "NVIDIA GPU {f} not readable", "👀"
+        )

test_s2idle.py

@@ -117,9 +117,9 @@ class TestParseArgs(unittest.TestCase):
 
     def test_version_command(self):
         """Test parse_args with version command"""
-        sys.argv = ["s2idle.py", "version"]
+        sys.argv = ["s2idle.py", "--version"]
         args = parse_args()
-        self.assertEqual(args.action, "version")
+        self.assertTrue(args.version)
 
 
 class TestMainFunction(unittest.TestCase):
@@ -214,7 +214,7 @@ class TestMainFunction(unittest.TestCase):
         """Test main function with version action"""
         sys.argv = ["s2idle.py", "version"]
         with patch("amd_debug.s2idle.parse_args") as mock_parse_args:
-            mock_parse_args.return_value = argparse.Namespace(action="version")
+            mock_parse_args.return_value = argparse.Namespace(version=True, action=None)
             mock_version.return_value = "1.0.0"
             with patch("builtins.print") as mock_print:
                 result = main()
@@ -226,7 +226,9 @@ class TestMainFunction(unittest.TestCase):
         """Test main function with no action specified"""
         sys.argv = ["s2idle.py"]
         with patch("amd_debug.s2idle.parse_args") as mock_parse_args:
-            mock_parse_args.return_value = argparse.Namespace(action=None)
+            mock_parse_args.return_value = argparse.Namespace(
+                version=False, action=None
+            )
             with self.assertRaises(SystemExit) as cm:
                 main()
             self.assertEqual(cm.exception.code, "no action specified")

test_validator.py

@@ -71,7 +71,8 @@ class TestValidator(unittest.TestCase):
         logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
 
     @patch("amd_debug.validator.SleepDatabase")
-    def setUp(self, _db_mock):
+    @patch("subprocess.run")
+    def setUp(self, _db_mock, _mock_run):
         """Set up a mock context for testing"""
         self.validator = SleepValidator(tool_debug=True, bios_debug=False)
 
@@ -830,3 +831,64 @@ class TestValidator(unittest.TestCase):
         )
         mock_os_write.assert_called_once_with(3, b"mem")
         mock_os_close.assert_called_once_with(3)
+
+    @patch("os.path.exists")
+    @patch("os.open")
+    @patch("os.write")
+    @patch("os.close")
+    def test_toggle_nvidia_file_not_exists(
+        self, mock_close, mock_write, mock_open, mock_exists
+    ):
+        """Test toggle_nvidia returns True if NVIDIA suspend file does not exist"""
+        mock_exists.return_value = False
+        result = self.validator.toggle_nvidia(b"suspend")
+        self.assertTrue(result)
+        mock_open.assert_not_called()
+        mock_write.assert_not_called()
+        mock_close.assert_not_called()
+
+    @patch("os.path.exists")
+    @patch("os.open")
+    @patch("os.write")
+    @patch("os.close")
+    def test_toggle_nvidia_success(
+        self, mock_close, mock_write, mock_open, mock_exists
+    ):
+        """Test toggle_nvidia writes value and returns True on success"""
+        mock_exists.return_value = True
+        mock_open.return_value = 42
+        mock_write.return_value = None
+        with patch.object(self.validator.db, "record_debug") as mock_record_debug:
+            result = self.validator.toggle_nvidia(b"suspend")
+            self.assertTrue(result)
+            mock_open.assert_called_once_with(
+                "/proc/driver/nvidia/suspend", os.O_WRONLY | os.O_SYNC
+            )
+            mock_write.assert_called_once_with(42, b"suspend")
+            mock_close.assert_called_once_with(42)
+            mock_record_debug.assert_called_once_with(
+                "Wrote b'suspend' to NVIDIA driver"
+            )
+
+    @patch("os.path.exists")
+    @patch("os.open")
+    @patch("os.write")
+    @patch("os.close")
+    def test_toggle_nvidia_oserror(
+        self, mock_close, mock_write, mock_open, mock_exists
+    ):
+        """Test toggle_nvidia handles OSError and returns False"""
+        mock_exists.return_value = True
+        mock_open.return_value = 99
+        mock_write.side_effect = OSError("write error")
+        with patch.object(
+            self.validator.db, "record_cycle_data"
+        ) as mock_record_cycle_data:
+            result = self.validator.toggle_nvidia(b"resume")
+            self.assertFalse(result)
+            mock_open.assert_called_once_with(
+                "/proc/driver/nvidia/suspend", os.O_WRONLY | os.O_SYNC
+            )
+            mock_write.assert_called_once_with(99, b"resume")
+            mock_close.assert_called_once_with(99)
+            mock_record_cycle_data.assert_called_once()