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

tests/test_verify_build.py

@@ -1,16 +1,19 @@
 # Copyright 2022-2025 Broadcom.
-# SPDX-License-Identifier: Apache-2
+# SPDX-License-Identifier: Apache-2.0
+# mypy: ignore-errors
 """
 Verify relenv builds.
 """
 import json
 import os
 import pathlib
+import shlex
 import shutil
 import subprocess
 import sys
 import textwrap
 import time
+import uuid
 
 import packaging
 import pytest
@@ -65,6 +68,48 @@ def _install_ppbt(pexec):
     assert p.returncode == 0, "Failed to extract toolchain"
 
 
+def _setup_buildenv(pyexec, env):
+    """
+    Setup build environment variables for compiling C extensions.
+
+    On Linux, this calls 'relenv buildenv --json' to get the proper compiler
+    flags and paths to use the relenv toolchain and bundled libraries instead
+    of system libraries.
+
+    :param pyexec: Path to the relenv Python executable
+    :param env: Environment dictionary to update with buildenv variables
+    """
+    if sys.platform != "linux":
+        return
+
+    p = subprocess.run(
+        [
+            str(pyexec),
+            "-m",
+            "relenv",
+            "buildenv",
+            "--json",
+        ],
+        capture_output=True,
+    )
+    try:
+        buildenv = json.loads(p.stdout)
+    except json.JSONDecodeError:
+        assert False, f"Failed to decode json: {p.stdout.decode()} {p.stderr.decode()}"
+
+    for k in buildenv:
+        env[k] = buildenv[k]
+
+
+@pytest.fixture(autouse=True)
+def _clear_ssl_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    """
+    Ensure preceding tests do not leave stale certificate paths behind.
+    """
+    monkeypatch.delenv("SSL_CERT_FILE", raising=False)
+    monkeypatch.delenv("SSL_CERT_DIR", raising=False)
+
+
 @pytest.fixture(scope="module")
 def arch():
     return build_arch()
