Spaces:
Running
Running
Download tests/runtime/test_provider_manager.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 34.1 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/tests/runtime/test_provider_manager.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/tests/runtime/test_provider_manager.py
-
curl -L -o test_provider_manager.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/tests/runtime/test_provider_manager.py
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")}
)
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"