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

test_database.py

@@ -0,0 +1,284 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+
+"""
+This module contains unit tests for the datbase functions in the amd-debug-tools package.
+"""
+import unittest
+
+from datetime import datetime
+
+from amd_debug.database import SleepDatabase
+
+
+class TestSleepDatabase(unittest.TestCase):
+    """Test SleepDatabase class"""
+
+    def setUp(self):
+        """Set up mocks and an in-memory database for testing"""
+        # Initialize SleepDatabase after mocks are set up
+        self.db = SleepDatabase(dbf=":memory:")
+
+    def test_start_cycle(self):
+        """Test starting a new sleep cycle"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        self.assertEqual(self.db.last_suspend, timestamp)
+        self.assertEqual(self.db.cycle_data_cnt, 0)
+        self.assertEqual(self.db.debug_cnt, 0)
+
+    def test_record_debug(self):
+        """Test recording a debug message"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        self.db.record_debug("Test debug message", level=5)
+        cur = self.db.db.cursor()
+        cur.execute(
+            "SELECT message, priority FROM debug WHERE t0=?",
+            (int(timestamp.strftime("%Y%m%d%H%M%S")),),
+        )
+        result = cur.fetchone()
+        self.assertEqual(result, ("Test debug message", 5))
+
+    def test_record_battery_energy(self):
+        """Test recording battery energy"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        self.db.record_battery_energy("Battery1", 50, 100, "mWh")
+        cur = self.db.db.cursor()
+        cur.execute(
+            "SELECT name, b0, b1, full, unit FROM battery WHERE t0=?",
+            (int(timestamp.strftime("%Y%m%d%H%M%S")),),
+        )
+        result = cur.fetchone()
+        self.assertEqual(result, ("Battery1", 50, None, 100, "mWh"))
+
+    def test_record_cycle_data(self):
+        """Test recording cycle data"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        self.db.record_cycle_data("Test cycle data", "symbol1")
+        cur = self.db.db.cursor()
+        cur.execute(
+            "SELECT message, symbol FROM cycle_data WHERE t0=?",
+            (int(timestamp.strftime("%Y%m%d%H%M%S")),),
+        )
+        result = cur.fetchone()
+        self.assertEqual(result, ("Test cycle data", "symbol1"))
+
+    def test_record_cycle(self):
+        """Test recording a sleep cycle"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        self.db.record_cycle(
+            requested_duration=100,
+            active_gpios="GPIO1",
+            wakeup_irqs="IRQ1",
+            kernel_duration=1.5,
+            hw_sleep_duration=2.5,
+        )
+        cur = self.db.db.cursor()
+        cur.execute(
+            "SELECT requested, gpio, wake_irq, kernel, hw FROM cycle WHERE t0=?",
+            (int(timestamp.strftime("%Y%m%d%H%M%S")),),
+        )
+        result = cur.fetchone()
+        self.assertEqual(result, (100, "GPIO1", "IRQ1", 1.5, 2.5))
+
+    def test_report_debug(self):
+        """Test reporting debug messages"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        self.db.record_debug("Test debug message", level=5)
+        result = self.db.report_debug(timestamp)
+        self.assertEqual(result, [("Test debug message", 5)])
+
+    def test_report_battery(self):
+        """Test reporting battery data"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        self.db.record_battery_energy("Battery1", 50, 100, "mWh")
+        result = self.db.report_battery(timestamp)
+        self.assertEqual(
+            result,
+            [
+                (
+                    int(timestamp.strftime("%Y%m%d%H%M%S")),
+                    "Battery1",
+                    50,
+                    None,
+                    100,
+                    "mWh",
+                )
+            ],
+        )
+
+    def test_record_prereq(self):
+        """Test recording a prereq message"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        self.db.record_prereq("Test prereq message", "symbol1")
+        cur = self.db.db.cursor()
+        cur.execute(
+            "SELECT message, symbol FROM prereq_data WHERE t0=?",
+            (int(timestamp.strftime("%Y%m%d%H%M%S")),),
+        )
+        result = cur.fetchone()
+        self.assertEqual(result, ("Test prereq message", "symbol1"))
+
+    def test_report_prereq(self):
+        """Test reporting prereq messages"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        self.db.record_prereq("Test prereq message 1", "symbol1")
+        self.db.record_prereq("Test prereq message 2", "symbol2")
+        result = self.db.report_prereq(timestamp)
+        self.assertEqual(
+            result,
+            [
+                (
+                    int(timestamp.strftime("%Y%m%d%H%M%S")),
+                    0,
+                    "Test prereq message 1",
+                    "symbol1",
+                ),
+                (
+                    int(timestamp.strftime("%Y%m%d%H%M%S")),
+                    1,
+                    "Test prereq message 2",
+                    "symbol2",
+                ),
+            ],
+        )
+
+    def test_report_prereq_no_data(self):
+        """Test reporting prereq messages when no data exists"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        result = self.db.report_prereq(timestamp)
+        self.assertEqual(result, [])
+
+    def test_report_prereq_none_timestamp(self):
+        """Test reporting prereq messages with None timestamp"""
+        result = self.db.report_prereq(None)
+        self.assertEqual(result, [])
+
+    def test_report_cycle(self):
+        """Test reporting a cycle from the database"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        self.db.record_cycle(
+            requested_duration=100,
+            active_gpios="GPIO1",
+            wakeup_irqs="IRQ1",
+            kernel_duration=1.5,
+            hw_sleep_duration=2.5,
+        )
+        result = self.db.report_cycle(timestamp)
+        self.assertEqual(
+            result,
+            [
+                (
+                    int(timestamp.strftime("%Y%m%d%H%M%S")),
+                    int(datetime.now().strftime("%Y%m%d%H%M%S")),
+                    100,
+                    "GPIO1",
+                    "IRQ1",
+                    1.5,
+                    2.5,
+                )
+            ],
+        )
+
+    def test_report_cycle_no_data(self):
+        """Test reporting a cycle when no data exists"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        result = self.db.report_cycle(timestamp)
+        self.assertEqual(result, [])
+
+    def test_report_cycle_none_timestamp(self):
+        """Test reporting a cycle with None timestamp"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        self.db.record_cycle(
+            requested_duration=100,
+            active_gpios="GPIO1",
+            wakeup_irqs="IRQ1",
+            kernel_duration=1.5,
+            hw_sleep_duration=2.5,
+        )
+        result = self.db.report_cycle(None)
+        self.assertEqual(
+            result,
+            [
+                (
+                    int(timestamp.strftime("%Y%m%d%H%M%S")),
+                    int(datetime.now().strftime("%Y%m%d%H%M%S")),
+                    100,
+                    "GPIO1",
+                    "IRQ1",
+                    1.5,
+                    2.5,
+                )
+            ],
+        )
+
+    def test_get_last_cycle(self):
+        """Test getting the last cycle from the database"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        self.db.record_cycle(
+            requested_duration=100,
+            active_gpios="GPIO1",
+            wakeup_irqs="IRQ1",
+            kernel_duration=1.5,
+            hw_sleep_duration=2.5,
+        )
+        result = self.db.get_last_cycle()
+        self.assertEqual(result, (int(timestamp.strftime("%Y%m%d%H%M%S")),))
+
+    def test_get_last_cycle_no_data(self):
+        """Test getting the last cycle when no data exists"""
+        result = self.db.get_last_cycle()
+        self.assertIsNone(result)
+
+    def test_get_last_prereq_ts(self):
+        """Test getting the last prereq timestamp from the database"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        self.db.record_prereq("Test prereq message 1", "symbol1")
+        self.db.record_prereq("Test prereq message 2", "symbol2")
+        result = self.db.get_last_prereq_ts()
+        self.assertEqual(result, int(timestamp.strftime("%Y%m%d%H%M%S")))
+
+    def test_get_last_prereq_ts_no_data(self):
+        """Test getting the last prereq timestamp when no data exists"""
+        result = self.db.get_last_prereq_ts()
+        self.assertIsNone(result)
+
+    def test_report_cycle_data(self):
+        """Test reporting cycle data"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        self.db.record_cycle_data("Test cycle data 1", "symbol1")
+        self.db.record_cycle_data("Test cycle data 2", "symbol2")
+        result = self.db.report_cycle_data(timestamp)
+        expected_result = "symbol1 Test cycle data 1\nsymbol2 Test cycle data 2\n"
+        self.assertEqual(result, expected_result)
+
+    def test_report_cycle_data_no_data(self):
+        """Test reporting cycle data when no data exists"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        result = self.db.report_cycle_data(timestamp)
+        self.assertEqual(result, "")
+
+    def test_report_cycle_data_none_timestamp(self):
+        """Test reporting cycle data with None timestamp"""
+        timestamp = datetime.now()
+        self.db.start_cycle(timestamp)
+        self.db.record_cycle_data("Test cycle data 1", "symbol1")
+        result = self.db.report_cycle_data(None)
+        expected_result = "symbol1 Test cycle data 1\n"
+        self.assertEqual(result, expected_result)

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),
+            ]
+        )