blob: c07b547782c625491e6ea278b962c8c032990a2b [file]
#!/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, Mock
import asyncio
import builtins
import logging
import tempfile
import unittest
import os
from platform import uname_result
import sys
from amd_debug.common import (
apply_prefix_wrapper,
bytes_to_gb,
Colors,
convert_string_to_bool,
colorize_choices,
check_lockdown,
compare_file,
find_ip_version,
fatal_error,
gb_to_pages,
get_distro,
get_log_priority,
get_pretty_distro,
get_system_mem,
is_root,
minimum_kernel,
print_color,
read_msr,
reboot,
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.UNDERLINE,
"🗣️": Colors.HEADER,
}
class TestCommon(unittest.TestCase):
"""Test common functions"""
@classmethod
def setUpClass(cls):
logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
def setUp(self):
"""Pin TERM to a known value
print_color reads TERM from the environment, so the tests would
otherwise depend on the terminal the test suite is invoked from.
"""
self.saved_term = os.environ.pop("TERM", None)
os.environ["TERM"] = "xterm"
def tearDown(self):
"""Restore the original TERM value"""
if self.saved_term is None:
os.environ.pop("TERM", None)
else:
os.environ["TERM"] = self.saved_term
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)
@patch("amd_debug.common.os.open", side_effect=OSError)
@patch("amd_debug.common.subprocess.run")
@patch("amd_debug.common.is_root", return_value=True)
@patch("amd_debug.common.os.path.exists", return_value=False)
def test_read_msr_loads_module(
self, mock_exists, mock_is_root, mock_run, mock_open_fd
):
"""Test read_msr loads the msr module via an absolute path and no shell"""
with self.assertRaises(PermissionError):
read_msr(0xC0010292, 0)
mock_run.assert_called_once_with(["/sbin/modprobe", "msr"], check=False)
# ensure the module load never went through a shell
_, kwargs = mock_run.call_args
self.assertNotIn("shell", kwargs)
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_minimum_kernel_with_suffix(self):
"""Test minimum_kernel function with version strings containing suffixes"""
with patch("platform.uname") as mock_uname:
# Test with +unreleased suffix (the bug case)
mock_uname.return_value = uname_result(
system="Linux",
node="foo",
release="7.18+unreleased-amd64",
version="baz",
machine="x86_64",
)
self.assertTrue(minimum_kernel(7, 18))
self.assertTrue(minimum_kernel(7, 17))
self.assertFalse(minimum_kernel(7, 19))
self.assertTrue(minimum_kernel(6, 10))
self.assertFalse(minimum_kernel(8, 0))
# Test with -rc suffix
mock_uname.return_value = uname_result(
system="Linux",
node="foo",
release="6.10-rc1-amd64",
version="baz",
machine="x86_64",
)
self.assertTrue(minimum_kernel(6, 10))
self.assertTrue(minimum_kernel(6, 9))
self.assertFalse(minimum_kernel(6, 11))
# Test with custom build suffix
mock_uname.return_value = uname_result(
system="Linux",
node="foo",
release="5.15+custom-build",
version="baz",
machine="x86_64",
)
self.assertTrue(minimum_kernel(5, 15))
self.assertTrue(minimum_kernel(5, 14))
self.assertFalse(minimum_kernel(5, 16))
# Test with -generic suffix (Ubuntu-style)
mock_uname.return_value = uname_result(
system="Linux",
node="foo",
release="5.4.0-generic",
version="baz",
machine="x86_64",
)
self.assertTrue(minimum_kernel(5, 4))
self.assertTrue(minimum_kernel(5, 3))
self.assertFalse(minimum_kernel(5, 5))
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)
@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")
def test_bytes_to_gb(self):
"""Test bytes_to_gb conversion"""
# 4096 bytes should be 4096*4096/(1024*1024*1024) GB
self.assertAlmostEqual(bytes_to_gb(1), 4096 / (1024 * 1024 * 1024))
self.assertAlmostEqual(bytes_to_gb(0), 0)
self.assertAlmostEqual(bytes_to_gb(1024), 1024 * 4096 / (1024 * 1024 * 1024))
def test_gb_to_pages(self):
"""Test gb_to_pages conversion"""
# 1 GB should be int(1 * (1024*1024*1024) / 4096)
self.assertEqual(gb_to_pages(1), int((1024 * 1024 * 1024) / 4096))
self.assertEqual(gb_to_pages(0), 0)
self.assertEqual(gb_to_pages(2), int(2 * (1024 * 1024 * 1024) / 4096))
@patch(
"builtins.open",
new_callable=mock_open,
read_data="MemTotal: 16384516 kB\n",
)
@patch("os.path.join", return_value="/proc/meminfo")
def test_get_system_mem_valid(self, _mock_join, mock_file):
"""Test get_system_mem returns correct value"""
expected_gb = 16384516 / (1024 * 1024)
self.assertAlmostEqual(get_system_mem(), expected_gb)
mock_file.assert_called_once_with("/proc/meminfo", "r", encoding="utf-8")
@patch("amd_debug.common.asyncio.run", return_value=True)
def test_reboot_dbus_fast_success(self, mock_asyncio_run):
"""Test reboot returns True when reboot_dbus_fast succeeds"""
result = reboot()
self.assertTrue(result)
mock_asyncio_run.assert_called_once()
@patch("amd_debug.common.asyncio.run", return_value=False)
def test_reboot_dbus_fast_failure_and_dbus_success(self, mock_asyncio_run):
"""Test reboot falls back to reboot_dbus when reboot_dbus_fast fails"""
# Mock the dbus module to avoid ImportError in CI
mock_dbus = Mock()
mock_bus = Mock()
mock_obj = Mock()
mock_intf = Mock()
mock_dbus.SystemBus.return_value = mock_bus
mock_bus.get_object.return_value = mock_obj
mock_obj.get_interface.return_value = mock_intf
mock_dbus.Interface = Mock(return_value=mock_intf)
with patch.dict("sys.modules", {"dbus": mock_dbus}):
result = reboot()
self.assertTrue(result)
@patch("amd_debug.common.asyncio.run", return_value=False)
def test_reboot_dbus_fast_failure_and_dbus_failure(self, mock_asyncio_run):
"""Test reboot returns False when both reboot_dbus_fast and reboot_dbus fail"""
# Mock the import to raise ImportError when dbus is imported
original_import = builtins.__import__
def mock_import(name, *args, **kwargs):
if name == "dbus":
raise ImportError("No module named 'dbus'")
return original_import(name, *args, **kwargs)
with patch("builtins.__import__", side_effect=mock_import):
result = reboot()
self.assertFalse(result)