test_builder.py

import shutil
import subprocess
import tarfile
import time
from pathlib import Path
from typing import Self

import pydantic
import pytest

from pyodide_build import common
from pyodide_build.build_env import BuildArgs, get_build_flag
from pyodide_build.recipe import builder as _builder
from pyodide_build.recipe.builder import (
    RecipeBuilder,
    RecipeBuilderPackage,
    RecipeBuilderSharedLibrary,
    RecipeBuilderStaticLibrary,
    _load_recipe,
)
from pyodide_build.recipe.spec import _SourceSpec

RECIPE_DIR = Path(__file__).parent / "_test_recipes"
WHEEL_DIR = Path(__file__).parent.parent / "_test_wheels"


@pytest.fixture
def tmp_builder(tmp_path):
    builder = RecipeBuilder.get_builder(
        recipe=RECIPE_DIR / "pkg_1",
        build_args=BuildArgs(),
        build_dir=tmp_path,
        force_rebuild=False,
        continue_=False,
    )

    yield builder


def test_constructor(tmp_path):
    builder = RecipeBuilder.get_builder(
        recipe=RECIPE_DIR / "beautifulsoup4",
        build_args=BuildArgs(),
        build_dir=tmp_path / "beautifulsoup4" / "build",
        force_rebuild=False,
        continue_=False,
    )

    assert builder.name == "beautifulsoup4"
    assert builder.version == "4.13.3"
    assert builder.fullname == "beautifulsoup4-4.13.3"

    assert builder.pkg_root == RECIPE_DIR / "beautifulsoup4"
    assert builder.build_dir == tmp_path / "beautifulsoup4" / "build"
    assert (
        builder.src_extract_dir
        == tmp_path / "beautifulsoup4" / "build" / "beautifulsoup4-4.13.3"
    )
    assert (
        builder.src_dist_dir
        == tmp_path / "beautifulsoup4" / "build" / "beautifulsoup4-4.13.3" / "dist"
    )
    assert builder.dist_dir == RECIPE_DIR / "beautifulsoup4" / "dist"
    assert builder.library_install_prefix == tmp_path / ".libs"


def test_get_builder(tmp_path):
    builder = RecipeBuilder.get_builder(
        recipe=RECIPE_DIR / "pkg_1",
        build_args=BuildArgs(),
        build_dir=tmp_path,
        force_rebuild=False,
        continue_=False,
    )

    assert isinstance(builder, RecipeBuilder)
    assert isinstance(builder, RecipeBuilderPackage)

    builder = RecipeBuilder.get_builder(
        recipe=RECIPE_DIR / "libtest",
        build_args=BuildArgs(),
        build_dir=tmp_path,
        force_rebuild=False,
        continue_=False,
    )

    assert isinstance(builder, RecipeBuilder)
    assert isinstance(builder, RecipeBuilderStaticLibrary)

    builder = RecipeBuilder.get_builder(
        recipe=RECIPE_DIR / "libtest_shared",
        build_args=BuildArgs(),
        build_dir=tmp_path,
        force_rebuild=False,
        continue_=False,
    )

    assert isinstance(builder, RecipeBuilder)
    assert isinstance(builder, RecipeBuilderSharedLibrary)


def test_load_recipe():
    root, recipe = _load_recipe(RECIPE_DIR / "pkg_1")
    assert root == RECIPE_DIR / "pkg_1"
    assert recipe.package.name == "pkg_1"

    root, recipe = _load_recipe(RECIPE_DIR / "pkg_1" / "meta.yaml")
    assert root == RECIPE_DIR / "pkg_1"
    assert recipe.package.name == "pkg_1"


def test_prepare_source(monkeypatch, tmp_path, dummy_xbuildenv):
    class subprocess_result:
        returncode = 0
        stdout = ""

    monkeypatch.setattr(subprocess, "run", lambda *args, **kwargs: subprocess_result)
    monkeypatch.setattr(_builder, "check_checksum", lambda *args, **kwargs: True)
    monkeypatch.setattr(shutil, "unpack_archive", lambda *args, **kwargs: True)
    monkeypatch.setattr(shutil, "move", lambda *args, **kwargs: True)

    test_pkgs = [
        RECIPE_DIR / "packaging/meta.yaml",
        # RECIPE_DIR / "micropip/meta.yaml",
    ]

    for pkg in test_pkgs:
        builder = RecipeBuilder.get_builder(
            recipe=pkg,
            build_args=BuildArgs(),
            build_dir=tmp_path / "build",
        )
        builder._prepare_source()
        assert builder.src_extract_dir.is_dir()


