relenv 0.21.1__py3-none-any.whl → 0.22.0__py3-none-any.whl

tests/test_create.py

@@ -12,12 +12,12 @@ from relenv.common import arches
 from relenv.create import CreateException, chdir, create
 
 
-def test_chdir(tmp_path):
+def test_chdir(tmp_path: pathlib.Path) -> None:
     with chdir(str(tmp_path)):
         assert pathlib.Path(os.getcwd()) == tmp_path
 
 
-def test_create(tmp_path):
+def test_create(tmp_path: pathlib.Path) -> None:
     to_be_archived = tmp_path / "to_be_archived"
     to_be_archived.mkdir()
     test_file = to_be_archived / "testfile"
@@ -34,21 +34,164 @@ def test_create(tmp_path):
     assert (to_dir / to_be_archived.name / test_file.name) in to_dir.glob("**/*")
 
 
-def test_create_tar_doesnt_exist(tmp_path):
+def test_create_tar_doesnt_exist(tmp_path: pathlib.Path) -> None:
     tar_file = tmp_path / "fake_archive"
     with patch("relenv.create.archived_build", return_value=tar_file):
         with pytest.raises(CreateException):
             create("foo", dest=tmp_path)
 
 
-def test_create_directory_exists(tmp_path):
+def test_create_directory_exists(tmp_path: pathlib.Path) -> None:
     (tmp_path / "foo").mkdir()
     with pytest.raises(CreateException):
         create("foo", dest=tmp_path)
 
 
-def test_create_arches_directory_exists(tmp_path):
-    mocked_arches = {key: [] for key in arches.keys()}
+def test_create_arches_directory_exists(tmp_path: pathlib.Path) -> None:
+    mocked_arches: dict[str, list[str]] = {key: [] for key in arches.keys()}
     with patch("relenv.create.arches", mocked_arches):
         with pytest.raises(CreateException):
             create("foo", dest=tmp_path)
