test_brewprovider.py

from .conftest import (
    _brew_formula_is_installed,
)
import logging
import shutil
import tempfile

from pathlib import Path

import pytest

from abxpkg import Binary, BrewProvider, SemVer
from abxpkg.exceptions import BinaryInstallError


class TestBrewProvider:
    def test_shallow_repository_uses_homebrew_owned_version_floor(
        self,
        tmp_path,
        test_machine,
    ):
        host_brew = Path(test_machine.require_tool("brew")).resolve()
        host_repository = host_brew.parent.parent
        brew_repository = tmp_path / "homebrew"
        brew_binary = brew_repository / "bin" / "brew"
        brew_binary.parent.mkdir(parents=True)
        shutil.copy2(host_brew, brew_binary)

        git_dir = brew_repository / ".git"
        (git_dir / "refs" / "heads").mkdir(parents=True)
        (git_dir / "refs" / "tags").mkdir(parents=True)
        (git_dir / "HEAD").write_text("ref: refs/heads/main\n")
        (git_dir / "refs" / "heads" / "main").write_text("a" * 40 + "\n")
        (git_dir / "refs" / "tags" / "99.0.0").write_text("b" * 40 + "\n")

        brew_script = brew_repository / "Library" / "Homebrew" / "brew.sh"
        brew_script.parent.mkdir(parents=True)
        shutil.copy2(
            host_repository / "Library" / "Homebrew" / "brew.sh",
            brew_script,
        )

        version = BrewProvider().installer_version_handler(
            "brew",
            abspath=brew_binary,
        )

        assert version == SemVer("4.3.0")

    def test_install_root_alias_symlinks_formula_into_requested_bin_dir(
        self,
        test_machine,
    ):
        test_machine.require_tool("brew")
        formula = test_machine.pick_missing_brew_formula()

        with tempfile.TemporaryDirectory() as temp_dir:
            install_root = Path(temp_dir) / "brew-root"
            provider = BrewProvider(
                install_root=install_root,
                postinstall_scripts=True,
                min_release_age=3,
            )

            installed = provider.install(formula, no_cache=True)
            assert installed is not None
            bin_dir = provider.bin_dir
            assert bin_dir is not None

            test_machine.assert_shallow_binary_loaded(installed)
            assert provider.install_root == install_root.resolve()
            assert bin_dir == (install_root / "bin").resolve()
            assert installed.loaded_abspath is not None
            assert installed.loaded_abspath == bin_dir / formula
            assert installed.loaded_abspath.is_symlink()
            assert installed.loaded_abspath.resolve() != installed.loaded_abspath

            provider.uninstall(formula, quiet=True, no_cache=True)
            assert not installed.loaded_abspath.exists()

    def test_provider_direct_methods_exercise_real_lifecycle(self, test_machine):
        test_machine.require_tool("brew")
        formula = test_machine.pick_missing_brew_formula()
        provider = BrewProvider(postinstall_scripts=True, min_release_age=3)

        installed, _ = test_machine.exercise_provider_lifecycle(
            provider,
            bin_name=formula,
        )
        assert provider.install_root is not None
        assert provider.bin_dir == provider.install_root / "bin"
        assert installed.loaded_abspath is not None
        assert installed.loaded_abspath.parent == provider.bin_dir

    def test_unsupported_min_release_age_warns_and_continues(
        self,
        test_machine,
        caplog,
    ):
        test_machine.require_tool("brew")
        formula = test_machine.pick_missing_brew_formula()

        provider_for_cleanup = BrewProvider(
            postinstall_scripts=False,
            min_release_age=3,
        )
        try:
            with caplog.at_level(logging.WARNING, logger="abxpkg.binprovider"):
                installed = BrewProvider().install(
                    formula,
                    min_release_age=1,
                )
            test_machine.assert_shallow_binary_loaded(installed)
            assert "ignoring unsupported min_release_age=1" in caplog.text

            caplog.clear()
            binary = Binary(
                name=formula,
                binproviders=[BrewProvider()],
                postinstall_scripts=False,
                min_release_age=1,
            )
            with caplog.at_level(logging.WARNING, logger="abxpkg.binprovider"):
                installed = binary.install(no_cache=True)
            test_machine.assert_shallow_binary_loaded(installed)
            assert "ignoring unsupported min_release_age=1" in caplog.text
        finally:
            provider_for_cleanup.uninstall(formula, quiet=True, no_cache=True)

    def test_postinstall_disable_is_live_and_min_version_is_enforced(
        self,
        test_machine,
    ):
        test_machine.require_tool("brew")
        formula = test_machine.pick_missing_brew_formula()
        provider = BrewProvider(postinstall_scripts=True, min_release_age=3)

        installed = provider.install(
            formula,
            postinstall_scripts=False,
            min_release_age=3,
            no_cache=True,
        )
        test_machine.assert_shallow_binary_loaded(installed)

        updated = provider.update(
            formula,
            postinstall_scripts=False,
            min_release_age=3,
            no_cache=True,
        )
        test_machine.assert_shallow_binary_loaded(updated)

        with pytest.raises(ValueError):
            provider.update(
                formula,
                postinstall_scripts=True,
                min_release_age=3,
                min_version=SemVer("999.0.0"),
                no_cache=True,
            )

        too_new = Binary(
            name=formula,
            binproviders=[
                BrewProvider(postinstall_scripts=True, min_release_age=3),
            ],
            postinstall_scripts=True,
            min_release_age=3,
            min_version=SemVer("999.0.0"),
        )
        with pytest.raises(BinaryInstallError):
            too_new.install(no_cache=True)

    def test_helper_install_args_used_by_native_brew_backend(self, test_machine):
        test_machine.require_tool("brew")
        # Keep this multi-package contract independent of the lifecycle
        # candidate picker. ``watch`` pulls a comparatively large dependency
        # closure on fresh macOS runners, while these two leaf formulae test
        # the same native multi-argument install path.
        primary = "hello"
        extra = "fzy"

        cleanup_provider = BrewProvider(
            postinstall_scripts=True,
            min_release_age=3,
        )
        for pkg in (primary, extra):
            if _brew_formula_is_installed(cleanup_provider, pkg):
                assert cleanup_provider.uninstall(pkg, no_cache=True) is True
            assert not _brew_formula_is_installed(cleanup_provider, pkg)

        provider = BrewProvider(
            postinstall_scripts=True,
            min_release_age=3,
        ).get_provider_with_overrides(
            overrides={primary: {"install_args": [primary, extra]}},
        )

        installed = provider.install(primary, no_cache=True)
        test_machine.assert_shallow_binary_loaded(installed)

        assert _brew_formula_is_installed(provider, primary)
        assert _brew_formula_is_installed(provider, extra)

        assert provider.uninstall(primary, no_cache=True) is True
        assert not _brew_formula_is_installed(provider, primary)
        assert not _brew_formula_is_installed(provider, extra)

    def test_binary_direct_methods_exercise_real_lifecycle(self, test_machine):
        test_machine.require_tool("brew")
        formula = test_machine.pick_missing_brew_formula()
        binary = Binary(
            name=formula,
            binproviders=[
                BrewProvider(postinstall_scripts=True, min_release_age=3),
            ],
            postinstall_scripts=True,
            min_release_age=3,
        )
        test_machine.exercise_binary_lifecycle(binary)

    def test_provider_dry_run_does_not_install_formula(self, test_machine):
        test_machine.require_tool("brew")
        provider = BrewProvider(postinstall_scripts=False, min_release_age=3)
        test_machine.exercise_provider_dry_run(
            provider,
            bin_name=test_machine.pick_missing_brew_formula(),
        )

    def test_search_finds_real_brew_formula_and_install_works(self, test_machine):
        test_machine.require_tool("brew")
        provider = BrewProvider(postinstall_scripts=True, min_release_age=3)
        results = provider.search("jq")
        assert results, "brew search jq should return matches"
        names = [r.name for r in results]
        assert "jq" in names
        match = next(r for r in results if r.name == "jq")
        assert match.overrides == {"brew": {"install_args": ["jq"]}}
        assert match.loaded_abspath is None
        assert match.loaded_version is None
        provider.uninstall("jq", quiet=True, no_cache=True)
        installed = match.install()
        test_machine.assert_shallow_binary_loaded(installed)
        assert installed.name == "jq"