claude-proxy / tests /runtime /test_provider_manager.py
dheraingoud's picture
Copilot App
Sync upstream v6.19.35 and preserve custom addons
a9e27c0
Raw History Blame Contribute Delete
34.1 kB
import asyncio from typing import cast from unittest.mock import AsyncMock, MagicMock, patch import httpx2 import pytest from pydantic import ValidationError from free_claude_code.application.errors import ApplicationUnavailableError from free_claude_code.application.model_metadata import ProviderModelInfo from free_claude_code.application.ports import ModelCatalogPort from free_claude_code.config.api_keys import normalize_api_keys from free_claude_code.config.settings import Settings from free_claude_code.providers.base import BaseProvider from free_claude_code.providers.nvidia_nim import NvidiaNimProvider from free_claude_code.providers.runtime import ProviderRuntime from free_claude_code.runtime.provider_manager import ProviderRuntimeManager from tests.runtime.catalog_support import finish_discovery, finish_publication class FakeRuntime(ProviderRuntime): def __init__(self, settings: Settings) -> None: self.settings = settings self.cleanup_calls = 0 self.cleanup_error: Exception | None = None self.cleanup_started: asyncio.Event | None = None self.cleanup_release: asyncio.Event | None = None self.provider = MagicMock() self.provider.list_model_infos = AsyncMock(return_value=frozenset()) def is_cached(self, provider_id: str, api_key_number: int = 1) -> bool: return provider_id == "cached" async def resolve_provider( self, provider_id: str, api_key_number: int = 1 ) -> BaseProvider: if provider_id in {"lmstudio", "llamacpp", "ollama"}: raise ConnectionError("Local fixture is offline") return cast(BaseProvider, self.provider) async def cleanup(self) -> None: self.cleanup_calls += 1 if self.cleanup_started is not None: self.cleanup_started.set() if self.cleanup_release is not None: await self.cleanup_release.wait() if self.cleanup_error is not None: raise self.cleanup_error class RuntimeFactory: def __init__(self) -> None: self.runtimes: list[FakeRuntime] = [] self.error: Exception | None = None def __call__( self, settings: Settings, admission_registry, history_cache=None ) -> ProviderRuntime: if self.error is not None: raise self.error runtime = FakeRuntime(settings) self.runtimes.append(runtime) return runtime class RecordingModelCatalogPublisher: def __init__(self) -> None: self.events: list[str] = [] self.snapshots: list[tuple[str, tuple[str, ...]]] = [] def publish(self, runtime: ModelCatalogPort) -> None: self._record("publish", runtime) def _record(self, event: str, runtime: ModelCatalogPort) -> None: self.events.append(event) self.snapshots.append( ( runtime.current_settings().model, tuple(info.model_id for info in runtime.cached_prefixed_model_infos()), ) ) def _settings(model: str) -> Settings: return Settings().model_copy( update={"model": model, "nvidia_nim_api_keys": normalize_api_keys("test-key")} ) @pytest.mark.asyncio async def test_discovery_error_follows_attempt_and_generation_without_losing_cache(): factory = RuntimeFactory() settings = _settings("nvidia_nim/one") manager = ProviderRuntimeManager(settings, runtime_factory=factory) provider = factory.runtimes[0].provider manager.cache_model_infos("nvidia_nim", {ProviderModelInfo("one")}) provider.list_model_infos.side_effect = httpx2.ProxyError("secret-canary") try: with patch( "free_claude_code.runtime.provider_manager.logger.warning" ) as warning: result = await manager.refresh_model_list_cache() message = result.failure_messages["nvidia_nim"] assert "proxy" in message assert manager.catalog_status()["provider_errors"] == {"nvidia_nim": message} assert manager.cached_model_ids()["nvidia_nim"] == frozenset({"one"}) assert warning.call_args.args[-1] == message assert "secret-canary" not in str(warning.call_args) entered, release = asyncio.Event(), asyncio.Event() async def held(): entered.set() await release.wait() return frozenset({ProviderModelInfo("two")}) provider.list_model_infos.side_effect = held refresh = asyncio.create_task(manager.refresh_provider("nvidia_nim")) await entered.wait() local_states = dict.fromkeys(("lmstudio", "llamacpp", "ollama"), "unavailable") assert manager.catalog_status()["providers"] == { "nvidia_nim": "starting", **local_states, } assert manager.catalog_status()["provider_errors"] == {} release.set() assert (await refresh).failure_messages == {} assert manager.catalog_status()["providers"] == { "nvidia_nim": "ready", **local_states, } provider.list_model_infos.side_effect = httpx2.ProxyError("secret-canary") await manager.refresh_provider("nvidia_nim") await manager.replace(settings, commit=AsyncMock()) assert manager.catalog_status()["provider_errors"] == {} await finish_discovery(manager) assert manager.catalog_status()["provider_errors"] == {} finally: await manager.close() @pytest.mark.asyncio async def test_startup_generation_lease_and_shutdown_close_exactly_once() -> None: factory = RuntimeFactory() settings = _settings("nvidia_nim/one") manager = ProviderRuntimeManager(settings, runtime_factory=factory) lease = await manager.acquire() assert lease.generation_id == 1 assert lease.settings is settings assert lease.model_info("nvidia_nim", "missing") is None assert lease.is_provider_cached("cached") is True assert (await lease.resolve_provider("nvidia_nim")) is factory.runtimes[0].provider await lease.release() await lease.release() await manager.close() await manager.close() assert factory.runtimes[0].cleanup_calls == 1 with pytest.raises(ApplicationUnavailableError, match="shutting down"): await manager.acquire() @pytest.mark.asyncio async def test_custom_tail_edit_preserves_metadata_and_first_key_change_evicts_it(): provider_id = "custom_" + "c" * 32 definition = { "provider_id": provider_id, "display_name": "Gateway", "base_url": "https://gateway.example/v1", "api_keys": ["catalog-first", "catalog-tail"], } def settings(keys): return Settings.model_validate( { "FCC_CUSTOM_PROVIDERS": [{**definition, "api_keys": keys}], "MODEL": f"{provider_id}/one", } ) async def held_models(): await asyncio.Event().wait() def factory(config, registry, history_cache=None): runtime = FakeRuntime(config) runtime.provider.list_model_infos = AsyncMock(side_effect=held_models) return runtime manager = ProviderRuntimeManager( settings(["catalog-first", "catalog-tail"]), runtime_factory=factory ) manager.cache_model_infos( provider_id, {ProviderModelInfo("one", context_window_tokens=1234)} ) try: await manager.replace( settings(["catalog-first", "new-tail"]), commit=AsyncMock() ) cached = manager.cached_prefixed_model_infos() assert [(info.model_id, info.context_window_tokens) for info in cached] == [ (f"{provider_id}/one", 1234) ] await manager.replace( settings(["new-tail", "catalog-first"]), commit=AsyncMock() ) assert not manager.cached_prefixed_model_infos() finally: await manager.close() @pytest.mark.asyncio async def test_connected_provider_refresh_and_eviction_are_targeted() -> None: factory = RuntimeFactory() connected: set[str] = set() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, connected_provider_ids=lambda: tuple(connected), ) factory.runtimes[0].provider.list_model_infos = AsyncMock( return_value=frozenset( {ProviderModelInfo(model_id="gpt-visible", supports_thinking=True)} ) ) connected.add("openai") await manager.connected_provider_changed("openai", connected=True) await finish_discovery(manager) assert manager.cached_model_ids()["openai"] == frozenset({"gpt-visible"}) connected.clear() assert "openai" not in manager.cached_model_ids() await manager.connected_provider_changed("openai", connected=False) assert "openai" not in manager.cached_model_ids() await manager.close() @pytest.mark.asyncio async def test_catalog_publication_tracks_warm_refresh_and_direct_cache() -> None: factory = RuntimeFactory() publisher = RecordingModelCatalogPublisher() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, model_catalog_publisher=publisher, ) factory.runtimes[0].provider.list_model_infos = AsyncMock( return_value=frozenset({ProviderModelInfo("warm-model")}) ) await manager.refresh_model_list_cache() await finish_publication(manager) manager.start_model_list_refresh() refresh_task = manager._current.refresh_task assert refresh_task is not None await refresh_task manager.cache_model_infos( "nvidia_nim", {ProviderModelInfo("tested-model")}, ) await finish_publication(manager) assert ("nvidia_nim/one", ("nvidia_nim/warm-model",)) in publisher.snapshots assert publisher.snapshots[-1] == ("nvidia_nim/one", ("nvidia_nim/tested-model",)) await manager.close() @pytest.mark.asyncio async def test_failed_startup_discovery_still_ensures_a_fresh_catalog() -> None: factory = RuntimeFactory() publisher = RecordingModelCatalogPublisher() manager = ProviderRuntimeManager( _settings("nvidia_nim/configured"), runtime_factory=factory, model_catalog_publisher=publisher, ) factory.runtimes[0].provider.list_model_infos = AsyncMock( side_effect=RuntimeError("upstream unavailable") ) result = await manager.refresh_model_list_cache() assert result.failed_provider_ids == ("nvidia_nim",) await finish_publication(manager) assert publisher.events == ["publish"] assert publisher.snapshots == [("nvidia_nim/configured", ())] await manager.close() @pytest.mark.asyncio async def test_catalog_publication_tracks_connected_account_changes() -> None: factory = RuntimeFactory() publisher = RecordingModelCatalogPublisher() connected: set[str] = set() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, connected_provider_ids=lambda: tuple(connected), model_catalog_publisher=publisher, ) await finish_discovery(manager) await finish_publication(manager) publisher.events.clear() publisher.snapshots.clear() factory.runtimes[0].provider.list_model_infos = AsyncMock( return_value=frozenset({ProviderModelInfo("gpt-connected")}) ) connected.add("openai") await manager.connected_provider_changed("openai", connected=True) await finish_discovery(manager) await finish_publication(manager) assert publisher.snapshots[-1] == ("nvidia_nim/one", ("openai/gpt-connected",)) connected.clear() await manager.connected_provider_changed("openai", connected=False) await finish_discovery(manager) await finish_publication(manager) assert publisher.snapshots[-1] == ("nvidia_nim/one", ()) await manager.close() @pytest.mark.asyncio async def test_catalog_publication_tracks_replacement_and_its_refresh() -> None: factory = RuntimeFactory() publisher = RecordingModelCatalogPublisher() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, model_catalog_publisher=publisher, ) await manager.replace( _settings("nvidia_nim/two"), commit=AsyncMock(), ) refresh_task = manager._current.refresh_task assert refresh_task is not None await refresh_task await finish_publication(manager) assert publisher.events == ["publish"] assert publisher.snapshots == [ ("nvidia_nim/two", ()), ] await manager.close() @pytest.mark.asyncio async def test_catalog_publication_failure_is_warning_only_and_secret_safe() -> None: factory = RuntimeFactory() secret = "private-catalog-write-detail" publisher = MagicMock() publisher.publish.side_effect = PermissionError(secret) manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, model_catalog_publisher=publisher, ) with patch("free_claude_code.runtime.provider_manager.logger.warning") as warning: await manager.refresh_model_list_cache() await finish_publication(manager) manager.cache_model_infos( "nvidia_nim", {ProviderModelInfo("tested-model")}, ) await finish_publication(manager) assert warning.call_count == 2 log_blob = " ".join( str(value) for call in warning.call_args_list for value in (*call.args, *call.kwargs.values()) ) assert "PermissionError" in log_blob assert secret not in log_blob await manager.close() @pytest.mark.asyncio async def test_replacement_keeps_leased_generation_open_until_final_release() -> None: factory = RuntimeFactory() first_settings = _settings("nvidia_nim/one") second_settings = _settings("nvidia_nim/two") manager = ProviderRuntimeManager(first_settings, runtime_factory=factory) old_lease = await manager.acquire() old_catalog = manager.catalog_snapshot() for settings in ( manager.current_settings(), old_lease.settings, old_catalog.settings, ): with pytest.raises(ValidationError, match="frozen_instance"): settings.__setattr__("model", "nvidia_nim/mutated") committed: list[str] = [] generation_id = await manager.replace( second_settings, commit=AsyncMock(side_effect=lambda: committed.append("persisted")), ) new_lease = await manager.acquire() assert generation_id == 2 assert committed == ["persisted"] assert new_lease.generation_id == 2 assert new_lease.settings is second_settings assert old_lease.settings.model == "nvidia_nim/one" assert old_catalog.settings.model == "nvidia_nim/one" assert manager.catalog_snapshot().settings is second_settings assert factory.runtimes[0].cleanup_calls == 0 await new_lease.release() await old_lease.release() assert factory.runtimes[0].cleanup_calls == 1 await manager.close() assert factory.runtimes[1].cleanup_calls == 1 @pytest.mark.asyncio async def test_hot_replacement_shares_admission_and_retires_clients() -> None: first_settings = _settings("nvidia_nim/one") second_settings = _settings("nvidia_nim/two") clients: list[MagicMock] = [] def create_client(*_args: object, **_kwargs: object) -> MagicMock: client = MagicMock() client.close = AsyncMock() clients.append(client) return client with patch( "free_claude_code.providers.openai_chat.client.AsyncOpenAI", side_effect=create_client, ): manager = ProviderRuntimeManager(first_settings) old_lease = await manager.acquire() old_provider = await old_lease.resolve_provider("nvidia_nim") refresh = AsyncMock(return_value=frozenset()) with patch.object(NvidiaNimProvider, "list_model_infos", refresh): await manager.replace(second_settings, commit=AsyncMock()) new_lease = await manager.acquire() new_provider = await new_lease.resolve_provider("nvidia_nim") await asyncio.sleep(0) assert isinstance(old_provider, NvidiaNimProvider) assert isinstance(new_provider, NvidiaNimProvider) assert new_provider is not old_provider assert new_provider._admission is old_provider._admission assert (await old_lease.resolve_provider("nvidia_nim")) is old_provider clients[0].close.assert_not_awaited() await new_lease.release() await old_lease.release() clients[0].close.assert_awaited_once() clients[1].close.assert_not_awaited() refresh.assert_awaited_once() await manager.close() clients[1].close.assert_awaited_once() @pytest.mark.asyncio async def test_replacement_closes_unleased_generation_immediately() -> None: factory = RuntimeFactory() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, ) await manager.replace( _settings("nvidia_nim/two"), commit=AsyncMock(), ) assert factory.runtimes[0].cleanup_calls == 1 await manager.close() @pytest.mark.asyncio async def test_cancelled_replacement_does_not_cancel_owned_generation_cleanup() -> None: factory = RuntimeFactory() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, ) cleanup_started = asyncio.Event() cleanup_release = asyncio.Event() refresh_started = asyncio.Event() factory.runtimes[0].cleanup_started = cleanup_started factory.runtimes[0].cleanup_release = cleanup_release async def refresh(*_args: object, **_kwargs: object) -> None: refresh_started.set() await asyncio.Event().wait() with patch.object(manager, "_discover_provider", side_effect=refresh): replace_task = asyncio.create_task( manager.replace( _settings("nvidia_nim/two"), commit=AsyncMock(), ) ) await cleanup_started.wait() await refresh_started.wait() replace_task.cancel() with pytest.raises(asyncio.CancelledError): await replace_task retired = manager._retired[1] assert manager.current_generation_id == 2 assert retired.cleanup_task is not None assert not retired.cleanup_task.cancelled() assert factory.runtimes[0].cleanup_calls == 1 close_task = asyncio.create_task(manager.close()) await asyncio.sleep(0) assert not close_task.done() cleanup_release.set() await close_task assert factory.runtimes[0].cleanup_calls == 1 assert factory.runtimes[1].cleanup_calls == 1 assert manager._retired == {} @pytest.mark.asyncio async def test_cancelled_final_lease_release_keeps_owned_cleanup_running() -> None: factory = RuntimeFactory() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, ) lease = await manager.acquire() await manager.replace( _settings("nvidia_nim/two"), commit=AsyncMock(), ) cleanup_started = asyncio.Event() cleanup_release = asyncio.Event() factory.runtimes[0].cleanup_started = cleanup_started factory.runtimes[0].cleanup_release = cleanup_release release_task = asyncio.create_task(lease.release()) await cleanup_started.wait() release_task.cancel() with pytest.raises(asyncio.CancelledError): await release_task retired = manager._retired[1] assert retired.active_leases == 0 assert retired.cleanup_task is not None assert not retired.cleanup_task.cancelled() assert factory.runtimes[0].cleanup_calls == 1 close_task = asyncio.create_task(manager.close()) await asyncio.sleep(0) assert not close_task.done() cleanup_release.set() await close_task assert factory.runtimes[0].cleanup_calls == 1 assert manager._retired == {} @pytest.mark.asyncio async def test_hot_cleanup_failure_keeps_published_replacement() -> None: factory = RuntimeFactory() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, ) factory.runtimes[0].cleanup_error = RuntimeError("cleanup failed") generation_id = await manager.replace( _settings("nvidia_nim/two"), commit=AsyncMock(), ) assert generation_id == 2 assert manager.current_generation_id == 2 assert factory.runtimes[0].cleanup_calls == 1 assert 1 in manager._retired factory.runtimes[0].cleanup_error = None await manager.close() assert factory.runtimes[0].cleanup_calls == 2 assert manager._retired == {} @pytest.mark.asyncio async def test_candidate_construction_failure_preserves_current_generation() -> None: factory = RuntimeFactory() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, ) factory.error = RuntimeError("cannot construct") with pytest.raises(RuntimeError, match="cannot construct"): await manager.replace( _settings("nvidia_nim/two"), commit=AsyncMock(), ) assert manager.current_generation_id == 1 assert manager.current_settings().model == "nvidia_nim/one" assert factory.runtimes[0].cleanup_calls == 0 await manager.close() @pytest.mark.asyncio async def test_failed_candidate_cleanup_is_retried_at_shutdown() -> None: factory = RuntimeFactory() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, ) async def fail_commit() -> None: factory.runtimes[1].cleanup_error = RuntimeError("private cleanup detail") raise OSError("disk full") with pytest.raises(OSError, match="disk full"): await manager.replace( _settings("nvidia_nim/two"), commit=fail_commit, ) assert manager.current_generation_id == 1 assert factory.runtimes[0].cleanup_calls == 0 assert factory.runtimes[1].cleanup_calls == 1 assert manager._unpublished == {factory.runtimes[1]} manager.cache_model_infos("lmstudio", {ProviderModelInfo("cached")}) with pytest.raises( RuntimeError, match="One or more provider runtimes failed to close", ) as exc_info: await manager.close() assert "private cleanup detail" not in str(exc_info.value) assert manager._closed is False assert manager._unpublished == {factory.runtimes[1]} assert manager.cached_model_ids() == {"lmstudio": frozenset({"cached"})} factory.runtimes[1].cleanup_error = None await manager.close() assert factory.runtimes[0].cleanup_calls == 1 assert factory.runtimes[1].cleanup_calls == 3 assert manager._unpublished == set() assert manager.cached_model_ids() == {} assert manager._closed is True @pytest.mark.asyncio async def test_later_replacement_retries_failed_unpublished_candidate() -> None: factory = RuntimeFactory() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, ) async def fail_commit() -> None: factory.runtimes[1].cleanup_error = RuntimeError("cleanup failed") raise OSError("disk full") with pytest.raises(OSError, match="disk full"): await manager.replace( _settings("nvidia_nim/two"), commit=fail_commit, ) factory.runtimes[1].cleanup_error = None generation_id = await manager.replace( _settings("nvidia_nim/three"), commit=AsyncMock(), ) assert generation_id == 2 assert factory.runtimes[1].cleanup_calls == 2 assert manager._unpublished == set() await manager.close() @pytest.mark.asyncio async def test_cancelled_candidate_cleanup_remains_owned_until_shutdown() -> None: factory = RuntimeFactory() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, ) cleanup_started = asyncio.Event() cleanup_release = asyncio.Event() async def fail_commit() -> None: candidate = factory.runtimes[1] candidate.cleanup_started = cleanup_started candidate.cleanup_release = cleanup_release raise OSError("disk full") replace_task = asyncio.create_task( manager.replace( _settings("nvidia_nim/two"), commit=fail_commit, ) ) await cleanup_started.wait() replace_task.cancel() with pytest.raises(asyncio.CancelledError): await replace_task assert manager._unpublished == {factory.runtimes[1]} assert factory.runtimes[1].cleanup_calls == 1 cleanup_release.set() await manager.close() assert factory.runtimes[1].cleanup_calls == 2 assert manager._unpublished == set() @pytest.mark.asyncio async def test_concurrent_replacements_are_serialized_in_call_order() -> None: factory = RuntimeFactory() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, ) first_entered = asyncio.Event() release_first = asyncio.Event() async def first_commit(): first_entered.set() await release_first.wait() first = asyncio.create_task( manager.replace(_settings("nvidia_nim/two"), commit=first_commit) ) await first_entered.wait() second = asyncio.create_task( manager.replace(_settings("nvidia_nim/three"), commit=AsyncMock()) ) await asyncio.sleep(0) assert len(factory.runtimes) == 2 assert manager.current_generation_id == 1 assert not second.done() release_first.set() assert await asyncio.gather(first, second) == [2, 3] assert manager.current_settings().model == "nvidia_nim/three" assert [runtime.cleanup_calls for runtime in factory.runtimes[:2]] == [1, 1] await manager.close() @pytest.mark.asyncio async def test_shutdown_waits_for_active_lease_then_rejects_new_work() -> None: factory = RuntimeFactory() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, ) lease = await manager.acquire() close_task = asyncio.create_task(manager.close()) await asyncio.sleep(0) assert not close_task.done() with pytest.raises(ApplicationUnavailableError, match="shutting down"): await manager.acquire() await lease.release() await close_task assert factory.runtimes[0].cleanup_calls == 1 @pytest.mark.asyncio async def test_cancelled_shutdown_retains_generation_for_retry() -> None: factory = RuntimeFactory() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, ) lease = await manager.acquire() close_task = asyncio.create_task(manager.close()) await asyncio.sleep(0) close_task.cancel() with pytest.raises(asyncio.CancelledError): await close_task with pytest.raises(ApplicationUnavailableError, match="shutting down"): await manager.acquire() with pytest.raises(ApplicationUnavailableError, match="shutting down"): await manager.replace(_settings("nvidia_nim/two"), commit=AsyncMock()) assert factory.runtimes[0].cleanup_calls == 0 await lease.release() await manager.close() assert factory.runtimes[0].cleanup_calls == 1 assert manager._closed is True @pytest.mark.asyncio async def test_cancelled_shutdown_reuses_the_same_owned_cleanup_task() -> None: factory = RuntimeFactory() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, ) cleanup_started = asyncio.Event() cleanup_release = asyncio.Event() cleanup_calls = 0 async def cleanup() -> None: nonlocal cleanup_calls cleanup_calls += 1 cleanup_started.set() await cleanup_release.wait() with patch.object(factory.runtimes[0], "cleanup", side_effect=cleanup): close_task = asyncio.create_task(manager.close()) await cleanup_started.wait() close_task.cancel() with pytest.raises(asyncio.CancelledError): await close_task assert manager._closed is False assert manager._retired retry_task = asyncio.create_task(manager.close()) await asyncio.sleep(0) assert not retry_task.done() cleanup_release.set() await retry_task assert cleanup_calls == 1 assert manager._retired == {} assert manager._closed is True @pytest.mark.asyncio async def test_failed_shutdown_cleanup_is_retryable() -> None: factory = RuntimeFactory() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, ) manager.cache_model_infos("lmstudio", {ProviderModelInfo("cached")}) factory.runtimes[0].cleanup_error = RuntimeError("private provider detail") with pytest.raises( RuntimeError, match="One or more provider runtimes failed to close", ) as exc_info: await manager.close() assert "private provider detail" not in str(exc_info.value) assert manager._closed is False assert 1 in manager._retired assert manager.cached_model_ids() == {"lmstudio": frozenset({"cached"})} assert factory.runtimes[0].cleanup_calls == 1 factory.runtimes[0].cleanup_error = None await manager.close() assert factory.runtimes[0].cleanup_calls == 2 assert manager._retired == {} assert manager.cached_model_ids() == {} assert manager._closed is True @pytest.mark.asyncio async def test_application_catalog_survives_generation_replacement() -> None: factory = RuntimeFactory() manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, ) manager.cache_model_infos( "lmstudio", {ProviderModelInfo("persisted", supports_thinking=True)}, ) await manager.replace( _settings("nvidia_nim/two"), commit=AsyncMock(), ) assert manager.cached_model_ids()["lmstudio"] == frozenset({"persisted"}) assert manager.cached_model_info("lmstudio", "persisted") == ProviderModelInfo( "persisted", supports_thinking=True, ) await manager.close() @pytest.mark.asyncio async def test_generation_lease_keeps_its_model_metadata_after_replacement() -> None: factory = RuntimeFactory() first_settings = _settings("open_router/one").model_copy( update={"open_router_api_keys": normalize_api_keys("open-router-key")} ) manager = ProviderRuntimeManager(first_settings, runtime_factory=factory) manager.cache_model_infos( "open_router", { ProviderModelInfo( "old-model", context_window_tokens=32_000, max_output_tokens=4_096, ) }, ) factory.runtimes[0].provider.list_model_infos.return_value = frozenset( { ProviderModelInfo( "old-model", context_window_tokens=32_000, max_output_tokens=4_096 ) } ) lease = await manager.acquire() await lease.resolve_provider("open_router") await manager.replace( first_settings, commit=AsyncMock(), ) factory.runtimes[-1].provider.list_model_infos.return_value = frozenset( {ProviderModelInfo("old-model", max_output_tokens=16384)} ) new_lease = await manager.acquire() await new_lease.resolve_provider("open_router") new_info = new_lease.model_info("open_router", "old-model") assert new_info is not None and new_info.max_output_tokens == 16384 assert lease.model_info("open_router", "old-model") == ProviderModelInfo( "open_router/old-model", context_window_tokens=32_000, max_output_tokens=4_096, ) await lease.release() await new_lease.release() await manager.close() @pytest.mark.asyncio async def test_replacement_prunes_and_rejects_removed_remote_provider_cache() -> None: factory = RuntimeFactory() first_settings = _settings("open_router/one").model_copy( update={"open_router_api_keys": normalize_api_keys("open-router-key")} ) manager = ProviderRuntimeManager(first_settings, runtime_factory=factory) manager.cache_model_infos("open_router", {ProviderModelInfo("old-model")}) await manager.replace( _settings("nvidia_nim/two"), commit=AsyncMock(), ) manager.cache_model_infos("open_router", {ProviderModelInfo("late-old-model")}) assert "open_router" not in manager.cached_model_ids() await manager.close() @pytest.mark.asyncio async def test_generation_lifecycle_traces_contain_minimal_correlation_fields() -> None: factory = RuntimeFactory() with patch("free_claude_code.runtime.provider_manager.trace_event") as trace: manager = ProviderRuntimeManager( _settings("nvidia_nim/one"), runtime_factory=factory, ) lease = await manager.acquire() await manager.replace( _settings("nvidia_nim/two"), commit=AsyncMock(), reason="test_replace", ) await lease.release() await manager.close() events = [call.kwargs for call in trace.call_args_list] names = [event["event"] for event in events] assert names == [ "provider_generation.published", "provider_generation.published", "provider_generation.retired", "provider_generation.closed", "provider_generation.retired", "provider_generation.closed", ] assert events[1]["generation_id"] == 2 assert events[1]["previous_generation_id"] == 1 assert events[1]["reason"] == "test_replace" assert events[2]["active_leases"] == 1 assert events[3]["forced"] is False
import asyncio
from typing import cast
from unittest.mock import AsyncMock, MagicMock, patch
import httpx2
import pytest
from pydantic import ValidationError
from free_claude_code.application.errors import ApplicationUnavailableError
from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.application.ports import ModelCatalogPort
from free_claude_code.config.api_keys import normalize_api_keys
from free_claude_code.config.settings import Settings
from free_claude_code.providers.base import BaseProvider
from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
from free_claude_code.providers.runtime import ProviderRuntime
from free_claude_code.runtime.provider_manager import ProviderRuntimeManager
from tests.runtime.catalog_support import finish_discovery, finish_publication
class FakeRuntime(ProviderRuntime):
def __init__(self, settings: Settings) -> None:
self.settings = settings
self.cleanup_calls = 0
self.cleanup_error: Exception | None = None
self.cleanup_started: asyncio.Event | None = None
self.cleanup_release: asyncio.Event | None = None
self.provider = MagicMock()
self.provider.list_model_infos = AsyncMock(return_value=frozenset())
def is_cached(self, provider_id: str, api_key_number: int = 1) -> bool:
return provider_id == "cached"
async def resolve_provider(
self, provider_id: str, api_key_number: int = 1
) -> BaseProvider:
if provider_id in {"lmstudio", "llamacpp", "ollama"}:
raise ConnectionError("Local fixture is offline")
return cast(BaseProvider, self.provider)
async def cleanup(self) -> None:
self.cleanup_calls += 1
if self.cleanup_started is not None:
self.cleanup_started.set()
if self.cleanup_release is not None:
await self.cleanup_release.wait()
if self.cleanup_error is not None:
raise self.cleanup_error
class RuntimeFactory:
def __init__(self) -> None:
self.runtimes: list[FakeRuntime] = []
self.error: Exception | None = None
def __call__(
self, settings: Settings, admission_registry, history_cache=None
) -> ProviderRuntime:
if self.error is not None:
raise self.error
runtime = FakeRuntime(settings)
self.runtimes.append(runtime)
return runtime
class RecordingModelCatalogPublisher:
def __init__(self) -> None:
self.events: list[str] = []
self.snapshots: list[tuple[str, tuple[str, ...]]] = []
def publish(self, runtime: ModelCatalogPort) -> None:
self._record("publish", runtime)
def _record(self, event: str, runtime: ModelCatalogPort) -> None:
self.events.append(event)
self.snapshots.append(
(
runtime.current_settings().model,
tuple(info.model_id for info in runtime.cached_prefixed_model_infos()),
)
)
def _settings(model: str) -> Settings:
return Settings().model_copy(
update={"model": model, "nvidia_nim_api_keys": normalize_api_keys("test-key")}
)
@pytest.mark.asyncio
async def test_discovery_error_follows_attempt_and_generation_without_losing_cache():
factory = RuntimeFactory()
settings = _settings("nvidia_nim/one")
manager = ProviderRuntimeManager(settings, runtime_factory=factory)
provider = factory.runtimes[0].provider
manager.cache_model_infos("nvidia_nim", {ProviderModelInfo("one")})
provider.list_model_infos.side_effect = httpx2.ProxyError("secret-canary")
try:
with patch(
"free_claude_code.runtime.provider_manager.logger.warning"