def test_check_executables(tmp_path, monkeypatch):
    builder = RecipeBuilder.get_builder(
        recipe=RECIPE_DIR / "pkg_test_executable",
        build_args=BuildArgs(),
        build_dir=tmp_path,
    )

    monkeypatch.setattr(
        common, "find_missing_executables", lambda executables: ["echo"]
    )
    with pytest.raises(
        RuntimeError, match="The following executables are required to build"
    ):
        builder._check_executables()


def test_get_helper_vars(tmp_path):
    builder = RecipeBuilder.get_builder(
        recipe=RECIPE_DIR / "pkg_1",
        build_args=BuildArgs(),
        build_dir=tmp_path / "pkg_1" / "build",
    )

    helper_vars = builder._get_helper_vars()

    assert helper_vars["PKGDIR"] == str(RECIPE_DIR / "pkg_1")
    assert helper_vars["PKG_VERSION"] == "1.0.0"
    assert helper_vars["PKG_BUILD_DIR"] == str(
        tmp_path / "pkg_1" / "build" / "pkg_1-1.0.0"
    )
    assert helper_vars["DISTDIR"] == str(
        tmp_path / "pkg_1" / "build" / "pkg_1-1.0.0" / "dist"
    )
    assert helper_vars["WASM_LIBRARY_DIR"] == str(tmp_path / ".libs")
    assert helper_vars["EM_PKG_CONFIG_PATH"] == str(
        tmp_path / ".libs" / "lib" / "pkgconfig"
    )
    assert helper_vars["PKG_CONFIG_LIBDIR"] == str(
        tmp_path / ".libs" / "lib" / "pkgconfig"
    )


def test_create_constraints_file_no_override(tmp_path, dummy_xbuildenv):
    builder = RecipeBuilder.get_builder(
        recipe=RECIPE_DIR
        / "pkg_test_executable",  # constraints not set, so no override
        build_args=BuildArgs(),
        build_dir=tmp_path,
    )

    path = builder._create_constraints_file()
    assert path == get_build_flag("PIP_CONSTRAINT")


def test_create_constraints_file_override(tmp_path, dummy_xbuildenv):
    builder = RecipeBuilder.get_builder(
        recipe=RECIPE_DIR / "pkg_test_constraint",
        build_args=BuildArgs(),
        build_dir=tmp_path,
    )

    paths = builder._create_constraints_file()
    assert paths == get_build_flag("PIP_CONSTRAINT") + " " + str(
        tmp_path / "constraints.txt"
    )

    data = Path(paths.split()[-1]).read_text().strip().split("\n")
    assert data[-3:] == ["numpy < 2.0", "pytest == 7.0", "setuptools < 75"], data


class MockSourceSpec(_SourceSpec):
    @pydantic.model_validator(mode="after")
    def _check_patches_extra(self) -> Self:
        return self


@pytest.mark.parametrize("is_wheel", [False, True])
def test_needs_rebuild(tmpdir, is_wheel):
    pkg_root = Path(tmpdir)
    buildpath = pkg_root / "build"
    meta_yaml = pkg_root / "meta.yaml"
    version = "12"
    if is_wheel:
        dist_dir = pkg_root / "dist"
        dist_dir.mkdir()
        # Build of current version with wrong abi
        (dist_dir / "regex-12-cp311-cp311-pyemscripten_2024_0_wasm32.whl").touch()
        # Build of old version with current abi
        (dist_dir / "regex-11-cp312-cp312-pyemscripten_2024_0_wasm32.whl").touch()
        # the version we're trying to build
        packaged = dist_dir / "regex-12-cp312-cp312-pyemscripten_2024_0_wasm32.whl"
    else:
        packaged = buildpath / ".packaged"

    patch_file = pkg_root / "patch"
    extra_file = pkg_root / "extra"
    src_path = pkg_root / "src"
    src_path_file = src_path / "file"

    source_metadata = MockSourceSpec(
        patches=[
            str(patch_file),
        ],
        extras=[
            (str(extra_file), ""),
        ],
        path=str(src_path),
    )

    buildpath.mkdir()
    meta_yaml.touch()
    patch_file.touch()
    extra_file.touch()
    src_path.mkdir()
    src_path_file.touch()

    # No .packaged file, rebuild
    assert _builder.needs_rebuild(
        pkg_root, buildpath, source_metadata, is_wheel, version
    )

    # .packaged file exists, no rebuild
    packaged.touch()
    assert not _builder.needs_rebuild(
        pkg_root, buildpath, source_metadata, is_wheel, version
    )

    # newer meta.yaml file, rebuild
    packaged.touch()
    time.sleep(0.01)
    meta_yaml.touch()
    assert _builder.needs_rebuild(
        pkg_root, buildpath, source_metadata, is_wheel, version
    )

    # newer patch file, rebuild
    packaged.touch()
    time.sleep(0.01)
    patch_file.touch()
    assert _builder.needs_rebuild(
        pkg_root, buildpath, source_metadata, is_wheel, version
    )

    # newer extra file, rebuild
    packaged.touch()
    time.sleep(0.01)
    extra_file.touch()
    assert _builder.needs_rebuild(
        pkg_root, buildpath, source_metadata, is_wheel, version
    )

    # newer source path, rebuild
    packaged.touch()
    time.sleep(0.01)
    src_path_file.touch()
    assert _builder.needs_rebuild(
        pkg_root, buildpath, source_metadata, is_wheel, version
    )

    # newer .packaged file, no rebuild
    packaged.touch()
    assert not _builder.needs_rebuild(
        pkg_root, buildpath, source_metadata, is_wheel, version
    )


