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
"""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"