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