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

test_installer.py

@@ -0,0 +1,281 @@
+#!/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.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_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", "libdisplay-info-bin"]
+        )
+        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", "libdisplay-info"]
+        )
+        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_called_once_with(["pacman", "-Sy", "libdisplay-info"])
+        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_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.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=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)

test_kernel.py

@@ -0,0 +1,205 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+
+"""
+This module contains unit tests for the kernel log functions in the amd-debug-tools package.
+"""
+from unittest.mock import patch, mock_open
+
+import unittest
+import logging
+
+from amd_debug.kernel import sscanf_bios_args, get_kernel_command_line, DmesgLogger
+
+
+class TestKernelLog(unittest.TestCase):
+    """Test Common kernel scan functions"""
+
+    @classmethod
+    def setUpClass(cls):
+        logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
+
+    def test_get_kernel_command_line(self):
+        """Test get_kernel_command_line function"""
+
+        # Test case with a valid kernel command line that is fully filtered
+        kernel_cmdline = "quiet splash"
+        expected_output = ""
+        with patch(
+            "builtins.open", new_callable=mock_open, read_data=kernel_cmdline
+        ) as _mock_file:
+            result = get_kernel_command_line()
+            self.assertEqual(result, expected_output)
+
+        # Test case with an empty kernel command line
+        kernel_cmdline = ""
+        expected_output = ""
+        with patch(
+            "builtins.open", new_callable=mock_open, read_data=kernel_cmdline
+        ) as _mock_file:
+            result = get_kernel_command_line()
+            self.assertEqual(result, expected_output)
+
+        # Test case with a kernel command line containing special characters
+        kernel_cmdline = "quiet splash --debug=1"
+        expected_output = "--debug=1"
+        with patch(
+            "builtins.open", new_callable=mock_open, read_data=kernel_cmdline
+        ) as _mock_file:
+            result = get_kernel_command_line()
+            self.assertEqual(result, expected_output)
+
+        # Test case with a kernel command line containing special characters
+        kernel_cmdline = "quiet splash initrd=foo modprobe.blacklist=foo"
+        expected_output = "modprobe.blacklist=foo"
+        with patch(
+            "builtins.open", new_callable=mock_open, read_data=kernel_cmdline
+        ) as _mock_file:
+            result = get_kernel_command_line()
+            self.assertEqual(result, expected_output)
+
+    def test_sscanf_bios_args(self):
+        """Test sscanf_bios_args function"""
+
+        # Test case with a valid line
+        line = 'ex_trace_args: "format_string", 0x1234, 0x5678'
+        expected_output = "format_string"
+        result = sscanf_bios_args(line)
+        self.assertEqual(result, expected_output)
+
+        # Test case with an invalid line
+        line = 'invalid_line: "format_string", 0x1234, 0x5678'
+        result = sscanf_bios_args(line)
+        self.assertIsNone(result)
+
+        # Test case with a line containing "Unknown"
+        line = 'ex_trace_args: "format_string", Unknown, 0x5678'
+        expected_output = "format_string"
+        result = sscanf_bios_args(line)
+        self.assertEqual(result, expected_output)
+
+        # make sure that lines with ex_trace_point are not parsed
+        line = 'ex_trace_point: "format_string", 0x1234, 0x5678'
+        result = sscanf_bios_args(line)
+        self.assertTrue(result)
+
+        # test a real post code line
+        line = 'ex_trace_args: "  POST CODE: %X  ACPI TIMER: %X  TIME: %d.%d ms\\n", b0003f33, 83528798, 0, 77, 0, 0'
+        expected_output = "POST CODE: B0003F33  ACPI TIMER: 83528798  TIME: 0.77 ms"
+        result = sscanf_bios_args(line)
+        self.assertEqual(result, expected_output)
+
+        # test a real _REG print
+        line = 'ex_trace_args:  "  OEM-ASL-PCIe Address (0x%X)._REG (%d %d)  PCSA = %d\\n", ec303000, 2, 0, 0, 0, 0'
+        expected_output = "OEM-ASL-PCIe Address (0xEC303000)._REG (2 0)  PCSA = 0"
+        result = sscanf_bios_args(line)
+        self.assertEqual(result, expected_output)
+
+        # test case of too may arguments
+        line = 'ex_trace_args         :  "  APGE                  = %d\\n", 1, 0, 0, 0, 0, 0'
+        expected_output = "APGE                  = 1"
+        result = sscanf_bios_args(line)
+        self.assertEqual(result, expected_output)
+
+        # test case for Dispatch notify
+        line = "evmisc-0132 ev_queue_notify_reques: Dispatching Notify on [UBTC] (Device) Value 0x80 (Status Change) Node 00000000851b15c1"
+        expected_output = (
+            "Dispatching Notify on [UBTC] (Device) Value 0x80 (Status Change)"
+        )
+        result = sscanf_bios_args(line)
+        self.assertEqual(result, expected_output)
+
+
+class TestDmesgLogger(unittest.TestCase):
+    """Test Dmesg logger functions"""
+
+    @classmethod
+    def setUpClass(cls):
+        logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
+
+    def test_dmesg_logger_initialization(self):
+        """Test initialization of DmesgLogger"""
+
+        with patch("subprocess.run") as mock_run:
+            # Mock the subprocess output for dmesg -h
+            mock_run.return_value.stdout = b"--since supported\n"
+            mock_run.return_value.returncode = 0
+
+            logger = DmesgLogger()
+            self.assertTrue(logger.since_support)
+            self.assertEqual(logger.command, ["dmesg", "-t", "-k"])
+
+    def test_dmesg_logger_refresh_head(self):
+        """Test _refresh_head method of DmesgLogger"""
+
+        with patch("subprocess.run") as mock_run:
+            # Mock the subprocess output for dmesg
+            mock_run.return_value.stdout = b"line1\nline2\n"
+            mock_run.return_value.returncode = 0
+
+            logger = DmesgLogger()
+            logger._refresh_head()  # pylint: disable=protected-access
+            self.assertEqual(logger.buffer, "line1\nline2\n")
+
+    def test_dmesg_logger_seek_tail(self):
+        """Test seek_tail method of DmesgLogger"""
+
+        with patch("subprocess.run") as mock_run:
+            # Mock the subprocess output for dmesg
+            mock_run.return_value.stdout = b"line1\nline2\n"
+            mock_run.return_value.returncode = 0
+
+            logger = DmesgLogger()
+            logger.seek_tail()
+            self.assertEqual(logger.buffer, "line1\nline2\n")
+
+    def test_dmesg_logger_process_callback(self):
+        """Test process_callback method of DmesgLogger"""
+
+        with patch("subprocess.run") as mock_run:
+            # Mock the subprocess output for dmesg
+            mock_run.return_value.stdout = b"line1\nline2\n"
+            mock_run.return_value.returncode = 0
+
+            logger = DmesgLogger()
+            logger._refresh_head()  # pylint: disable=protected-access
+
+            mock_callback = unittest.mock.Mock()
+            logger.process_callback(mock_callback)
+
+            mock_callback.assert_any_call("line1", None)
+            mock_callback.assert_any_call("line2", None)
+
+    def test_dmesg_logger_match_line(self):
+        """Test match_line method of DmesgLogger"""
+
+        with patch("subprocess.run") as mock_run:
+            # Mock the subprocess output for dmesg
+            mock_run.return_value.stdout = b"line1\nline2\n"
+            mock_run.return_value.returncode = 0
+
+            logger = DmesgLogger()
+            logger._refresh_head()  # pylint: disable=protected-access
+
+            result = logger.match_line(["line1"])
+            self.assertEqual(result, "line1")
+
+            result = logger.match_line(["nonexistent"])
+            self.assertEqual(result, "")
+
+    def test_dmesg_logger_match_pattern(self):
+        """Test match_pattern method of DmesgLogger"""
+
+        with patch("subprocess.run") as mock_run:
+            # Mock the subprocess output for dmesg
+            mock_run.return_value.stdout = b"line1\nline2\n"
+            mock_run.return_value.returncode = 0
+
+            logger = DmesgLogger()
+            logger._refresh_head()  # pylint: disable=protected-access
+
+            result = logger.match_pattern(r"line\d")
+            self.assertEqual(result, "line1")
+
+            result = logger.match_pattern(r"nonexistent")
+            self.assertEqual(result, "")

