Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
import json
from pathlib import Path
from unittest.mock import patch
import pytest
from fastapi.testclient import TestClient
from free_claude_code.application.errors import InvalidRequestError
from free_claude_code.application.routing import ModelRouter
from free_claude_code.config.settings import Settings
from free_claude_code.core.gateway_model_ids import desktop_model_id
from free_claude_code.harnesses import claude_desktop_integration as desktop
from tests.api.support import create_test_app
ROOT = "/admin/api/integrations/claude-desktop"
def test_pending_disconnect_survives_runtime_restart(monkeypatch):
settings = Settings(host="127.0.0.1", port=4321, proxy_auth_token="original")
root = desktop.config_root()
profile = root / "configLibrary" / f"{desktop.FCC_ID}.json"
unlink = Path.unlink
def fail(path, *args, **kwargs):
if path == profile:
raise PermissionError("test")
return unlink(path, *args, **kwargs)
with TestClient(
create_test_app(settings),
base_url="http://127.0.0.1",
client=("127.0.0.1", 50000),
) as client:
assert client.post(ROOT + "/connect").status_code == 200
with monkeypatch.context() as patch:
patch.setattr(Path, "unlink", fail)
assert client.post(ROOT + "/disconnect").status_code == 503
assert client.get(ROOT).json()["disconnect_pending"] is True
before = profile.read_bytes()
with TestClient(
create_test_app(settings.model_copy(update={"proxy_auth_token": "rotated"})),
base_url="http://127.0.0.1",
client=("127.0.0.1", 50000),
) as client:
status = client.get(ROOT).json()
assert status["disconnect_pending"] is True
assert profile.read_bytes() == before
refused = client.post(ROOT + "/connect")
assert refused.status_code == 400
assert "Finish disconnecting" in refused.json()["detail"]
result = client.post(ROOT + "/disconnect").json()
assert result["connected"] is False
assert result["disconnect_pending"] is False
assert not profile.exists()
@pytest.fixture
def client():
app = create_test_app(
Settings(host="0.0.0.0", port=4321, proxy_auth_token="desktop-secret")
)
with TestClient(
app, base_url="http://127.0.0.1", client=("127.0.0.1", 50000)
) as client:
yield client
def test_desktop_routes_connect_disconnect_and_hide_credentials(client):
root = desktop.config_root()
response = client.get(ROOT)
assert response.json()["connected"] is False
assert response.headers["cache-control"] == "no-store"
assert not root.exists()
response = client.post(ROOT + "/connect")
assert response.status_code == 200
assert response.json()["connected"] is True
assert "desktop-secret" not in response.text
profile = root / "configLibrary" / f"{desktop.FCC_ID}.json"
assert (
json.loads(profile.read_text())["inferenceGatewayBaseUrl"]
== "http://127.0.0.1:4321"
)
config = json.loads(profile.read_text())
models = [desktop_model_id("nvidia_nim/one")]
config["inferenceModels"] = models
profile.write_text(json.dumps(config))
before = {path: path.stat().st_mtime_ns for path in root.rglob("*.json")}
response = client.get(ROOT)
assert response.json()["connected"] is True
assert "desktop-secret" not in response.text
assert json.loads(profile.read_text())["inferenceModels"] == models
assert before == {path: path.stat().st_mtime_ns for path in root.rglob("*.json")}
assert client.post(ROOT + "/disconnect").json()["connected"] is False
assert not profile.exists()
@pytest.mark.parametrize("action", ["", "/connect", "/disconnect", "/refresh"])
def test_desktop_admin_routes_reject_other_origins(client, action):
response = client.request(
"POST" if action else "GET",
ROOT + action,
headers={"Origin": "https://evil.test"},
)
assert response.status_code == 403
assert not desktop.config_root().exists()
def test_managed_desktop_error_is_safe(client, monkeypatch):
def managed():
raise desktop.ManagedDesktopError("private-policy-secret")
monkeypatch.setattr(desktop, "check_unmanaged", managed)
response = client.post(ROOT + "/connect")
assert response.status_code == 400
assert "private-policy-secret" not in response.text
assert "organization" in response.json()["detail"]
def test_desktop_model_view_preserves_labels_and_query_precedence():
ref = "nvidia_nim/nemotron-3.5"
settings = Settings().model_copy(
update={
"model": ref,
"model_opus": None,
"model_haiku": None,
"model_fallbacks": (),
"proxy_auth_enabled": False,
}
)
with TestClient(create_test_app(settings)) as client:
headers = {"X-FCC-Model-View": "claude-desktop"}
payload = client.get("/v1/models", headers=headers).json()
models = [row for row in payload["data"] if "/" in row["id"]]
assert [row["id"] for row in models] == [
desktop_model_id(ref),
desktop_model_id(ref, no_thinking=True),
]
assert [row["display_name"] for row in models] == [ref, ref + " (no thinking)"]
regular = client.get("/v1/models").json()
assert client.get("/v1/models?view=claude", headers=headers).json() == regular
assert (
client.get(
"/v1/models", headers={"X-FCC-Model-View": "invalid"}
).status_code
== 422
)
route = ModelRouter(settings).resolve(models[0]["id"])
assert route.primary.provider_model_ref == ref
assert (
ModelRouter(settings).resolve(models[1]["id"]).reasoning_preference.value
== "off"
)
@pytest.mark.parametrize(
"model",
["claude-fcc/", "claude-fcc/zz", "claude-fcc", desktop_model_id("unknown/model")],
)
def test_invalid_desktop_model_never_routes_to_default(model):
with pytest.raises(InvalidRequestError):
ModelRouter(Settings()).resolve(model)
@pytest.mark.parametrize("no_thinking", [False, True])
def test_desktop_token_count_routes_to_original_provider(no_thinking):
ref = "groq/desktop-model"
app = create_test_app(Settings(proxy_auth_enabled=False))
with (
TestClient(app) as client,
patch("free_claude_code.api.routes.get_token_count", return_value=7),
patch("free_claude_code.api.handlers.token_count.trace_event") as trace,
):
response = client.post(
"/v1/messages/count_tokens",
json={
"model": desktop_model_id(ref, no_thinking=no_thinking),
"messages": [{"role": "user", "content": "hello"}],
},
)
assert response.status_code == 200
assert response.json()["input_tokens"] == 7
routed = next(
call.kwargs
for call in trace.call_args_list
if call.kwargs["stage"] == "routing"
)
assert routed["provider_model_ref"] == ref
def test_pending_windows_migration_reports_recovery_without_writes(client, monkeypatch):
monkeypatch.setattr(desktop.sys, "platform", "win32")
legacy = desktop.legacy_windows_root()
assert legacy is not None
legacy.mkdir()
history = legacy / "history.json"
history.write_text('{"chat":"keep"}')
response = client.post(ROOT + "/connect")
assert response.status_code == 400
detail = response.json()["detail"]
assert "Launch Claude Desktop" in detail
assert "quit" in detail
assert "retry Connect" in detail
assert not desktop.config_root().exists()
assert history.read_text() == '{"chat":"keep"}'