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
10.1 KB
Raw Blame
import asyncio
import contextlib
import os
from pathlib import Path
from typing import Any
from unittest.mock import AsyncMock, MagicMock

import pytest
import pytest_asyncio

from free_claude_code.config import env_migrations, paths
from free_claude_code.config.loader import clear_settings_cache
from free_claude_code.harnesses import (
    claude_desktop_integration,
    claude_integration,
    claude_onboarding,
    codex_integration,
    jetbrains_acp_integration,
    vscode_chat_integration,
)
from tests.providers.support import (
    immediate_admission,
    make_provider_config,
)

# Set deterministic process overrides before any test resolves Settings.
os.environ.setdefault("NVIDIA_NIM_API_KEY", "test_key")
os.environ.setdefault("MODEL", "nvidia_nim/test-model")
os.environ["PTB_TIMEDELTA"] = "1"
# Tests keep proxy authentication disabled unless a case enables it explicitly.
os.environ["ANTHROPIC_AUTH_TOKEN"] = ""


@pytest.fixture(autouse=True)
def _isolate_managed_config(monkeypatch, tmp_path):
    """Keep every test away from real home, checkout, and running-server config."""

    config_dir = tmp_path / ".fcc"
    monkeypatch.setenv("DSH_HOME", str(tmp_path / ".dsh"))
    monkeypatch.delenv("FCC_DSH_DESKTOP_API_KEY", raising=False)
    monkeypatch.setattr(
        vscode_chat_integration,
        "config_path",
        lambda: tmp_path / "vscode/chatLanguageModels.json",
    )
    monkeypatch.setattr(
        jetbrains_acp_integration,
        "config_path",
        lambda: tmp_path / ".jetbrains/acp.json",
    )
    monkeypatch.setattr(
        jetbrains_acp_integration,
        "registry_path",
        lambda: tmp_path / "jetbrains/installed.json",
    )
    monkeypatch.setattr(
        jetbrains_acp_integration, "system_root", lambda: tmp_path / "jetbrains/systems"
    )
    monkeypatch.setattr(
        claude_desktop_integration, "config_root", lambda: tmp_path / "Claude-3p"
    )
    monkeypatch.setattr(claude_desktop_integration, "check_unmanaged", lambda: None)
    monkeypatch.setattr(
        claude_desktop_integration,
        "legacy_windows_root",
        lambda: tmp_path / "LegacyClaude-3p",
    )
    monkeypatch.setattr(paths, "config_dir_path", lambda: config_dir)
    monkeypatch.setattr(env_migrations, "legacy_env_paths", lambda: ())
    monkeypatch.setattr(env_migrations, "verified_checkout_env_path", lambda: None)
    monkeypatch.setattr(
        claude_integration, "settings_path", lambda: tmp_path / "vscode/settings.json"
    )
    monkeypatch.setattr(
        claude_onboarding, "state_path", lambda: tmp_path / ".claude.json"
    )
    monkeypatch.setattr(
        codex_integration, "config_path", lambda: tmp_path / ".codex/config.toml"
    )
    clear_settings_cache()
    yield
    clear_settings_cache()


@pytest.fixture
def provider_config():

    return make_provider_config(
        api_key="test_key",
        base_url="https://test.api.nvidia.com/v1",
        http_read_timeout=300.0,
        http_write_timeout=10.0,
        http_connect_timeout=10.0,
        proxy=None,
        log_raw_sse_events=False,
        log_api_error_tracebacks=False,
    )


@pytest.fixture
def nim_provider(provider_config):
    from free_claude_code.config.nim import NimSettings
    from free_claude_code.providers.nvidia_nim import NvidiaNimProvider

    return NvidiaNimProvider(
        provider_config,
        nim_settings=NimSettings(),
        admission=immediate_admission(),
    )


@pytest.fixture
def open_router_provider(provider_config):
    from free_claude_code.providers.open_router import OpenRouterProvider

    return OpenRouterProvider(provider_config, admission=immediate_admission())


@pytest.fixture
def lmstudio_provider(provider_config):
    from free_claude_code.providers.lmstudio import LMStudioProvider

    lmstudio_config = make_provider_config(
        api_key="lm-studio",
        base_url="http://localhost:1234/v1",
        http_read_timeout=provider_config.http_read_timeout,
        http_write_timeout=provider_config.http_write_timeout,
        http_connect_timeout=provider_config.http_connect_timeout,
        proxy=None,
        log_raw_sse_events=False,
        log_api_error_tracebacks=False,
    )
    return LMStudioProvider(lmstudio_config, admission=immediate_admission())


@pytest.fixture
def llamacpp_provider(provider_config):
    from free_claude_code.providers.openai_chat import create_openai_chat_provider

    llamacpp_config = make_provider_config(
        api_key="llamacpp",
        base_url="http://localhost:8080/v1",
        http_read_timeout=300.0,
        http_write_timeout=10.0,
        http_connect_timeout=10.0,
        proxy=None,
        log_raw_sse_events=False,
        log_api_error_tracebacks=False,
    )
    return create_openai_chat_provider(
        "llamacpp",
        llamacpp_config,
        immediate_admission(),
    )


