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

test_display.py

@@ -0,0 +1,143 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+
+"""
+This module contains unit tests for the display functions in the amd-debug-tools package.
+"""
+
+import logging
+import unittest
+from unittest.mock import patch, MagicMock
+from amd_debug.display import Display
+
+
+class TestDisplay(unittest.TestCase):
+    """Unit tests for the Display class in amd-debug-tools"""
+
+    @classmethod
+    def setUpClass(cls):
+        logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
+
+    @patch("amd_debug.display.Context")
+    @patch("amd_debug.display.read_file")
+    @patch("os.path.exists")
+    def test_display_initialization(self, mock_exists, mock_read_file, mock_context):
+        """Test the Display class initialization and EDID retrieval"""
+        # Mock the pyudev Context and its list_devices method
+        mock_device = MagicMock()
+        mock_device.device_path = "/devices/card0"
+        mock_device.sys_path = "/sys/devices/card0"
+        mock_device.sys_name = "card0"
+        mock_context.return_value.list_devices.return_value = [mock_device]
+
+        # Mock os.path.exists and read_file behavior
+        mock_exists.side_effect = lambda path: "status" in path or "enabled" in path
+        mock_read_file.side_effect = lambda path: (
+            "connected" if "status" in path else "enabled"
+        )
+
+        # Initialize the Display class
+        display = Display()
+
+        # Verify the EDID paths are correctly set
+        expected_edid = {"card0": "/sys/devices/card0/edid"}
+        self.assertEqual(display.get_edid(), expected_edid)
+        mock_context.assert_called_once()
+
+    @patch("amd_debug.display.Context")
+    def test_no_connected_displays(self, mock_context):
+        """Test the Display class when no connected displays are found"""
+        # Mock the pyudev Context to return no devices
+        mock_context.return_value.list_devices.return_value = []
+
+        # Initialize the Display class
+        display = Display()
+
+        # Verify the EDID dictionary is empty
+        self.assertEqual(display.get_edid(), {})
+
+    @patch("amd_debug.display.Context")
+    def test_device_without_card(self, mock_context):
+        """Test the Display class with a device that does not have 'card' in the name"""
+        # Mock the pyudev Context to return a device without 'card' in the name
+        mock_device = MagicMock()
+        mock_device.device_path = "/devices/other_device"
+        mock_device.sys_path = "/sys/devices/other_device"
+        mock_device.sys_name = "other_device"
+        mock_context.return_value.list_devices.return_value = [mock_device]
+
+        # Initialize the Display class
+        display = Display()
+
+        # Verify the EDID dictionary is empty
+        self.assertEqual(display.get_edid(), {})
+
+    @patch("amd_debug.display.Context")
+    @patch("amd_debug.display.read_file")
+    @patch("os.path.exists")
+    def test_device_not_enabled(self, mock_exists, mock_read_file, mock_context):
+        """Test the Display class with a device that is not enabled"""
+        # Mock the pyudev Context to return a device that is not enabled
+        mock_device = MagicMock()
+        mock_device.device_path = "/devices/card0"
+        mock_device.sys_path = "/sys/devices/card0"
+        mock_device.sys_name = "card0"
+        mock_context.return_value.list_devices.return_value = [mock_device]
+
+        # Mock os.path.exists and read_file behavior
+        mock_exists.side_effect = lambda path: "status" in path or "enabled" in path
+        mock_read_file.side_effect = lambda path: (
+            "connected" if "status" in path else "disabled"
+        )
+
+        # Initialize the Display class
+        display = Display()
+
+        # Verify the EDID dictionary is empty
+        self.assertEqual(display.get_edid(), {})
+
+    @patch("amd_debug.display.Context")
+    @patch("amd_debug.display.read_file")
+    @patch("os.path.exists")
+    def test_missing_status_file(self, mock_exists, mock_read_file, mock_context):
+        """Test the Display class when the status file is missing"""
+        # Mock the pyudev Context to return a device with a missing status file
+        mock_device = MagicMock()
+        mock_device.device_path = "/devices/card0"
+        mock_device.sys_path = "/sys/devices/card0"
+        mock_device.sys_name = "card0"
+        mock_context.return_value.list_devices.return_value = [mock_device]
+
+        # Mock os.path.exists to return False for the status file
+        mock_exists.side_effect = lambda path: "enabled" in path
+        mock_read_file.side_effect = lambda path: "enabled" if "enabled" in path else ""
+
+        # Initialize the Display class
+        display = Display()
+
+        # Verify the EDID dictionary is empty
+        self.assertEqual(display.get_edid(), {})
+
+    @patch("amd_debug.display.Context")
+    @patch("amd_debug.display.read_file")
+    @patch("os.path.exists")
+    def test_status_not_connected(self, mock_exists, mock_read_file, mock_context):
+        """Test the Display class when the status file does not indicate connected"""
+        # Mock the pyudev Context to return a device with a status file that does not indicate connected
+        mock_device = MagicMock()
+        mock_device.device_path = "/devices/card0"
+        mock_device.sys_path = "/sys/devices/card0"
+        mock_device.sys_name = "card0"
+        mock_context.return_value.list_devices.return_value = [mock_device]
+
+        # Mock os.path.exists and read_file behavior
+        mock_exists.side_effect = lambda path: "status" in path or "enabled" in path
+        mock_read_file.side_effect = lambda path: (
+            "not_connected" if "status" in path else "enabled"
+        )
+
+        # Initialize the Display class
+        display = Display()
+
+        # Verify the EDID dictionary is empty
+        self.assertEqual(display.get_edid(), {})

