Zakaria
244 lines
9.6 KiB
Python
244 lines
9.6 KiB
Python
"""Tests for agent/transcription_registry.py and agent/transcription_provider.py.
|
|
|
|
Covers:
|
|
- Registration happy path
|
|
- Registration rejection: non-TranscriptionProvider type
|
|
- Registration rejection: empty/whitespace name
|
|
- Built-in name shadowing: warning + silent ignore (no exception)
|
|
- Re-registration: overwrites + logs at debug
|
|
- Case + whitespace insensitivity on lookup
|
|
- ABC contract: default implementations work
|
|
- ABC contract: transcribe() must be implemented
|
|
- Sync invariant: registry built-ins match tools/transcription_tools.py
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
from typing import Any, Optional
|
|
|
|
import pytest
|
|
|
|
from agent import transcription_registry
|
|
from agent.transcription_provider import TranscriptionProvider
|
|
|
|
|
|
class _FakeProvider(TranscriptionProvider):
|
|
def __init__(
|
|
self,
|
|
name: str = "fake",
|
|
display: Optional[str] = None,
|
|
available: bool = True,
|
|
transcribe_impl: Optional[Any] = None,
|
|
):
|
|
self._name = name
|
|
self._display = display
|
|
self._available = available
|
|
self._transcribe_impl = transcribe_impl
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
return self._name
|
|
|
|
@property
|
|
def display_name(self) -> str:
|
|
return self._display if self._display is not None else super().display_name
|
|
|
|
def is_available(self) -> bool:
|
|
return self._available
|
|
|
|
def transcribe(self, file_path: str, **kw):
|
|
if self._transcribe_impl is not None:
|
|
return self._transcribe_impl(file_path, **kw)
|
|
return {"success": True, "transcript": f"fake({file_path})", "provider": self._name}
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def _reset_registry():
|
|
transcription_registry._reset_for_tests()
|
|
yield
|
|
transcription_registry._reset_for_tests()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Registration
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestRegistration:
|
|
def test_happy_path(self):
|
|
p = _FakeProvider(name="openrouter")
|
|
transcription_registry.register_provider(p)
|
|
assert transcription_registry.get_provider("openrouter") is p
|
|
assert [r.name for r in transcription_registry.list_providers()] == ["openrouter"]
|
|
|
|
def test_rejects_non_provider_type(self):
|
|
with pytest.raises(TypeError, match="expects a TranscriptionProvider instance"):
|
|
transcription_registry.register_provider("not a provider") # type: ignore[arg-type]
|
|
assert transcription_registry.list_providers() == []
|
|
|
|
def test_rejects_empty_name(self):
|
|
p = _FakeProvider(name="")
|
|
with pytest.raises(ValueError, match="non-empty string"):
|
|
transcription_registry.register_provider(p)
|
|
assert transcription_registry.list_providers() == []
|
|
|
|
def test_rejects_whitespace_name(self):
|
|
p = _FakeProvider(name=" ")
|
|
with pytest.raises(ValueError, match="non-empty string"):
|
|
transcription_registry.register_provider(p)
|
|
assert transcription_registry.list_providers() == []
|
|
|
|
@pytest.mark.parametrize(
|
|
"builtin",
|
|
["local", "local_command", "groq", "openai", "mistral", "xai"],
|
|
)
|
|
def test_rejects_builtin_shadow_with_warning(self, builtin, caplog):
|
|
p = _FakeProvider(name=builtin)
|
|
with caplog.at_level(logging.WARNING, logger="agent.transcription_registry"):
|
|
transcription_registry.register_provider(p)
|
|
assert "shadows a built-in name" in caplog.text
|
|
assert builtin in caplog.text
|
|
assert transcription_registry.get_provider(builtin) is None
|
|
assert transcription_registry.list_providers() == []
|
|
|
|
def test_builtin_shadow_case_insensitive(self, caplog):
|
|
for variant in ("OPENAI", "OpenAi", " openai ", "oPeNaI"):
|
|
transcription_registry._reset_for_tests()
|
|
with caplog.at_level(logging.WARNING, logger="agent.transcription_registry"):
|
|
transcription_registry.register_provider(_FakeProvider(name=variant))
|
|
assert transcription_registry.list_providers() == [], (
|
|
f"variant {variant!r} should have been rejected as a built-in shadow"
|
|
)
|
|
|
|
def test_reregistration_overwrites(self, caplog):
|
|
p1 = _FakeProvider(name="openrouter")
|
|
p2 = _FakeProvider(name="openrouter")
|
|
transcription_registry.register_provider(p1)
|
|
with caplog.at_level(logging.DEBUG, logger="agent.transcription_registry"):
|
|
transcription_registry.register_provider(p2)
|
|
assert transcription_registry.get_provider("openrouter") is p2
|
|
assert "re-registered" in caplog.text
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Lookup
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestLookup:
|
|
def test_get_provider_missing_returns_none(self):
|
|
assert transcription_registry.get_provider("nonexistent") is None
|
|
|
|
def test_get_provider_non_string_returns_none(self):
|
|
assert transcription_registry.get_provider(None) is None # type: ignore[arg-type]
|
|
assert transcription_registry.get_provider(123) is None # type: ignore[arg-type]
|
|
|
|
def test_get_provider_case_insensitive(self):
|
|
p = _FakeProvider(name="openrouter")
|
|
transcription_registry.register_provider(p)
|
|
assert transcription_registry.get_provider("OPENROUTER") is p
|
|
assert transcription_registry.get_provider("OpenRouter") is p
|
|
|
|
def test_get_provider_whitespace_tolerant(self):
|
|
p = _FakeProvider(name="openrouter")
|
|
transcription_registry.register_provider(p)
|
|
assert transcription_registry.get_provider(" openrouter ") is p
|
|
|
|
def test_list_providers_sorted(self):
|
|
transcription_registry.register_provider(_FakeProvider(name="zylo"))
|
|
transcription_registry.register_provider(_FakeProvider(name="alpha"))
|
|
transcription_registry.register_provider(_FakeProvider(name="middle"))
|
|
names = [p.name for p in transcription_registry.list_providers()]
|
|
assert names == ["alpha", "middle", "zylo"]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# ABC contract
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestABCContract:
|
|
def test_must_implement_transcribe(self):
|
|
class Incomplete(TranscriptionProvider):
|
|
@property
|
|
def name(self) -> str:
|
|
return "incomplete"
|
|
# transcribe NOT implemented
|
|
|
|
with pytest.raises(TypeError, match="abstract"):
|
|
Incomplete() # type: ignore[abstract]
|
|
|
|
def test_must_implement_name(self):
|
|
class Incomplete(TranscriptionProvider):
|
|
def transcribe(self, file_path, **kw):
|
|
return {"success": True, "transcript": "", "provider": "incomplete"}
|
|
# name NOT implemented
|
|
|
|
with pytest.raises(TypeError, match="abstract"):
|
|
Incomplete() # type: ignore[abstract]
|
|
|
|
def test_display_name_defaults_to_title(self):
|
|
p = _FakeProvider(name="openrouter")
|
|
assert p.display_name == "Openrouter"
|
|
|
|
def test_display_name_override_respected(self):
|
|
p = _FakeProvider(name="openrouter", display="OpenRouter STT")
|
|
assert p.display_name == "OpenRouter STT"
|
|
|
|
def test_is_available_default_true(self):
|
|
p = _FakeProvider(name="openrouter")
|
|
assert p.is_available() is True
|
|
|
|
def test_list_models_default_empty(self):
|
|
p = _FakeProvider(name="openrouter")
|
|
assert p.list_models() == []
|
|
|
|
def test_default_model_none_when_no_models(self):
|
|
p = _FakeProvider(name="openrouter")
|
|
assert p.default_model() is None
|
|
|
|
def test_default_model_first_listed(self):
|
|
class WithModels(_FakeProvider):
|
|
def list_models(self):
|
|
return [{"id": "whisper-large-v3-turbo"}, {"id": "whisper-large-v3"}]
|
|
|
|
p = WithModels(name="openrouter")
|
|
assert p.default_model() == "whisper-large-v3-turbo"
|
|
|
|
def test_get_setup_schema_default_minimal(self):
|
|
p = _FakeProvider(name="openrouter")
|
|
schema = p.get_setup_schema()
|
|
assert schema["name"] == "Openrouter"
|
|
assert schema["env_vars"] == []
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Sync invariant: registry built-ins vs dispatcher built-ins
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestBuiltinSync:
|
|
"""``_BUILTIN_NAMES`` in agent/transcription_registry.py is duplicated
|
|
from ``BUILTIN_STT_PROVIDERS`` in tools/transcription_tools.py
|
|
(importing directly would create a circular dependency). This test
|
|
fails loudly if the two lists drift — a new built-in added to
|
|
transcription_tools.py MUST also be added to
|
|
transcription_registry.py's ``_BUILTIN_NAMES`` or the registry will
|
|
accept a name the dispatcher will silently route to the wrong
|
|
handler.
|
|
"""
|
|
|
|
def test_registry_builtins_match_dispatcher_builtins(self):
|
|
from tools.transcription_tools import BUILTIN_STT_PROVIDERS
|
|
|
|
assert transcription_registry._BUILTIN_NAMES == BUILTIN_STT_PROVIDERS, (
|
|
"agent.transcription_registry._BUILTIN_NAMES and "
|
|
"tools.transcription_tools.BUILTIN_STT_PROVIDERS have drifted!\n"
|
|
f" Registry only: {sorted(transcription_registry._BUILTIN_NAMES - BUILTIN_STT_PROVIDERS)}\n"
|
|
f" Dispatcher only: {sorted(BUILTIN_STT_PROVIDERS - transcription_registry._BUILTIN_NAMES)}\n"
|
|
"Add the missing names to whichever list is incomplete. "
|
|
"These two lists exist as a circular-import workaround and "
|
|
"MUST be kept in sync manually."
|
|
)
|