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

test_common.py

@@ -0,0 +1,332 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+
+"""
+This module contains unit tests for the common functions in the amd-debug-tools package.
+"""
+from unittest.mock import patch, mock_open, call
+
+import logging
+import tempfile
+import unittest
+import os
+from platform import uname_result
+
+
+from amd_debug.common import (
+    apply_prefix_wrapper,
+    Colors,
+    colorize_choices,
+    check_lockdown,
+    compare_file,
+    fatal_error,
+    get_distro,
+    get_log_priority,
+    get_pretty_distro,
+    is_root,
+    minimum_kernel,
+    print_color,
+    run_countdown,
+    systemd_in_use,
+    running_ssh,
+)
+
+color_dict = {
+    "🚦": Colors.WARNING,
+    "🦟": Colors.DEBUG,
+    "❌": Colors.FAIL,
+    "👀": Colors.FAIL,
+    "✅": Colors.OK,
+    "🔋": Colors.OK,
+    "🐧": Colors.OK,
+    "💻": Colors.OK,
+    "○": Colors.OK,
+    "💤": Colors.OK,
+    "💯": Colors.UNDERLINE,
+    "🗣️": Colors.HEADER,
+}
+
+
+class TestCommon(unittest.TestCase):
+    """Test common functions"""
+
+    @classmethod
+    def setUpClass(cls):
+        logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
+
+    def test_read_compare_file(self):
+        """Test read_file and compare_file strip files correctly"""
+
+        f = tempfile.NamedTemporaryFile()
+        f.write("foo bar baz\n ".encode("utf-8"))
+        f.seek(0)
+        self.assertTrue(compare_file(f.name, "foo bar baz"))
+
+    def test_countdown(self):
+        """Test countdown function"""
+
+        result = run_countdown("Full foo", 1)
+        self.assertTrue(result)
+        result = run_countdown("Half foo", 0.5)
+        self.assertTrue(result)
+        result = run_countdown("No foo", 0)
+        self.assertTrue(result)
+        result = run_countdown("Negative foo", -1)
+        self.assertFalse(result)
+
+    @patch("os.path.exists", return_value=True)
+    @patch("builtins.open", new_callable=mock_open, read_data="ID=foo\nVERSION_ID=bar")
+    def test_get_distro_known(self, mock_exists, _mock_open):
+        """Test get_distro function"""
+        distro = get_distro()
+        mock_exists.assert_has_calls(
+            [
+                call("/etc/os-release", "r", encoding="utf-8"),
+                call().__enter__(),
+                call().__iter__(),
+                call().__exit__(None, None, None),
+            ]
+        )
+        self.assertEqual(distro, "foo")
+
+    @patch("os.path.exists", return_value=False)
+    def test_get_distro_unknown(self, mock_exists):
+        """Test get_distro function"""
+        distro = get_distro()
+        mock_exists.assert_has_calls(
+            [
+                call("/etc/os-release"),
+                call("/etc/arch-release"),
+                call("/etc/fedora-release"),
+                call("/etc/debian_version"),
+            ]
+        )
+        self.assertEqual(distro, "unknown")
+
+    @patch("os.path.exists", return_value=True)
+    @patch("builtins.open", new_callable=mock_open, read_data="PRETTY_NAME=Foo")
+    def test_get_pretty_distro_known(self, mock_exists, _mock_open):
+        """Test get_distro function"""
+        distro = get_pretty_distro()
+        self.assertEqual(distro, "Foo")
+        mock_exists.assert_has_calls(
+            [
+                call("/etc/os-release", "r", encoding="utf-8"),
+                call().__enter__(),
+                call().__iter__(),
+                call().__exit__(None, None, None),
+            ]
+        )
+
+    @patch("os.path.exists", return_value=False)
+    def test_get_pretty_distro_unknown(self, mock_exists):
+        """Test get_distro function"""
+        distro = get_pretty_distro()
+        self.assertEqual(distro, "Unknown")
+        mock_exists.assert_has_calls(
+            [
+                call("/etc/os-release"),
+            ]
+        )
+
+    @patch("os.path.exists", return_value=True)
+    @patch(
+        "builtins.open",
+        new_callable=mock_open,
+        read_data="[none] integrity confidentiality",
+    )
+    def test_lockdown_pass(self, mock_exists, _mock_file):
+        """Test lockdown function"""
+        lockdown = check_lockdown()
+        mock_exists.assert_called_once_with(
+            "/sys/kernel/security/lockdown", "r", encoding="utf-8"
+        )
+        self.assertFalse(lockdown)
+
+    @patch("os.path.exists", return_value=True)
+    @patch(
+        "builtins.open",
+        new_callable=mock_open,
+        read_data="none [integrity] confidentiality",
+    )
+    def test_lockdown_fail_integrity(self, mock_exists, _mock_file):
+        """Test lockdown function"""
+        lockdown = check_lockdown()
+        mock_exists.assert_called_once_with(
+            "/sys/kernel/security/lockdown", "r", encoding="utf-8"
+        )
+        self.assertTrue(lockdown)
+
+    @patch("os.path.exists", return_value=True)
+    @patch(
+        "builtins.open",
+        new_callable=mock_open,
+        read_data="none integrity [confidentiality]",
+    )
+    def test_lockdown_fail_confidentiality(self, mock_exists, _mock_file):
+        """Test lockdown function"""
+        lockdown = check_lockdown()
+        mock_exists.assert_called_once_with(
+            "/sys/kernel/security/lockdown", "r", encoding="utf-8"
+        )
+        self.assertTrue(lockdown)
+
+    @patch("os.path.exists", return_value=False)
+    def test_lockdown_missing(self, mock_exists):
+        """Test lockdown function"""
+        lockdown = check_lockdown()
+        mock_exists.assert_called_once_with("/sys/kernel/security/lockdown")
+        self.assertFalse(lockdown)
+
+    @patch("builtins.print")
+    def test_print_color(self, mocked_print):
+        """Test print_color function for all expected levels"""
+        message = "foo"
+        # test all color groups
+        for group, color in color_dict.items():
+            prefix = f"{group} "
+            print_color(message, group)
+            mocked_print.assert_called_once_with(
+                f"{prefix}{color}{message}{Colors.ENDC}"
+            )
+            mocked_print.reset_mock()
+
+        # call without a group
+        print_color(message, Colors.WARNING)
+        mocked_print.assert_called_once_with(f"{Colors.WARNING}{message}{Colors.ENDC}")
+        mocked_print.reset_mock()
+
+        # test dumb terminal
+        os.environ["TERM"] = "dumb"
+        print_color(message, Colors.WARNING)
+        mocked_print.assert_called_once_with(f"{message}")
+
+    @patch("builtins.print")
+    def test_fatal_error(self, mocked_print):
+        """Test fatal_error function"""
+        with patch("sys.exit") as mock_exit:
+            fatal_error("foo")
+            mocked_print.assert_called_once_with(f"👀 {Colors.FAIL}foo{Colors.ENDC}")
+            mock_exit.assert_called_once_with(1)
+
+    @patch("os.geteuid", return_value=0)
+    def test_is_root_true(self, mock_geteuid):
+        """Test is_root function when user is root"""
+        self.assertTrue(is_root())
+        mock_geteuid.assert_called_once()
+        self.assertEqual(mock_geteuid.call_count, 1)
+
+    @patch("os.geteuid", return_value=1000)
+    def test_is_root_false(self, mock_geteuid):
+        """Test is_root function when user is not root"""
+        self.assertFalse(is_root())
+        mock_geteuid.assert_called_once()
+        self.assertEqual(mock_geteuid.call_count, 1)
+
+    def test_get_log_priority(self):
+        """Test get_log_priority works for expected values"""
+        ret = get_log_priority(None)
+        self.assertEqual(ret, "○")
+        ret = get_log_priority("foo")
+        self.assertEqual(ret, "foo")
+        ret = get_log_priority("3")
+        self.assertEqual(ret, "❌")
+        ret = get_log_priority(4)
+        self.assertEqual(ret, "🚦")
+        ret = get_log_priority(7)
+        self.assertEqual(ret, "🦟")
+
+    def test_minimum_kernel(self):
+        """Test minimum_kernel function"""
+        with patch("platform.uname") as mock_uname:
+            mock_uname.return_value = uname_result(
+                system="Linux",
+                node="foo",
+                release="6.12.0-rc5",
+                version="baz",
+                machine="x86_64",
+            )
+            self.assertTrue(minimum_kernel("6", "12"))
+            self.assertFalse(minimum_kernel("6", "13"))
+            self.assertTrue(minimum_kernel(5, 1))
+            self.assertFalse(minimum_kernel(7, 1))
+            with self.assertRaises(ValueError):
+                minimum_kernel("foo", "bar")
+            with self.assertRaises(TypeError):
+                minimum_kernel(None, None)
+
+    def test_systemd_in_use(self):
+        """Test systemd_in_use function"""
+        with patch(
+            "builtins.open", new_callable=mock_open, read_data="systemd"
+        ) as mock_file:
+            self.assertTrue(systemd_in_use())
+            mock_file.assert_called_once_with("/proc/1/comm", "r", encoding="utf-8")
+        with patch(
+            "builtins.open", new_callable=mock_open, read_data="upstart"
+        ) as mock_file:
+            self.assertFalse(systemd_in_use())
+            mock_file.assert_called_once_with("/proc/1/comm", "r", encoding="utf-8")
+
+    def test_running_in_ssh(self):
+        """Test running_in_ssh function"""
+        with patch("os.environ", {"SSH_TTY": "/dev/pts/0"}):
+            self.assertTrue(running_ssh())
+        with patch("os.environ", {}):
+            self.assertFalse(running_ssh())
+
+    def test_apply_prefix_wrapper(self):
+        """Test apply_prefix_wrapper function"""
+        header = "Header:"
+        message = "Line 1\nLine 2\nLine 3"
+        expected_output = "Header:\n" "│ Line 1\n" "│ Line 2\n" "└─ Line 3\n"
+        self.assertEqual(apply_prefix_wrapper(header, message), expected_output)
+
+        # Test with a single line message
+        message = "Single Line"
+        expected_output = "Header:\n└─ Single Line\n"
+        self.assertEqual(apply_prefix_wrapper(header, message), expected_output)
+
+        # Test with an empty message
+        message = ""
+        expected_output = "Header:\n"
+        self.assertEqual(apply_prefix_wrapper(header, message), expected_output)
+
+        # Test with leading/trailing whitespace in the message
+        message = "  Line 1\nLine 2  \n  Line 3  "
+        expected_output = "Header:\n" "│ Line 1\n" "│ Line 2\n" "└─ Line 3\n"
+        self.assertEqual(apply_prefix_wrapper(header, message), expected_output)
+
+    def test_colorize_choices_with_default(self):
+        """Test colorize_choices function with a default value"""
+        choices = ["option1", "option2", "option3"]
+        default = "option2"
+        expected_output = f"{Colors.OK}{default}{Colors.ENDC}, option1, option3"
+        self.assertEqual(colorize_choices(choices, default), expected_output)
+
+    def test_colorize_choices_without_default(self):
+        """Test colorize_choices function when default is not in choices"""
+        choices = ["option1", "option2", "option3"]
+        default = "option4"
+        with self.assertRaises(ValueError) as context:
+            colorize_choices(choices, default)
+        self.assertEqual(
+            str(context.exception), "Default choice 'option4' not in choices"
+        )
+
+    def test_colorize_choices_empty_list(self):
+        """Test colorize_choices function with an empty list"""
+        choices = []
+        default = "option1"
+        with self.assertRaises(ValueError) as context:
+            colorize_choices(choices, default)
+        self.assertEqual(
+            str(context.exception), "Default choice 'option1' not in choices"
+        )
+
+    def test_colorize_choices_single_choice(self):
+        """Test colorize_choices function with a single choice"""
+        choices = ["option1"]
+        default = "option1"
+        expected_output = f"{Colors.OK}{default}{Colors.ENDC}"
+        self.assertEqual(colorize_choices(choices, default), expected_output)

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)