test_failures.py

@@ -0,0 +1,146 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+
+"""
+This module contains unit tests for the failure functions in the amd-debug-tools package.
+"""
+
+from unittest.mock import patch, call
+
+import logging
+import unittest
+import os
+
+import amd_debug.failures
+
+
+class TestFailures(unittest.TestCase):
+    """Test failure functions"""
+
+    @classmethod
+    def setUpClass(cls):
+        logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
+
+    @patch("builtins.print")
+    def test_failures(self, mocked_print):
+        """Test failure functions"""
+
+        cls = amd_debug.failures.RtcAlarmWrong()
+        self.assertEqual(
+            cls.get_description(), "rtc_cmos is not configured to use ACPI alarm"
+        )
+        self.assertEqual(
+            str(cls),
+            "Some problems can occur during wakeup cycles if the HPET RTC "
+            "emulation is used to wake systems. This can manifest in unexpected "
+            "wakeups or high power consumption.For more information on this failure "
+            "see:https://github.com/systemd/systemd/issues/24279",
+        )
+        cls = amd_debug.failures.MissingAmdgpu()
+        self.assertEqual(cls.get_description(), "AMDGPU driver is missing")
+        cls = amd_debug.failures.MissingAmdgpuFirmware(["foo", "bar"])
+        self.assertEqual(cls.get_description(), "AMDGPU firmware is missing")
+        cls = amd_debug.failures.AmdgpuPpFeatureMask()
+        self.assertEqual(cls.get_description(), "AMDGPU ppfeaturemask changed")
+        cls = amd_debug.failures.MissingAmdPmc()
+        self.assertEqual(cls.get_description(), "AMD-PMC driver is missing")
+        cls = amd_debug.failures.MissingThunderbolt()
+        self.assertEqual(cls.get_description(), "thunderbolt driver is missing")
+        cls = amd_debug.failures.MissingXhciHcd()
+        self.assertEqual(cls.get_description(), "xhci_hcd driver is missing")
+        cls = amd_debug.failures.MissingDriver("4")
+        self.assertEqual(cls.get_description(), "4 driver is missing")
+        cls = amd_debug.failures.AcpiBiosError("5")
+        self.assertEqual(cls.get_description(), "ACPI BIOS Errors detected")
+        cls = amd_debug.failures.UnsupportedModel()
+        self.assertEqual(cls.get_description(), "Unsupported CPU model")
+        cls = amd_debug.failures.UserNvmeConfiguration()
+        self.assertEqual(cls.get_description(), "NVME ACPI support is disabled")
+        cls = amd_debug.failures.AcpiNvmeStorageD3Enable("foo", 2)
+        self.assertEqual(cls.get_description(), "foo missing ACPI attributes")
+        cls = amd_debug.failures.DevSlpHostIssue()
+        self.assertEqual(
+            cls.get_description(), "AHCI controller doesn't support DevSlp"
+        )
+        cls = amd_debug.failures.DevSlpDiskIssue()
+        self.assertEqual(cls.get_description(), "SATA disk doesn't support DevSlp")
+        cls = amd_debug.failures.SleepModeWrong()
+        self.assertEqual(
+            cls.get_description(),
+            "The system hasn't been configured for Modern Standby in BIOS setup",
+        )
+        cls = amd_debug.failures.DeepSleep()
+        self.assertEqual(
+            cls.get_description(),
+            "The kernel command line is asserting the system to use deep sleep",
+        )
+        cls = amd_debug.failures.FadtWrong()
+        self.assertEqual(
+            cls.get_description(),
+            "The kernel didn't emit a message that low power idle was supported",
+        )
+        cls = amd_debug.failures.Irq1Workaround()
+        self.assertEqual(
+            cls.get_description(),
+            "The wakeup showed an IRQ1 wakeup source, which might be a platform firmware bug",
+        )
+        cls = amd_debug.failures.KernelRingBufferWrapped()
+        self.assertEqual(cls.get_description(), "Kernel ringbuffer has wrapped")
+        cls = amd_debug.failures.AmdHsmpBug()
+        self.assertEqual(cls.get_description(), "amd-hsmp built in to kernel")
+        cls = amd_debug.failures.WCN6855Bug()
+        self.assertEqual(
+            cls.get_description(),
+            "The firmware loaded for the WCN6855 causes spurious wakeups",
+        )
+        cls = amd_debug.failures.I2CHidBug("touchpad", "block")
+        self.assertEqual(
+            cls.get_description(),
+            "The touchpad device has been reported to cause high power consumption and spurious wakeups",
+        )
+        cls = amd_debug.failures.SpuriousWakeup(1, 0)
+        self.assertEqual(
+            cls.get_description(), "Userspace wasn't asleep at least 0:00:01"
+        )
+        cls = amd_debug.failures.LowHardwareSleepResidency(5, 30)
+        self.assertEqual(
+            cls.get_description(), "System had low hardware sleep residency"
+        )
+        cls = amd_debug.failures.MSRFailure()
+        self.assertEqual(cls.get_description(), "PC6 or CC6 state disabled")
+        cls = amd_debug.failures.TaintedKernel()
+        self.assertEqual(cls.get_description(), "Kernel is tainted")
+        cls = amd_debug.failures.DMArNotEnabled()
+        self.assertEqual(cls.get_description(), "Pre-boot DMA protection disabled")
+        cls = amd_debug.failures.MissingIommuACPI("foo")
+        self.assertEqual(cls.get_description(), "Device foo missing from ACPI tables")
+        cls = amd_debug.failures.MissingIommuPolicy("foo")
+        self.assertEqual(
+            cls.get_description(), "Device foo does not have IOMMU policy applied"
+        )
+        cls = amd_debug.failures.IommuPageFault("foo")
+        self.assertEqual(cls.get_description(), "Page fault reported for foo")
+        cls = amd_debug.failures.SMTNotEnabled()
+        self.assertEqual(cls.get_description(), "SMT is not enabled")
+        cls = amd_debug.failures.ASpmWrong()
+        self.assertEqual(cls.get_description(), "ASPM is overridden")
+        cls = amd_debug.failures.UnservicedGpio()
+        self.assertEqual(cls.get_description(), "GPIO interrupt is not serviced")
+        cls = amd_debug.failures.DmiNotSetup()
+        self.assertEqual(cls.get_description(), "DMI data was not scanned")
+        cls = amd_debug.failures.LimitedCores(10, 7)
+        self.assertEqual(cls.get_description(), "CPU cores have been limited")
+        cls = amd_debug.failures.RogAllyOldMcu(1, 2)
+        self.assertEqual(cls.get_description(), "Rog Ally MCU firmware is too old")
+        os.environ["TERM"] = "dumb"
+        cls = amd_debug.failures.RogAllyMcuPowerSave()
+        self.assertEqual(cls.get_description(), "Rog Ally MCU power save is disabled")
+        failure = "The MCU powersave feature is disabled which will cause problems with the controller after suspend/resume."
+        self.assertEqual(str(cls), failure)
+        cls.get_failure()
+        mocked_print.assert_has_calls(
+            [
+                call("🚦 Rog Ally MCU power save is disabled"),
+                call(failure),
+            ]
+        )