@pytest.mark.parametrize("modify_rpath", [False, True])
def test_copy_sharedlib(tmp_path, modify_rpath):
    wheel_file_name = "sharedlib_test_py-1.0-cp310-cp310-emscripten_3_1_21_wasm32.whl"
    wheel = WHEEL_DIR / "wheel" / wheel_file_name
    libdir = WHEEL_DIR / "lib"

    wheel_copy = tmp_path / wheel_file_name
    shutil.copy(wheel, wheel_copy)

    common.unpack_wheel(wheel_copy)
    name, ver, _ = wheel.name.split("-", 2)
    wheel_dir_name = f"{name}-{ver}"
    wheel_dir = tmp_path / wheel_dir_name

    dep_map = _builder.copy_sharedlibs(wheel_copy, wheel_dir, libdir, modify_rpath)

    deps = ("sharedlib-test.so", "sharedlib-test-dep.so", "sharedlib-test-dep2.so")
    for dep in deps:
        assert dep in dep_map


def test_extract_tarballname():
    url = "https://www.test.com/ball.tar.gz"
    headers = [
        {},
        {"Content-Disposition": "inline"},
        {"Content-Disposition": "attachment"},
        {"Content-Disposition": 'attachment; filename="ball 2.tar.gz"'},
        {"Content-Disposition": "attachment; filename*=UTF-8''ball%203.tar.gz"},
    ]
    tarballnames = [
        "ball.tar.gz",
        "ball.tar.gz",
        "ball.tar.gz",
        "ball 2.tar.gz",
        "ball 3.tar.gz",
    ]

    for header, tarballname in zip(headers, tarballnames, strict=True):
        assert _builder._extract_tarballname(url, header) == tarballname


class TestInstallToLibraryDir:
    """Tests for _install_to_library_dir method."""

    def test_copies_distdir_to_library_install_prefix(self, tmp_path):
        builder = RecipeBuilder.get_builder(
            recipe=RECIPE_DIR / "libtest",
            build_args=BuildArgs(),
            build_dir=tmp_path / "libtest" / "build",
        )

        # Create fake artifacts in src_dist_dir
        builder.src_dist_dir.mkdir(parents=True, exist_ok=True)
        lib_dir = builder.src_dist_dir / "lib"
        include_dir = builder.src_dist_dir / "include"
        lib_dir.mkdir()
        include_dir.mkdir()
        (lib_dir / "libtest.a").write_text("fake static lib")
        (include_dir / "test.h").write_text("fake header")

        builder._install_to_library_dir()

        # Verify artifacts were copied to library_install_prefix
        assert (builder.library_install_prefix / "lib" / "libtest.a").exists()
        assert (
            builder.library_install_prefix / "lib" / "libtest.a"
        ).read_text() == "fake static lib"
        assert (builder.library_install_prefix / "include" / "test.h").exists()
        assert (
            builder.library_install_prefix / "include" / "test.h"
        ).read_text() == "fake header"

    def test_noop_when_distdir_missing(self, tmp_path):
        builder = RecipeBuilder.get_builder(
            recipe=RECIPE_DIR / "libtest",
            build_args=BuildArgs(),
            build_dir=tmp_path / "libtest" / "build",
        )

        # src_dist_dir does not exist, should not raise
        assert not builder.src_dist_dir.exists()
        builder._install_to_library_dir()
        assert not builder.library_install_prefix.exists()

    def test_merges_with_existing_library_dir(self, tmp_path):
        builder = RecipeBuilder.get_builder(
            recipe=RECIPE_DIR / "libtest",
            build_args=BuildArgs(),
            build_dir=tmp_path / "libtest" / "build",
        )

        # Pre-populate library_install_prefix with existing artifacts
        lib_dir = builder.library_install_prefix / "lib"
        lib_dir.mkdir(parents=True)
        (lib_dir / "libexisting.a").write_text("existing lib")

        # Create new artifacts in src_dist_dir
        builder.src_dist_dir.mkdir(parents=True, exist_ok=True)
        dist_lib_dir = builder.src_dist_dir / "lib"
        dist_lib_dir.mkdir()
        (dist_lib_dir / "libtest.a").write_text("new lib")

        builder._install_to_library_dir()

        # Both old and new artifacts should exist
        assert (
            builder.library_install_prefix / "lib" / "libexisting.a"
        ).read_text() == "existing lib"
        assert (
            builder.library_install_prefix / "lib" / "libtest.a"
        ).read_text() == "new lib"