+
+
+def test_create_with_minor_version(tmp_path: pathlib.Path) -> None:
+    """Test that minor version (e.g., '3.12') resolves to latest micro version."""
+    import argparse
+    import sys
+
+    from relenv.create import main
+    from relenv.pyversions import Version
+
+    # Mock python_versions to return some test versions
+    all_versions = {
+        Version("3.11.5"): "aaa111",
+        Version("3.12.5"): "abc123",
+        Version("3.12.6"): "def456",
+        Version("3.12.7"): "ghi789",
+        Version("3.13.1"): "zzz999",
+    }
+
+    def mock_python_versions(minor: str | None = None) -> dict[Version, str]:
+        """Mock that filters versions by minor version like the real function."""
+        if minor is None:
+            return all_versions
+        # Filter versions matching the minor version
+        mv = Version(minor)
+        return {
+            v: h
+            for v, h in all_versions.items()
+            if v.major == mv.major and v.minor == mv.minor
+        }
+
+    # Create a fake archive
+    to_be_archived = tmp_path / "to_be_archived"
+    to_be_archived.mkdir()
+    test_file = to_be_archived / "testfile"
+    test_file.touch()
+    tar_file = tmp_path / "fake_archive"
+    with tarfile.open(str(tar_file), "w:xz") as tar:
+        tar.add(str(to_be_archived), to_be_archived.name)
+
+    # Use appropriate architecture for the platform
+    test_arch = "amd64" if sys.platform == "win32" else "x86_64"
+    args = argparse.Namespace(name="test_env", arch=test_arch, python="3.12")
+
+    with chdir(str(tmp_path)):
+        with patch("relenv.create.python_versions", side_effect=mock_python_versions):
+            with patch("relenv.create.archived_build", return_value=tar_file):
+                with patch("relenv.create.build_arch", return_value=test_arch):
+                    main(args)
+
+    to_dir = tmp_path / "test_env"
+    assert to_dir.exists()
+
+
+def test_create_with_full_version(tmp_path: pathlib.Path) -> None:
+    """Test that full version (e.g., '3.12.7') still works."""
+    import argparse
+    import sys
+
+    from relenv.create import main
+    from relenv.pyversions import Version
+
+    # Mock python_versions to return some test versions
+    all_versions = {
+        Version("3.11.5"): "aaa111",
+        Version("3.12.5"): "abc123",
+        Version("3.12.6"): "def456",
+        Version("3.12.7"): "ghi789",
+        Version("3.13.1"): "zzz999",
+    }
+
+    def mock_python_versions(minor: str | None = None) -> dict[Version, str]:
+        """Mock that filters versions by minor version like the real function."""
+        if minor is None:
+            return all_versions
+        # Filter versions matching the minor version
+        mv = Version(minor)
+        return {
+            v: h
+            for v, h in all_versions.items()
+            if v.major == mv.major and v.minor == mv.minor
+        }
+
+    # Create a fake archive
+    to_be_archived = tmp_path / "to_be_archived"
+    to_be_archived.mkdir()
+    test_file = to_be_archived / "testfile"
+    test_file.touch()
+    tar_file = tmp_path / "fake_archive"
+    with tarfile.open(str(tar_file), "w:xz") as tar:
+        tar.add(str(to_be_archived), to_be_archived.name)
+
+    # Use appropriate architecture for the platform
+    test_arch = "amd64" if sys.platform == "win32" else "x86_64"
+    args = argparse.Namespace(name="test_env", arch=test_arch, python="3.12.7")
+
+    with chdir(str(tmp_path)):
+        with patch("relenv.create.python_versions", side_effect=mock_python_versions):
+            with patch("relenv.create.archived_build", return_value=tar_file):
+                with patch("relenv.create.build_arch", return_value=test_arch):
+                    main(args)
+
+    to_dir = tmp_path / "test_env"
+    assert to_dir.exists()
+
+
+def test_create_with_unknown_minor_version(tmp_path: pathlib.Path) -> None:
+    """Test that unknown minor version produces an error."""
+    import argparse
+    import sys
+
+    from relenv.create import main
+    from relenv.pyversions import Version
+
+    # Mock python_versions to return empty dict for unknown version
+    all_versions = {
+        Version("3.11.5"): "aaa111",
+        Version("3.12.5"): "abc123",
+        Version("3.12.6"): "def456",
+        Version("3.12.7"): "ghi789",
+        Version("3.13.1"): "zzz999",
+    }
+
+    # Use appropriate architecture for the platform
+    test_arch = "amd64" if sys.platform == "win32" else "x86_64"
+    args = argparse.Namespace(name="test_env", arch=test_arch, python="3.99")
+
+    def mock_python_versions(minor: str | None = None) -> dict[Version, str]:
+        """Mock that filters versions by minor version like the real function."""
+        if minor is None:
+            return all_versions
+        # Filter versions matching the minor version
+        mv = Version(minor)
+        return {
+            v: h
+            for v, h in all_versions.items()
+            if v.major == mv.major and v.minor == mv.minor
+        }
+
+    with patch("relenv.create.python_versions", side_effect=mock_python_versions):
+        with patch("relenv.create.build_arch", return_value=test_arch):
+            with pytest.raises(SystemExit):
+                main(args)

tests/test_downloads.py

@@ -1,22 +1,24 @@
 # Copyright 2022-2025 Broadcom.
-# SPDX-License-Identifier: Apache-2
+# SPDX-License-Identifier: Apache-2.0
 import pathlib
 import subprocess
 import sys
+
+# mypy: ignore-errors
 from unittest.mock import patch
 
-from relenv.build.common import Download
+from relenv.build.common.download import Download
 from relenv.common import RelenvException
 
 
-def test_download_url():
+def test_download_url() -> None:
     download = Download(
         "test", "https://test.com/{version}/test-{version}.tar.xz", version="1.0.0"
     )
     assert download.url == "https://test.com/1.0.0/test-1.0.0.tar.xz"
 
 
-def test_download_url_change_version():
+def test_download_url_change_version() -> None:
     download = Download(
         "test", "https://test.com/{version}/test-{version}.tar.xz", version="1.0.0"
     )
@@ -24,7 +26,7 @@ def test_download_url_change_version():
     assert download.url == "https://test.com/1.2.2/test-1.2.2.tar.xz"
 
 