test_installer.py

@@ -0,0 +1,279 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+
+"""
+This module contains unit tests for the installer functions in the amd-debug-tools package.
+"""
+from unittest.mock import patch, mock_open
+
+import logging
+import unittest
+
+from amd_debug.installer import Installer
+
+
+class TestInstaller(unittest.TestCase):
+    """Test installer functions"""
+
+    @classmethod
+    def setUpClass(cls):
+        logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
+
+    def setUp(self):
+        self.installer = Installer(tool_debug=False)
+
+    @patch("builtins.print")
+    @patch("shutil.copy", return_value=None)
+    @patch("os.chmod", return_value=None)
+    @patch("builtins.open")
+    @patch("subprocess.call", return_value=0)
+    @patch("os.makedirs", return_value=None)
+    def test_install_hook(
+        self,
+        _mock_mkdir,
+        _mock_call,
+        _mock_open,
+        _mock_chmod,
+        _mock_shutil,
+        _mock_print,
+    ):
+        """Test install hook function"""
+        self.installer.install()
+
+    @patch("builtins.print")
+    @patch("shutil.copy", return_value=None)
+    @patch("os.chmod", return_value=None)
+    @patch("builtins.open")
+    @patch("subprocess.call", return_value=0)
+    @patch("os.makedirs", return_value=None)
+    def test_install_hook_missing_path(
+        self,
+        _mock_mkdir,
+        _mock_call,
+        _mock_open,
+        _mock_chmod,
+        _mock_shutil,
+        _mock_print,
+    ):
+        """Test install hook function, but some paths are missing"""
+        with patch("os.path.exists", return_value=False):
+            self.installer.install()
+
+    @patch("builtins.print")
+    @patch("os.remove", return_value=None)
+    @patch("builtins.open")
+    @patch("amd_debug.installer.get_distro", return_value="ubuntu")
+    @patch("subprocess.call", return_value=0)
+    def test_remove_hook(
+        self, _mock_call, _mock_get_distro, _mock_open, _mock_remove, _mock_print
+    ):
+        """Test remove hook function"""
+        with patch("os.path.exists", return_value=True):
+            self.installer.remove()
+
+    @patch("builtins.print")
+    @patch("os.path.exists", return_value=False)
+    @patch("subprocess.call", return_value=0)
+    def test_remove_hook_missing_path(self, _mock_call, _mock_exists, _mock_print):
+        """Test remove hook function when the file is missing"""
+        self.installer.remove()
+
+    @patch("builtins.print")
+    @patch("subprocess.call", return_value=0)
+    def test_already_installed_iasl(self, _mock_call, _mock_print):
+        """Test that an already installed iasl is found"""
+        self.installer.set_requirements("iasl")
+        ret = self.installer.install_dependencies()
+        self.assertTrue(ret)
+
+    @patch("builtins.print")
+    @patch("amd_debug.installer.get_distro", return_value="ubuntu")
+    @patch("os.execvp", return_value=None)
+    @patch("subprocess.check_call", return_value=0)
+    @patch("subprocess.call", return_value=1)
+    def test_install_iasl_ubuntu(
+        self, _mock_call, _mock_check_call, _mock_distro, _fake_sudo, _mock_print
+    ):
+        """Test install requirements function"""
+        self.installer.set_requirements("iasl")
+        ret = self.installer.install_dependencies()
+        _mock_check_call.assert_called_once_with(["apt", "install", "acpica-tools"])
+        self.assertTrue(ret)
+
+    @patch("builtins.print")
+    @patch("amd_debug.installer.get_distro", return_value="fedora")
+    @patch(
+        "builtins.open", new_callable=mock_open, read_data="VARIANT_ID=workstation\n"
+    )
+    @patch("os.execvp", return_value=None)
+    @patch("subprocess.check_call", return_value=0)
+    @patch("subprocess.call", return_value=1)
+    def test_install_iasl_fedora(
+        self,
+        _mock_call,
+        _mock_check_call,
+        _mock_variant,
+        _mock_distro,
+        _fake_sudo,
+        _mock_print,
+    ):
+        """Test install requirements function"""
+        self.installer.set_requirements("iasl")
+        ret = self.installer.install_dependencies()
+        _mock_check_call.assert_called_once_with(
+            ["dnf", "install", "-y", "acpica-tools"]
+        )
+        self.assertTrue(ret)
+
+    @patch("builtins.print")
+    @patch("amd_debug.installer.get_distro", return_value="ubuntu")
+    @patch("os.execvp", return_value=None)
+    @patch("subprocess.check_call", return_value=0)
+    @patch("subprocess.call", return_value=1)
+    def test_install_ethtool_ubuntu(
+        self, _mock_call, _mock_check_call, _mock_distro, _fake_sudo, _mock_print
+    ):
+        """Test install requirements function"""
+        self.installer.set_requirements("ethtool")
+        ret = self.installer.install_dependencies()
+        _mock_check_call.assert_called_once_with(["apt", "install", "ethtool"])
+        self.assertTrue(ret)
+
+    @patch("builtins.print")
+    @patch("amd_debug.installer.get_distro", return_value="fedora")
+    @patch(
+        "builtins.open", new_callable=mock_open, read_data="VARIANT_ID=workstation\n"
+    )
+    @patch("os.execvp", return_value=None)
+    @patch("subprocess.check_call", return_value=0)
+    @patch("subprocess.call", return_value=1)
+    def test_install_ethtool_fedora(
+        self,
+        _mock_call,
+        _mock_check_call,
+        _mock_variant,
+        _mock_distro,
+        _fake_sudo,
+        _mock_print,
+    ):
+        """Test install requirements function"""
+        self.installer.set_requirements("ethtool")
+        ret = self.installer.install_dependencies()
+        _mock_check_call.assert_called_once_with(["dnf", "install", "-y", "ethtool"])
+        self.assertTrue(ret)
+
+    @patch("builtins.print")
+    @patch("amd_debug.installer.get_distro", return_value="arch")
+    @patch("os.execvp", return_value=None)
+    @patch("subprocess.check_call", return_value=0)
+    @patch("subprocess.call", return_value=1)
+    def test_install_ethtool_arch(
+        self,
+        _mock_call,
+        _mock_check_call,
+        _mock_distro,
+        _fake_sudo,
+        _mock_print,
+    ):
+        """Test install requirements function"""
+        self.installer.set_requirements("ethtool")
+        ret = self.installer.install_dependencies()
+        _mock_check_call.assert_called_once_with(["pacman", "-Sy", "ethtool"])
+        self.assertTrue(ret)
+
+    @patch("builtins.print")
+    @patch("os.path.exists", return_value=False)
+    @patch("os.execvp", return_value=None)
+    @patch("amd_debug.installer.get_distro", return_value="gentoo")
+    @patch("subprocess.call", return_value=1)
+    def test_install_iasl_gentoo(
+        self, _mock_call, _mock_distro, _fake_sudo, _mock_exists, _mock_print
+    ):
+        """Test install requirements function"""
+        self.installer.set_requirements("iasl", "ethtool")
+        ret = self.installer.install_dependencies()
+        self.assertFalse(ret)
+
+    @patch("builtins.print")
+    @patch("amd_debug.installer.get_distro", return_value="ubuntu")
+    @patch("os.execvp", return_value=None)
+    @patch("subprocess.check_call", return_value=0)
+    @patch("subprocess.call", return_value=1)
+    def test_install_edid_decode_ubuntu(
+        self, _mock_call, _mock_check_call, _mock_distro, _fake_sudo, _mock_print
+    ):
+        """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"])
+        self.assertTrue(ret)
+
+    @patch("builtins.print")
+    @patch("amd_debug.installer.get_distro", return_value="fedora")
+    @patch(
+        "builtins.open", new_callable=mock_open, read_data="VARIANT_ID=workstation\n"
+    )
+    @patch("os.execvp", return_value=None)
+    @patch("subprocess.check_call", return_value=0)
+    @patch("subprocess.call", return_value=1)
+    def test_install_edid_decode_fedora(
+        self,
+        _mock_call,
+        _mock_check_call,
+        _mock_variant,
+        _mock_distro,
+        _fake_sudo,
+        _mock_print,
+    ):
+        """Test install requirements function for edid-decode on Fedora"""
+        self.installer.set_requirements("edid-decode")
+        ret = self.installer.install_dependencies()
+        _mock_check_call.assert_called_once_with(
+            ["dnf", "install", "-y", "edid-decode"]
+        )
+        self.assertTrue(ret)
+
+    @patch("builtins.print")
+    @patch("amd_debug.installer.get_distro", return_value="arch")
+    @patch("os.execvp", return_value=None)
+    @patch("subprocess.check_call", return_value=0)
+    @patch("subprocess.call", return_value=1)
+    def test_install_edid_decode_arch(
+        self,
+        _mock_call,
+        _mock_check_call,
+        _mock_distro,
+        _fake_sudo,
+        _mock_print,
+    ):
+        """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)
+
+    @patch("builtins.print")
+    @patch("os.path.exists", return_value=False)
+    @patch("os.execvp", return_value=None)
+    @patch("amd_debug.installer.get_distro", return_value="gentoo")
+    @patch("subprocess.call", return_value=1)
+    def test_install_edid_decode_gentoo(
+        self, _mock_call, _mock_distro, _fake_sudo, _mock_exists, _mock_print
+    ):
+        """Test install requirements function for edid-decode on unsupported distro"""
+        self.installer.set_requirements("edid-decode")
+        ret = self.installer.install_dependencies()
+        self.assertFalse(ret)
+
+    @patch("builtins.print")
+    @patch("os.path.exists", return_value=False)
+    @patch("os.execvp", return_value=None)
+    @patch("amd_debug.installer.get_distro", return_value="gentoo")
+    @patch("subprocess.call", return_value=255)
+    def test_install_edid_decode_present(
+        self, _mock_call, _mock_distro, _fake_sudo, _mock_exists, _mock_print
+    ):
+        """Test install requirements function for edid-decode on unsupported distro"""
+        self.installer.set_requirements("edid-decode")
+        ret = self.installer.install_dependencies()
+        self.assertTrue(ret)