test_launcher.py

@@ -0,0 +1,53 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+
+"""
+This module contains unit tests for the launcher in the amd-debug-tools package.
+"""
+from unittest.mock import patch
+
+import logging
+import unittest
+
+import amd_debug
+
+
+class TestLauncher(unittest.TestCase):
+    """Test launcher functions"""
+
+    @classmethod
+    def setUpClass(cls):
+        logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
+
+    def setUp(self):
+        launcher = None
+
+    def test_launcher_unknown(self):
+        """Test launching as unknown exe"""
+
+        with patch("builtins.print") as mock_print:
+            amd_debug.launch_tool("unknown_exe.py")
+            mock_print.assert_called_once_with(
+                "\033[91mUnknown exe: unknown_exe.py\033[0m"
+            )
+
+    def test_launcher_amd_s2idle(self):
+        """Test launching amd_s2idle"""
+
+        with patch("amd_debug.s2idle.main") as mock_main:
+            amd_debug.launch_tool("amd_s2idle.py")
+            mock_main.assert_called_once()
+
+    def test_launcher_amd_bios(self):
+        """Test launching amd_bios"""
+
+        with patch("amd_debug.bios.main") as mock_main:
+            amd_debug.launch_tool("amd_bios.py")
+            mock_main.assert_called_once()
+
+    def test_launcher_amd_pstate(self):
+        """Test launching amd_pstate"""
+
+        with patch("amd_debug.pstate.main") as mock_main:
+            amd_debug.launch_tool("amd_pstate.py")
+            mock_main.assert_called_once()