-def test_download_filepath():
+def test_download_filepath() -> None:
     download = Download(
         "test",
         "https://test.com/{version}/test-{version}.tar.xz",
@@ -38,7 +40,7 @@ def test_download_filepath():
         assert str(download.filepath) == "/tmp/test-1.0.0.tar.xz"
 
 
-def test_download_filepath_change_destination():
+def test_download_filepath_change_destination() -> None:
     download = Download(
         "test",
         "https://test.com/{version}/test-{version}.tar.xz",
@@ -53,7 +55,7 @@ def test_download_filepath_change_destination():
         assert str(download.filepath) == "/tmp/foo/test-1.0.0.tar.xz"
 
 
-def test_download_exists(tmp_path):
+def test_download_exists(tmp_path: pathlib.Path) -> None:
     download = Download(
         "test",
         "https://test.com/{version}/test-{version}.tar.xz",
@@ -65,25 +67,25 @@ def test_download_exists(tmp_path):
     assert download.exists() is True
 
 
-def test_validate_md5sum(tmp_path):
+def test_validate_md5sum(tmp_path: pathlib.Path) -> None:
     fake_md5 = "fakemd5"
-    with patch("relenv.build.common.verify_checksum") as run_mock:
+    with patch("relenv.build.common.download.verify_checksum") as run_mock:
         assert Download.validate_checksum(str(tmp_path), fake_md5) is True
         run_mock.assert_called_with(str(tmp_path), fake_md5)
 
 
-def test_validate_md5sum_failed(tmp_path):
+def test_validate_md5sum_failed(tmp_path: pathlib.Path) -> None:
     fake_md5 = "fakemd5"
     with patch(
-        "relenv.build.common.verify_checksum", side_effect=RelenvException
+        "relenv.build.common.download.verify_checksum", side_effect=RelenvException
     ) as run_mock:
         assert Download.validate_checksum(str(tmp_path), fake_md5) is False
         run_mock.assert_called_with(str(tmp_path), fake_md5)
 
 
-def test_validate_signature(tmp_path):
+def test_validate_signature(tmp_path: pathlib.Path) -> None:
     sig = "fakesig"
-    with patch("relenv.build.common.runcmd") as run_mock:
+    with patch("relenv.build.common.download.runcmd") as run_mock:
         assert Download.validate_signature(str(tmp_path), sig) is True
         run_mock.assert_called_with(
             ["gpg", "--verify", sig, str(tmp_path)],
@@ -92,9 +94,11 @@ def test_validate_signature(tmp_path):
         )
 
 
-def test_validate_signature_failed(tmp_path):
+def test_validate_signature_failed(tmp_path: pathlib.Path) -> None:
     sig = "fakesig"
-    with patch("relenv.build.common.runcmd", side_effect=RelenvException) as run_mock:
+    with patch(
+        "relenv.build.common.download.runcmd", side_effect=RelenvException
+    ) as run_mock:
         assert Download.validate_signature(str(tmp_path), sig) is False
         run_mock.assert_called_with(
             ["gpg", "--verify", sig, str(tmp_path)],

tests/test_fips_photon.py

@@ -1,9 +1,12 @@
-# Copyright 2023-2025 Broadcom.
+# Copyright 2022-2025 Broadcom.
 # SPDX-License-Identifier: Apache-2.0
 #
 import os
 import pathlib
+
+# mypy: ignore-errors
 import subprocess
+from typing import Any
 
 import pytest
 
@@ -12,7 +15,7 @@ from tests.test_verify_build import _install_ppbt
 from .conftest import get_build_version
 
 
-def check_test_environment():
+def check_test_environment() -> bool:
     path = pathlib.Path("/etc/os-release")
     if path.exists():
         release = path.read_text()
@@ -28,7 +31,7 @@ pytestmark = [
 ]
 
 
-def test_fips_mode(pyexec, build):
+def test_fips_mode(pyexec: str, build: Any) -> None:
     _install_ppbt(pyexec)
     env = os.environ.copy()
     proc = subprocess.run(

tests/test_module_imports.py

@@ -0,0 +1,44 @@
+# Copyright 2022-2025 Broadcom.
+# SPDX-License-Identifier: Apache-2.0
+#
+from __future__ import annotations
+
+import importlib
+import pathlib
+from typing import TYPE_CHECKING, Any, Callable, List, Sequence, TypeVar, cast
+
+import pytest
+
+if TYPE_CHECKING:
+    from _pytest.mark.structures import ParameterSet
+
+F = TypeVar("F", bound=Callable[..., object])
+
+
+def typed_parametrize(*args: Any, **kwargs: Any) -> Callable[[F], F]:
+    """Type-aware wrapper around pytest.mark.parametrize."""
+    decorator = pytest.mark.parametrize(*args, **kwargs)
+    return cast(Callable[[F], F], decorator)
+
+
+def _top_level_modules() -> Sequence["ParameterSet"]:
+    relenv_dir = pathlib.Path(__file__).resolve().parents[1] / "relenv"
+    params: List["ParameterSet"] = []
+    for path in sorted(relenv_dir.iterdir()):
+        if not path.is_file() or path.suffix != ".py":
+            continue
+        stem = path.stem
+        if stem == "__init__":
+            module_name = "relenv"
+        else:
+            module_name = f"relenv.{stem}"
+        params.append(pytest.param(module_name, id=module_name))
+    return params
+
+
+@typed_parametrize("module_name", _top_level_modules())
+def test_import_top_level_module(module_name: str) -> None:
+    """
+    Ensure each top-level module in the relenv package can be imported.
+    """
+    importlib.import_module(module_name)

tests/test_pyversions_runtime.py

@@ -0,0 +1,177 @@
+# Copyright 2022-2025 Broadcom.
+# SPDX-License-Identifier: Apache-2.0
+#
+from __future__ import annotations
+
+import hashlib
+import pathlib
+import subprocess
+from typing import Any, Dict, Sequence
+
+import pytest
+
+from relenv import pyversions
+
+
+def test_python_versions_returns_versions() -> None:
+    versions: Dict[pyversions.Version, str] = pyversions.python_versions()
+    assert versions, "python_versions() should return known versions"
+    first_version = next(iter(versions))
+    assert isinstance(first_version, pyversions.Version)
+    assert isinstance(versions[first_version], str)
+
+
+def test_python_versions_filters_minor() -> None:
+    versions = pyversions.python_versions("3.11")
+    assert versions
+    assert all(version.major == 3 and version.minor == 11 for version in versions)
+    sorted_versions = sorted(versions)
+    assert sorted_versions[-1] in versions
+
+
+def test_release_urls_handles_old_versions() -> None:
+    tarball, signature = pyversions._release_urls(pyversions.Version("3.1.3"))
+    assert tarball.endswith(".tar.xz")
+    assert signature is not None
+
+
+def test_release_urls_no_signature_before_23() -> None:
+    tarball, signature = pyversions._release_urls(pyversions.Version("2.2.3"))
+    assert tarball.endswith(".tar.xz")
+    assert signature is None
+
+
+def test_ref_version_and_path_helpers() -> None:
+    html = '<a href="download/Python-3.11.9.tgz">Python 3.11.9</a>'
+    version = pyversions._ref_version(html)
+    assert str(version) == "3.11.9"
+    assert pyversions._ref_path(html) == "download/Python-3.11.9.tgz"
+
+
+def test_digest(tmp_path: pathlib.Path) -> None:
+    file = tmp_path / "data.bin"
+    file.write_bytes(b"abc")
+    assert pyversions.digest(file) == hashlib.sha1(b"abc").hexdigest()
+
+
+def test_get_keyid_parses_second_line() -> None:
+    proc = subprocess.CompletedProcess(
+        ["gpg"],
+        1,
+        stdout=b"",
+        stderr=b"gpg: error\n[GNUPG:] INV_SGNR 0 CB1234\n",
+    )
+    assert pyversions._get_keyid(proc) == "CB1234"
+
+
+def test_verify_signature_success(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    called: Dict[str, list[str]] = {}
+
+    def fake_run(
+        cmd: Sequence[str], **kwargs: Any
+    ) -> subprocess.CompletedProcess[bytes]:
+        called.setdefault("cmd", []).extend(cmd)
+        return subprocess.CompletedProcess(cmd, 0, stdout=b"", stderr=b"")
+
+    monkeypatch.setattr(pyversions.subprocess, "run", fake_run)
+    assert pyversions.verify_signature("archive.tgz", "archive.tgz.asc") is True
+    assert called["cmd"][0] == "gpg"
+
+
+def test_verify_signature_failure_with_missing_key(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    responses: list[str] = []
+
+    def fake_run(
+        cmd: Sequence[str], **kwargs: Any
+    ) -> subprocess.CompletedProcess[bytes]:
+        if len(responses) == 0:
+            responses.append("first")
+            stderr = b"gpg: error\n[GNUPG:] INV_SGNR 0 ABCDEF12\nNo public key\n"
+            return subprocess.CompletedProcess(cmd, 1, stdout=b"", stderr=stderr)
+        return subprocess.CompletedProcess(cmd, 0, stdout=b"", stderr=b"")
+
+    monkeypatch.setattr(pyversions.subprocess, "run", fake_run)
+    monkeypatch.setattr(pyversions, "_receive_key", lambda keyid, server: True)
+    assert pyversions.verify_signature("archive.tgz", "archive.tgz.asc") is True
+
+
+def test_sha256_digest(tmp_path: pathlib.Path) -> None:
+    """Test SHA-256 digest computation."""
+    file = tmp_path / "data.bin"
+    file.write_bytes(b"test data")
+    assert pyversions.sha256_digest(file) == hashlib.sha256(b"test data").hexdigest()
+
+
+def test_detect_openssl_versions(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test OpenSSL version detection from GitHub releases."""
+    mock_html = """
+    <html>
+    <a href="/openssl/openssl/releases/tag/openssl-3.5.4">openssl-3.5.4</a>
+    <a href="/openssl/openssl/releases/tag/openssl-3.5.3">openssl-3.5.3</a>
+    <a href="/openssl/openssl/releases/tag/openssl-3.4.0">openssl-3.4.0</a>
+    </html>
+    """
+
+    def fake_fetch(url: str) -> str:
+        return mock_html
+
+    monkeypatch.setattr(pyversions, "fetch_url_content", fake_fetch)
+    versions = pyversions.detect_openssl_versions()
+    assert isinstance(versions, list)
+    assert "3.5.4" in versions
+    assert "3.5.3" in versions
+    assert "3.4.0" in versions
+    # Verify sorting (latest first)
+    assert versions[0] == "3.5.4"
+
+
+def test_detect_sqlite_versions(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test SQLite version detection from sqlite.org."""
+    mock_html = """
+    <html>
+    <a href="2024/sqlite-autoconf-3500400.tar.gz">sqlite-autoconf-3500400.tar.gz</a>
+    <a href="2024/sqlite-autoconf-3500300.tar.gz">sqlite-autoconf-3500300.tar.gz</a>
+    </html>
+    """
+
+    def fake_fetch(url: str) -> str:
+        return mock_html
+
+    monkeypatch.setattr(pyversions, "fetch_url_content", fake_fetch)
+    versions = pyversions.detect_sqlite_versions()
+    assert isinstance(versions, list)
+    # Should return list of tuples (version, sqliteversion)
+    assert len(versions) > 0
+    assert isinstance(versions[0], tuple)
+    assert len(versions[0]) == 2
+    # Check that conversion worked
+    version, sqlite_ver = versions[0]
+    assert version == "3.50.4.0"
+    assert sqlite_ver == "3500400"
+
+
+def test_detect_xz_versions(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test XZ version detection from tukaani.org."""
+    mock_html = """
+    <html>
+    <a href="xz-5.8.1.tar.gz">xz-5.8.1.tar.gz</a>
+    <a href="xz-5.8.0.tar.gz">xz-5.8.0.tar.gz</a>
+    <a href="xz-5.6.3.tar.gz">xz-5.6.3.tar.gz</a>
+    </html>
+    """
+
+    def fake_fetch(url: str) -> str:
+        return mock_html
+
+    monkeypatch.setattr(pyversions, "fetch_url_content", fake_fetch)
+    versions = pyversions.detect_xz_versions()
+    assert isinstance(versions, list)
+    assert "5.8.1" in versions
+    assert "5.8.0" in versions
+    assert "5.6.3" in versions
+    # Verify sorting (latest first)
+    assert versions[0] == "5.8.1"