Spaces:
Running
Running
Download tests/conftest.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 10.9 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/tests/conftest.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/tests/conftest.py
-
curl -L -o conftest.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/tests/conftest.py
10.9 kB
| 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.core.stream_delivery import ( | |
| StreamDeliveryState, | |
| bind_stream_delivery, | |
| ) | |
| from free_claude_code.harnesses import ( | |
| antigravity, | |
| 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"] = "" | |
| def _response_delivery_context(request): | |
| """Direct provider tests run inside an unreleased private response context.""" | |
| if "api" in request.node.path.relative_to(Path(__file__).parent).parts: | |
| yield | |
| return | |
| with bind_stream_delivery(StreamDeliveryState()): | |
| yield | |
| 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.setattr( | |
| antigravity, | |
| "config_path", | |
| lambda: tmp_path / ".gemini/antigravity-cli/settings.json", | |
| ) | |
| 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() | |
| 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, | |
| ) | |
| def nim_provider(provider_config): | |
| from free_claude_code.providers.nvidia_nim import NvidiaNimProvider | |
| return NvidiaNimProvider( | |
| provider_config, | |
| admission=immediate_admission(), | |
| ) | |
| def open_router_provider(provider_config): | |
| from free_claude_code.providers.open_router import OpenRouterProvider | |
| return OpenRouterProvider(provider_config, admission=immediate_admission()) | |
| 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()) | |
| 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(), | |
| ) | |
| 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 | |
| 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 | |
| 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 | |
| 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 | |
| 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 | |
| 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) | |
| 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() | |
| 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() | |