Spaces:
Running
Running
Download tests/runtime/test_integration_startup.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 15.7 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/tests/runtime/test_integration_startup.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/tests/runtime/test_integration_startup.py
-
curl -L -o test_integration_startup.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/tests/runtime/test_integration_startup.py
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 | |
| 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 | |
| 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, | |
| ) | |
| 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() | |
| 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() | |
| 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() | |
| 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() | |
| 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() | |
| 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() | |
| 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 | |
| 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() | |
| 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() | |
| 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() | |
| 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() | |