class TestCreateLibraryArchive:
    """Tests for _create_library_archive method."""

    @pytest.fixture(autouse=True)
    def _cleanup_dist_dir(self):
        dist_dir = RECIPE_DIR / "libtest" / "dist"
        yield
        shutil.rmtree(dist_dir, ignore_errors=True)

    def _populate_dist_dir(self, builder):
        """Set up a dist_dir with typical FHS-structured library artifacts."""
        builder.dist_dir.mkdir(parents=True, exist_ok=True)
        lib_dir = builder.dist_dir / "lib"
        include_dir = builder.dist_dir / "include"
        pkgconfig_dir = lib_dir / "pkgconfig"
        lib_dir.mkdir()
        include_dir.mkdir()
        pkgconfig_dir.mkdir(parents=True)
        (lib_dir / "libtest.a").write_text("fake static lib")
        (include_dir / "test.h").write_text("fake header")
        (pkgconfig_dir / "test.pc").write_text("Name: test\nVersion: 1.0.0\n")

    def test_creates_tar_gz_archive(self, tmp_path):
        builder = RecipeBuilder.get_builder(
            recipe=RECIPE_DIR / "libtest",
            build_args=BuildArgs(),
            build_dir=tmp_path / "libtest" / "build",
        )
        self._populate_dist_dir(builder)

        archive_path = builder._create_library_archive()

        assert archive_path is not None
        assert archive_path.exists()
        assert archive_path.name == "libtest-1.0.0-wasm32.tar.gz"
        assert archive_path.parent == builder.dist_dir

    def test_archive_contains_all_artifacts(self, tmp_path):
        builder = RecipeBuilder.get_builder(
            recipe=RECIPE_DIR / "libtest",
            build_args=BuildArgs(),
            build_dir=tmp_path / "libtest" / "build",
        )
        self._populate_dist_dir(builder)

        archive_path = builder._create_library_archive()

        with tarfile.open(archive_path, "r:gz") as tf:
            names = {m.name for m in tf.getmembers() if m.isfile()}

        assert "./lib/libtest.a" in names
        assert "./include/test.h" in names
        assert "./lib/pkgconfig/test.pc" in names

    def test_returns_none_when_dist_dir_missing(self, tmp_path):
        builder = RecipeBuilder.get_builder(
            recipe=RECIPE_DIR / "libtest",
            build_args=BuildArgs(),
            build_dir=tmp_path / "libtest" / "build",
        )

        assert not builder.dist_dir.exists()
        assert builder._create_library_archive() is None

    def test_returns_none_when_dist_dir_empty(self, tmp_path):
        builder = RecipeBuilder.get_builder(
            recipe=RECIPE_DIR / "libtest",
            build_args=BuildArgs(),
            build_dir=tmp_path / "libtest" / "build",
        )
        builder.dist_dir.mkdir(parents=True)

        assert builder._create_library_archive() is None

    def test_archive_is_extractable_with_correct_layout(self, tmp_path):
        builder = RecipeBuilder.get_builder(
            recipe=RECIPE_DIR / "libtest",
            build_args=BuildArgs(),
            build_dir=tmp_path / "libtest" / "build",
        )
        self._populate_dist_dir(builder)

        archive_path = builder._create_library_archive()

        extract_dir = tmp_path / "extracted"
        shutil.unpack_archive(archive_path, extract_dir)

        assert (extract_dir / "lib" / "libtest.a").read_text() == "fake static lib"
        assert (extract_dir / "include" / "test.h").read_text() == "fake header"
        assert (extract_dir / "lib" / "pkgconfig" / "test.pc").exists()