Skip to content

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
7.7 KB
Raw Blame
import asyncio
import json
import threading
from unittest.mock import AsyncMock, MagicMock

import pytest
import pytest_asyncio

from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.config.loader import ManagedConfigStore
from free_claude_code.config.settings import Settings
from free_claude_code.harnesses import vscode_chat_integration as vscode
from free_claude_code.providers.base import BaseProvider
from free_claude_code.providers.runtime.runtime import ProviderRuntime
from free_claude_code.runtime.application import ApplicationRuntime
from free_claude_code.runtime.configuration import ConfigurationService
from free_claude_code.runtime.provider_manager import ProviderRuntimeManager
from tests.runtime.catalog_support import (
    finish_discovery,
    finish_publication,
    pause_next_write,
)


@pytest_asyncio.fixture
async def runtime(request):
    settings = Settings(
        model="nvidia_nim/one",
        nvidia_nim_api_keys="test",
        proxy_auth_token="managed",
        messaging_platform="none",
    )
    provider = MagicMock(spec=BaseProvider)
    provider.list_model_infos = AsyncMock(
        return_value=frozenset({ProviderModelInfo("one")})
    )

    async def construct(provider_id, *_):
        if provider_id in {"lmstudio", "llamacpp", "ollama"}:
            raise ConnectionError()
        return provider

    manager = ProviderRuntimeManager(
        settings,
        runtime_factory=lambda s, admission_registry: ProviderRuntime(
            s,
            admission_registry,
            provider_constructor=construct,
        ),
    )
    app = ApplicationRuntime(
        manager,
        configuration=ConfigurationService(ManagedConfigStore()),
        transcriber=None,
    )
    if getattr(request, "param", False):
        vscode.configure(vscode.config_path(), "http://127.0.0.1:1", "old", ())
    await app.start()
    try:
        yield app
    finally:
        await app.close()


async def settle(runtime):
    await finish_discovery(runtime.provider_manager)
    task = runtime._integrations._vscode_update.task
    if task:
        await asyncio.wait_for(asyncio.shield(task), 5)


@pytest.mark.asyncio
async def test_catalog_updates_connected_file_and_disconnect_stays_removed(runtime):
    await runtime.connect_vscode_chat()
    await settle(runtime)
    path = vscode.config_path()
    runtime.provider_manager.cache_model_infos(
        "nvidia_nim", (ProviderModelInfo("two"),)
    )
    await finish_publication(runtime.provider_manager)
    await settle(runtime)
    models = json.loads(path.read_text())[0]["models"]
    assert {m["id"] for m in models} == {"nvidia_nim/one", "nvidia_nim/two"}
    assert (await runtime.vscode_chat_status())["connected"]
    await runtime.disconnect_vscode_chat()
    runtime._integrations.catalog_changed()
    await settle(runtime)
    assert json.loads(path.read_text()) == []
    assert not (await runtime.vscode_chat_status())["connected"]


@pytest.mark.asyncio
async def test_update_arriving_during_write_is_not_lost(runtime, monkeypatch):
    await runtime.connect_vscode_chat()
    await settle(runtime)
    entered, release = asyncio.Event(), threading.Event()
    loop = asyncio.get_running_loop()
    original = vscode.configure
    calls = 0

    def held(*args, **kwargs):
        nonlocal calls
        calls += 1
        if calls == 1:
            loop.call_soon_threadsafe(entered.set)
            assert release.wait(5)
        return original(*args, **kwargs)

    monkeypatch.setattr(vscode, "configure", held)
    try:
        runtime._integrations.catalog_changed()
        await asyncio.wait_for(entered.wait(), 5)
        runtime.provider_manager.cache_model_infos(
            "nvidia_nim", (ProviderModelInfo("late"),)
        )
        await finish_publication(runtime.provider_manager)
    finally:
        release.set()
    await settle(runtime)
    assert calls >= 2
    assert "nvidia_nim/late" in [
        m["id"] for m in json.loads(vscode.config_path().read_text())[0]["models"]
    ]


