claude-proxy / tests /api /test_admin.py
dheraingoud's picture
Copilot App
Sync upstream v6.19.35 and preserve custom addons
a9e27c0
Raw History Blame Contribute Delete
83.4 kB
import json import mimetypes import os from dataclasses import replace from pathlib import Path from unittest.mock import AsyncMock, patch import httpx import pytest from fastapi.testclient import TestClient from free_claude_code.application.connected_accounts import ( ConnectedAccountLoginMode, ConnectedAccountState, ConnectedAccountStatus, ) from free_claude_code.application.model_metadata import ( ProviderModelInfo, ProviderModelRefreshResult, ) from free_claude_code.config.admin.values import MASKED_SECRET from free_claude_code.config.api_keys import normalize_api_keys from free_claude_code.config.env_files import ( dotenv_values_from_file, dotenv_values_from_text, ) from free_claude_code.config.model_refs import ModelFallback, decode_model_fallbacks from free_claude_code.config.provider_catalog import PROVIDER_CATALOG from free_claude_code.config.server_urls import local_admin_url from free_claude_code.config.settings import Settings from free_claude_code.core.version import package_version from tests.api.support import ( create_test_app, post_config, provider_manager_for_app, runtime_for_app, ) def _local_client(app): return TestClient( app, base_url="http://127.0.0.1", client=("127.0.0.1", 50000), ) @pytest.mark.parametrize( "path", ( "/admin/chat", "/admin/chat/old-session", "/admin/api/chat/sessions", "/admin/api/chat/events", "/admin/api/chat/settings", f"/admin/assets/{package_version()}/chat_sessions.js", f"/admin/assets/{package_version()}/chat_sessions.css", ), ) def test_retired_chat_urls_are_not_served(path): client = _local_client(create_test_app()) assert client.get(path).status_code == 404 def test_admin_retains_code_without_chat_markup(): client = _local_client(create_test_app()) response = client.get("/admin") assert response.status_code == 200 assert 'id="view-code"' in response.text assert 'id="view-chat"' not in response.text assert "chat_sessions" not in response.text assert client.get("/admin/code").status_code == 200 def test_admin_retirement_preview_apply_and_runtime_agree(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) env_file.write_text( "FCC_CONFIG_SCHEMA=1\nMODEL=groq/default\nMODEL_OPUS=groq/managed\n" "GITHUB_MODELS_TOKEN=preserve-secret\nGITHUB_MODELS_PROXY=http://user:secret@proxy.test\nPRIVATE=hidden\n", encoding="utf-8", ) monkeypatch.setenv("MODEL_OPUS", "github_models/retired-process") app = create_test_app() client = _local_client(app) body = post_config( client, "/admin/api/config/apply", json={ "values": { "MODEL_SONNET": "github_models/stale", "MODEL_OPUS": "deepseek/cannot-unlock", "MODEL_FALLBACKS": "groq/a,github_models/old,deepseek/b", } }, ).json() assert body["applied"] text = env_file.read_text(encoding="utf-8") assert "MODEL=groq/default" in text assert "MODEL_SONNET" not in text assert "MODEL_OPUS=groq/managed" in text assert decode_model_fallbacks( dotenv_values_from_file(env_file)["MODEL_FALLBACKS"] ) == (ModelFallback(model="groq/a"), ModelFallback(model="deepseek/b")) assert "preserve-secret" in text and "http://user:secret@proxy.test" in text assert "preserve-secret" not in body["env_preview"] assert "http://user:secret@proxy.test" not in body["env_preview"] assert "PRIVATE=********" in body["env_preview"] effective = provider_manager_for_app(app).current_settings() assert effective.model == "groq/default" assert effective.model_opus is None and effective.model_sonnet is None assert effective.model_fallbacks == ( ModelFallback(model="groq/a"), ModelFallback(model="deepseek/b"), ) def test_admin_super_migration_preview_apply_and_runtime_agree(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) old = "nvidia_nim/nvidia/nemotron-3-super-120b-a12b" new = "nvidia_nim/nvidia/nemotron-3-ultra-550b-a55b" env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) env_file.write_text( "FCC_CONFIG_SCHEMA=2\nMODEL=groq/default\nMODEL_OPUS=groq/managed\nPRIVATE=hidden\n", encoding="utf-8", ) monkeypatch.setenv("MODEL_OPUS", old) app = create_test_app() client = _local_client(app) submission = { "values": { "MODEL": old, "MODEL_SONNET": old, "MODEL_OPUS": "deepseek/cannot-unlock", "MODEL_FALLBACKS": f"{old},{new},groq/backup", "REASONING_SONNET": "off", } } response = post_config(client, "/admin/api/config/apply", json=submission) assert response.status_code == 200 body = response.json() assert body["applied"] assert old not in body["env_preview"] assert "PRIVATE=********" in body["env_preview"] values = dotenv_values_from_file(env_file) assert values["MODEL"] == values["MODEL_SONNET"] == new assert values["MODEL_OPUS"] == "groq/managed" assert values["REASONING_SONNET"] == "off" assert values["PRIVATE"] == "hidden" effective = provider_manager_for_app(app).current_settings() assert effective.model == effective.model_sonnet == effective.model_opus == new assert effective.model_fallbacks == ( ModelFallback(model=new), ModelFallback(model="groq/backup"), ) assert os.environ["MODEL_OPUS"] == old @pytest.fixture(autouse=True) def _offline_credential_checks(monkeypatch): """These tests exercise config persistence; probe HTTP has its own suite.""" monkeypatch.setattr( "free_claude_code.runtime.application.check_credentials", AsyncMock(return_value=()), ) def _set_home(monkeypatch, tmp_path: Path) -> None: monkeypatch.setenv("HOME", str(tmp_path)) monkeypatch.setenv("USERPROFILE", str(tmp_path)) monkeypatch.chdir(tmp_path) def _clear_process_config(monkeypatch) -> None: for key in ( "MODEL", "MODEL_FALLBACKS", "BEDROCK_BASE_URL", "BEDROCK_PROXY", "ANTHROPIC_AUTH_TOKEN", "PROXY_AUTH_ENABLED", "TELEGRAM_PROXY_URL", "FCC_ENV_FILE", "CLOUDFLARE_ACCOUNT_ID", "GITHUB_MODELS_TOKEN", "HOST", "PORT", "FCC_OPEN_BROWSER", "VOICE_NOTE_ENABLED", "WHISPER_DEVICE", "LOG_FILE", "ZAI_BASE_URL", "CLAUDE_WORKSPACE", "CLAUDE_CLI_BIN", ): monkeypatch.delenv(key, raising=False) for descriptor in PROVIDER_CATALOG.values(): if descriptor.credential_env is not None: monkeypatch.delenv(descriptor.credential_env, raising=False) if descriptor.proxy_attr is None: continue alias = Settings.model_fields[descriptor.proxy_attr].validation_alias if alias is not None: monkeypatch.delenv(str(alias), raising=False) def _catalog_proxy_env_keys() -> tuple[str, ...]: keys: list[str] = [] for descriptor in PROVIDER_CATALOG.values(): if descriptor.proxy_attr is None: continue alias = Settings.model_fields[descriptor.proxy_attr].validation_alias if alias is not None: keys.append(str(alias)) return tuple(keys) @pytest.mark.parametrize( "path", ["/admin", "/admin/model_config", "/admin/messaging", "/admin/integrations"] ) def test_admin_page_is_loopback_only(monkeypatch, tmp_path, path): _set_home(monkeypatch, tmp_path) app = create_test_app() assert _local_client(app).get(path).status_code == 200 remote_client = TestClient(app, client=("203.0.113.10", 50000)) assert remote_client.get(path).status_code == 403 def test_admin_page_uses_installed_version(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) monkeypatch.setattr( "free_claude_code.api.admin_routes.package_version", lambda: "9.8.7", ) response = _local_client(create_test_app()).get("/admin") assert response.status_code == 200 assert "<p>Server Control · v9.8.7</p>" in response.text assert 'href="https://github.com/Alishahryar1/free-claude-code"' in response.text assert 'target="_blank"' in response.text assert 'rel="noopener noreferrer"' in response.text assert 'aria-label="Open Free Claude Code on GitHub"' in response.text assert 'src="/admin/assets/9.8.7/app-icon.svg"' in response.text assert 'href="/admin/assets/9.8.7/admin.css"' in response.text assert 'href="/admin/assets/9.8.7/code_sessions.css"' in response.text assert 'src="/admin/assets/9.8.7/model_combobox.js"' in response.text assert 'src="/admin/assets/9.8.7/form_controls.js"' in response.text assert 'src="/admin/assets/9.8.7/code_sessions.js"' in response.text assert 'src="/admin/assets/9.8.7/admin.js"' in response.text assert 'href="/admin/assets/admin.css"' not in response.text assert 'href="/admin/assets/code_sessions.css"' not in response.text assert 'src="/admin/assets/code_sessions.js"' not in response.text assert 'src="/admin/assets/admin.js"' not in response.text @pytest.mark.parametrize( ("filename", "media_type"), ( ("admin.css", "text/css"), ("admin.js", "text/javascript"), ("form_controls.js", "text/javascript"), ("code_sessions.css", "text/css"), ("code_sessions.js", "text/javascript"), ("session_ui.js", "text/javascript"), ("model_combobox.js", "text/javascript"), ("providers/openrouter.svg", "image/svg+xml"), ("providers/lightning.png", "image/png"), ), ) def test_admin_versioned_assets_serve_packaged_files( monkeypatch, tmp_path, filename, media_type, ): mimetypes.init() monkeypatch.setitem(mimetypes.types_map, Path(filename).suffix, "text/plain") asset_path = ( Path(__file__).resolve().parents[2] / "src" / "free_claude_code" / "api" / "admin_static" / filename ) _set_home(monkeypatch, tmp_path) response = _local_client(create_test_app()).get( f"/admin/assets/{package_version()}/{filename}" ) assert response.status_code == 200 assert response.headers["content-type"].startswith(media_type) assert response.content == asset_path.read_bytes() def test_admin_versioned_logo_reuses_packaged_app_icon(monkeypatch, tmp_path): asset_path = ( Path(__file__).resolve().parents[2] / "src" / "free_claude_code" / "assets" / "app-icon.svg" ) _set_home(monkeypatch, tmp_path) response = _local_client(create_test_app()).get( f"/admin/assets/{package_version()}/app-icon.svg" ) assert response.status_code == 200 assert response.headers["content-type"].startswith("image/svg+xml") assert response.content == asset_path.read_bytes() @pytest.mark.parametrize( "path", ( "/admin", f"/admin/assets/{package_version()}/app-icon.svg", f"/admin/assets/{package_version()}/admin.css", f"/admin/assets/{package_version()}/admin.js", f"/admin/assets/{package_version()}/code_sessions.css", f"/admin/assets/{package_version()}/code_sessions.js", f"/admin/assets/{package_version()}/model_combobox.js", "/admin/api/config", ), ) def test_admin_responses_are_never_cached(monkeypatch, tmp_path, path): _set_home(monkeypatch, tmp_path) response = _local_client(create_test_app()).get(path) assert response.status_code == 200 assert response.headers["cache-control"] == "no-store" @pytest.mark.parametrize( ("path", "client_host", "expected_status"), ( ("/admin", "203.0.113.10", 403), ("/admin/assets/admin.js", "127.0.0.1", 404), ( f"/admin/assets/{package_version()}.stale/admin.js", "127.0.0.1", 404, ), ( f"/admin/assets/{package_version()}/missing.js", "127.0.0.1", 404, ), ( f"/admin/assets/{package_version()}/admin.js", "203.0.113.10", 403, ), ), ) def test_admin_http_errors_are_never_cached( monkeypatch, tmp_path, path, client_host, expected_status, ): _set_home(monkeypatch, tmp_path) client = TestClient( create_test_app(), base_url="http://127.0.0.1", client=(client_host, 50000), ) response = client.get(path) assert response.status_code == expected_status assert response.headers["cache-control"] == "no-store" def test_admin_apply_payload_validation_errors_are_never_cached(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) response = _local_client(create_test_app()).post( "/admin/api/config/apply", content="{", headers={"Content-Type": "application/json"}, ) assert response.status_code == 422 assert response.headers["cache-control"] == "no-store" def test_admin_unexpected_errors_are_never_cached(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) client = TestClient( create_test_app(), base_url="http://127.0.0.1", client=("127.0.0.1", 50000), raise_server_exceptions=False, ) with patch( "free_claude_code.runtime.configuration.ConfigurationService.admin_config", side_effect=RuntimeError("test error"), ): response = client.get("/admin/api/config") assert response.status_code == 500 assert response.headers["cache-control"] == "no-store" def test_admin_cache_policy_does_not_match_similar_public_paths(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) response = _local_client(create_test_app()).get("/administrator") assert response.status_code == 404 assert "cache-control" not in response.headers def test_admin_api_fetches_bypass_browser_cache(): script = Path("src/free_claude_code/api/admin_static/admin.js").read_text( encoding="utf-8" ) assert 'cache: "no-store"' in script class _FakeConnectedAccount: def __init__(self, provider_id: str = "openai") -> None: self.provider_id = provider_id self.connected = False self.revision = 0 self.cancelled = False self.started_modes: list[ConnectedAccountLoginMode] = [] def is_connected(self) -> bool: return self.connected def status(self) -> ConnectedAccountStatus: status = ConnectedAccountStatus( provider_id=self.provider_id, state=( ConnectedAccountState.CONNECTED if self.connected else ConnectedAccountState.DISCONNECTED ), connected=self.connected, revision=self.revision, ) if self.provider_id == "github_copilot": return replace( status, display_identity="octocat" if self.connected else None, supported_login_modes=(ConnectedAccountLoginMode.DEVICE,), default_login_mode=ConnectedAccountLoginMode.DEVICE, ) return replace(status, email="safe@example.com" if self.connected else None) async def start_login( self, mode: ConnectedAccountLoginMode ) -> ConnectedAccountStatus: self.started_modes.append(mode) return replace( self.status(), state=ConnectedAccountState.CONNECTING, connected=False, attempt_id="login_safe", mode=mode, authorization_url=( "https://auth.openai.com/safe" if mode == ConnectedAccountLoginMode.BROWSER else None ), verification_url=( "https://github.com/login/device" if mode == ConnectedAccountLoginMode.DEVICE else None ), user_code="ABCD-1234" if mode == ConnectedAccountLoginMode.DEVICE else None, ) async def cancel_login(self) -> ConnectedAccountStatus: self.cancelled = True return self.status() async def disconnect(self) -> ConnectedAccountStatus: self.connected = False self.revision += 1 return self.status() async def close(self) -> None: return None def test_admin_connected_account_routes_are_safe_loopback_only_and_uncached( monkeypatch, tmp_path ): _set_home(monkeypatch, tmp_path) account = _FakeConnectedAccount() app = create_test_app(connected_accounts={"openai": account}) client = _local_client(app) status_response = client.get("/admin/api/providers/openai/auth") login_response = client.post( "/admin/api/providers/openai/auth/login", json={"mode": "browser"}, ) cancel_response = client.post("/admin/api/providers/openai/auth/cancel") assert status_response.status_code == 200 assert status_response.headers["cache-control"] == "no-store" assert status_response.json()["state"] == "disconnected" assert login_response.status_code == 200 assert login_response.json() == { "provider_id": "openai", "state": "connecting", "connected": False, "revision": 0, "attempt_id": "login_safe", "mode": "browser", "authorization_url": "https://auth.openai.com/safe", "supported_login_modes": ["browser", "device"], "default_login_mode": "browser", } assert "token" not in login_response.text.lower() assert cancel_response.status_code == 200 assert account.cancelled is True remote = TestClient(app, client=("203.0.113.10", 50000)) assert remote.get("/admin/api/providers/openai/auth").status_code == 403 @pytest.mark.parametrize( ("provider_id", "default_mode"), [("openai", "browser"), ("github_copilot", "device")], ) @pytest.mark.parametrize("payload", [{}, {"mode": None}]) def test_admin_login_uses_the_provider_default( monkeypatch, tmp_path, provider_id, default_mode, payload, ): _set_home(monkeypatch, tmp_path) account = _FakeConnectedAccount(provider_id) client = _local_client( create_test_app(providers={}, connected_accounts={provider_id: account}) ) response = client.post( f"/admin/api/providers/{provider_id}/auth/login", json=payload ) assert response.status_code == 200 assert response.headers["cache-control"] == "no-store" assert response.json()["mode"] == default_mode assert account.started_modes == [ConnectedAccountLoginMode(default_mode)] if default_mode == "device": assert response.json()["user_code"] == "ABCD-1234" assert response.json()["verification_url"] == "https://github.com/login/device" assert "authorization_url" not in response.json() @pytest.mark.parametrize("mode", ["browser", "unrecognized"]) def test_admin_rejects_unsupported_login_modes_before_starting( monkeypatch, tmp_path, mode ): _set_home(monkeypatch, tmp_path) account = _FakeConnectedAccount("github_copilot") client = _local_client( create_test_app(providers={}, connected_accounts={"github_copilot": account}) ) response = client.post( "/admin/api/providers/github_copilot/auth/login", json={"mode": mode} ) assert response.status_code == 422 assert response.headers["cache-control"] == "no-store" assert account.started_modes == [] def test_admin_connected_account_identity_modes_and_disconnect_are_independent( monkeypatch, tmp_path ): _set_home(monkeypatch, tmp_path) openai = _FakeConnectedAccount() copilot = _FakeConnectedAccount("github_copilot") openai.connected = copilot.connected = True client = _local_client( create_test_app( providers={}, connected_accounts={"openai": openai, "github_copilot": copilot}, ) ) openai_status = client.get("/admin/api/providers/openai/auth").json() copilot_status = client.get("/admin/api/providers/github_copilot/auth").json() assert openai_status["email"] == "safe@example.com" assert openai_status["supported_login_modes"] == ["browser", "device"] assert copilot_status["display_identity"] == "octocat" assert "email" not in copilot_status assert copilot_status["supported_login_modes"] == ["device"] assert copilot_status["default_login_mode"] == "device" assert "token" not in str(copilot_status).lower() cancelled = client.post("/admin/api/providers/github_copilot/auth/cancel") assert cancelled.status_code == 200 assert copilot.cancelled is True assert openai.cancelled is False disconnected = client.delete("/admin/api/providers/github_copilot/auth") assert disconnected.status_code == 200 assert disconnected.json()["connected"] is False assert disconnected.json()["supported_login_modes"] == ["device"] assert client.get("/admin/api/providers/openai/auth").json()["connected"] is True def test_admin_openai_keeps_explicit_device_login(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) account = _FakeConnectedAccount() client = _local_client(create_test_app(connected_accounts={"openai": account})) response = client.post( "/admin/api/providers/openai/auth/login", json={"mode": "device"} ) assert response.status_code == 200 assert account.started_modes == [ConnectedAccountLoginMode.DEVICE] def test_admin_rejects_auth_routes_for_non_connected_provider(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) response = _local_client(create_test_app()).get( "/admin/api/providers/nvidia_nim/auth" ) assert response.status_code == 404 def test_admin_page_no_longer_renders_generated_env_panel(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) app = create_test_app() response = _local_client(app).get("/admin") assert response.status_code == 200 assert "Generated Env" not in response.text assert "envPreview" not in response.text def test_admin_page_no_longer_renders_global_status_header(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) app = create_test_app() response = _local_client(app).get("/admin") assert response.status_code == 200 assert "Local Admin" not in response.text assert "serverStatus" not in response.text assert "modelBadge" not in response.text def test_admin_static_no_longer_fetches_global_status_header(): script = Path("src/free_claude_code/api/admin_static/admin.js").read_text( encoding="utf-8" ) assert 'api("/admin/api/status")' not in script assert "updateHeader" not in script assert '"Running"' not in script assert "serverStatus" not in script assert "modelBadge" not in script def test_admin_static_hides_managed_source_label(): script = Path("src/free_claude_code/api/admin_static/admin.js").read_text( encoding="utf-8" ) assert 'managed_env: "",' in script assert "hasOwnProperty.call(labels, source)" in script assert 'parts.push("locked")' in script assert "sourceEl.textContent = source" in script def test_admin_static_places_reasoning_fields_in_model_config(): script = Path("src/free_claude_code/api/admin_static/admin.js").read_text( encoding="utf-8" ) assert 'sections: ["models", "web_tools"]' in script assert 'sections: ["models", "thinking", "web_tools"]' not in script def test_admin_static_model_combobox_owns_dropdown_and_search_behavior(): script = Path("src/free_claude_code/api/admin_static/admin.js").read_text( encoding="utf-8" ) combobox_script = Path( "src/free_claude_code/api/admin_static/model_combobox.js" ).read_text(encoding="utf-8") styles = Path("src/free_claude_code/api/admin_static/admin.css").read_text( encoding="utf-8" ) assert 'api("/admin/api/models" + (refresh ? "/refresh" : "")' in script assert 'field.type === "model" || field.type === "optional_model"' in script assert "new window.FccModelCombobox" in script assert 'input.setAttribute("role", "combobox")' in combobox_script assert 'this.listbox.setAttribute("role", "listbox")' in combobox_script assert 'this.toggle.className = "model-combobox-toggle"' in combobox_script assert "class FccModelCombobox" in combobox_script assert 'input.addEventListener("click", () => this.open())' in combobox_script assert 'event.key === "ArrowDown" || event.key === "ArrowUp"' in combobox_script assert "this.setActive(this.visibleOptions.length - 1)" in combobox_script assert 'event.key === "Enter"' in combobox_script assert 'event.key === "Escape"' in combobox_script assert 'document.createElement("datalist")' not in combobox_script assert ".model-combobox-list" in styles assert ".model-combobox-option.active" in styles assert styles.count("background-image: var(--dropdown-chevron)") == 2 def test_admin_static_model_combobox_preserves_custom_slugs_and_none_semantics(): script = Path("src/free_claude_code/api/admin_static/admin.js").read_text( encoding="utf-8" ) assert '? ["None", ...state.modelOptions]' in script assert "You can still enter a custom slug." in script assert 'input.dataset.fieldType === "optional_model"' in script assert "return null;" in script assert "await hydrateModelOptions();" in script assert "Model fields remain editable" in script assert "result.failed_providers || []" in script assert '"warn"' in script def test_admin_config_masks_secrets_and_exposes_manifest(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() response = _local_client(app).get("/admin/api/config") assert response.status_code == 200 body = response.json() keys = {field["key"] for field in body["fields"]} assert "MODEL_FABLE" in keys assert "REASONING_FABLE" in keys assert "ANTHROPIC_AUTH_TOKEN" in keys assert "PROXY_AUTH_ENABLED" in keys assert "LOG_LEVEL" in keys assert "OPENROUTER_API_KEY" in keys assert "AWS_BEARER_TOKEN_BEDROCK" in keys assert "BEDROCK_BASE_URL" in keys assert "FIREWORKS_API_KEY" in keys assert "CLOUDFLARE_API_TOKEN" in keys assert "CLOUDFLARE_ACCOUNT_ID" in keys assert "GITHUB_MODELS_TOKEN" not in keys assert "GEMINI_API_KEY" in keys assert "GROQ_API_KEY" in keys assert "SAMBANOVA_API_KEY" in keys assert "TELEGRAM_PROXY_URL" in keys assert "CEREBRAS_API_KEY" in keys assert "OLLAMA_API_KEY" in keys assert "FCC_OPEN_BROWSER" in keys assert "ZAI_BASE_URL" not in keys assert "CLAUDE_WORKSPACE" not in keys assert "CLAUDE_CLI_BIN" not in keys assert "LOG_FILE" not in keys auth_field = next( field for field in body["fields"] if field["key"] == "ANTHROPIC_AUTH_TOKEN" ) assert auth_field["secret"] is True assert auth_field["value"] == MASKED_SECRET assert auth_field["source"] == "default" assert auth_field["nullable"] is False telegram_proxy_field = next( field for field in body["fields"] if field["key"] == "TELEGRAM_PROXY_URL" ) assert telegram_proxy_field["secret"] is True assert telegram_proxy_field["value"] is None assert telegram_proxy_field["configured"] is False assert telegram_proxy_field["nullable"] is True assert body["paths"] == {"managed": str(tmp_path / ".fcc" / ".env")} catalog_smoke_keys = { f"FCC_SMOKE_MODEL_{provider_id.upper()}" for provider_id in PROVIDER_CATALOG } actual_smoke_keys = { field["key"] for field in body["fields"] if field["key"].startswith("FCC_SMOKE_MODEL_") } assert actual_smoke_keys == catalog_smoke_keys | { "FCC_SMOKE_MODEL_MISTRAL_REASONING" } open_browser_field = next( field for field in body["fields"] if field["key"] == "FCC_OPEN_BROWSER" ) assert open_browser_field["type"] == "boolean" assert open_browser_field["value"] == "true" assert open_browser_field["restart_required"] is False assert "PROVIDER_PROGRESS_TIMEOUT" not in {field["key"] for field in body["fields"]} model_field_types = { field["key"]: field["type"] for field in body["fields"] if field["key"] in { "MODEL", "MODEL_FABLE", "MODEL_OPUS", "MODEL_SONNET", "MODEL_HAIKU", "MODEL_FALLBACKS", } } assert model_field_types == { "MODEL": "model", "MODEL_FABLE": "optional_model", "MODEL_OPUS": "optional_model", "MODEL_SONNET": "optional_model", "MODEL_HAIKU": "optional_model", "MODEL_FALLBACKS": "model_list", } fallback_field = next( field for field in body["fields"] if field["key"] == "MODEL_FALLBACKS" ) assert fallback_field["label"] == "Fallback Models" assert fallback_field["value"] is None assert fallback_field["nullable"] is True assert fallback_field["restart_required"] is False assert "fails before output" in fallback_field["description"] assert "every client" in fallback_field["description"] assert "multiple providers" in fallback_field["description"] reasoning_policy = next( field for field in body["fields"] if field["key"] == "REASONING_POLICY" ) assert reasoning_policy["section"] == "models" assert reasoning_policy["type"] == "select" assert reasoning_policy["value"] == "client" assert reasoning_policy["options"] == [ {"value": "off", "label": "Off"}, {"value": "client", "label": "From client"}, {"value": "low", "label": "Low"}, {"value": "medium", "label": "Medium"}, {"value": "high", "label": "High"}, {"value": "xhigh", "label": "X-High"}, {"value": "max", "label": "Max"}, ] route_reasoning = next( field for field in body["fields"] if field["key"] == "REASONING_FABLE" ) assert route_reasoning["options"] == [ {"value": "inherit", "label": "Inherit"}, *reasoning_policy["options"], ] assert all( field["section"] == "models" for field in body["fields"] if field["key"].startswith("REASONING_") ) assert "reasoning" not in {section["id"] for section in body["sections"]} restart_required = { field["key"] for field in body["fields"] if field["restart_required"] is True } assert { "ANTHROPIC_AUTH_TOKEN", "DEBUG_PLATFORM_EDITS", "DEBUG_SUBAGENT_STACK", "LOG_RAW_API_PAYLOADS", "LOG_API_ERROR_TRACEBACKS", "LOG_RAW_MESSAGING_CONTENT", "LOG_RAW_CLI_DIAGNOSTICS", "LOG_MESSAGING_ERROR_DETAILS", } <= restart_required def test_admin_models_include_configured_and_cached_canonical_slugs(): settings = Settings( model="nvidia_nim/configured-model", model_opus="open_router/anthropic/configured-opus", open_router_api_keys=normalize_api_keys("open-router-key"), ) app = create_test_app(settings) provider_manager_for_app(app).cache_model_infos( "open_router", { ProviderModelInfo("anthropic/configured-opus"), ProviderModelInfo("meta/llama-3.3"), }, ) response = _local_client(app).get("/admin/api/models") assert response.status_code == 200 assert { key: value for key, value in response.json().items() if key != "model_labels" } == { "models": [ "nvidia_nim/configured-model", "open_router/anthropic/configured-opus", "open_router/meta/llama-3.3", ], "failed_providers": [], } def test_admin_model_refresh_returns_the_updated_canonical_catalog(): settings = Settings( model="deepseek/deepseek-chat", deepseek_api_keys=normalize_api_keys("deepseek-key"), ) app = create_test_app(settings) runtime = app.state.services.admin async def refresh_models() -> ProviderModelRefreshResult: provider_manager_for_app(app).cache_model_infos( "deepseek", {ProviderModelInfo("deepseek-reasoner")}, ) return ProviderModelRefreshResult(refreshed_provider_ids=("deepseek",)) runtime.refresh_models = AsyncMock(side_effect=refresh_models) response = _local_client(app).post("/admin/api/models/refresh") assert response.status_code == 200 assert { key: value for key, value in response.json().items() if key != "model_labels" } == { "models": ["deepseek/deepseek-chat", "deepseek/deepseek-reasoner"], "failed_providers": [], } runtime.refresh_models.assert_awaited_once_with() def test_admin_model_refresh_reports_partial_provider_failures(): settings = Settings(model="deepseek/deepseek-chat") app = create_test_app(settings) runtime = app.state.services.admin runtime.refresh_models = AsyncMock( return_value=ProviderModelRefreshResult( refreshed_provider_ids=("deepseek",), failed_provider_ids=("open_router",), ) ) response = _local_client(app).post("/admin/api/models/refresh") assert response.status_code == 200 assert { key: value for key, value in response.json().items() if key != "model_labels" } == { "models": ["deepseek/deepseek-chat"], "failed_providers": ["open_router"], } def test_admin_config_preserves_managed_env_source_contract(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) env_file.write_text("MODEL=open_router/managed-model\n", encoding="utf-8") app = create_test_app() response = _local_client(app).get("/admin/api/config") assert response.status_code == 200 body = response.json() model_field = next(field for field in body["fields"] if field["key"] == "MODEL") assert model_field["source"] == "managed_env" assert model_field["locked"] is False def test_admin_apply_persists_open_browser_for_next_launch(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"FCC_OPEN_BROWSER": False}}, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert body["pending_fields"] == [] assert body["restart"] == { "required": False, "automatic": False, "admin_url": None, "fields": [], } managed_env = tmp_path / ".fcc" / ".env" assert "FCC_OPEN_BROWSER=false" in managed_env.read_text(encoding="utf-8") def test_admin_apply_hot_publishes_ordered_model_fallbacks(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() value = "open_router/vendor/model-a,groq/vendor/model-b" response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"MODEL_FALLBACKS": value}}, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert body["restart"]["required"] is False assert provider_manager_for_app(app).current_settings().model_fallbacks == ( ModelFallback(model="open_router/vendor/model-a"), ModelFallback(model="groq/vendor/model-b"), ) managed_env = tmp_path / ".fcc" / ".env" assert ( decode_model_fallbacks(dotenv_values_from_file(managed_env)["MODEL_FALLBACKS"]) == provider_manager_for_app(app).current_settings().model_fallbacks ) loaded = _local_client(app).get("/admin/api/config").json() field = next(item for item in loaded["fields"] if item["key"] == "MODEL_FALLBACKS") assert ( decode_model_fallbacks(field["value"]) == provider_manager_for_app(app).current_settings().model_fallbacks ) assert field["source"] == "managed_env" def test_admin_apply_null_removes_model_fallbacks(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) env_file.write_text( "FCC_CONFIG_SCHEMA=1\nMODEL_FALLBACKS=open_router/vendor/model-a\n", encoding="utf-8", ) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"MODEL_FALLBACKS": None}}, ) assert response.status_code == 200 assert response.json()["applied"] is True assert provider_manager_for_app(app).current_settings().model_fallbacks is None assert "MODEL_FALLBACKS=" not in env_file.read_text(encoding="utf-8") def test_admin_ignores_retired_progress_setting_without_writing( monkeypatch, tmp_path, ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"PROVIDER_PROGRESS_TIMEOUT": 0}}, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert body["valid"] is True assert body["errors"] == [] assert "provider_progress_timeout" not in ( provider_manager_for_app(app).current_settings().model_dump() ) managed_env = tmp_path / ".fcc" / ".env" assert "PROVIDER_PROGRESS_TIMEOUT=" not in managed_env.read_text(encoding="utf-8") def test_admin_apply_masks_telegram_proxy_credentials(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() proxy_url = "https://user:password@proxy.example:8443" response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"TELEGRAM_PROXY_URL": proxy_url}}, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert "TELEGRAM_PROXY_URL=********" in body["env_preview"] assert proxy_url not in body["env_preview"] env_file = tmp_path / ".fcc" / ".env" text = env_file.read_text(encoding="utf-8") assert f"TELEGRAM_PROXY_URL={proxy_url}" in text def test_admin_apply_null_removes_optional_secret(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) env_file.write_text( "FCC_CONFIG_SCHEMA=1\nTELEGRAM_PROXY_URL=https://secret.invalid\n", encoding="utf-8", ) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"TELEGRAM_PROXY_URL": None}}, ) assert response.status_code == 200 assert response.json()["applied"] is True assert "TELEGRAM_PROXY_URL=" not in env_file.read_text(encoding="utf-8") @pytest.mark.parametrize("submitted", [MASKED_SECRET, "", " "]) def test_admin_apply_masked_or_blank_secret_is_unchanged( monkeypatch, tmp_path, submitted, ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) env_file.write_text( "FCC_CONFIG_SCHEMA=1\nOPENROUTER_API_KEY=original-secret\n", encoding="utf-8", ) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"OPENROUTER_API_KEY": submitted}}, ) assert response.status_code == 200 assert response.json()["applied"] is True assert json.loads( dotenv_values_from_text(env_file.read_text(encoding="utf-8"))[ "OPENROUTER_API_KEY" ] ) == ["original-secret"] def test_admin_apply_rejects_bad_model_shape(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"MODEL": "missing-provider-prefix"}}, ) assert response.status_code == 200 body = response.json() assert body["applied"] is False assert body["valid"] is False assert any("provider type" in error for error in body["errors"]) def test_admin_apply_rejects_duplicate_model_fallbacks(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() duplicate = "groq/vendor/model,groq/vendor/model" response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"MODEL_FALLBACKS": duplicate}}, ) assert response.status_code == 200 body = response.json() assert body["applied"] is False assert body["valid"] is False assert any("duplicate" in error.lower() for error in body["errors"]) @pytest.mark.parametrize("proxy_key", _catalog_proxy_env_keys()) def test_admin_apply_rejects_invalid_catalog_provider_proxy( monkeypatch, tmp_path, proxy_key, ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) invalid_proxy = "not-a-proxy://user:leaked-secret@proxy.example:8080" response = post_config( _local_client(create_test_app()), "/admin/api/config/apply", json={"values": {proxy_key: invalid_proxy}}, ) assert response.status_code == 200 body = response.json() assert body["applied"] is False assert body["valid"] is False assert body["errors"] == [ ( f"{proxy_key}: must be a proxy URL with a supported scheme and host " "(for example http://127.0.0.1:8080 or socks5://127.0.0.1:1080)" ) ] assert invalid_proxy not in response.text assert "leaked-secret" not in response.text @pytest.mark.parametrize( "proxy", ( "http://user:password@127.0.0.1:8080", "https://proxy.example:8443", "socks5://127.0.0.1:1080", "socks5h://proxy.example:1080", " http://127.0.0.1:8080 ", ), ) def test_admin_apply_accepts_httpx_provider_proxy(monkeypatch, tmp_path, proxy): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) response = post_config( _local_client(create_test_app()), "/admin/api/config/apply", json={"values": {"OPENAI_PROXY": proxy}}, ) assert response.status_code == 200 assert response.json()["applied"] is True assert response.json()["valid"] is True @pytest.mark.parametrize( "proxy", ( "copied Admin page text", "socks://127.0.0.1:1080", "http://", "http:///path", "http://proxy.example:notaport", ), ) def test_admin_apply_rejects_unusable_provider_proxy(monkeypatch, tmp_path, proxy): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) response = post_config( _local_client(create_test_app()), "/admin/api/config/apply", json={"values": {"OPENAI_PROXY": proxy}}, ) assert response.status_code == 200 body = response.json() assert body["applied"] is False assert body["valid"] is False assert len(body["errors"]) == 1 assert body["errors"][0].startswith("OPENAI_PROXY: must be a proxy URL") assert "OPENAI_PROXY=********" in body["env_preview"] def test_admin_apply_rejects_invalid_provider_proxy_without_side_effects( monkeypatch, tmp_path, ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) env_file.write_text("MODEL=open_router/test-model\n", encoding="utf-8") callbacks: list[str] = [] def restart_callback() -> None: callbacks.append("restart") app = create_test_app(restart_callback=restart_callback) _local_client(app).get("/admin/api/config") baseline = env_file.read_bytes() invalid_proxy = "invalid://user:leaked-secret@proxy.example:8080" response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"OPENAI_PROXY": invalid_proxy}}, ) assert response.status_code == 200 body = response.json() assert body["valid"] is False assert body["applied"] is False assert body["pending_fields"] == [] assert env_file.read_bytes() == baseline assert callbacks == [] assert invalid_proxy not in response.text assert "leaked-secret" not in response.text def test_admin_apply_validates_retained_proxy_and_allows_removal( monkeypatch, tmp_path, ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) invalid_proxy = "invalid://proxy.example:8080" original = f"GROQ_PROXY={invalid_proxy}\n" env_file.write_text(original, encoding="utf-8") app = create_test_app() _local_client(app).get("/admin/api/config") baseline = env_file.read_bytes() rejected = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"MODEL": "open_router/test-model"}}, ) assert rejected.status_code == 200 assert rejected.json()["applied"] is False assert env_file.read_bytes() == baseline removed = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"GROQ_PROXY": None}}, ) assert removed.status_code == 200 assert removed.json()["applied"] is True assert "GROQ_PROXY=" not in env_file.read_text(encoding="utf-8") @pytest.mark.parametrize("submitted", (MASKED_SECRET, "", " ")) def test_admin_apply_preserves_valid_stored_proxy_secret( monkeypatch, tmp_path, submitted, ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) env_file.write_text( "OPENAI_PROXY=http://user:password@127.0.0.1:8080\n", encoding="utf-8", ) response = post_config( _local_client(create_test_app()), "/admin/api/config/apply", json={"values": {"OPENAI_PROXY": submitted}}, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert body["valid"] is True assert "OPENAI_PROXY=********" in body["env_preview"] assert "password" not in response.text def test_admin_apply_writes_complete_managed_env_and_masks_preview( monkeypatch, tmp_path ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={ "values": { "MODEL": "open_router/test-model", "OPENROUTER_API_KEY": "router-secret", } }, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert "OPENROUTER_API_KEY=********" in body["env_preview"] env_file = tmp_path / ".fcc" / ".env" text = env_file.read_text("utf-8") assert "MODEL=open_router/test-model" in text assert json.loads(dotenv_values_from_text(text)["OPENROUTER_API_KEY"]) == [ "router-secret" ] assert "ANTHROPIC_AUTH_TOKEN=" not in text assert "PROXY_AUTH_ENABLED=" not in text assert "HOST=" not in text assert "PORT=" not in text assert body["restart"] == { "required": False, "automatic": False, "admin_url": None, "fields": [], } def test_admin_apply_writes_fireworks_key_and_masks_preview(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={ "values": { "MODEL": "fireworks/test-model", "FIREWORKS_API_KEY": "fw-secret", } }, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert "FIREWORKS_API_KEY=********" in body["env_preview"] env_file = tmp_path / ".fcc" / ".env" text = env_file.read_text(encoding="utf-8") assert "MODEL=fireworks/test-model" in text assert json.loads(dotenv_values_from_text(text)["FIREWORKS_API_KEY"]) == [ "fw-secret" ] def test_admin_apply_writes_gemini_key_and_masks_preview(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={ "values": { "MODEL": "gemini/models/gemini-3.1-flash-lite", "GEMINI_API_KEY": "gm-secret", } }, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert "GEMINI_API_KEY=********" in body["env_preview"] env_file = tmp_path / ".fcc" / ".env" text = env_file.read_text(encoding="utf-8") assert "MODEL=gemini/models/gemini-3.1-flash-lite" in text assert json.loads(dotenv_values_from_text(text)["GEMINI_API_KEY"]) == ["gm-secret"] def test_admin_apply_writes_groq_key_and_masks_preview(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={ "values": { "MODEL": "groq/llama-3.3-70b-versatile", "GROQ_API_KEY": "gq-secret", } }, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert "GROQ_API_KEY=********" in body["env_preview"] env_file = tmp_path / ".fcc" / ".env" text = env_file.read_text(encoding="utf-8") assert "MODEL=groq/llama-3.3-70b-versatile" in text assert json.loads(dotenv_values_from_text(text)["GROQ_API_KEY"]) == ["gq-secret"] def test_admin_apply_writes_sambanova_key_and_masks_preview(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={ "values": { "MODEL": "sambanova/Meta-Llama-3.3-70B-Instruct", "SAMBANOVA_API_KEY": "sn-secret", } }, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert "SAMBANOVA_API_KEY=********" in body["env_preview"] env_file = tmp_path / ".fcc" / ".env" text = env_file.read_text(encoding="utf-8") assert "MODEL=sambanova/Meta-Llama-3.3-70B-Instruct" in text assert json.loads(dotenv_values_from_text(text)["SAMBANOVA_API_KEY"]) == [ "sn-secret" ] def test_admin_apply_writes_cerebras_key_and_masks_preview(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={ "values": { "MODEL": "cerebras/llama3.1-8b", "CEREBRAS_API_KEY": "cb-secret", } }, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert "CEREBRAS_API_KEY=********" in body["env_preview"] env_file = tmp_path / ".fcc" / ".env" text = env_file.read_text(encoding="utf-8") assert "MODEL=cerebras/llama3.1-8b" in text assert json.loads(dotenv_values_from_text(text)["CEREBRAS_API_KEY"]) == [ "cb-secret" ] def test_admin_apply_writes_bedrock_region_config_and_masks_key(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={ "values": { "MODEL": "bedrock/openai.gpt-oss-120b", "AWS_BEARER_TOKEN_BEDROCK": "bedrock-secret", "BEDROCK_BASE_URL": ("https://bedrock-mantle.us-west-2.api.aws/v1"), } }, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert "AWS_BEARER_TOKEN_BEDROCK=********" in body["env_preview"] env_file = tmp_path / ".fcc" / ".env" text = env_file.read_text(encoding="utf-8") assert "MODEL=bedrock/openai.gpt-oss-120b" in text assert json.loads(dotenv_values_from_text(text)["AWS_BEARER_TOKEN_BEDROCK"]) == [ "bedrock-secret" ] assert "BEDROCK_BASE_URL=https://bedrock-mantle.us-west-2.api.aws/v1" in text def test_admin_apply_writes_cloudflare_fields_and_masks_preview(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={ "values": { "MODEL": "cloudflare/@cf/moonshotai/kimi-k2.6", "CLOUDFLARE_API_TOKEN": "cf-secret", "CLOUDFLARE_ACCOUNT_ID": "cf-account", } }, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert "CLOUDFLARE_API_TOKEN=********" in body["env_preview"] assert "CLOUDFLARE_ACCOUNT_ID=cf-account" in body["env_preview"] env_file = tmp_path / ".fcc" / ".env" text = env_file.read_text(encoding="utf-8") assert "MODEL=cloudflare/@cf/moonshotai/kimi-k2.6" in text assert json.loads(dotenv_values_from_text(text)["CLOUDFLARE_API_TOKEN"]) == [ "cf-secret" ] assert "CLOUDFLARE_ACCOUNT_ID=cf-account" in text def test_admin_apply_writes_huggingface_key_and_masks_preview(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={ "values": { "MODEL": "huggingface/openai/gpt-oss-120b:fastest", "HUGGINGFACE_API_KEY": "hf-secret", } }, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert body["pending_fields"] == ["HUGGINGFACE_API_KEY"] assert "HUGGINGFACE_API_KEY=********" in body["env_preview"] env_file = tmp_path / ".fcc" / ".env" text = env_file.read_text(encoding="utf-8") assert "MODEL=huggingface/openai/gpt-oss-120b:fastest" in text assert json.loads(dotenv_values_from_text(text)["HUGGINGFACE_API_KEY"]) == [ "hf-secret" ] @pytest.mark.parametrize( ("device", "credential_key"), [ ("nvidia_nim", "NVIDIA_NIM_API_KEY"), ("cpu", "HUGGINGFACE_API_KEY"), ], ) def test_admin_key_change_requires_restart_for_active_voice_backend( monkeypatch, tmp_path, device, credential_key, ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) env_file.write_text( "\n".join( [ "VOICE_NOTE_ENABLED=true", f"WHISPER_DEVICE={device}", f"{credential_key}=old-key", "", ] ), encoding="utf-8", ) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {credential_key: "new-key"}}, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert body["pending_fields"] == [credential_key] assert body["restart"] == { "required": True, "automatic": False, "admin_url": None, "fields": [credential_key], } @pytest.mark.parametrize( ("key", "initial", "updated"), [ ("ANTHROPIC_AUTH_TOKEN", "old-token", "new-token"), ("DEBUG_PLATFORM_EDITS", "true", "false"), ("DEBUG_SUBAGENT_STACK", "true", "false"), ("LOG_RAW_API_PAYLOADS", "true", "false"), ("LOG_API_ERROR_TRACEBACKS", "true", "false"), ("LOG_RAW_MESSAGING_CONTENT", "true", "false"), ("LOG_RAW_CLI_DIAGNOSTICS", "true", "false"), ("LOG_MESSAGING_ERROR_DETAILS", "true", "false"), ], ) def test_admin_constructor_captured_setting_requires_restart( monkeypatch, tmp_path, key, initial, updated, ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) env_file.write_text(f"{key}={initial}\n", encoding="utf-8") app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {key: updated}}, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert body["pending_fields"] == [key] assert body["restart"] == { "required": True, "automatic": False, "admin_url": None, "fields": [key], } def test_admin_apply_writes_cohere_key_and_masks_preview(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={ "values": { "MODEL": "cohere/command-a-plus-05-2026", "COHERE_API_KEY": "cohere-secret", } }, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert "COHERE_API_KEY=********" in body["env_preview"] env_file = tmp_path / ".fcc" / ".env" text = env_file.read_text(encoding="utf-8") assert "MODEL=cohere/command-a-plus-05-2026" in text assert json.loads(dotenv_values_from_text(text)["COHERE_API_KEY"]) == [ "cohere-secret" ] def test_admin_apply_replaces_retired_model_and_ignores_retired_credential( monkeypatch, tmp_path ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={ "values": { "MODEL": "github_models/openai/gpt-4.1", "GITHUB_MODELS_TOKEN": "github-secret", } }, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert "GITHUB_MODELS_TOKEN" not in body["env_preview"] env_file = tmp_path / ".fcc" / ".env" text = env_file.read_text(encoding="utf-8") assert "MODEL=" not in text assert "GITHUB_MODELS_TOKEN" not in text def test_admin_apply_preserves_hidden_diagnostics_and_smoke_values( monkeypatch, tmp_path ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) env_file.write_text( "\n".join( [ "MODEL=nvidia_nim/old-model", "LOG_RAW_API_PAYLOADS=true", "FCC_SMOKE_MODEL_ZAI=zai/smoke-model", "", ] ), encoding="utf-8", ) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"MODEL": "open_router/test-model"}}, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True text = env_file.read_text("utf-8") assert "MODEL=open_router/test-model" in text assert "LOG_RAW_API_PAYLOADS=true" in text assert "FCC_SMOKE_MODEL_ZAI=zai/smoke-model" in text def test_admin_apply_preserves_unrecognized_managed_zai_base_url(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) env_file.write_text( "\n".join( [ "MODEL=zai/glm-5.2", "ZAI_API_KEY=zai-secret", "ZAI_BASE_URL=https://custom.zai.invalid/v1", "", ] ), encoding="utf-8", ) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"MODEL": "zai/glm-5.2"}}, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True text = env_file.read_text("utf-8") assert json.loads(dotenv_values_from_text(text)["ZAI_API_KEY"]) == ["zai-secret"] assert "ZAI_BASE_URL=https://custom.zai.invalid/v1" in text def test_admin_apply_preserves_unrecognized_managed_assignments(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) env_file.write_text( "\n".join( [ "MODEL=open_router/test-model", "CLAUDE_WORKSPACE=C:/custom/workspace", "CLAUDE_CLI_BIN=claude-custom", "", ] ), encoding="utf-8", ) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"MODEL": "open_router/test-model"}}, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True text = env_file.read_text("utf-8") assert "MODEL=open_router/test-model" in text assert "CLAUDE_WORKSPACE=C:/custom/workspace" in text assert "CLAUDE_CLI_BIN=claude-custom" in text @pytest.mark.parametrize("already_saved", [True, False]) def test_admin_ignores_retired_request_settings_and_preserves_saved_values( monkeypatch, tmp_path, already_saved ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) retired = { "FAST_PREFIX_DETECTION": "true", "ENABLE_NETWORK_PROBE_MOCK": "false", "ENABLE_TITLE_GENERATION_SKIP": "obsolete-invalid-boolean", "ENABLE_SUGGESTION_MODE_SKIP": "true", "ENABLE_FILEPATH_EXTRACTION_MOCK": "false", } saved = {"UNRELATED_CUSTOM_SETTING": "keep-me"} if already_saved: saved.update(retired) env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) env_file.write_text( "\n".join(f"{key}={value}" for key, value in saved.items()) + "\n", encoding="utf-8", ) with _local_client(create_test_app()) as client: response = client.get("/admin/api/config") assert response.status_code == 200 fields = {field["key"] for field in response.json()["fields"]} assert not fields.intersection(retired) response = post_config( client, "/admin/api/config/apply", json={"values": {**dict.fromkeys(retired, "false"), "LOG_LEVEL": "DEBUG"}}, ) assert response.status_code == 200 assert response.json()["applied"] is True values = dotenv_values_from_text(env_file.read_text(encoding="utf-8")) assert values["LOG_LEVEL"] == "DEBUG" if not already_saved: assert not values.keys() & retired.keys() for key, value in saved.items(): assert values[key] == value assert f"{key}=********" in response.json()["env_preview"] def test_admin_apply_restart_required_reports_automatic_restart(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) callbacks: list[str] = [] def restart_callback() -> None: callbacks.append("restart") app = create_test_app(restart_callback=restart_callback) instance_id = _local_client(app).get("/admin/api/status").json()["instance_id"] response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"PORT": "9090"}}, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert body["pending_fields"] == ["PORT"] assert body["restart"] == { "required": True, "automatic": True, "admin_url": "http://127.0.0.1:9090/admin", "fields": ["PORT"], "instance_id": instance_id, } assert callbacks == ["restart"] @pytest.mark.parametrize("origin", ["http://127.0.0.1:8082", "http://localhost:9090"]) def test_admin_restart_status_can_be_read_from_another_local_address(origin): app = create_test_app() response = _local_client(app).get("/admin/api/status", headers={"Origin": origin}) assert response.status_code == 200 assert response.headers["Access-Control-Allow-Origin"] == origin assert response.headers["Vary"] == "Origin" initial = response.json() assert initial["status"] == "running" assert isinstance(initial["instance_id"], str) and initial["instance_id"] runtime_for_app(app).begin_shutdown() stopping = _local_client(app).get("/admin/api/status").json() assert stopping["status"] == "stopping" assert stopping["instance_id"] == initial["instance_id"] def test_admin_restart_status_does_not_allow_a_remote_web_origin(): response = _local_client(create_test_app()).get( "/admin/api/status", headers={"Origin": "https://example.com"} ) assert response.status_code == 403 assert "Access-Control-Allow-Origin" not in response.headers def test_admin_apply_restart_required_reports_manual_fallback(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"PORT": "9091"}}, ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert body["pending_fields"] == ["PORT"] assert body["restart"] == { "required": True, "automatic": False, "admin_url": None, "fields": ["PORT"], } def test_restart_signal_failure_reports_saved_config_and_manual_restart( monkeypatch, tmp_path, caplog ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) def restart_callback() -> None: raise RuntimeError("private restart failure detail") app = create_test_app(restart_callback=restart_callback) client = _local_client(app) original_port = client.get("/admin/api/status").json()["port"] response = post_config( client, "/admin/api/config/apply", json={"values": {"PORT": "9090"}} ) assert response.status_code == 200 body = response.json() assert body["applied"] is True assert body["restart"] == { "required": True, "automatic": False, "admin_url": None, "fields": ["PORT"], } assert "PORT=9090" in (tmp_path / ".fcc" / ".env").read_text() status = client.get("/admin/api/status").json() assert status["port"] == original_port assert status["pending_fields"] == ["PORT"] assert "private restart failure detail" not in response.text + caplog.text @pytest.mark.parametrize( "followup", [{"PORT": "9090"}, {"MODEL": "nvidia_nim/new"}, {"LOG_LEVEL": "WARNING"}], ) @pytest.mark.parametrize("signal_recovers", [False, True]) def test_pending_restart_survives_later_apply( monkeypatch, tmp_path, followup, signal_recovers ): from unittest.mock import MagicMock from free_claude_code.config.loader import ManagedConfigStore _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) store = ManagedConfigStore() store.initialize() settings = store.read().settings callback = MagicMock( side_effect=[ RuntimeError("first signal failed"), None if signal_recovers else RuntimeError("still unavailable"), ] ) app = create_test_app(settings, restart_callback=callback) client = _local_client(app) assert post_config( client, "/admin/api/config/apply", json={"values": {"PORT": "9090"}} ).json()["restart"]["required"] result = post_config( client, "/admin/api/config/apply", json={"values": followup} ).json() fields = ["PORT", "LOG_LEVEL"] if "LOG_LEVEL" in followup else ["PORT"] assert result["applied"] is True assert result["restart"]["required"] is True assert result["restart"]["automatic"] is signal_recovers assert result["restart"]["fields"] == fields assert callback.call_count == 2 status = client.get("/admin/api/status").json() assert status["port"] == settings.port assert status["pending_fields"] == ([] if signal_recovers else fields) assert provider_manager_for_app(app).current_generation_id == 1 def test_reverting_pending_restart_restores_hot_apply(monkeypatch, tmp_path): from unittest.mock import MagicMock from free_claude_code.config.loader import ManagedConfigStore _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) store = ManagedConfigStore() store.initialize() settings = store.read().settings callback = MagicMock(side_effect=RuntimeError("restart failed")) app = create_test_app(settings, restart_callback=callback) client = _local_client(app) post_config(client, "/admin/api/config/apply", json={"values": {"PORT": "9090"}}) with patch.object(provider_manager_for_app(app), "_start_pass", MagicMock()): result = post_config( client, "/admin/api/config/apply", json={"values": {"PORT": str(settings.port), "MODEL": "nvidia_nim/new"}}, ).json() assert result["applied"] is True assert result["restart"]["required"] is False assert callback.call_count == 1 status = client.get("/admin/api/status").json() assert status["pending_fields"] == [] assert status["port"] == settings.port assert status["model"] == "nvidia_nim/new" def test_admin_process_env_values_are_locked_and_not_written(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) monkeypatch.setenv("MODEL", "open_router/process-model") app = create_test_app() config = _local_client(app).get("/admin/api/config").json() model_field = next(field for field in config["fields"] if field["key"] == "MODEL") assert model_field["locked"] is True assert model_field["source"] == "process" response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"MODEL": "deepseek/managed-model"}}, ) assert response.status_code == 200 env_file = tmp_path / ".fcc" / ".env" assert "deepseek/managed-model" not in env_file.read_text("utf-8") def test_admin_process_model_fallbacks_are_locked_and_not_written( monkeypatch, tmp_path ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) monkeypatch.setenv("MODEL_FALLBACKS", "open_router/process-model") app = create_test_app() config = _local_client(app).get("/admin/api/config").json() field = next(item for item in config["fields"] if item["key"] == "MODEL_FALLBACKS") assert field["locked"] is True assert field["source"] == "process" response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"MODEL_FALLBACKS": "groq/managed-model"}}, ) assert response.status_code == 200 env_file = tmp_path / ".fcc" / ".env" assert "MODEL_FALLBACKS=" not in env_file.read_text("utf-8") def test_admin_never_reads_arbitrary_current_directory_env(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) monkeypatch.chdir(tmp_path) (tmp_path / ".env").write_text( "MODEL=deepseek/deepseek-chat\nDEEPSEEK_API_KEY=deepseek-secret\n", encoding="utf-8", ) app = create_test_app() config = _local_client(app).get("/admin/api/config").json() model_field = next(field for field in config["fields"] if field["key"] == "MODEL") assert model_field["value"] == "nvidia_nim/nvidia/nemotron-3-ultra-550b-a55b" assert model_field["source"] == "default" response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {}}, ) assert response.status_code == 200 managed_text = (tmp_path / ".fcc" / ".env").read_text("utf-8") assert "MODEL=deepseek/deepseek-chat" not in managed_text assert "DEEPSEEK_API_KEY=deepseek-secret" not in managed_text def test_admin_migration_removes_blank_required_managed_values(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) env_file.write_text( "MESSAGING_PLATFORM=\nWHISPER_DEVICE=\n", encoding="utf-8", ) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"NVIDIA_NIM_API_KEY": "nim-secret"}}, ) assert response.status_code == 200 assert response.json()["applied"] is True managed_text = (tmp_path / ".fcc" / ".env").read_text("utf-8") assert json.loads(dotenv_values_from_text(managed_text)["NVIDIA_NIM_API_KEY"]) == [ "nim-secret" ] assert "MESSAGING_PLATFORM=" not in managed_text assert "WHISPER_DEVICE=" not in managed_text def test_admin_migrates_empty_auth_token_to_explicit_disabled_state( monkeypatch, tmp_path ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) env_file.write_text( "ANTHROPIC_AUTH_TOKEN=\nPROVIDER_RATE_LIMIT=1\n", encoding="utf-8", ) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"PROVIDER_RATE_LIMIT": "2"}}, ) assert response.status_code == 200 assert response.json()["applied"] is True managed_lines = env_file.read_text("utf-8").splitlines() assert not any(line.startswith("ANTHROPIC_AUTH_TOKEN=") for line in managed_lines) assert "PROXY_AUTH_ENABLED=false" in managed_lines assert "PROVIDER_RATE_LIMIT=2" in managed_lines @pytest.mark.parametrize( ("submitted", "message"), [ (None, "this setting cannot be removed"), ("", "this setting cannot be blank"), (" ", "this setting cannot be blank"), ], ) def test_admin_apply_rejects_missing_required_value_without_writing( monkeypatch, tmp_path, submitted, message, ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) env_file = tmp_path / ".fcc" / ".env" env_file.parent.mkdir(parents=True) original = "ANTHROPIC_AUTH_TOKEN=\nMESSAGING_PLATFORM=none\n" env_file.write_text(original, encoding="utf-8") app = create_test_app() _local_client(app).get("/admin/api/config") baseline = env_file.read_bytes() response = post_config( _local_client(app), "/admin/api/config/apply", json={"values": {"MESSAGING_PLATFORM": submitted}}, ) assert response.status_code == 200 body = response.json() assert body["applied"] is False assert body["valid"] is False assert f"MESSAGING_PLATFORM: {message}" in body["errors"] assert env_file.read_bytes() == baseline def test_admin_apply_preserves_false_and_numeric_zero(monkeypatch, tmp_path): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() response = post_config( _local_client(app), "/admin/api/config/apply", json={ "values": { "FCC_OPEN_BROWSER": False, "HTTP_WRITE_TIMEOUT": 0, } }, ) assert response.status_code == 200 assert response.json()["applied"] is True managed = (tmp_path / ".fcc" / ".env").read_text(encoding="utf-8") assert "FCC_OPEN_BROWSER=false" in managed assert "HTTP_WRITE_TIMEOUT=0" in managed @pytest.mark.parametrize("provider_id", ["lmstudio", "llamacpp", "ollama"]) def test_admin_local_provider_status_reports_reachable( monkeypatch, tmp_path, provider_id ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() class FakeAsyncClient: def __init__(self, *args, **kwargs): pass async def __aenter__(self): return self async def __aexit__(self, *args): return None async def get(self, url: str): return httpx.Response(200, json={"data": []}) with patch("free_claude_code.api.admin_routes.httpx.AsyncClient", FakeAsyncClient): response = _local_client(app).get( f"/admin/api/providers/{provider_id}/local-status" ) assert response.status_code == 200 assert response.json()["provider_id"] == provider_id assert response.json()["status"] == "reachable" def test_admin_local_provider_status_checks_only_requested_provider( monkeypatch, tmp_path ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() calls = 0 class CountingAsyncClient: def __init__(self, *args, **kwargs): pass async def __aenter__(self): return self async def __aexit__(self, *args): return None async def get(self, url: str): nonlocal calls calls += 1 return httpx.Response(200, json={"data": []}) with patch( "free_claude_code.api.admin_routes.httpx.AsyncClient", CountingAsyncClient ): response = _local_client(app).get("/admin/api/providers/lmstudio/local-status") assert response.status_code == 200 assert calls == 1 def test_admin_config_exposes_structured_provider_configuration_targets( monkeypatch, tmp_path ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) response = _local_client(create_test_app()).get("/admin/api/config") assert response.status_code == 200 providers = { provider["provider_id"]: provider for provider in response.json()["provider_status"] } assert providers["nvidia_nim"]["configuration_keys"] == ["NVIDIA_NIM_API_KEY"] assert providers["nvidia_nim"]["missing_configuration_keys"] == [ "NVIDIA_NIM_API_KEY" ] assert "configuration" not in providers["nvidia_nim"] assert providers["lmstudio"]["status"] == "configured" assert providers["lmstudio"]["configuration_keys"] == ["LM_STUDIO_BASE_URL"] def test_admin_local_provider_failure_does_not_return_exception_text( monkeypatch, tmp_path ): _set_home(monkeypatch, tmp_path) _clear_process_config(monkeypatch) app = create_test_app() class FailingAsyncClient: async def __aenter__(self): return self async def __aexit__(self, *args): return None async def get(self, url: str): raise RuntimeError( "Provider rejected credential CREDENTIAL[unrecognized-format-987654321]" ) with patch( "free_claude_code.api.admin_routes.httpx.AsyncClient", return_value=FailingAsyncClient(), ): response = _local_client(app).get("/admin/api/providers/lmstudio/local-status") assert response.status_code == 200 provider = response.json() assert provider["status"] == "offline" assert provider["message"] == ( "Could not connect. Verify the URL and that the local provider is running." ) assert "CREDENTIAL[unrecognized-format-987654321]" not in provider["message"] assert "RuntimeError" not in provider["message"] assert provider["error_type"] == "unexpected_error" assert "CREDENTIAL[unrecognized-format-987654321]" not in response.text assert "RuntimeError" not in response.text @pytest.mark.parametrize( "result", ( {"provider_id": "nvidia_nim", "ok": True, "models": ["model-a"]}, { "provider_id": "nvidia_nim", "ok": False, "message": "NVIDIA_NIM_API_KEY is not set.", }, ), ) def test_admin_provider_test_route_preserves_runtime_result( monkeypatch, tmp_path, result ): _set_home(monkeypatch, tmp_path) app = create_test_app() runtime = runtime_for_app(app) with patch.object(runtime, "test_provider", new=AsyncMock(return_value=result)): response = _local_client(app).post( "/admin/api/providers/nvidia_nim/test", json={}, ) assert response.status_code == 200 assert response.json() == result def test_admin_provider_test_exposes_completed_attempt_failure(): app = create_test_app() manager = provider_manager_for_app(app) message = "The model-list request returned HTTP 403." result = ProviderModelRefreshResult( failed_provider_ids=("nvidia_nim",), failure_messages={"nvidia_nim": message}, ) with patch.object(manager, "refresh_provider", new=AsyncMock(return_value=result)): response = _local_client(app).post( "/admin/api/providers/nvidia_nim/test", json={} ) assert response.status_code == 200 assert response.json() == { "provider_id": "nvidia_nim", "ok": False, "message": message, } def test_admin_launch_url_uses_loopback_for_wildcard_host(): settings = Settings.model_construct(host="0.0.0.0", port=8082) assert local_admin_url(settings) == "http://127.0.0.1:8082/admin"
import json
import mimetypes
import os
from dataclasses import replace
from pathlib import Path
from unittest.mock import AsyncMock, patch
import httpx
import pytest
from fastapi.testclient import TestClient
from free_claude_code.application.connected_accounts import (
ConnectedAccountLoginMode,
ConnectedAccountState,
ConnectedAccountStatus,
)
from free_claude_code.application.model_metadata import (
ProviderModelInfo,
ProviderModelRefreshResult,
)
from free_claude_code.config.admin.values import MASKED_SECRET
from free_claude_code.config.api_keys import normalize_api_keys
from free_claude_code.config.env_files import (
dotenv_values_from_file,
dotenv_values_from_text,
)
from free_claude_code.config.model_refs import ModelFallback, decode_model_fallbacks
from free_claude_code.config.provider_catalog import PROVIDER_CATALOG
from free_claude_code.config.server_urls import local_admin_url
from free_claude_code.config.settings import Settings
from free_claude_code.core.version import package_version
from tests.api.support import (
create_test_app,
post_config,
provider_manager_for_app,
runtime_for_app,
)
def _local_client(app):
return TestClient(
app,
base_url="http://127.0.0.1",
client=("127.0.0.1", 50000),
)
@pytest.mark.parametrize(
"path",
(
"/admin/chat",
"/admin/chat/old-session",
"/admin/api/chat/sessions",
"/admin/api/chat/events",
"/admin/api/chat/settings",
f"/admin/assets/{package_version()}/chat_sessions.js",
f"/admin/assets/{package_version()}/chat_sessions.css",
),
)
def test_retired_chat_urls_are_not_served(path):
client = _local_client(create_test_app())
assert client.get(path).status_code == 404
def test_admin_retains_code_without_chat_markup():
client = _local_client(create_test_app())
response = client.get("/admin")
assert response.status_code == 200
assert 'id="view-code"' in response.text
assert 'id="view-chat"' not in response.text
assert "chat_sessions" not in response.text
assert client.get("/admin/code").status_code == 200
def test_admin_retirement_preview_apply_and_runtime_agree(monkeypatch, tmp_path):
_set_home(monkeypatch, tmp_path)
_clear_process_config(monkeypatch)
env_file = tmp_path / ".fcc" / ".env"
env_file.parent.mkdir(parents=True)
env_file.write_text(
"FCC_CONFIG_SCHEMA=1\nMODEL=groq/default\nMODEL_OPUS=groq/managed\n"
"GITHUB_MODELS_TOKEN=preserve-secret\nGITHUB_MODELS_PROXY=http://user:secret@proxy.test\nPRIVATE=hidden\n",
encoding="utf-8",
)
monkeypatch.setenv("MODEL_OPUS", "github_models/retired-process")
app = create_test_app()
client = _local_client(app)
body = post_config(
client,
"/admin/api/config/apply",
json={
"values": {
"MODEL_SONNET": "github_models/stale",
"MODEL_OPUS": "deepseek/cannot-unlock",
"MODEL_FALLBACKS": "groq/a,github_models/old,deepseek/b",
}
},
).json()
assert body["applied"]
text = env_file.read_text(encoding="utf-8")