@@ -320,27 +365,7 @@ def test_pip_install_salt_w_package_requirements(
 
     _install_ppbt(pyexec)
     env = os.environ.copy()
-
-    # if sys.platform == "linux":
-    #    p = subprocess.run(
-    #        [
-    #            pyexec,
-    #            "-m",
-    #            "relenv",
-    #            "buildenv",
-    #            "--json",
-    #        ],
-    #        capture_output=True,
-    #    )
-    #    try:
-    #        buildenv = json.loads(p.stdout)
-    #    except json.JSONDecodeError:
-    #        assert (
-    #            False
-    #        ), f"Failed to decode json: {p.stdout.decode()} {p.stderr.decode()}"
-    #    for k in buildenv:
-    #        env[k] = buildenv[k]
-
+    _setup_buildenv(pyexec, env)
     env["RELENV_BUILDENV"] = "yes"
     env["USE_STATIC_REQUIREMENTS"] = "1"
     p = subprocess.run(
@@ -413,7 +438,15 @@ def test_pip_install_salt_w_package_requirements(
         "26.4.0",
     ],
 )
-def test_pip_install_pyzmq(pipexec, pyexec, pyzmq_version, build_version, arch, build):
+def test_pip_install_pyzmq(
+    pipexec,
+    pyexec,
+    pyzmq_version,
+    build_version,
+    arch,
+    build,
+    tmp_path: pathlib.Path,
+) -> None:
 
     if pyzmq_version == "23.2.0" and "3.12" in build_version:
         pytest.xfail(f"{pyzmq_version} does not install on 3.12")
@@ -483,6 +516,157 @@ def test_pip_install_pyzmq(pipexec, pyexec, pyzmq_version, build_version, arch,
     env["ZMQ_PREFIX"] = "bundled"
     env["RELENV_BUILDENV"] = "yes"
     env["USE_STATIC_REQUIREMENTS"] = "1"
+
+    if sys.platform == "linux":
+        fake_bsd_root = tmp_path / "fake_libbsd"
+        (fake_bsd_root / "bsd").mkdir(parents=True, exist_ok=True)
+        (fake_bsd_root / "bsd" / "string.h").write_text(
+            textwrap.dedent(
+                """\
+                #ifndef RELENV_FAKE_BSD_STRING_H
+                #define RELENV_FAKE_BSD_STRING_H
+
+                #include <stddef.h>
+
+                #ifdef __cplusplus
+                extern "C" {
+                #endif
+
+                size_t strlcpy(char *dst, const char *src, size_t siz);
+                size_t strlcat(char *dst, const char *src, size_t siz);
+
+                #ifdef __cplusplus
+                }
+                #endif
+
+                #endif  /* RELENV_FAKE_BSD_STRING_H */
+                """
+            )
+        )
+        (fake_bsd_root / "string.c").write_text(
+            textwrap.dedent(
+                """\
+                #include <stddef.h>
+                #include <string.h>
+
+                static size_t relenv_strlen(const char *s) {
+                    size_t len = 0;
+                    if (s == NULL) {
+                        return 0;
+                    }
+                    while (s[len] != '\\0') {
+                        ++len;
+                    }
+                    return len;
+                }
+
+                static size_t relenv_strnlen(const char *s, size_t maxlen) {
+                    size_t len = 0;
+                    if (s == NULL) {
+                        return 0;
+                    }
+                    while (len < maxlen && s[len] != '\\0') {
+                        ++len;
+                    }
+                    return len;
+                }
+
+                size_t strlcpy(char *dst, const char *src, size_t siz) {
+                    size_t src_len = relenv_strlen(src);
+                    if (siz == 0 || dst == NULL) {
+                        return src_len;
+                    }
+                    size_t copy = src_len;
+                    if (copy >= siz) {
+                        copy = siz - 1;
+                    }
+                    if (copy > 0 && src != NULL) {
+                        memcpy(dst, src, copy);
+                    }
+                    dst[copy] = '\\0';
+                    return src_len;
+                }
+
+                size_t strlcat(char *dst, const char *src, size_t siz) {
+                    size_t dst_len = relenv_strnlen(dst, siz);
+                    size_t src_len = relenv_strlen(src);
+                    size_t initial_len = dst_len;
+                    if (dst == NULL || dst_len >= siz) {
+                        return initial_len + src_len;
+                    }
+                    size_t space = (siz > dst_len + 1) ? siz - dst_len - 1 : 0;
+                    size_t copy = 0;
+                    if (space > 0 && src != NULL) {
+                        copy = src_len;
+                        if (copy > space) {
+                            copy = space;
+                        }
+                        if (copy > 0) {
+                            memcpy(dst + dst_len, src, copy);
+                        }
+                        dst_len += copy;
+                    }
+                    dst[dst_len] = '\\0';
+                    return initial_len + src_len;
+                }
+                """
+            )
+        )
+        include_flag = f"-I{fake_bsd_root}"
+        for key in ("CFLAGS", "CXXFLAGS", "CPPFLAGS"):
+            env[key] = " ".join(filter(None, [env.get(key, ""), include_flag])).strip()
+        env["CPATH"] = ":".join(
+            filter(None, [str(fake_bsd_root), env.get("CPATH", "")])
+        )
+        for key in ("C_INCLUDE_PATH", "CPLUS_INCLUDE_PATH"):
+            env[key] = ":".join(filter(None, [str(fake_bsd_root), env.get(key, "")]))
+        cc_value = env.get("CC")
+        if cc_value:
+            cc_args = shlex.split(cc_value)
+        else:
+            cc_path = shutil.which("cc") or shutil.which("gcc")
+            assert cc_path, "C compiler not found for libbsd shim"
+            cc_args = [cc_path]
+        obj_path = fake_bsd_root / "string.o"
+        compile_result = subprocess.run(
+            cc_args
+            + [
+                "-c",
+                "-O2",
+                "-fPIC",
+                "-o",
+                str(obj_path),
+                str(fake_bsd_root / "string.c"),
+            ],
+            env=env,
+        )
+        assert compile_result.returncode == 0, "Failed to compile libbsd shim"
+        ar_value = env.get("AR")
+        if ar_value:
+            ar_args = shlex.split(ar_value)
+        else:
+            ar_path = shutil.which("ar")
+            assert ar_path, "Archiver not found for libbsd shim"
+            ar_args = [ar_path]
+        libbsd_static = fake_bsd_root / "libbsd.a"
+        archive_result = subprocess.run(
+            ar_args + ["rcs", str(libbsd_static), str(obj_path)],
+            env=env,
+        )
+        assert archive_result.returncode == 0, "Failed to archive libbsd shim"
+        lib_dir_flag = f"-L{fake_bsd_root}"
+        env["LDFLAGS"] = " ".join(
+            filter(None, [lib_dir_flag, env.get("LDFLAGS", "")])
+        ).strip()
+        env["LIBS"] = " ".join(filter(None, ["-lbsd", env.get("LIBS", "")])).strip()
+        env["LIBRARY_PATH"] = ":".join(
+            filter(None, [str(fake_bsd_root), env.get("LIBRARY_PATH", "")])
+        )
+        env["ac_cv_func_strlcpy"] = "yes"
+        env["ac_cv_func_strlcat"] = "yes"
+        env["ac_cv_have_decl_strlcpy"] = "yes"
+        env["ac_cv_have_decl_strlcat"] = "yes"
+
     p = subprocess.run(
         [
             str(pipexec),
@@ -826,6 +1010,7 @@ def test_shebangs(pipexec, build, minor_version):
 def test_moving_pip_installed_c_extentions(pipexec, pyexec, build, minor_version):
     _install_ppbt(pyexec)
     env = os.environ.copy()
+    _setup_buildenv(pyexec, env)
     env["RELENV_DEBUG"] = "yes"
     env["RELENV_BUILDENV"] = "yes"
     p = subprocess.run(
@@ -857,11 +1042,6 @@ def test_cryptography_rpath(
     pyexec, pipexec, build, minor_version, cryptography_version
 ):
     _install_ppbt(pyexec)
-    # log.warn("Extract ppbt")
-    # p = subprocess.run(
-    #    [pyexec, "-c", "import ppbt; ppbt.extract()"],
-    # )
-    # assert p.returncode == 0
 
     def find_library(path, search):
         for root, dirs, files in os.walk(path):
@@ -870,6 +1050,7 @@ def test_cryptography_rpath(
                     return fname
 
     env = os.environ.copy()
+    _setup_buildenv(pyexec, env)
     env["RELENV_BUILDENV"] = "yes"
     p = subprocess.run(
         [
@@ -1155,7 +1336,7 @@ def test_install_python_ldap(pipexec, pyexec, build):
     tar xvf cyrus-sasl-{saslver}.tar.gz
     cd cyrus-sasl-{saslver}
     ./configure --prefix=$RELENV_PATH
-    make
+    make -j"$(nproc)"
     make install
     cd ..
 
@@ -1164,7 +1345,7 @@ def test_install_python_ldap(pipexec, pyexec, build):
     tar xvf openldap-{ldapver}.tgz
     cd openldap-{ldapver}
     ./configure --prefix=$RELENV_PATH
-    make
+    make -j"$(nproc)"
     make install
     cd ..
 
@@ -1184,6 +1365,7 @@ def test_install_python_ldap(pipexec, pyexec, build):
 
     subprocess.run(["/usr/bin/bash", "buildscript.sh"], check=True)
     env = os.environ.copy()
+    _setup_buildenv(pyexec, env)
     env["RELENV_DEBUG"] = "yes"
     env["RELENV_BUILDENV"] = "yes"
 
@@ -1215,9 +1397,16 @@ def test_install_with_target_shebang(pipexec, build, minor_version):
         check=True,
         env=env,
     )
-    shebang = pathlib.Path(extras / "bin" / "cowsay").open().readlines()[2].strip()
+    exec_line = ""
+    for line in pathlib.Path(extras / "bin" / "cowsay").read_text().splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        if stripped.startswith('"exec"'):
+            exec_line = stripped
+            break
     assert (
-        shebang
+        exec_line
         == '"exec" "$(dirname "$(readlink -f "$0")")/../../bin/python{}" "$0" "$@"'.format(
             minor_version
         )
@@ -1764,7 +1953,7 @@ def test_install_editable_package_in_extras(
 def rockycontainer(build):
     if not shutil.which("docker"):
         pytest.skip(reason="No docker binary found")
-    name = "rocky10"
+    name = f"rocky10-{uuid.uuid4().hex}"
     subprocess.run(
         [
             "docker",
@@ -1815,10 +2004,35 @@ def rockycontainer(build):
 
 
 @pytest.mark.skip_on_windows
-def test_no_openssl_binary(rockycontainer, pipexec, pyexec):
+def test_no_openssl_binary(rockycontainer, pipexec, pyexec, build):
     _install_ppbt(pyexec)
     env = os.environ.copy()
+    _setup_buildenv(pyexec, env)
     env["RELENV_BUILDENV"] = "yes"
+    if sys.platform == "linux":
+        toolchain_path = pathlib.Path(env["TOOLCHAIN_PATH"])
+        triplet = env["TRIPLET"]
+        sysroot_lib = toolchain_path / triplet / "sysroot" / "lib"
+        sysroot_lib.mkdir(parents=True, exist_ok=True)
+        bz2_sources = sorted(
+            (pathlib.Path(build) / "lib").glob("libbz2.so*"),
+            key=lambda p: len(p.name),
+        )
+        if not bz2_sources:
+            pytest.fail(
+                "libbz2.so not found in relenv build; cryptography build cannot proceed"
+            )
+        for bz2_source in bz2_sources:
+            target = sysroot_lib / bz2_source.name
+            if target.exists() or target.is_symlink():
+                if target.is_symlink():
+                    try:
+                        if target.readlink() == bz2_source:
+                            continue
+                    except OSError:
+                        pass
+                target.unlink()
+            target.symlink_to(bz2_source)
     proc = subprocess.run(
         [
             str(pipexec),
@@ -1882,3 +2096,232 @@ def test_install_setuptools_25_2_to_25_3(pipexec, build, minor_version, pip_vers
         ],
         check=True,
     )
+
+
+def test_expat_version(pyexec):
+    """
+    Verify that the build contains the correct expat version.
+
+    This validates that update_expat() successfully updated the bundled
+    expat library to match the version in python-versions.json.
+
+    Works on all platforms: Linux, Darwin (macOS), and Windows.
+    """
+    from relenv.build.common import get_dependency_version
+
+    # Map sys.platform to relenv platform names
+    platform_map = {
+        "linux": "linux",
+        "darwin": "darwin",
+        "win32": "win32",
+    }
+    platform = platform_map.get(sys.platform)
+    if not platform:
+        pytest.skip(f"Unknown platform: {sys.platform}")
+
+    # Get expected version from python-versions.json
+    expat_info = get_dependency_version("expat", platform)
+    if not expat_info:
+        pytest.skip(f"No expat version defined in python-versions.json for {platform}")
+
+    expected_version = expat_info["version"]
+
+    # Get actual version from the build
+    proc = subprocess.run(
+        [str(pyexec), "-c", "import pyexpat; print(pyexpat.EXPAT_VERSION)"],
+        capture_output=True,
+        check=True,
+    )
+
+    actual_version_str = proc.stdout.decode().strip()
+    # Format is "expat_X_Y_Z", extract version
+    assert actual_version_str.startswith(
+        "expat_"
+    ), f"Unexpected EXPAT_VERSION format: {actual_version_str}"
+
+    # Convert "expat_2_7_3" -> "2.7.3"
+    actual_version = actual_version_str.replace("expat_", "").replace("_", ".")
+
+    assert actual_version == expected_version, (
+        f"Expat version mismatch on {platform}: expected {expected_version}, "
+        f"found {actual_version} (from {actual_version_str})"
+    )
+
+
+def test_sqlite_version(pyexec):
+    """
+    Verify that the build contains the correct SQLite version.
+
+    This validates that SQLite was built with the version specified
+    in python-versions.json.
+
+    Works on all platforms: Linux, Darwin (macOS), and Windows.
+    """
+    from relenv.build.common import get_dependency_version
+
+    # Map sys.platform to relenv platform names
+    platform_map = {
+        "linux": "linux",
+        "darwin": "darwin",
+        "win32": "win32",
+    }
+    platform = platform_map.get(sys.platform)
+    if not platform:
+        pytest.skip(f"Unknown platform: {sys.platform}")
+
+    # Get expected version from python-versions.json
+    sqlite_info = get_dependency_version("sqlite", platform)
+    if not sqlite_info:
+        pytest.skip(f"No sqlite version defined in python-versions.json for {platform}")
+
+    expected_version = sqlite_info["version"]
+
+    # Get actual version from the build
+    proc = subprocess.run(
+        [str(pyexec), "-c", "import sqlite3; print(sqlite3.sqlite_version)"],
+        capture_output=True,
+        check=True,
+    )
+
+    actual_version = proc.stdout.decode().strip()
+
+    # SQLite version in JSON is like "3.50.4.0" but runtime shows "3.50.4"
+    # So we need to handle both formats
+    if expected_version.count(".") == 3:
+        # Remove trailing .0 for comparison
+        expected_version = ".".join(expected_version.split(".")[:3])
+
+    assert actual_version == expected_version, (
+        f"SQLite version mismatch on {platform}: expected {expected_version}, "
+        f"found {actual_version}"
+    )
+
+
+def test_openssl_version(pyexec):
+    """
+    Verify that the build contains the correct OpenSSL version.
+
+    This validates that OpenSSL was built with the version specified
+    in python-versions.json.
+
+    Works on all platforms: Linux, Darwin (macOS), and Windows.
+    """
+    import re
+
+    from relenv.build.common import get_dependency_version
+
+    # Map sys.platform to relenv platform names
+    platform_map = {
+        "linux": "linux",
+        "darwin": "darwin",
+        "win32": "win32",
+    }
+    platform = platform_map.get(sys.platform)
+    if not platform:
+        pytest.skip(f"Unknown platform: {sys.platform}")
+
+    # Get expected version from python-versions.json
+    openssl_info = get_dependency_version("openssl", platform)
+    if not openssl_info:
+        pytest.skip(
+            f"No openssl version defined in python-versions.json for {platform}"
+        )
+
+    expected_version = openssl_info["version"]
+
+    # Get actual version from the build
+    proc = subprocess.run(
+        [str(pyexec), "-c", "import ssl; print(ssl.OPENSSL_VERSION)"],
+        capture_output=True,
+        check=True,
+    )
+
+    actual_version_str = proc.stdout.decode().strip()
+    # Format is "OpenSSL 3.5.4 30 Sep 2025"
+    # Extract version number
+    match = re.search(r"OpenSSL (\d+\.\d+\.\d+)", actual_version_str)
+    if not match:
+        pytest.fail(f"Could not parse OpenSSL version from: {actual_version_str}")
+
+    actual_version = match.group(1)
+
+    assert actual_version == expected_version, (
+        f"OpenSSL version mismatch on {platform}: expected {expected_version}, "
+        f"found {actual_version} (from {actual_version_str})"
+    )
+
+
+def test_xz_lzma_functionality(pyexec):
+    """
+    Verify that the lzma module works correctly.
+
+    This is especially important for Windows builds which use a config.h
+    compatibility shim from XZ 5.4.7 to support newer XZ versions that
+    removed MSBuild support.
+
+    If this test fails, it indicates that the config.h in
+    relenv/_resources/xz/config.h is no longer compatible with the
+    current XZ version being used.
+
+    Works on all platforms: Linux, Darwin (macOS), and Windows.
+    """
+    # Test that lzma module loads and basic compression works
+    test_code = """
+import lzma
+import sys
+
+# Test basic compression/decompression
+test_data = b"Hello, World! " * 100
+compressed = lzma.compress(test_data)
+decompressed = lzma.decompress(compressed)
+
+if test_data != decompressed:
+    print("ERROR: Decompressed data does not match original", file=sys.stderr)
+    sys.exit(1)
+
+# Verify compression actually happened
+if len(compressed) >= len(test_data):
+    print("ERROR: Compression did not reduce size", file=sys.stderr)
+    sys.exit(2)
+
+# Test different formats (skip FORMAT_RAW as it requires explicit filters)
+for fmt in [lzma.FORMAT_XZ, lzma.FORMAT_ALONE]:
+    try:
+        data = lzma.compress(test_data, format=fmt)
+        result = lzma.decompress(data)
+        if result != test_data:
+            print(f"ERROR: Format {fmt} failed round-trip", file=sys.stderr)
+            sys.exit(3)
+    except Exception as e:
+        print(f"ERROR: Format {fmt} raised exception: {e}", file=sys.stderr)
+        sys.exit(4)
+
+# Test streaming compression/decompression
+import io
+output = io.BytesIO()
+with lzma.LZMAFile(output, "w") as f:
+    f.write(test_data)
+
+compressed_stream = output.getvalue()
+input_stream = io.BytesIO(compressed_stream)
+with lzma.LZMAFile(input_stream, "r") as f:
+    decompressed_stream = f.read()
+
+if decompressed_stream != test_data:
+    print("ERROR: Streaming compression/decompression failed", file=sys.stderr)
+    sys.exit(5)
+
+print("OK")
+"""
+
+    proc = subprocess.run(
+        [str(pyexec), "-c", test_code],
+        capture_output=True,
+        check=False,
+    )
+
+    assert proc.returncode == 0, (
+        f"LZMA functionality test failed (exit code {proc.returncode}): "
+        f"{proc.stderr.decode()}"
+    )
+    assert proc.stdout.decode().strip() == "OK"