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

test_common.py

@@ -16,9 +16,11 @@ from platform import uname_result
 from amd_debug.common import (
     apply_prefix_wrapper,
     Colors,
+    convert_string_to_bool,
     colorize_choices,
     check_lockdown,
     compare_file,
+    find_ip_version,
     fatal_error,
     get_distro,
     get_log_priority,
@@ -330,3 +332,113 @@ class TestCommon(unittest.TestCase):
         default = "option1"
         expected_output = f"{Colors.OK}{default}{Colors.ENDC}"
         self.assertEqual(colorize_choices(choices, default), expected_output)
+
+    @patch("amd_debug.common.read_file")
+    @patch("os.path.exists")
+    def test_find_ip_version_found(self, mock_exists, mock_read_file):
+        """Test find_ip_version returns True when expected value is found"""
+        base_path = "/foo"
+        kind = "bar"
+        hw_ver = {"baz": 42}
+
+        # Simulate file exists and value matches
+        def exists_side_effect(path):
+            return True
+
+        mock_exists.side_effect = exists_side_effect
+        mock_read_file.return_value = "42"
+        result = find_ip_version(base_path, kind, hw_ver)
+        self.assertTrue(result)
+        b = os.path.join(base_path, "ip_discovery", "die", "0", kind, "0")
+        expected_path = os.path.join(b, "baz")
+        mock_exists.assert_any_call(expected_path)
+        mock_read_file.assert_any_call(expected_path)
+
+    @patch("amd_debug.common.read_file")
+    @patch("os.path.exists")
+    def test_find_ip_version_not_found_due_to_missing_file(
+        self, mock_exists, mock_read_file
+    ):
+        """Test find_ip_version returns False if file does not exist"""
+        base_path = "/foo"
+        kind = "bar"
+        hw_ver = {"baz": 42}
+        # Simulate file does not exist
+        mock_exists.return_value = False
+        result = find_ip_version(base_path, kind, hw_ver)
+        self.assertFalse(result)
+        b = os.path.join(base_path, "ip_discovery", "die", "0", kind, "0")
+        expected_path = os.path.join(b, "baz")
+        mock_exists.assert_any_call(expected_path)
+        mock_read_file.assert_not_called()
+
+    @patch("amd_debug.common.read_file")
+    @patch("os.path.exists")
+    def test_find_ip_version_not_found_due_to_value_mismatch(
+        self, mock_exists, mock_read_file
+    ):
+        """Test find_ip_version returns False if value does not match"""
+        base_path = "/foo"
+        kind = "bar"
+        hw_ver = {"baz": 42}
+        # Simulate file exists but value does not match
+        mock_exists.return_value = True
+        mock_read_file.return_value = "99"
+        result = find_ip_version(base_path, kind, hw_ver)
+        self.assertFalse(result)
+        b = os.path.join(base_path, "ip_discovery", "die", "0", kind, "0")
+        expected_path = os.path.join(b, "baz")
+        mock_exists.assert_any_call(expected_path)
+        mock_read_file.assert_any_call(expected_path)
+
+    @patch("amd_debug.common.read_file")
+    @patch("os.path.exists")
+    def test_find_ip_version_multiple_keys(self, mock_exists, mock_read_file):
+        """Test find_ip_version with multiple keys in hw_ver"""
+        base_path = "/foo"
+        kind = "bar"
+        hw_ver = {"baz": 42, "qux": 99}
+
+        # First key: file exists, value does not match
+        # Second key: file exists, value matches
+        def exists_side_effect(path):
+            return True
+
+        def read_file_side_effect(path):
+            if path.endswith("baz"):
+                return "0"
+            if path.endswith("qux"):
+                return "99"
+            return "0"
+
+        mock_exists.side_effect = exists_side_effect
+        mock_read_file.side_effect = read_file_side_effect
+        result = find_ip_version(base_path, kind, hw_ver)
+        self.assertFalse(result)
+
+    def test_convert_string_to_bool_true_values(self):
+        """Test convert_string_to_bool returns True for truthy string values"""
+        self.assertTrue(convert_string_to_bool("True"))
+        self.assertTrue(convert_string_to_bool("1"))
+        self.assertTrue(convert_string_to_bool("'nonempty'"))
+        self.assertTrue(convert_string_to_bool('"nonempty"'))
+
+    def test_convert_string_to_bool_false_values(self):
+        """Test convert_string_to_bool returns False for falsy string values"""
+        self.assertFalse(convert_string_to_bool("False"))
+        self.assertFalse(convert_string_to_bool("0"))
+        self.assertFalse(convert_string_to_bool("''"))
+        self.assertFalse(convert_string_to_bool('""'))
+        self.assertFalse(convert_string_to_bool("None"))
+
+    def test_convert_string_to_bool_invalid_syntax(self):
+        """Test convert_string_to_bool exits on invalid syntax"""
+        with patch("sys.exit") as mock_exit:
+            convert_string_to_bool("not_a_bool")
+            mock_exit.assert_called_once_with("Invalid entry: not_a_bool")
+
+    def test_convert_string_to_bool_invalid_value(self):
+        """Test convert_string_to_bool exits on invalid value"""
+        with patch("sys.exit") as mock_exit:
+            convert_string_to_bool("[unclosed_list")
+            mock_exit.assert_called_once_with("Invalid entry: [unclosed_list")

test_installer.py

@@ -192,7 +192,7 @@ class TestInstaller(unittest.TestCase):
         """Test install requirements function"""
         self.installer.set_requirements("iasl", "ethtool")
         ret = self.installer.install_dependencies()
-        self.assertFalse(ret)
+        self.assertTrue(ret)
 
     @patch("builtins.print")
     @patch("amd_debug.installer.get_distro", return_value="ubuntu")
@@ -205,7 +205,9 @@ class TestInstaller(unittest.TestCase):
         """Test install requirements function for edid-decode on Ubuntu"""
         self.installer.set_requirements("edid-decode")
         ret = self.installer.install_dependencies()
-        _mock_check_call.assert_called_once_with(["apt", "install", "edid-decode"])
+        _mock_check_call.assert_called_once_with(
+            ["apt", "install", "libdisplay-info-bin"]
+        )
         self.assertTrue(ret)
 
     @patch("builtins.print")
@@ -229,7 +231,7 @@ class TestInstaller(unittest.TestCase):
         self.installer.set_requirements("edid-decode")
         ret = self.installer.install_dependencies()
         _mock_check_call.assert_called_once_with(
-            ["dnf", "install", "-y", "edid-decode"]
+            ["dnf", "install", "-y", "libdisplay-info"]
         )
         self.assertTrue(ret)
 
@@ -249,8 +251,8 @@ class TestInstaller(unittest.TestCase):
         """Test install requirements function for edid-decode on Arch"""
         self.installer.set_requirements("edid-decode")
         ret = self.installer.install_dependencies()
-        _mock_check_call.assert_not_called()  # edid-decode is not supported on Arch
-        self.assertFalse(ret)
+        _mock_check_call.assert_called_once_with(["pacman", "-Sy", "libdisplay-info"])
+        self.assertTrue(ret)
 
     @patch("builtins.print")
     @patch("os.path.exists", return_value=False)
@@ -263,7 +265,7 @@ class TestInstaller(unittest.TestCase):
         """Test install requirements function for edid-decode on unsupported distro"""
         self.installer.set_requirements("edid-decode")
         ret = self.installer.install_dependencies()
-        self.assertFalse(ret)
+        self.assertTrue(ret)
 
     @patch("builtins.print")
     @patch("os.path.exists", return_value=False)

test_prerequisites.py

@@ -8,7 +8,7 @@ This module contains unit tests for the prerequisite functions in the amd-debug-
 import logging
 import unittest
 import subprocess
-from unittest.mock import patch, MagicMock
+from unittest.mock import patch, MagicMock, mock_open
 
 from amd_debug.prerequisites import PrerequisiteValidator
 from amd_debug.failures import *
@@ -180,20 +180,22 @@ class TestPrerequisiteValidator(unittest.TestCase):
         self.assertTrue(result)
         self.mock_db.record_prereq.assert_called_with("IOMMU disabled", "✅")
 
-    def test_check_iommu_no_dma_protection(self):
+    @patch(
+        "amd_debug.prerequisites.open",
+        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"""
         self.validator.cpu_family = 0x1A
         self.validator.cpu_model = 0x20
         iommu_device = MagicMock(sys_path="/sys/devices/iommu")
-        thunderbolt_device = MagicMock(sys_path="/sys/devices/thunderbolt")
         self.mock_pyudev.list_devices.side_effect = [
             [iommu_device],
-            [thunderbolt_device],
             [],
             [],
         ]
-        with patch("amd_debug.prerequisites.read_file", return_value="0"):
-            result = self.validator.check_iommu()
+        result = self.validator.check_iommu()
         self.assertFalse(result)
         self.assertTrue(
             any(isinstance(f, DMArNotEnabled) for f in self.validator.failures)
@@ -202,20 +204,22 @@ class TestPrerequisiteValidator(unittest.TestCase):
             "IOMMU is misconfigured: Pre-boot DMA protection not enabled", "❌"
         )
 
-    def test_check_iommu_missing_acpi_device(self):
+    @patch(
+        "amd_debug.prerequisites.open",
+        new_callable=unittest.mock.mock_open,
+        read_data=b"\x00" * 36 + b"\xff" * 4,
+    )
+    def test_check_iommu_missing_acpi_device(self, _mock_open):
         """Test check_iommu when MSFT0201 ACPI device is missing"""
         self.validator.cpu_family = 0x1A
         self.validator.cpu_model = 0x20
         iommu_device = MagicMock(sys_path="/sys/devices/iommu")
-        thunderbolt_device = MagicMock(sys_path="/sys/devices/thunderbolt")
         self.mock_pyudev.list_devices.side_effect = [
             [iommu_device],
-            [thunderbolt_device],
             [],
             [],
         ]
-        with patch("amd_debug.prerequisites.read_file", return_value="1"):
-            result = self.validator.check_iommu()
+        result = self.validator.check_iommu()
         self.assertFalse(result)
         self.assertTrue(
             any(isinstance(f, MissingIommuACPI) for f in self.validator.failures)
@@ -224,47 +228,48 @@ class TestPrerequisiteValidator(unittest.TestCase):
             "IOMMU is misconfigured: missing MSFT0201 ACPI device", "❌"
         )
 
-    def test_check_iommu_missing_policy(self):
+    @patch(
+        "amd_debug.prerequisites.open",
+        new_callable=unittest.mock.mock_open,
+        read_data=b"\x00" * 36 + b"\xff" * 4,
+    )
+    def test_check_iommu_missing_policy(self, _mock_open):
         """Test check_iommu when policy is not bound to MSFT0201"""
         self.validator.cpu_family = 0x1A
         self.validator.cpu_model = 0x20
         iommu_device = MagicMock(sys_path="/sys/devices/iommu")
-        thunderbolt_device = MagicMock(sys_path="/sys/devices/thunderbolt")
         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],
-            [thunderbolt_device],
             [acpi_device],
             [platform_device],
         ]
-        with patch("amd_debug.prerequisites.read_file", return_value="1"), patch(
-            "os.path.exists", return_value=False
-        ):
-            result = self.validator.check_iommu()
+        result = self.validator.check_iommu()
         self.assertFalse(result)
         self.assertTrue(
             any(isinstance(f, MissingIommuPolicy) for f in self.validator.failures)
         )
 
-    def test_check_iommu_properly_configured(self):
+    @patch(
+        "amd_debug.prerequisites.open",
+        new_callable=unittest.mock.mock_open,
+        read_data=b"\x00" * 36 + b"\xff" * 4,
+    )
+    @patch("amd_debug.prerequisites.os.path.exists", return_value=True)
+    def test_check_iommu_properly_configured(self, _mock_open, _mock_exists):
         """Test check_iommu when IOMMU is properly configured"""
         self.validator.cpu_family = 0x1A
         self.validator.cpu_model = 0x20
         iommu_device = MagicMock(sys_path="/sys/devices/iommu")
-        thunderbolt_device = MagicMock(sys_path="/sys/devices/thunderbolt")
         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],
-            [thunderbolt_device],
             [acpi_device],
             [platform_device],
         ]
-        with patch("amd_debug.prerequisites.read_file", return_value="1"), patch(
-            "os.path.exists", return_value=True
-        ):
-            result = self.validator.check_iommu()
+        result = self.validator.check_iommu()
         self.assertTrue(result)
         self.mock_db.record_prereq.assert_called_with("IOMMU properly configured", "✅")
 
@@ -495,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")
@@ -540,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")
@@ -564,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")
@@ -588,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")
@@ -623,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):
@@ -633,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):
@@ -1001,7 +1002,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")
@@ -1029,7 +1030,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")
@@ -1705,9 +1706,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"""
@@ -1737,7 +1735,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
         result = self.validator.capture_edid()
         self.assertTrue(result)
         self.mock_db.record_prereq.assert_called_with(
-            "edid-decode not installed, unable to decode EDID", "👀"
+            "Failed to capture EDID table", "👀"
         )
 
     @patch("amd_debug.prerequisites.subprocess.check_output")
@@ -1750,9 +1748,9 @@ class TestPrerequisiteValidator(unittest.TestCase):
             returncode=1, cmd="edid-decode", output=b"Error decoding EDID"
         )
         result = self.validator.capture_edid()
-        self.assertFalse(result)
+        self.assertTrue(result)
         self.mock_db.record_prereq.assert_called_with(
-            "Failed to capture EDID table: b'Error decoding EDID'", "👀"
+            "Failed to capture EDID table", "👀"
         )
 
     @patch("amd_debug.prerequisites.subprocess.check_output")
@@ -1767,3 +1765,164 @@ class TestPrerequisiteValidator(unittest.TestCase):
         self.mock_db.record_debug.assert_called_with(
             apply_prefix_wrapper("EDID for Monitor1:", "Decoded EDID data")
         )
+
+    @patch("amd_debug.prerequisites.find_ip_version", return_value=True)
+    @patch("amd_debug.prerequisites.os.path.exists")
+    @patch("amd_debug.prerequisites.read_file")
+    def test_check_dpia_pg_dmcub_usb4_found(
+        self, mock_read_file, mock_path_exists, mock_find_ip_version
+    ):
+        """Test check_dpia_pg_dmcub when USB4 routers are found"""
+        usb4_device = MagicMock()
+        self.mock_pyudev.list_devices.side_effect = [
+            [usb4_device],  # First call: USB4 present
+        ]
+        result = self.validator.check_dpia_pg_dmcub()
+        self.assertTrue(result)
+        self.mock_db.record_debug.assert_called_with(
+            "USB4 routers found, no need to check DMCUB version"
+        )
+
+    @patch("amd_debug.prerequisites.find_ip_version", return_value=True)
+    @patch("amd_debug.prerequisites.os.path.exists", return_value=True)
+    @patch("amd_debug.prerequisites.read_file", return_value="0x90001B01")
+    def test_check_dpia_pg_dmcub_dmcub_fw_version_new_enough(
+        self, mock_read_file, mock_path_exists, mock_find_ip_version
+    ):
+        """Test check_dpia_pg_dmcub when DMCUB firmware version is new enough"""
+        self.mock_pyudev.list_devices.side_effect = [
+            [],  # First call: no USB4
+            [
+                MagicMock(
+                    properties={
+                        "PCI_CLASS": "30000",
+                        "PCI_ID": "1002abcd",
+                        "PCI_SLOT_NAME": "0000:01:00.0",
+                    },
+                    sys_path="/sys/devices/pci0000:01/0000:01:00.0",
+                )
+            ],
+        ]
+        with patch("builtins.open", new_callable=mock_open, read_data="3") as mock_file:
+            handlers = (
+                mock_file.return_value,
+                mock_open(read_data="5").return_value,
+                mock_open(read_data="0").return_value,
+            )
+            mock_open.side_effect = handlers
+            result = self.validator.check_dpia_pg_dmcub()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_not_called()
+
+    @patch("amd_debug.prerequisites.find_ip_version", return_value=True)
+    @patch("amd_debug.prerequisites.os.path.exists", return_value=True)
+    @patch("amd_debug.prerequisites.read_file", return_value="0x8001B00")
+    def test_check_dpia_pg_dmcub_dmcub_fw_version_too_old(
+        self, mock_read_file, mock_path_exists, mock_find_ip_version
+    ):
+        """Test check_dpia_pg_dmcub when DMCUB firmware version is too old"""
+        self.mock_pyudev.list_devices.side_effect = [
+            [],  # First call: no USB4
+            [
+                MagicMock(
+                    properties={
+                        "PCI_CLASS": "30000",
+                        "PCI_ID": "1002abcd",
+                        "PCI_SLOT_NAME": "0000:01:00.0",
+                    },
+                    sys_path="/sys/devices/pci0000:01/0000:01:00.0",
+                )
+            ],
+        ]
+        result = self.validator.check_dpia_pg_dmcub()
+        self.assertFalse(result)
+        self.mock_db.record_prereq.assert_called_with(
+            "DMCUB Firmware is outdated", "❌"
+        )
+        self.assertTrue(
+            any(isinstance(f, DmcubTooOld) for f in self.validator.failures)
+        )
+
+    @patch("amd_debug.prerequisites.find_ip_version", return_value=True)
+    @patch("amd_debug.prerequisites.os.path.exists", return_value=False)
+    @patch(
+        "amd_debug.prerequisites.read_file",
+        side_effect=[
+            "",  # sysfs read returns empty, so fallback to debugfs
+            "DMCUB fw: 09001B00\nOther line\n",  # debugfs read
+        ],
+    )
+    def test_check_dpia_pg_dmcub_debugfs_version_new_enough(
+        self, mock_read_file, mock_path_exists, mock_find_ip_version
+    ):
+        """Test check_dpia_pg_dmcub when DMCUB version is found in debugfs and is new enough"""
+        self.mock_pyudev.list_devices.side_effect = [
+            [],  # First call: no USB4
+            [
+                MagicMock(
+                    properties={
+                        "PCI_CLASS": "30000",
+                        "PCI_ID": "1002abcd",
+                        "PCI_SLOT_NAME": "0",
+                    },
+                    sys_path="/sys/devices/pci0000:01/0000:01:00.0",
+                )
+            ],
+        ]
+        result = self.validator.check_dpia_pg_dmcub()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_not_called()
+
+    @patch("amd_debug.prerequisites.find_ip_version", return_value=True)
+    @patch("amd_debug.prerequisites.os.path.exists", return_value=False)
+    @patch(
+        "amd_debug.prerequisites.read_file",
+        side_effect=[
+            "DMCUB fw: 0x08001B00\nOther line\n",  # debugfs read
+        ],
+    )
+    def test_check_dpia_pg_dmcub_debugfs_version_too_old(
+        self, mock_read_file, mock_path_exists, mock_find_ip_version
+    ):
+        """Test check_dpia_pg_dmcub when DMCUB version is found in debugfs and is too old"""
+        self.mock_pyudev.list_devices.side_effect = [
+            [],  # First call: no USB4
+            [
+                MagicMock(
+                    properties={
+                        "PCI_CLASS": "30000",
+                        "PCI_ID": "1002abcd",
+                        "PCI_SLOT_NAME": "0",
+                    },
+                    sys_path="/sys/devices/pci0000:01/0000:01:00.0",
+                )
+            ],
+        ]
+        result = self.validator.check_dpia_pg_dmcub()
+        self.assertFalse(result)
+        self.mock_db.record_prereq.assert_called_with(
+            "DMCUB Firmware is outdated", "❌"
+        )
+        self.assertTrue(
+            any(isinstance(f, DmcubTooOld) for f in self.validator.failures)
+        )
+
+    @patch("amd_debug.prerequisites.find_ip_version", return_value=False)
+    def test_check_dpia_pg_dmcub_no_matching_dcn(self, mock_find_ip_version):
+        """Test check_dpia_pg_dmcub when no matching DCN is found"""
+        self.mock_pyudev.list_devices.side_effect = [
+            [],  # First call: no USB4
+            [
+                MagicMock(
+                    properties={
+                        "PCI_CLASS": "30000",
+                        "PCI_ID": "1002abcd",
+                        "PCI_SLOT_NAME": "0",
+                    },
+                    sys_path="/sys/devices/pci0000:01/0000:01:00.0",
+                )
+            ],
+        ]
+        result = self.validator.check_dpia_pg_dmcub()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_not_called()