Files
devplacepy/tests/unit/services/openai_gateway/routing.py
T
retoorandClaude Sonnet 5.5 bc11475f29 Send per-app provider attribution titles from one gateway app registry
Add openai_gateway/apps.py as the single list of internal gateway apps and
send X-OpenRouter-Title (plus legacy X-Title and HTTP-Referer) per app to
every upstream. Label the Devii agent, bots, modifier, quiz grading, SEO
metadata, community and sync callers. Shorten two app references that
exceeded the 30 character limit and were recorded as default.
Also includes the pending Muse Code, route health and Responses work.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-04 18:45:09 +01:00

807 lines
26 KiB
Python

# retoor <retoor@molodetz.nl>
import pytest
from pydantic import ValidationError
from devplacepy.services.openai_gateway import routing as r
from devplacepy.services.openai_gateway.usage import pricing_from_cfg
from tests.conftest import run_async
class _FakeModelsResponse:
def __init__(self, status_code, payload=None):
self.status_code = status_code
self._payload = payload
def json(self):
return self._payload
class _FakeModelsClient:
def __init__(self, status_code, payload=None, error=None):
self.status_code = status_code
self.payload = payload
self.error = error
self.requested_url = None
self.headers = None
async def __aenter__(self):
return self
async def __aexit__(self, *exc_info):
return False
async def get(self, url):
self.requested_url = url
if self.error is not None:
raise self.error
return _FakeModelsResponse(self.status_code, self.payload)
def _patch_stealth_client(monkeypatch, fake_client):
def _factory(**kwargs):
fake_client.headers = kwargs.get("headers")
return fake_client
monkeypatch.setattr("devplacepy.stealth.stealth_async_client", _factory)
def _cleanup(providers, models):
for name in providers:
r.provider_store.remove(name)
for source in models:
r.model_store.remove(source)
def test_no_routes_pass_through(local_db):
assert r.chat_overlay("ghost-model-xyz", {}) is None
assert r.embed_overlay("ghost-embed-xyz", {}) is None
assert r.image_overlay("ghost-image-xyz", {}) is None
def test_chat_route_overlay_and_economy(local_db):
r.provider_store.set(
r.ProviderIn(
name="utor",
base_url="https://up.example/v1/chat/completions",
api_key="k1",
)
)
r.model_store.set(
r.ModelRouteIn(
source_model="ut-chat",
provider="utor",
target_model="vendor/big",
kind="chat",
context_window=64000,
price_cache_hit_per_m=1.0,
price_cache_miss_per_m=2.0,
price_output_per_m=8.0,
)
)
try:
overlay = r.chat_overlay("ut-chat", {"gateway_model_context_map": "{}"})
assert overlay["gateway_force_model"] is True
assert overlay["gateway_model"] == "vendor/big"
assert overlay["gateway_upstream_url"] == "https://up.example/v1/chat/completions"
assert overlay["gateway_api_key"] == "k1"
assert overlay["gateway_price_output_per_m"] == 8.0
assert overlay["gateway_model_context_map"]["vendor/big"] == 64000
pricing = pricing_from_cfg(overlay)
assert pricing.chat_output_per_m == 8.0
assert pricing.chat_cache_miss_per_m == 2.0
finally:
_cleanup(["utor"], ["ut-chat"])
def test_resolve_fallback_returns_none_without_a_configured_fallback(local_db):
r.model_store.set(r.ModelRouteIn(source_model="fb-primary", target_model="v/a"))
try:
assert r.resolve_fallback("fb-primary", "chat") is None
finally:
_cleanup([], ["fb-primary"])
def test_resolve_fallback_returns_none_for_an_unknown_source(local_db):
assert r.resolve_fallback("ghost-fb-source", "chat") is None
def test_resolve_fallback_rejects_self_reference(local_db):
with pytest.raises(ValidationError):
r.ModelRouteIn(
source_model="fb-self", target_model="v/a", fallback_model="fb-self"
)
def test_resolve_fallback_returns_the_configured_route(local_db):
r.model_store.set(
r.ModelRouteIn(
source_model="fb-backup", target_model="v/backup", kind="chat"
)
)
r.model_store.set(
r.ModelRouteIn(
source_model="fb-primary",
target_model="v/primary",
kind="chat",
fallback_model="fb-backup",
)
)
try:
fallback = r.resolve_fallback("fb-primary", "chat")
assert fallback is not None
assert fallback.source_model == "fb-backup"
assert fallback.target_model == "v/backup"
finally:
_cleanup([], ["fb-primary", "fb-backup"])
def test_resolve_fallback_ignores_an_inactive_fallback_route(local_db):
r.model_store.set(
r.ModelRouteIn(
source_model="fb-backup-off",
target_model="v/backup",
kind="chat",
is_active=False,
)
)
r.model_store.set(
r.ModelRouteIn(
source_model="fb-primary-2",
target_model="v/primary",
kind="chat",
fallback_model="fb-backup-off",
)
)
try:
assert r.resolve_fallback("fb-primary-2", "chat") is None
finally:
_cleanup([], ["fb-primary-2", "fb-backup-off"])
def test_resolve_fallback_ignores_a_fallback_of_a_different_kind(local_db):
r.model_store.set(
r.ModelRouteIn(
source_model="fb-backup-embed", target_model="v/e", kind="embed"
)
)
r.model_store.set(
r.ModelRouteIn(
source_model="fb-primary-3",
target_model="v/primary",
kind="chat",
fallback_model="fb-backup-embed",
)
)
try:
assert r.resolve_fallback("fb-primary-3", "chat") is None
finally:
_cleanup([], ["fb-primary-3", "fb-backup-embed"])
def _chain_route(source, target, fallback="", active=True):
r.model_store.set(
r.ModelRouteIn(
source_model=source,
target_model=target,
kind="chat",
fallback_model=fallback,
is_active=active,
)
)
def _mark_health(source, status):
from devplacepy.services.openai_gateway import health
code = "" if status == "ok" else "http_500"
message = "" if status == "ok" else "boom"
health.record_health(
source, health.ProbeResult(status == "ok", code, message, 1.0)
)
def test_fallback_chain_skips_bad_and_inactive_links(local_db):
_chain_route("chain-a", "v/a", "chain-b")
_chain_route("chain-b", "v/b", "chain-c")
_chain_route("chain-c", "v/c", "chain-d")
_chain_route("chain-d", "v/d", "", active=False)
_mark_health("chain-b", "bad")
try:
line = r.resolve_fallback_chain("chain-a", "chat")
assert [m.source_model for m in line] == ["chain-c"]
finally:
_cleanup([], ["chain-a", "chain-b", "chain-c", "chain-d"])
def test_fallback_chain_stops_on_cycles(local_db):
_chain_route("chain-e", "v/e", "chain-f")
_chain_route("chain-f", "v/f", "chain-e")
try:
line = r.resolve_fallback_chain("chain-e", "chat")
assert [m.source_model for m in line] == ["chain-f"]
finally:
_cleanup([], ["chain-e", "chain-f"])
def test_fallback_chain_respects_max_hops(local_db):
names = [f"chain-h{i}" for i in range(8)]
for pos, name in enumerate(names):
nxt = names[pos + 1] if pos + 1 < len(names) else ""
_chain_route(name, f"v/{name}", nxt)
try:
line = r.resolve_fallback_chain(names[0], "chat", max_hops=3)
assert [m.source_model for m in line] == names[1:4]
assert len(r.resolve_fallback_chain(names[0], "chat")) <= 5
finally:
_cleanup([], names)
def test_entry_route_preroutes_bad_models(local_db):
_chain_route("chain-g", "v/g", "chain-h")
_chain_route("chain-h", "v/h")
_mark_health("chain-g", "bad")
try:
assert r.resolve_entry_route("chain-g", "chat").source_model == "chain-h"
assert r.resolve_entry_route("chain-h", "chat").source_model == "chain-h"
assert r.resolve_entry_route("ghost-entry", "chat") is None
finally:
_cleanup([], ["chain-g", "chain-h"])
def test_entry_route_falls_back_to_original_when_line_is_empty(local_db):
_chain_route("chain-i", "v/i", "chain-j")
_chain_route("chain-j", "v/j")
_mark_health("chain-i", "bad")
_mark_health("chain-j", "bad")
try:
assert r.resolve_entry_route("chain-i", "chat").source_model == "chain-i"
finally:
_cleanup([], ["chain-i", "chain-j"])
def test_vision_merge_overlay(local_db):
r.provider_store.set(
r.ProviderIn(
name="utvis",
base_url="https://vis.example/v1/chat/completions",
api_key="vk",
)
)
r.model_store.set(
r.ModelRouteIn(
source_model="ut-vision",
provider="utvis",
target_model="vendor/vlm",
kind="chat",
vision_model="vendor/describe",
price_input_per_m=0.5,
)
)
try:
overlay = r.chat_overlay("ut-vision", {})
assert overlay["gateway_vision_enabled"] is True
assert overlay["gateway_vision_model"] == "vendor/describe"
assert overlay["gateway_vision_url"] == "https://vis.example/v1/chat/completions"
assert overlay["gateway_vision_key"] == "vk"
assert overlay["gateway_vision_price_input_per_m"] == 0.5
finally:
_cleanup(["utvis"], ["ut-vision"])
def test_image_route_and_kind_isolation(local_db):
r.provider_store.set(
r.ProviderIn(
name="utimg",
base_url="https://img.example/v1/chat/completions",
api_key="ik",
)
)
r.model_store.set(
r.ModelRouteIn(
source_model="ut-image",
provider="utimg",
target_model="vendor/flux",
kind="image",
price_input_per_m=0.05,
)
)
try:
overlay = r.image_overlay("ut-image", {})
assert overlay["gateway_image_model"] == "vendor/flux"
assert overlay["gateway_image_url"] == "https://img.example/v1/images"
assert overlay["gateway_image_key"] == "ik"
assert overlay["gateway_image_price_per_call"] == 0.05
assert r.chat_overlay("ut-image", {}) is None
assert r.embed_overlay("ut-image", {}) is None
pricing = pricing_from_cfg(overlay)
assert pricing.image_per_call == 0.05
finally:
_cleanup(["utimg"], ["ut-image"])
def test_embed_route_and_kind_isolation(local_db):
r.provider_store.set(
r.ProviderIn(
name="utemb",
base_url="https://emb.example/v1/chat/completions",
api_key="ek",
)
)
r.model_store.set(
r.ModelRouteIn(
source_model="ut-embed",
provider="utemb",
target_model="vendor/embed",
kind="embed",
price_input_per_m=0.13,
)
)
try:
overlay = r.embed_overlay("ut-embed", {})
assert overlay["gateway_embed_model"] == "vendor/embed"
assert overlay["gateway_embed_url"] == "https://emb.example/v1/embeddings"
assert overlay["gateway_embed_key"] == "ek"
assert overlay["gateway_embed_price_input_per_m"] == 0.13
assert r.chat_overlay("ut-embed", {}) is None
finally:
_cleanup(["utemb"], ["ut-embed"])
def test_embed_overlay_blank_provider_key_preserves_top_level_key(local_db):
r.provider_store.set(
r.ProviderIn(
name="utemblank",
base_url="https://emb.example/v1/chat/completions",
api_key="",
)
)
r.model_store.set(
r.ModelRouteIn(
source_model="ut-embed-blank",
provider="utemblank",
target_model="vendor/embed",
kind="embed",
)
)
try:
base_cfg = {"gateway_embed_key": "top-level-fallback-key"}
overlay = r.embed_overlay("ut-embed-blank", base_cfg)
assert "gateway_embed_key" not in overlay
merged = {**base_cfg, **overlay}
assert merged["gateway_embed_key"] == "top-level-fallback-key"
finally:
_cleanup(["utemblank"], ["ut-embed-blank"])
def test_inactive_route_ignored(local_db):
r.model_store.set(
r.ModelRouteIn(
source_model="ut-off",
target_model="vendor/x",
kind="chat",
is_active=False,
)
)
try:
assert r.chat_overlay("ut-off", {}) is None
finally:
_cleanup([], ["ut-off"])
def test_blank_provider_uses_default_upstream(local_db):
r.model_store.set(
r.ModelRouteIn(
source_model="ut-default",
target_model="vendor/def",
kind="chat",
price_output_per_m=3.0,
)
)
try:
overlay = r.chat_overlay("ut-default", {})
assert overlay["gateway_model"] == "vendor/def"
assert "gateway_upstream_url" not in overlay
assert "gateway_api_key" not in overlay
assert overlay["gateway_price_output_per_m"] == 3.0
finally:
_cleanup([], ["ut-default"])
def test_provider_with_a_client_profile_gets_extra_headers(local_db):
r.provider_store.set(
r.ProviderIn(
name="zen",
base_url="https://opencode.ai/zen/v1/chat/completions",
api_key="public",
client_profile="opencode",
)
)
r.model_store.set(
r.ModelRouteIn(source_model="ut-zen", provider="zen", target_model="kimi-k3")
)
try:
overlay = r.chat_overlay("ut-zen", {})
headers = overlay["gateway_extra_request_headers"]
assert headers["x-opencode-client"]
assert "User-Agent" in headers
finally:
_cleanup(["zen"], ["ut-zen"])
def test_provider_without_a_client_profile_gets_no_extra_headers(local_db):
r.provider_store.set(
r.ProviderIn(name="plainprov", base_url="https://up.example/v1/chat/completions")
)
r.model_store.set(
r.ModelRouteIn(source_model="ut-plain", provider="plainprov", target_model="vendor/x")
)
try:
overlay = r.chat_overlay("ut-plain", {})
assert "gateway_extra_request_headers" not in overlay
finally:
_cleanup(["plainprov"], ["ut-plain"])
def test_provider_with_a_muse_profile_gets_muse_headers(local_db):
r.provider_store.set(
r.ProviderIn(
name="meta",
base_url="https://api.meta.ai/v1/responses",
api_key="secret",
client_profile="muse",
)
)
r.model_store.set(
r.ModelRouteIn(
source_model="ut-muse",
provider="meta",
target_model="muse-spark",
)
)
try:
overlay = r.chat_overlay("ut-muse", {})
headers = overlay["gateway_extra_request_headers"]
assert headers["X-Client-Id"] == "tbh:exec"
assert headers["User-Agent"].startswith("muse-build/")
finally:
_cleanup(["meta"], ["ut-muse"])
def test_client_profile_rejects_unknown_value():
with pytest.raises(ValidationError):
r.ProviderIn(name="badprofile", client_profile="not-a-real-profile")
def test_tier2_and_off_peak_fields_propagate_through_overlay(local_db):
r.model_store.set(
r.ModelRouteIn(
source_model="ut-tiered",
target_model="vendor/tiered",
kind="chat",
price_cache_hit_per_m=0.0028,
price_cache_miss_per_m=0.14,
price_output_per_m=0.28,
context_tier_threshold_tokens=128_000,
price_output_per_m_tier2=0.56,
off_peak_start_minute=990,
off_peak_end_minute=30,
off_peak_discount_pct=25.0,
)
)
try:
overlay = r.chat_overlay("ut-tiered", {})
assert overlay["gateway_context_tier_threshold_tokens"] == 128_000
assert overlay["gateway_price_output_per_m_tier2"] == 0.56
assert overlay["gateway_price_cache_hit_per_m_tier2"] is None
assert overlay["gateway_off_peak_start_minute"] == 990
assert overlay["gateway_off_peak_end_minute"] == 30
assert overlay["gateway_off_peak_discount_pct"] == 25.0
pricing = pricing_from_cfg(overlay)
assert pricing.context_tier_threshold_tokens == 128_000
assert pricing.chat_output_per_m_tier2 == 0.56
assert pricing.chat_cache_hit_per_m_tier2 is None
assert pricing.off_peak_start_minute == 990
finally:
_cleanup([], ["ut-tiered"])
def test_unrouted_request_never_gains_tier_or_off_peak_keys(local_db):
assert r.chat_overlay("ghost-model-untiered", {}) is None
pricing = pricing_from_cfg({})
assert pricing.context_tier_threshold_tokens == 0
assert pricing.off_peak_start_minute is None
assert pricing.off_peak_end_minute is None
assert pricing.chat_output_per_m_tier2 is None
def test_off_peak_window_requires_both_start_and_end():
with pytest.raises(ValidationError):
r.ModelRouteIn(
source_model="ut-bad-window",
target_model="vendor/x",
off_peak_start_minute=60,
)
with pytest.raises(ValidationError):
r.ModelRouteIn(
source_model="ut-bad-window",
target_model="vendor/x",
off_peak_end_minute=120,
)
def test_seed_default_image_routes_is_idempotent(local_db):
r.model_store.remove(r.IMAGE_SOURCE_MODEL)
r.seed_default_image_routes()
route = r.model_store.get(r.IMAGE_SOURCE_MODEL)
assert route is not None
assert route.kind == "image"
assert route.target_model == r.FLUX_TARGET_MODEL
r.seed_default_image_routes()
assert r.model_store.get(r.IMAGE_SOURCE_MODEL).target_model == r.FLUX_TARGET_MODEL
def test_seed_default_deepseek_routes_is_idempotent_and_preserves_customization(
local_db,
):
r.seed_default_deepseek_routes()
flash = r.model_store.get("deepseek-v4-flash")
pro = r.model_store.get("deepseek-v4-pro")
assert flash is not None and pro is not None
assert flash.price_cache_hit_per_m == 0.0028
assert flash.price_cache_miss_per_m == 0.14
assert flash.price_output_per_m == 0.28
assert flash.context_window == 1_048_576
assert pro.price_cache_hit_per_m == 0.003625
assert pro.price_cache_miss_per_m == 0.435
assert pro.price_output_per_m == 0.87
r.model_store.set(
r.ModelRouteIn(
source_model="deepseek-v4-pro",
target_model="deepseek-v4-pro",
price_output_per_m=1.23,
)
)
try:
r.seed_default_deepseek_routes()
assert r.model_store.get("deepseek-v4-pro").price_output_per_m == 1.23
finally:
r.model_store.set(
r.ModelRouteIn(
source_model="deepseek-v4-pro",
target_model="deepseek-v4-pro",
price_cache_hit_per_m=0.003625,
price_cache_miss_per_m=0.435,
price_output_per_m=0.87,
context_window=1_048_576,
)
)
def test_seed_publishes_molodetz_aliases(local_db):
r.seed_default_deepseek_routes()
try:
molodetz = r.model_store.resolve("molodetz", "chat")
molodetz_pro = r.model_store.resolve("molodetz-pro", "chat")
assert molodetz is not None
assert molodetz.target_model == "deepseek-v4-flash"
assert molodetz_pro is not None
assert molodetz_pro.target_model == "deepseek-v4-pro"
sources = {row["source_model"] for row in r.model_store.list()}
assert {"molodetz", "molodetz-pro"} <= sources
finally:
r.model_store.remove("molodetz")
r.model_store.remove("molodetz-pro")
def test_models_url_from_base_swaps_chat_completions():
assert (
r._models_url_from_base("https://x.example/v1/chat/completions")
== "https://x.example/v1/models"
)
def test_models_url_from_base_appends_when_no_chat_completions_suffix():
assert r._models_url_from_base("https://x.example/v1") == "https://x.example/v1/models"
assert r._models_url_from_base("https://x.example/v1/") == "https://x.example/v1/models"
def test_models_url_from_base_blank_is_blank():
assert r._models_url_from_base("") == ""
assert r._models_url_from_base(" ") == ""
def test_fetch_provider_models_returns_ids_on_success(local_db, monkeypatch):
r.provider_store.set(
r.ProviderIn(
name="probeprov",
base_url="https://x.example/v1/chat/completions",
api_key="sk-probe",
)
)
fake_client = _FakeModelsClient(200, {"data": [{"id": "vendor/a"}, {"id": "vendor/b"}]})
_patch_stealth_client(monkeypatch, fake_client)
try:
models = run_async(r.fetch_provider_models("probeprov"))
assert models == ["vendor/a", "vendor/b"]
assert fake_client.requested_url == "https://x.example/v1/models"
assert fake_client.headers == {"authorization": "Bearer sk-probe"}
finally:
r.provider_store.remove("probeprov")
def test_fetch_provider_models_uses_default_provider_when_blank(local_db, monkeypatch):
monkeypatch.setattr(
r,
"_default_provider_credentials",
lambda: ("https://default.example/v1/chat/completions", "sk-default"),
)
fake_client = _FakeModelsClient(200, {"data": [{"id": "default/model"}]})
_patch_stealth_client(monkeypatch, fake_client)
models = run_async(r.fetch_provider_models(""))
assert models == ["default/model"]
assert fake_client.requested_url == "https://default.example/v1/models"
def test_fetch_provider_models_none_for_unknown_provider(local_db):
assert run_async(r.fetch_provider_models("no-such-provider")) is None
def test_fetch_provider_models_none_on_non_200(local_db, monkeypatch):
r.provider_store.set(
r.ProviderIn(name="probeprov404", base_url="https://x.example/v1/chat/completions")
)
fake_client = _FakeModelsClient(404, {})
_patch_stealth_client(monkeypatch, fake_client)
try:
assert run_async(r.fetch_provider_models("probeprov404")) is None
finally:
r.provider_store.remove("probeprov404")
def test_fetch_provider_models_none_on_malformed_payload(local_db, monkeypatch):
r.provider_store.set(
r.ProviderIn(name="probeprovbad", base_url="https://x.example/v1/chat/completions")
)
fake_client = _FakeModelsClient(200, {"not_data": []})
_patch_stealth_client(monkeypatch, fake_client)
try:
assert run_async(r.fetch_provider_models("probeprovbad")) is None
finally:
r.provider_store.remove("probeprovbad")
def test_fetch_provider_models_none_on_empty_list(local_db, monkeypatch):
r.provider_store.set(
r.ProviderIn(name="probeprovempty", base_url="https://x.example/v1/chat/completions")
)
fake_client = _FakeModelsClient(200, {"data": []})
_patch_stealth_client(monkeypatch, fake_client)
try:
assert run_async(r.fetch_provider_models("probeprovempty")) is None
finally:
r.provider_store.remove("probeprovempty")
def test_fetch_provider_models_none_on_network_error(local_db, monkeypatch):
r.provider_store.set(
r.ProviderIn(name="probeprovdown", base_url="https://x.example/v1/chat/completions")
)
fake_client = _FakeModelsClient(200, error=RuntimeError("connection refused"))
_patch_stealth_client(monkeypatch, fake_client)
try:
assert run_async(r.fetch_provider_models("probeprovdown")) is None
finally:
r.provider_store.remove("probeprovdown")
def test_fetch_provider_models_none_when_provider_has_no_base_url(local_db):
r.provider_store.set(r.ProviderIn(name="probeprovnourl", base_url=""))
try:
assert run_async(r.fetch_provider_models("probeprovnourl")) is None
finally:
r.provider_store.remove("probeprovnourl")
def test_provider_protocol_defaults_and_validates(local_db):
assert r.ProviderIn(name="p1").protocol == "chat_completions"
assert r.ProviderIn(name="p1", protocol="responses").protocol == "responses"
assert r.ProviderIn(name="p1", protocol=" Responses ").protocol == "responses"
with pytest.raises(ValidationError):
r.ProviderIn(name="p1", protocol="soap")
def test_provider_protocol_round_trips_through_store(local_db):
r.provider_store.set(
r.ProviderIn(
name="protometa",
base_url="https://api.meta.ai/v1/responses",
api_key="sk-test",
protocol="responses",
)
)
try:
saved = r.provider_store.get("protometa")
assert saved is not None
assert saved["protocol"] == "responses"
assert saved["base_url"] == "https://api.meta.ai/v1/responses"
finally:
r.provider_store.remove("protometa")
def test_chat_overlay_carries_provider_protocol(local_db):
r.provider_store.set(
r.ProviderIn(
name="protoovl",
base_url="https://api.meta.ai/v1/responses",
api_key="sk-test",
protocol="responses",
)
)
r.model_store.set(
r.ModelRouteIn(
source_model="meta-route",
provider="protoovl",
target_model="muse-spark-1.3-contributor",
kind="chat",
)
)
try:
overlay = r.chat_overlay("meta-route", {"gateway_model": "x"})
assert overlay["gateway_upstream_protocol"] == "responses"
assert (
overlay["gateway_upstream_url"]
== "https://api.meta.ai/v1/responses"
)
finally:
_cleanup(["protoovl"], ["meta-route"])
def test_responses_models_urls_probe_both_shapes():
assert r._responses_models_urls("https://api.meta.ai/v1/responses") == [
"https://api.meta.ai/v1/models",
"https://api.meta.ai/v1/muse-code/models",
]
assert r._responses_models_urls("") == []
def test_fetch_provider_models_tries_meta_listing_second(local_db, monkeypatch):
r.provider_store.set(
r.ProviderIn(
name="probeprovmeta",
base_url="https://api.meta.ai/v1/responses",
protocol="responses",
)
)
class _SeqClient:
def __init__(self):
self.requested_urls = []
async def __aenter__(self):
return self
async def __aexit__(self, *exc_info):
return False
async def get(self, url):
self.requested_urls.append(url)
if url == "https://api.meta.ai/v1/models":
return _FakeModelsResponse(404, {})
return _FakeModelsResponse(
200, {"data": [{"id": "muse-spark-1.3-contributor"}]}
)
fake_client = _SeqClient()
_patch_stealth_client(monkeypatch, fake_client)
try:
assert run_async(r.fetch_provider_models("probeprovmeta")) == [
"muse-spark-1.3-contributor"
]
assert fake_client.requested_urls == [
"https://api.meta.ai/v1/models",
"https://api.meta.ai/v1/muse-code/models",
]
finally:
r.provider_store.remove("probeprovmeta")