tests: add unit and functional tests for distro module

Add comprehensive test coverage for the distro module:

- 28 new unit tests covering LinuxDistro, Probe methods, regex patterns,
  SUSEProbe custom logic, register_probe, detect scoring/fallback, Spec
- 1 new functional test for local system detection
- Update TEST_SIZE counts in check.py (unit: 976->1004, functional: 368->369)

Coverage: 95% (untested: remote SSH session paths)

Assisted-By: Cursor-Claude-4-Sonnet
Signed-off-by: Harvey Lynden <hlynden@redhat.com>

Author: harvey0100

selftests/check.py

@@ -27,9 +27,9 @@
     "job-api-check-tmp-directory-exists": 1,
     "nrunner-interface": 90,
     "nrunner-requirement": 28,
-    "unit": 976,
+    "unit": 1004,
     "jobs": 11,
-    "functional-parallel": 368,
+    "functional-parallel": 369,
     "functional-serial": 7,
     "optional-plugins": 0,
     "optional-plugins-golang": 2,

selftests/functional/utils/distro.py

@@ -1,10 +1,12 @@
 import os
+import platform
 
 from avocado import Test
 from avocado.core.exit_codes import AVOCADO_ALL_OK
 from avocado.core.job import Job
 from avocado.core.nrunner.runnable import Runnable
 from avocado.core.suite import TestSuite
+from avocado.utils import distro
 
 
 class Distro(Test):
@@ -64,3 +66,28 @@ def test_debian_12_7(self):
             + os.uname().machine.encode()
             + b") version 12 release 7\n",
         )
+
+
+class DistroDetectLocal(Test):
+    """Tests distro detection on the local system without containers."""
+
+    def test_detect_current_system(self):
+        """Verify detect() returns a valid result for the running system."""
+        result = distro.detect()
+        self.assertIsInstance(result, distro.LinuxDistro)
+        has_release_file = any(
+            os.path.exists(p)
+            for p in [
+                "/etc/os-release",
+                "/etc/redhat-release",
+                "/etc/fedora-release",
+                "/etc/debian_version",
+            ]
+        )
+        if has_release_file:
+            self.assertNotEqual(
+                result.name,
+                distro.UNKNOWN_DISTRO_NAME,
+                "detect() should identify a known distro on this system",
+            )
+            self.assertEqual(result.arch, platform.machine())

selftests/unit/utils/distro.py

@@ -1,9 +1,28 @@
+import os
 import re
+import tempfile
+import unittest
 import unittest.mock
 
 from avocado.utils import distro
 
 
+class LinuxDistroTest(unittest.TestCase):
+    def test_init(self):
+        dist = distro.LinuxDistro("fedora", "38", "0", "x86_64")
+        self.assertEqual(dist.name, "fedora")
+        self.assertEqual(dist.version, "38")
+        self.assertEqual(dist.release, "0")
+        self.assertEqual(dist.arch, "x86_64")
+
+    def test_repr(self):
+        dist = distro.LinuxDistro("rhel", "9", "1", "x86_64")
+        self.assertEqual(
+            repr(dist),
+            "<LinuxDistro: name=rhel, version=9, release=1, arch=x86_64>",
+        )
+
+
 class ProbeTest(unittest.TestCase):
     def test_check_name_for_file_fail(self):
         class MyProbe(distro.Probe):
@@ -68,6 +87,288 @@ class MyProbe(distro.Probe):
             mocked.assert_called_once_with(distro_file)
         self.assertEqual(distro_name, probed_distro_name)
 
