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
import asyncio
import io
import threading
from concurrent.futures import ThreadPoolExecutor
from unittest.mock import patch
import pytest
from free_claude_code.config import loader
from free_claude_code.config.admin.persistence import prepare_admin_update
from free_claude_code.config.env_files import FCC_CONFIG_SCHEMA_ENV
from free_claude_code.config.env_migrations import CONFIG_SCHEMA_VERSION
from free_claude_code.config.loader import ManagedConfigStore
from free_claude_code.config.paths import config_lock_path
from free_claude_code.core.interprocess_lock import InterprocessFileLock
from free_claude_code.runtime.configuration import ConfigurationService
def test_reads_are_fresh_read_only_snapshots():
store = ManagedConfigStore()
store.initialize()
for port in (8123, 8124):
store.path.write_text(
f"{FCC_CONFIG_SCHEMA_ENV}={CONFIG_SCHEMA_VERSION}\nPORT={port}\n"
)
with patch(
"free_claude_code.config.loader.consolidate_managed_config",
side_effect=AssertionError("read migrated"),
):
snapshot = store.read()
assert snapshot.settings.port == port
assert snapshot.managed["PORT"] == str(port)
def test_read_does_not_recreate_missing_storage():
store = ManagedConfigStore()
with pytest.raises(ValueError, match="initializ"):
store.read()
assert not store.path.exists()
def test_preparation_uses_captured_disk_and_process_state(monkeypatch):
store = ManagedConfigStore()
store.initialize()
snapshot = store.read({"PORT": "8123"})
monkeypatch.setenv("PORT", "9999")
store.path.unlink()
prepared = prepare_admin_update(
{"PORT": "8124"}, snapshot, snapshot.settings, revision_key=b"test-revision-key"
)
assert prepared.settings is not None
assert prepared.settings.port == 8123
assert "PORT" not in prepared.target_values
@pytest.mark.asyncio
async def test_read_waits_for_storage_lock_without_blocking_event_loop():
store = ManagedConfigStore()
store.initialize()
service = ConfigurationService(store)
with InterprocessFileLock(config_lock_path()):
reader = asyncio.create_task(service.admin_values())
done, _ = await asyncio.wait({reader}, timeout=0.1)
try:
assert not done
finally:
await asyncio.wait_for(reader, 5)
@pytest.mark.parametrize("schema", ["", "999"])
def test_reads_and_commits_fail_closed_on_uninitialized_or_newer_schema(schema):
store = ManagedConfigStore()
store.initialize()
text = f"FCC_CONFIG_SCHEMA={schema}\nANTHROPIC_AUTH_TOKEN=preserve\n"
store.path.write_text(text)
with pytest.raises(ValueError, match="schema"):
store.read()
with pytest.raises(ValueError, match="schema"):
store.commit({"FCC_CONFIG_SCHEMA": "1"})
assert store.path.read_text() == text
def test_cooperative_commits_are_serialized_and_leave_complete_files():
store = ManagedConfigStore()
store.initialize()
original = loader.atomic_write_managed_config
writing = threading.Lock()
seen = []
def checked_write(values, **kwargs):
probe = InterprocessFileLock(config_lock_path())
try:
assert not probe.acquire(), "commit does not hold the shared write lock"
finally:
probe.release()
assert writing.acquire(blocking=False), "cooperative writes overlap"
try:
seen.append(values["PORT"])
return original(values, **kwargs)
finally:
writing.release()
def write(port):
ManagedConfigStore().commit({"FCC_CONFIG_SCHEMA": "1", "PORT": str(port)})
with (
patch(
"free_claude_code.config.loader.atomic_write_managed_config", checked_write
),
ThreadPoolExecutor(max_workers=8) as executor,
):
list(executor.map(write, range(8120, 8128)))
assert len(seen) == 8
assert store.read().managed["PORT"] == seen[-1]
assert not list(store.path.parent.glob("*.tmp"))
def test_atomic_commit_waits_for_an_open_snapshot_reader(monkeypatch):
store = ManagedConfigStore()
store.initialize()
store.commit({"FCC_CONFIG_SCHEMA": "1", "PORT": "8123"})
opened, release = threading.Event(), threading.Event()
original_open = io.open
reader_thread = None
def hold_reader(path, *args, **kwargs):
handle = original_open(path, *args, **kwargs)
if path == store.path and threading.current_thread() is reader_thread:
opened.set()
if not release.wait(5):
handle.close()
raise TimeoutError("snapshot reader was not released")
return handle
def read_snapshot():
nonlocal reader_thread
reader_thread = threading.current_thread()
return store.read({})
monkeypatch.setattr(io, "open", hold_reader)
with ThreadPoolExecutor(max_workers=2) as executor:
reader = executor.submit(read_snapshot)
writer = None
try:
assert opened.wait(5)
writer = executor.submit(
store.commit, {"FCC_CONFIG_SCHEMA": "1", "PORT": "8124"}
)
with pytest.raises(TimeoutError):
writer.result(timeout=0.1)
finally:
release.set()
assert reader.result(timeout=5).settings.port == 8123
assert writer.result(timeout=5) is None
assert store.read({}).settings.port == 8124
assert not list(store.path.parent.glob("*.tmp"))
@pytest.mark.asyncio
@pytest.mark.parametrize(
"operation", ["initialize", "admin_config", "admin_values", "prepare", "commit"]
)
async def test_storage_work_does_not_block_event_loop(operation):
store = ManagedConfigStore()
store.initialize()
service = ConfigurationService(store)
active = store.read().settings
prepared = await service.prepare({"PORT": "8123"}, active)
entered = threading.Event()
release = threading.Event()
heartbeat = asyncio.Event()
method = {"admin_config": "read", "admin_values": "read", "prepare": "read"}.get(
operation, operation
)
original = getattr(store, method)
def blocked(*args, **kwargs):
entered.set()
assert release.wait(5), "event loop failed to release storage"
assert heartbeat.is_set()
return original(*args, **kwargs)
async def observe():
while not entered.is_set():
await asyncio.sleep(0)
heartbeat.set()
release.set()
observer = asyncio.create_task(observe())
try:
with patch.object(store, method, side_effect=blocked):
if operation == "prepare":
await service.prepare({"PORT": "8124"}, active)
elif operation == "commit":
await service.commit(prepared)
else:
await getattr(service, operation)()
await asyncio.wait_for(observer, 5)
finally:
release.set()
observer.cancel()