Skip to content

Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)

Python
8.3 KB
Raw Blame
"""macOS runtime discovery and transactional application installation."""

import os
import plistlib
import subprocess
from pathlib import Path

import pytest

from free_claude_code.cli import macos_app


@pytest.fixture
def runtime(tmp_path, monkeypatch):
    base = tmp_path / "managed python"
    library = base / "lib/libpython3.14.dylib"
    library.parent.mkdir(parents=True)
    library.write_bytes(b"library")
    executable = tmp_path / "venv's 日本語/bin/python"
    executable.parent.mkdir(parents=True)
    executable.write_bytes(b"python")
    executable.chmod(0o755)
    monkeypatch.setattr(macos_app.sys, "executable", str(executable))
    monkeypatch.setattr(macos_app.sys, "base_prefix", str(base))
    monkeypatch.setattr(macos_app.platform, "python_implementation", lambda: "CPython")
    monkeypatch.setattr(macos_app.platform, "python_version", lambda: "3.14.7")
    monkeypatch.setattr(macos_app.platform, "machine", lambda: "x86_64")
    variables = {"LDLIBRARY": library.name, "Py_GIL_DISABLED": 0, "Py_DEBUG": 0}
    monkeypatch.setattr(macos_app.sysconfig, "get_config_var", variables.get)
    monkeypatch.setattr(
        macos_app, "metadata", lambda name: {"Requires-Python": "==3.14.7"}
    )
    return executable, library, variables


def test_runtime_uses_venv_executable_and_interpreter_architecture(runtime):
    executable, library, _variables = runtime
    settings, architecture = macos_app.runtime_settings()
    assert settings == {
        "PythonExecutable": str(executable),
        "PythonLibrary": str(library),
        "PythonVersion": "3.14.7",
    }
    assert architecture == "x86_64"


def test_runtime_keeps_symlinked_venv_identity(runtime):
    executable, library, _variables = runtime
    base_executable = library.parent / "python"
    executable.rename(base_executable)
    executable.symlink_to(base_executable)
    settings, _architecture = macos_app.runtime_settings()
    assert settings["PythonExecutable"] == str(executable)
    assert Path(settings["PythonExecutable"]).resolve() == base_executable


def test_unsupported_interpreter_architecture_is_rejected(runtime, monkeypatch):
    monkeypatch.setattr(macos_app.platform, "machine", lambda: "armv7l")
    with pytest.raises(ValueError, match="architecture"):
        macos_app.runtime_settings()


@pytest.mark.parametrize("variable", ["Py_GIL_DISABLED", "Py_DEBUG"])
def test_unsupported_runtime_build_is_rejected(runtime, variable):
    runtime[2][variable] = 1
    with pytest.raises(ValueError, match="release"):
        macos_app.runtime_settings()


def test_missing_runtime_library_is_rejected(runtime):
    runtime[1].unlink()
    with pytest.raises(ValueError, match="library"):
        macos_app.runtime_settings()


def test_wrong_python_version_is_rejected(runtime, monkeypatch):
    monkeypatch.setattr(macos_app.platform, "python_version", lambda: "3.15.0")
    with pytest.raises(ValueError, match="version"):
        macos_app.runtime_settings()


@pytest.fixture
def installer(tmp_path, monkeypatch, runtime):
    home = tmp_path / "home's 日本語"
    home.mkdir()
    resources = tmp_path / "package"
    templates = resources / "assets/macos"
    templates.mkdir(parents=True)
    (templates / "fcc-desktop-x86_64").write_bytes(b"intel template")
    (templates / "fcc-desktop-arm64").write_bytes(b"arm template")
    monkeypatch.setattr(macos_app, "files", lambda package: resources)
    monkeypatch.setattr(macos_app.Path, "home", lambda: home)
    monkeypatch.setattr(macos_app.sys, "platform", "darwin")
    calls = []

    def sign(command, **kwargs):
        bundle = Path(command[-1])
        assert (bundle / "Contents/Resources/runtime.plist").is_file()
        assert (bundle / "Contents/Resources/.free-claude-code-owner").is_file()
        assert (bundle / "Contents/MacOS/fcc-desktop").read_bytes() == b"intel template"
        calls.append(command)

    monkeypatch.setattr(macos_app.subprocess, "run", sign)
    return home, resources, calls