@pytest.mark.asyncio
async def test_bad_file_does_not_fail_catalog_and_disconnect_needs_no_catalog(
    runtime, monkeypatch
):
    await settle(runtime)
    path = vscode.config_path()
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text("{broken")
    await runtime.refresh_vscode_chat()
    await settle(runtime)
    assert runtime._integrations._vscode_update.state == "failed"
    assert runtime.provider_manager.catalog_status()["catalog_file"] == "ready"
    path.unlink()
    await runtime.connect_vscode_chat()
    monkeypatch.setattr(
        runtime.provider_manager,
        "catalog_snapshot",
        AsyncMock(side_effect=AssertionError("Must not wait")),
    )
    assert (await runtime.disconnect_vscode_chat())["connected"] is False


@pytest.mark.asyncio
async def test_disconnected_startup_does_not_create_file(runtime):
    await settle(runtime)
    assert not vscode.config_path().exists()


@pytest.mark.asyncio
@pytest.mark.parametrize("runtime", [True], indirect=True)
async def test_startup_refreshes_owned_group_and_only_writes_once(runtime):
    await settle(runtime)
    path = vscode.config_path()
    assert (
        json.loads(path.read_text())[0]["models"][0]["requestHeaders"]["x-api-key"]
        == "managed"
    )
    assert json.loads(path.read_text())[0]["models"]
    before = path.stat().st_mtime_ns
    await runtime.refresh_vscode_chat()
    await settle(runtime)
    assert path.stat().st_mtime_ns == before
    assert not runtime._integrations._vscode_update.changed


@pytest.mark.asyncio
async def test_disconnect_while_refresh_waits_for_ownership_never_reconnects(
    runtime, monkeypatch
):
    await runtime.connect_vscode_chat()
    await settle(runtime)
    entered, release = pause_next_write(
        monkeypatch, runtime._integrations._vscode_update.access
    )
    try:
        await runtime.refresh_vscode_chat()
        await asyncio.wait_for(entered.wait(), 5)
        await asyncio.wait_for(runtime.disconnect_vscode_chat(), 5)
    finally:
        release.set()
    await settle(runtime)
    assert json.loads(vscode.config_path().read_text()) == []


@pytest.mark.asyncio
async def test_replaced_generation_cannot_publish_old_url_or_token(
    runtime, monkeypatch
):
    await runtime.connect_vscode_chat()
    await settle(runtime)
    entered, release = pause_next_write(
        monkeypatch, runtime._integrations._vscode_update.access
    )
    try:
        await runtime.refresh_vscode_chat()
        await asyncio.wait_for(entered.wait(), 5)
        await runtime.provider_manager.replace(
            runtime.settings.model_copy(
                update={"port": 12345, "proxy_auth_token": "rotated"}
            ),
            commit=AsyncMock(),
            reason="test",
        )
    finally:
        release.set()
    await settle(runtime)
    group = json.loads(vscode.config_path().read_text())[0]
    assert all(m["requestHeaders"] == {"x-api-key": "rotated"} for m in group["models"])
    assert all(
        m["url"] == "http://127.0.0.1:12345/v1/messages" for m in group["models"]
    )


@pytest.mark.asyncio
async def test_codex_publication_failure_does_not_block_vscode(runtime):
    await runtime.connect_vscode_chat()
    await settle(runtime)
    publisher = MagicMock()
    publisher.publish.side_effect = PermissionError("denied")
    runtime.provider_manager._model_catalog_publisher = publisher
    runtime.provider_manager.cache_model_infos(
        "nvidia_nim", (ProviderModelInfo("new"),)
    )
    await finish_publication(runtime.provider_manager)
    await settle(runtime)
    assert runtime.provider_manager.catalog_status()["catalog_file"] == "failed"
    assert runtime._integrations._vscode_update.state == "ready"
    assert "nvidia_nim/new" in [
        m["id"] for m in json.loads(vscode.config_path().read_text())[0]["models"]
    ]