+    def test_name_for_file_contains_match(self):
+        fd, tmpfile = tempfile.mkstemp(suffix="-release")
+        with os.fdopen(fd, "w") as tmp:
+            tmp.write("Welcome to MyDistro 5.0\n")
+        self.addCleanup(os.unlink, tmpfile)
+
+        class MyProbe(distro.Probe):
+            CHECK_FILE = tmpfile
+            CHECK_FILE_CONTAINS = "MyDistro"
+            CHECK_FILE_DISTRO_NAME = "mydistro"
+
+        self.assertEqual(MyProbe().name_for_file_contains(), "mydistro")
+
+    def test_name_for_file_contains_no_match(self):
+        fd, tmpfile = tempfile.mkstemp(suffix="-release")
+        with os.fdopen(fd, "w") as tmp:
+            tmp.write("Some other content\n")
+        self.addCleanup(os.unlink, tmpfile)
+
+        class MyProbe(distro.Probe):
+            CHECK_FILE = tmpfile
+            CHECK_FILE_CONTAINS = "MyDistro"
+            CHECK_FILE_DISTRO_NAME = "mydistro"
+
+        self.assertIsNone(MyProbe().name_for_file_contains())
+
+    def test_name_for_file_contains_ioerror(self):
+        class MyProbe(distro.Probe):
+            CHECK_FILE = "/etc/fake-release"
+            CHECK_FILE_CONTAINS = "MyDistro"
+            CHECK_FILE_DISTRO_NAME = "mydistro"
+
+        with unittest.mock.patch(
+            "avocado.utils.distro.os.path.exists", return_value=True
+        ):
+            with unittest.mock.patch(
+                "builtins.open", side_effect=IOError("Permission denied")
+            ):
+                self.assertIsNone(MyProbe().name_for_file_contains())
+
+    def test_version_from_file(self):
+        class MyProbe(distro.Probe):
+            CHECK_FILE = "/etc/fake-release"
+            CHECK_VERSION_REGEX = re.compile(r"Release (\d+)\.(\d+)")
+
+        with unittest.mock.patch(
+            "avocado.utils.distro.os.path.exists", return_value=True
+        ):
+            with unittest.mock.patch(
+                "builtins.open",
+                unittest.mock.mock_open(read_data="Release 9.3\n"),
+            ):
+                self.assertEqual(MyProbe().version(), "9")
+
+    def test_version_no_match(self):
+        class MyProbe(distro.Probe):
+            CHECK_FILE = "/etc/fake-release"
+            CHECK_VERSION_REGEX = re.compile(r"Release (\d+)\.(\d+)")
+
+        with unittest.mock.patch(
+            "avocado.utils.distro.os.path.exists", return_value=True
+        ):
+            with unittest.mock.patch(
+                "builtins.open",
+                unittest.mock.mock_open(read_data="No version here\n"),
+            ):
+                self.assertEqual(MyProbe().version(), distro.UNKNOWN_DISTRO_VERSION)
+
+    def test_release_from_file(self):
+        class MyProbe(distro.Probe):
+            CHECK_FILE = "/etc/fake-release"
+            CHECK_VERSION_REGEX = re.compile(r"Release (\d+)\.(\d+)")
+
+        with unittest.mock.patch(
+            "avocado.utils.distro.os.path.exists", return_value=True
+        ):
+            with unittest.mock.patch(
+                "builtins.open",
+                unittest.mock.mock_open(read_data="Release 9.3\n"),
+            ):
+                self.assertEqual(MyProbe().release(), "3")
+
+    def test_release_single_group(self):
+        class MyProbe(distro.Probe):
+            CHECK_FILE = "/etc/fake-release"
+            CHECK_VERSION_REGEX = re.compile(r"Release (\d+)")
+
+        with unittest.mock.patch(
+            "avocado.utils.distro.os.path.exists", return_value=True
+        ):
+            with unittest.mock.patch(
+                "builtins.open",
+                unittest.mock.mock_open(read_data="Release 9\n"),
+            ):
+                self.assertEqual(MyProbe().release(), distro.UNKNOWN_DISTRO_RELEASE)
+
+    def test_check_release_multiple_groups(self):
+        class MyProbe(distro.Probe):
+            CHECK_FILE = "/etc/fake-release"
+            CHECK_VERSION_REGEX = re.compile(r"Release (\d+)\.(\d+)")
+
+        self.assertTrue(MyProbe().check_release())
+
+    def test_check_release_single_group(self):
+        class MyProbe(distro.Probe):
+            CHECK_FILE = "/etc/fake-release"
+            CHECK_VERSION_REGEX = re.compile(r"Release (\d+)")
+
+        self.assertFalse(MyProbe().check_release())
+
+    def test_get_distro_detected(self):
+        fd, tmpfile = tempfile.mkstemp(suffix="-release")
+        with os.fdopen(fd, "w") as tmp:
+            tmp.write("TestDistro release 5.2 (Final)\n")
+        self.addCleanup(os.unlink, tmpfile)
+
+        class MyProbe(distro.Probe):
+            CHECK_FILE = tmpfile
+            CHECK_FILE_CONTAINS = "TestDistro"
+            CHECK_FILE_DISTRO_NAME = "testdistro"
+            CHECK_VERSION_REGEX = re.compile(r"TestDistro release (\d+)\.(\d+).*")
+
+        result = MyProbe().get_distro()
+        self.assertEqual(result.name, "testdistro")
+        self.assertEqual(result.version, "5")
+        self.assertEqual(result.release, "2")
+
+    def test_get_distro_unknown(self):
+        result = distro.Probe().get_distro()
+        self.assertIs(result, distro.UNKNOWN_DISTRO)
+
+    def test_check_for_remote_file_found(self):
+        mock_session = unittest.mock.MagicMock()
+        mock_session.cmd.return_value.exit_status = 0
+        probe = distro.Probe(session=mock_session)
+        self.assertTrue(probe.check_for_remote_file("/etc/some-file"))
+        mock_session.cmd.assert_called_once_with("test -f /etc/some-file")
+
+    def test_check_for_remote_file_not_found(self):
+        mock_session = unittest.mock.MagicMock()
+        mock_session.cmd.return_value.exit_status = 1
+        probe = distro.Probe(session=mock_session)
+        self.assertFalse(probe.check_for_remote_file("/etc/nonexistent"))
+
+
+class ProbeRegexTest(unittest.TestCase):
+    """Tests version regex patterns against real release file strings."""
+
+    def test_redhat_regex(self):
+        match = distro.RedHatProbe.CHECK_VERSION_REGEX.match(
+            "Red Hat Enterprise Linux Server release 9.3 (Plow)"
+        )
+        self.assertIsNotNone(match)
+        self.assertEqual(match.group(1), "9")
+        self.assertEqual(match.group(2), "3")
+
+    def test_centos_stream_regex(self):
+        match = distro.CentosStreamProbe.CHECK_VERSION_REGEX.match(
+            "CentOS Stream release 9"
+        )
+        self.assertIsNotNone(match)
+        self.assertEqual(match.group(1), "9")
+
+    def test_debian_numeric_version(self):
+        match = distro.DebianProbe.CHECK_VERSION_REGEX.match("12.7")
+        self.assertIsNotNone(match)
+        self.assertEqual(match.group(2), "12")
+
+    def test_debian_codename_version(self):
+        match = distro.DebianProbe.CHECK_VERSION_REGEX.match("trixie/sid")
+        self.assertIsNotNone(match)
+        self.assertEqual(match.group(1), "sid")
+
+    def test_ubuntu_regex(self):
+        content = 'NAME="Ubuntu"\nVERSION_ID="22.04"\nID=ubuntu\n'
+        match = distro.UbuntuProbe.CHECK_VERSION_REGEX.match(content)
+        self.assertIsNotNone(match)
+        self.assertEqual(match.group(1), "22.04")
+
+    def test_amazon_regex(self):
+        content = 'NAME="Amazon Linux"\nVERSION="2"\nVERSION_ID="2"\n'
+        match = distro.AmazonLinuxProbe.CHECK_VERSION_REGEX.match(content)
+        self.assertIsNotNone(match)
+        self.assertEqual(match.group(1), "2")
+
+
+class SUSEProbeTest(unittest.TestCase):
+    def test_suse_version_parsing(self):
+        os_release = (
+            'NAME="SUSE Linux Enterprise Server"\n'
+            'VERSION="12-SP2"\n'
+            'VERSION_ID="12.2"\n'
+            'ID="sles"\n'
+        )
+        fd, tmpfile = tempfile.mkstemp(suffix="-os-release")
+        with os.fdopen(fd, "w") as tmp:
+            tmp.write(os_release)
+        self.addCleanup(os.unlink, tmpfile)
+
+        with unittest.mock.patch.object(distro.SUSEProbe, "CHECK_FILE", tmpfile):
+            result = distro.SUSEProbe().get_distro()
+            self.assertEqual(result.name, "SuSE")
+            self.assertEqual(result.version, 12)
+            self.assertEqual(result.release, 2)
+
+
+class RegisterProbeTest(unittest.TestCase):
+    def setUp(self):
+        self._original_probes = distro.REGISTERED_PROBES[:]
+
+    def tearDown(self):
+        distro.REGISTERED_PROBES[:] = self._original_probes
+
+    def test_register_new_probe(self):
+        class CustomProbe(distro.Probe):
+            CHECK_FILE = "/etc/custom-release"
+
+        initial_count = len(distro.REGISTERED_PROBES)
+        distro.register_probe(CustomProbe)
+        self.assertEqual(len(distro.REGISTERED_PROBES), initial_count + 1)
+        self.assertIn(CustomProbe, distro.REGISTERED_PROBES)
+
+    def test_register_duplicate_ignored(self):
+        class CustomProbe(distro.Probe):
+            CHECK_FILE = "/etc/custom-release"
+
+        distro.register_probe(CustomProbe)
+        count_after_first = len(distro.REGISTERED_PROBES)
+        distro.register_probe(CustomProbe)
+        self.assertEqual(len(distro.REGISTERED_PROBES), count_after_first)
+
+
+class DetectTest(unittest.TestCase):
+    def setUp(self):
+        self._original_probes = distro.REGISTERED_PROBES[:]
+
+    def tearDown(self):
+        distro.REGISTERED_PROBES[:] = self._original_probes
+
+    def test_detect_returns_best_scoring(self):
+        fd, tmpfile = tempfile.mkstemp(suffix="-release")
+        with os.fdopen(fd, "w") as tmp:
+            tmp.write("HighScore release 3.1\n")
+        self.addCleanup(os.unlink, tmpfile)
+
+        class LowProbe(distro.Probe):
+            CHECK_FILE = tmpfile
+            CHECK_FILE_DISTRO_NAME = "lowscore"
+
+        class HighProbe(distro.Probe):
+            CHECK_FILE = tmpfile
+            CHECK_FILE_CONTAINS = "HighScore"
+            CHECK_FILE_DISTRO_NAME = "highscore"
+            CHECK_VERSION_REGEX = re.compile(r"HighScore release (\d+)\.(\d+).*")
+
+        distro.REGISTERED_PROBES[:] = [LowProbe, HighProbe]
+        result = distro.detect()
+        self.assertEqual(result.name, "highscore")
+        self.assertEqual(result.version, "3")
+        self.assertEqual(result.release, "1")
+
+    def test_detect_no_probes_returns_unknown(self):
+        distro.REGISTERED_PROBES[:] = []
+        result = distro.detect()
+        self.assertIs(result, distro.UNKNOWN_DISTRO)
+
+
+class SpecTest(unittest.TestCase):
+    def test_init_with_all_args(self):
+        spec = distro.Spec("fedora", min_version=38, min_release=0, arch="x86_64")
+        self.assertEqual(spec.name, "fedora")
+        self.assertEqual(spec.min_version, 38)
+        self.assertEqual(spec.min_release, 0)
+        self.assertEqual(spec.arch, "x86_64")
+
+    def test_init_defaults(self):
+        spec = distro.Spec("rhel")
+        self.assertEqual(spec.name, "rhel")
+        self.assertIsNone(spec.min_version)
+        self.assertIsNone(spec.min_release)
+        self.assertIsNone(spec.arch)
+
 
 if __name__ == "__main__":
     unittest.main()