@pytest.fixture
def mock_cli_session():
    from free_claude_code.messaging.managed_protocols import (
        ManagedClaudeSessionProtocol,
    )

    session = MagicMock(spec=ManagedClaudeSessionProtocol)
    session.start_task = MagicMock()  # This will return an async generator
    session.is_busy = False
    return session


@pytest.fixture
def mock_cli_manager():
    from free_claude_code.messaging.managed_protocols import (
        ManagedClaudeSessionManagerProtocol,
    )

    manager = MagicMock(spec=ManagedClaudeSessionManagerProtocol)
    manager.get_or_create_session = AsyncMock()
    manager.register_real_session_id = AsyncMock(return_value=True)
    manager.stop_all = AsyncMock()
    manager.remove_session = AsyncMock(return_value=True)
    manager.get_stats = MagicMock(return_value={"active_sessions": 0})
    return manager


@pytest.fixture
def mock_platform():
    from free_claude_code.messaging.platforms.ports import OutboundMessenger

    platform = MagicMock(spec=OutboundMessenger)
    platform.send_message = AsyncMock(return_value="msg_123")
    platform.edit_message = AsyncMock()
    platform.delete_message = AsyncMock()
    platform.queue_send_message = AsyncMock(return_value="msg_123")
    platform.queue_edit_message = AsyncMock()
    platform.queue_delete_messages = AsyncMock()
    platform.cancel_pending_voice = AsyncMock(return_value=None)
    platform.cancel_all_pending_voices = AsyncMock(return_value=())
    platform.cancel_pending_voices_in_scope = AsyncMock(return_value=())

    def _fire_and_forget(task):
        if asyncio.iscoroutine(task):
            # Create a task to avoid "coroutine was never awaited" warning
            return asyncio.create_task(task)
        return None

    platform.fire_and_forget = MagicMock(side_effect=_fire_and_forget)
    return platform


@pytest.fixture
def mock_session_store():
    from free_claude_code.messaging.trees import ConversationSnapshot, MessagingStore

    store = AsyncMock(spec=MessagingStore)
    store.get_tracked_message_ids_for_chat.return_value = []
    store.load_conversation_snapshot.return_value = ConversationSnapshot()
    return store


@pytest.fixture
def incoming_message_factory():
    _valid_keys = frozenset(
        {
            "text",
            "chat_id",
            "user_id",
            "message_id",
            "platform",
            "reply_to_message_id",
            "message_thread_id",
            "username",
            "timestamp",
            "raw_event",
            "status_message_id",
        }
    )

    def _create(**kwargs):
        from free_claude_code.messaging.models import IncomingMessage

        defaults: dict[str, Any] = {
            "text": "hello",
            "chat_id": "chat_1",
            "user_id": "user_1",
            "message_id": "msg_1",
            "platform": "telegram",
        }
        defaults.update(kwargs)
        if "timestamp" in defaults and isinstance(defaults["timestamp"], str):
            from datetime import datetime

            defaults["timestamp"] = datetime.fromisoformat(defaults["timestamp"])
        filtered = {k: v for k, v in defaults.items() if k in _valid_keys}
        return IncomingMessage(**filtered)

    return _create


@pytest.fixture(autouse=True)
def _propagate_loguru_to_caplog(caplog):
    """Capture Loguru directly without re-entering the stdlib interceptor."""
    from loguru import logger as loguru_logger

    handler_id = loguru_logger.add(
        caplog.handler,
        format="{message}",
        filter=lambda record: record["level"].no >= caplog.handler.level,
    )
    yield
    with contextlib.suppress(ValueError):
        loguru_logger.remove(
            handler_id
        )  # Handler already removed (e.g. by test_logging_config)


@pytest_asyncio.fixture
async def messaging_store_factory(tmp_path):
    """Real SQLite stores with fixture-owned lifetime and optional old JSON input."""
    from free_claude_code.runtime.messaging_import import import_legacy
    from free_claude_code.runtime.messaging_sqlite import SQLiteMessagingStore
    from free_claude_code.runtime.sqlite_database import SQLiteDatabase

    databases = {}

    async def create(*, storage_path=None, managed_message_cap=None):
        path = Path(storage_path) if storage_path is not None else tmp_path / "fcc.db"
        database_path = path.with_suffix(".db")
        database = databases.get(database_path)
        first = database is None
        if first:
            database = SQLiteDatabase(database_path, database_path.with_suffix(".lock"))
            await database.start()
            databases[database_path] = database
        store = SQLiteMessagingStore(database, managed_message_cap=managed_message_cap)
        if first and path.suffix == ".json":
            await import_legacy(database, path)
            await store.trim()
        return store

    try:
        yield create
    finally:
        for database in databases.values():
            await database.close()


@pytest_asyncio.fixture
async def database_factory():
    """Own database resources for tests that compose individual services."""
    from free_claude_code.runtime.sqlite_database import SQLiteDatabase

    databases = []

    def create(*args, **kwargs):
        database = SQLiteDatabase(*args, **kwargs)
        databases.append(database)
        return database

    try:
        yield create
    finally:
        for database in reversed(databases):
            await database.close()