claude-proxy / tests /runtime /test_integration_startup.py
dheraingoud's picture
Copilot App
Sync upstream v6.19.35 and preserve custom addons
a9e27c0
Raw History Blame Contribute Delete
15.7 kB
import asyncio
import json
import subprocess
import threading
from unittest.mock import AsyncMock, MagicMock
import httpx
import pytest
from free_claude_code.api.app import create_app
from free_claude_code.api.ports import ApiServices
from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.application.readiness import InitializationWait
from free_claude_code.config.api_keys import normalize_api_keys
from free_claude_code.config.loader import ManagedConfigStore
from free_claude_code.config.paths import claude_desktop_disconnect_path
from free_claude_code.config.settings import Settings
from free_claude_code.core.gateway_model_ids import desktop_model_id
from free_claude_code.harnesses import (
claude_desktop_integration as desktop,
)
from free_claude_code.harnesses import (
claude_integration,
claude_onboarding,
codex_integration,
)
from free_claude_code.harnesses import (
jetbrains_acp_integration as jb,
)
from free_claude_code.providers.base import BaseProvider
from free_claude_code.providers.runtime.runtime import ProviderRuntime
from free_claude_code.runtime.application import ApplicationRuntime
from free_claude_code.runtime.configuration import ConfigurationService
from free_claude_code.runtime.provider_manager import ProviderRuntimeManager
from tests.harnesses.test_integration_refresh import OLD_CLAUDE, OLD_CODEX, TOKEN
from tests.harnesses.test_jetbrains_acp_integration import install, write
from tests.web_tools_support import StubWebToolsClient
@pytest.fixture
def runtime():
settings = Settings().model_copy(
update={
"port": 8000,
"proxy_auth_token": TOKEN,
"messaging_platform": "none",
"model": "nvidia_nim/one",
"nvidia_nim_api_keys": normalize_api_keys("test"),
}
)
provider = MagicMock(spec=BaseProvider)
provider.list_model_infos = AsyncMock(
return_value=frozenset({ProviderModelInfo("one")})
)
async def construct(
_id, _settings, _admission_registry, _api_key_number, _history_cache=None
):
if _id in {"lmstudio", "llamacpp", "ollama"}:
raise ConnectionError("Local fixture is offline")
return provider
manager = ProviderRuntimeManager(
settings,
runtime_factory=lambda snapshot, admission_registry, history_cache=None: (
ProviderRuntime(
snapshot, admission_registry, provider_constructor=construct
)
),
)
return ApplicationRuntime(
manager,
configuration=ConfigurationService(ManagedConfigStore()),
transcriber=None,
)
def old_connections():
claude, codex = claude_integration.settings_path(), codex_integration.config_path()
claude.parent.mkdir(parents=True)
codex.parent.mkdir(parents=True)
claude.write_text(json.dumps(OLD_CLAUDE))
codex.write_text(OLD_CODEX)
return claude, codex
@pytest.mark.asyncio
async def test_jetbrains_startup_refresh_and_failed_discovery_allow_disconnect(
runtime, monkeypatch
):
install(jb.registry_path(), jb.system_root())
monkeypatch.setattr(
jb.subprocess,
"run",
lambda args, **kw: subprocess.CompletedProcess(args, 0, "v24.19.0", ""),
)
write(
jb.config_path(),
{
"agent_servers": {
"Claude Code (FCC)": {
"command": "old-node",
"env": {"FCC_JETBRAINS_ACP": "1", "ANTHROPIC_AUTH_TOKEN": "old"},
}
}
},
)
try:
await runtime.start()
await asyncio.wait_for(runtime._integrations._jetbrains_update.task, 5)
status = await runtime.jetbrains_acp_status()
assert status["connected"] is True
assert status["update"]["changed"] is True
entry = json.loads(jb.config_path().read_text())["agent_servers"][
"Claude Code (FCC)"
]
assert entry["env"]["ANTHROPIC_AUTH_TOKEN"] == TOKEN
assert entry["env"]["ANTHROPIC_BASE_URL"] == "http://127.0.0.1:8000"
jb.registry_path().unlink()
await runtime.refresh_jetbrains_acp()
await asyncio.wait_for(runtime._integrations._jetbrains_update.task, 5)
status = await runtime.jetbrains_acp_status()
assert status["update"]["state"] == "failed"
assert status["connected"] is True
assert (await runtime.disconnect_jetbrains_acp())["connected"] is False
finally:
await runtime.close()
async def finish(runtime):
await asyncio.wait_for(
asyncio.gather(
runtime._integrations._claude_update.task,
runtime._integrations._codex_update.task,
),
5,
)
@pytest.mark.asyncio
async def test_startup_refreshes_old_connections_and_status_is_read_only(runtime):
claude, codex = old_connections()
try:
await runtime.start()
await finish(runtime)
for status in (
await runtime.claude_vscode_status(),
await runtime.codex_integration_status(),
):
assert status["connected"] is True
assert status["update"] == {
"state": "ready",
"changed": True,
"message": None,
}
before = [p.stat().st_mtime_ns for p in (claude, codex)]
await runtime.claude_vscode_status()
await runtime.codex_integration_status()
assert [p.stat().st_mtime_ns for p in (claude, codex)] == before
assert not claude_onboarding.state_path().exists()
await runtime.disconnect_claude_vscode()
assert (await runtime.claude_vscode_status())["update"]["changed"] is False
await runtime.refresh_claude_vscode()
await runtime._integrations._claude_update.task
assert (await runtime.claude_vscode_status())["connected"] is False
finally:
await runtime.close()
@pytest.mark.asyncio
@pytest.mark.parametrize("source", ['{"hasCompletedOnboarding":false}', "{invalid"])
async def test_startup_preserves_global_onboarding(runtime, source):
old_connections()
state = claude_onboarding.state_path()
state.write_text(source)
try:
await runtime.start()
await finish(runtime)
assert (await runtime.claude_vscode_status())["connected"] is True
assert state.read_text() == source
finally:
await runtime.close()
@pytest.mark.asyncio
async def test_codex_wait_does_not_delay_http_or_claude(runtime, monkeypatch):
old_connections()
entered, release = asyncio.Event(), asyncio.Event()
wait_for_catalog = runtime.provider_manager.wait_for_catalog_file
async def held(wait):
assert wait.remaining is None
entered.set()
await release.wait()
return await wait_for_catalog(wait)
monkeypatch.setattr(runtime.provider_manager, "wait_for_catalog_file", held)
app = create_app(
ApiServices(
runtime.provider_manager, runtime, runtime, web_tools=StubWebToolsClient()
)
)
try:
await asyncio.wait_for(runtime.start(), 1)
await asyncio.wait_for(entered.wait(), 5)
await asyncio.wait_for(runtime._integrations._claude_update.task, 5)
async with httpx.AsyncClient(
transport=httpx.ASGITransport(app=app), base_url="http://127.0.0.1"
) as client:
assert (await client.get("/health")).status_code == 200
status = (await client.get("/admin/api/integrations/codex")).json()
assert status["connected"] is None
assert status["update"]["state"] == "starting"
assert (await runtime.claude_vscode_status())["connected"] is True
assert (await client.get("/admin/api/status")).json()["startup"][
"integrations"
]["codex"]["state"] == "starting"
release.set()
await finish(runtime)
assert (await runtime.codex_integration_status())["connected"] is True
finally:
release.set()
await runtime.close()
@pytest.mark.asyncio
async def test_unrecognized_codex_never_waits_for_catalog(runtime, monkeypatch):
wait = AsyncMock(side_effect=AssertionError("No connection to refresh"))
monkeypatch.setattr(runtime.provider_manager, "wait_for_catalog_file", wait)
try:
await runtime.start()
await finish(runtime)
wait.assert_not_awaited()
assert (await runtime.codex_integration_status())["connected"] is False
assert not codex_integration.config_path().exists()
assert not claude_onboarding.state_path().exists()
finally:
await runtime.close()
@pytest.mark.asyncio
async def test_update_failure_is_isolated_and_retry_finishes(runtime):
claude, _ = old_connections()
claude.write_text("{secret-invalid-json")
try:
await runtime.start()
await finish(runtime)
status = await runtime.claude_vscode_status()
assert status["update"]["state"] == "failed"
assert "secret" not in status["update"]["message"]
assert (await runtime.codex_integration_status())["connected"] is True
claude.write_text(json.dumps(OLD_CLAUDE))
assert (await runtime.claude_vscode_status())["update"]["state"] == "failed"
assert "CLAUDE_CODE_DISABLE_ADVISOR_TOOL" not in claude.read_text()
await runtime.refresh_claude_vscode()
task = runtime._integrations._claude_update.task
await runtime.refresh_claude_vscode()
assert runtime._integrations._claude_update.task is task
await asyncio.wait_for(task, 5)
assert (await runtime.claude_vscode_status())["connected"] is True
finally:
await runtime.close()
@pytest.mark.asyncio
async def test_shutdown_drains_integration_writer(runtime, monkeypatch):
entered, release = threading.Event(), threading.Event()
write = claude_integration.refresh_connected
def held(*args):
entered.set()
assert release.wait(5)
return write(*args)
monkeypatch.setattr(claude_integration, "refresh_connected", held)
close = None
try:
await runtime.start()
assert await asyncio.to_thread(entered.wait, 5)
close = asyncio.create_task(runtime.close())
await asyncio.sleep(0)
assert not close.done()
release.set()
assert await asyncio.wait_for(close, 5)
finally:
release.set()
if close is not None:
await close
else:
await runtime.close()
@pytest.mark.asyncio
async def test_unbounded_initialization_wait_remains_owned_on_cancel():
release = asyncio.Event()
work = asyncio.create_task(release.wait())
wait = InitializationWait(None)
observer = asyncio.create_task(wait.wait(work))
try:
await asyncio.sleep(0)
observer.cancel()
with pytest.raises(asyncio.CancelledError):
await observer
assert not work.done()
release.set()
assert await wait.wait(work)
assert wait.remaining is None
finally:
release.set()
await work
@pytest.mark.asyncio
async def test_codex_refresh_rechecks_catalog_generation_before_writing(
runtime, monkeypatch
):
old_connections()
original = runtime.provider_manager.wait_for_catalog_file
calls = 0
async def replace_after_wait(wait):
nonlocal calls
generation = await original(wait)
calls += 1
if calls == 1:
settings = runtime.settings.model_copy(update={"model": "nvidia_nim/new"})
await runtime.provider_manager.replace(settings, commit=AsyncMock())
return generation
monkeypatch.setattr(
runtime.provider_manager, "wait_for_catalog_file", replace_after_wait
)
try:
await runtime.start()
await finish(runtime)
assert calls == 2
assert (await runtime.codex_integration_status())["connected"] is True
finally:
await runtime.close()
@pytest.mark.asyncio
@pytest.mark.parametrize("integration", ["claude-vscode", "codex"])
async def test_refresh_endpoint_is_local_only_and_does_not_connect(
runtime, integration
):
app = create_app(
ApiServices(
runtime.provider_manager, runtime, runtime, web_tools=StubWebToolsClient()
)
)
try:
await runtime.start()
await finish(runtime)
async with httpx.AsyncClient(
transport=httpx.ASGITransport(app=app), base_url="http://127.0.0.1"
) as client:
path = f"/admin/api/integrations/{integration}"
blocked = await client.post(
path + "/refresh", headers={"Origin": "https://other.test"}
)
assert blocked.status_code == 403
response = await client.post(path + "/refresh")
assert response.status_code == 200
assert response.json()["update"]["state"] == "starting"
await finish(runtime)
assert (await client.get(path)).json()["connected"] is False
assert not claude_integration.settings_path().exists()
assert not codex_integration.config_path().exists()
finally:
await runtime.close()
@pytest.mark.asyncio
async def test_desktop_startup_rotates_selected_profile_and_disconnect_stays_off(
runtime,
):
root = desktop.config_root()
desktop.configure(
root,
"http://localhost:9999",
"old-token",
True,
disconnect_path=claude_desktop_disconnect_path(),
)
profile = root / "configLibrary" / f"{desktop.FCC_ID}.json"
config = json.loads(profile.read_text())
models = [
{"name": desktop_model_id("nvidia_nim/one"), "labelOverride": "Pinned model"},
{"name": desktop_model_id("nvidia_nim/two"), "maxEffort": "high"},
]
config["inferenceModels"] = models
profile.write_text(json.dumps(config))
try:
await runtime.start()
await runtime._integrations._desktop_update.task
refreshed = json.loads(profile.read_text())
assert refreshed["inferenceModels"] == models
assert refreshed["inferenceGatewayApiKey"] == TOKEN
assert refreshed["inferenceGatewayBaseUrl"] == "http://127.0.0.1:8000"
result = await runtime.claude_desktop_status()
assert result["connected"] is True
assert result["update"]["changed"] is True
before = {p: p.stat().st_mtime_ns for p in root.rglob("*.json")}
await runtime.claude_desktop_status()
assert before == {p: p.stat().st_mtime_ns for p in root.rglob("*.json")}
await runtime.disconnect_claude_desktop()
await runtime.refresh_claude_desktop()
await runtime._integrations._desktop_update.task
assert (await runtime.claude_desktop_status())["connected"] is False
finally:
await runtime.close()
@pytest.mark.asyncio
async def test_desktop_failure_does_not_block_other_startup(runtime, monkeypatch):
def fail(*args, **kwargs):
raise ValueError("private-invalid-file")
monkeypatch.setattr(desktop, "refresh_connected", fail)
try:
await runtime.start()
await runtime._integrations._desktop_update.task
await finish(runtime)
assert runtime._integrations._desktop_update.state == "failed"
assert (
"private-invalid-file" not in runtime._integrations._desktop_update.message
)
assert runtime._integrations._claude_update.state == "ready"
assert runtime._integrations._codex_update.state == "ready"
finally:
await runtime.close()