def test_complete_bundle_is_signed_before_publication(installer, runtime):
    home, _resources, calls = installer
    app = macos_app.install()
    assert app == home / "Applications/Free Claude Code.app"
    contents = app / "Contents"
    with (contents / "Info.plist").open("rb") as stream:
        info = plistlib.load(stream)
    assert info["CFBundleIdentifier"] == macos_app.BUNDLE_ID
    assert info["CFBundleExecutable"] == "fcc-desktop"
    assert info["LSUIElement"] and info["LSMultipleInstancesProhibited"]
    with (contents / "Resources/runtime.plist").open("rb") as stream:
        assert plistlib.load(stream)["PythonExecutable"] == str(runtime[0])
    assert (home / "Desktop/Free Claude Code.app").resolve() == app.resolve()
    assert [call[:-1] for call in calls] == [
        ["/usr/bin/codesign", "--force", "--sign", "-"],
        ["/usr/bin/codesign", "--verify", "--strict"],
    ]
    if os.name != "nt":
        assert (contents / "MacOS/fcc-desktop").stat().st_mode & 0o111 == 0o111


def owned_app(home):
    app = home / "Applications/Free Claude Code.app"
    (app / "Contents").mkdir(parents=True)
    (app / "Contents/.free-claude-code-owner").write_text(macos_app.BUNDLE_ID)
    (app / "old").write_text("preserve on failure")
    return app


def test_upgrade_replaces_legacy_owned_bundle_and_updates_runtime(
    installer, runtime, monkeypatch
):
    home, _resources, _calls = installer
    app = owned_app(home)
    macos_app.install()
    assert not (app / "old").exists()
    new_python = runtime[0].with_name("python-new")
    new_python.write_bytes(b"python")
    new_python.chmod(0o755)
    monkeypatch.setattr(macos_app.sys, "executable", str(new_python))
    macos_app.install()
    with (app / "Contents/Resources/runtime.plist").open("rb") as stream:
        assert plistlib.load(stream)["PythonExecutable"] == str(new_python)
    assert list(app.parent.iterdir()) == [app]


@pytest.mark.parametrize("failure", ["sign", "publish", "resource"])
def test_failure_preserves_existing_app(installer, monkeypatch, failure):
    home, resources, _calls = installer
    app = owned_app(home)
    if failure == "sign":

        def fail(*args, **kwargs):
            raise subprocess.CalledProcessError(1, "codesign")

        monkeypatch.setattr(macos_app.subprocess, "run", fail)
    elif failure == "publish":
        rename = Path.rename

        def fail(path, destination):
            if path.name == "Free Claude Code.app" and path != app:
                raise OSError("publication failed")
            return rename(path, destination)

        monkeypatch.setattr(Path, "rename", fail)
    else:
        (resources / "assets/macos/fcc-desktop-x86_64").unlink()
    with pytest.raises((OSError, subprocess.CalledProcessError)):
        macos_app.install()
    assert (app / "old").read_text() == "preserve on failure"
    assert list(app.parent.iterdir()) == [app]


def test_unowned_app_is_preserved(installer):
    home, _resources, calls = installer
    app = home / "Applications/Free Claude Code.app"
    app.mkdir(parents=True)
    with pytest.raises(ValueError, match="not managed"):
        macos_app.install()
    assert app.is_dir() and not calls


def test_failed_restore_keeps_backup_for_recovery(installer, monkeypatch):
    home, _resources, _calls = installer
    app = owned_app(home)
    rename = Path.rename

    def fail(path, destination):
        if destination == app:
            raise OSError("destination unavailable")
        return rename(path, destination)

    monkeypatch.setattr(Path, "rename", fail)
    with pytest.raises(OSError):
        macos_app.install()
    backups = list(app.parent.glob(".fcc-app-*/previous.app/old"))
    assert len(backups) == 1
    assert backups[0].read_text() == "preserve on failure"


def test_app_symlink_is_not_treated_as_owned(installer):
    home, _resources, _calls = installer
    app = owned_app(home)
    real = app.with_name("Other.app")
    app.rename(real)
    app.symlink_to(real, target_is_directory=True)
    with pytest.raises(ValueError, match="not managed"):
        macos_app.install()
    assert (real / "old").read_text() == "preserve on failure"


def test_unrelated_desktop_item_is_preserved(installer):
    home, _resources, _calls = installer
    desktop = home / "Desktop"
    desktop.mkdir()
    item = desktop / "Free Claude Code.app"
    item.write_text("unrelated")
    macos_app.install()
    assert item.read_text() == "unrelated"