Hermes-agent

tests/agent/test_transcription_registry.py

@@ -0,0 +1,243 @@
+"""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."
+        )