hermes-agent/tests/agent/test_probe_cache_followups.py

"""Tests for probe-cache follow-ups on the #29988/#37595/#50572 salvage.

Covers:
- _query_ollama_api_show TTL caching (positive-only, namespaced key)
- persistent context-cache key normalization (trailing-slash dedup)
"""

from __future__ import annotations

from tests.agent.metadata_transport import metadata_transport  # noqa: F401
from unittest.mock import MagicMock, patch

import pytest



@pytest.fixture(autouse=True)
def _clear_probe_cache():
    """Module-level caches must not leak between tests."""
    from agent import model_metadata
    model_metadata._LOCAL_CTX_PROBE_CACHE.clear()
    model_metadata._endpoint_probe_path_cache.clear()
    yield
    model_metadata._LOCAL_CTX_PROBE_CACHE.clear()
    model_metadata._endpoint_probe_path_cache.clear()


def _mock_show_response(ctx=131072):
    resp = MagicMock()
    resp.status_code = 200
    resp.json.return_value = {
        "model_info": {"llama.context_length": ctx},
        "parameters": "",
    }
    return resp


def _client_mock(resp):
    client = MagicMock()
    client.__enter__ = lambda s: client
    client.__exit__ = MagicMock(return_value=False)
    client.post.return_value = resp
    return client


class TestOllamaApiShowCaching:

    def test_failure_never_memoized(self):
        """A down server must be re-probed on the next call (startup race)."""
        from agent.model_metadata import _query_ollama_api_show

        bad = MagicMock()
        bad.status_code = 404
        client = _client_mock(bad)
        with patch("httpx.Client", return_value=client):
            assert _query_ollama_api_show("llama3", "http://127.0.0.1:11434") is None
            assert _query_ollama_api_show("llama3", "http://127.0.0.1:11434") is None

        assert client.post.call_count == 2  # None was NOT cached




class TestDetectLocalServerTypeCache:
    """#29988: detect_local_server_type memoized with a bounded TTL."""

    def _get_client(self, server_type="ollama"):
        ollama_resp = MagicMock()
        ollama_resp.status_code = 200
        ollama_resp.json.return_value = {"models": []}
        miss = MagicMock()
        miss.status_code = 404

        client = MagicMock()
        client.__enter__ = lambda s: client
        client.__exit__ = MagicMock(return_value=False)

        def _get(url, *a, **k):
            if url.endswith("/api/tags"):
                return ollama_resp
            return miss

        client.get.side_effect = _get
        return client


    def test_ttl_expiry_allows_server_swap_redetection(self):
        """Stopping Ollama and starting LM Studio on the same port must be
        re-detected once the TTL lapses — the cache is bounded, not
        process-lifetime."""
        from agent import model_metadata
        from agent.model_metadata import detect_local_server_type
        import time as _time

        client = self._get_client()
        with patch("httpx.Client", return_value=client):
            assert detect_local_server_type("http://127.0.0.1:11434") == "ollama"

        # Age the entry past the TTL, then swap the backend behind the URL.
        ((key, (val, _ts)),) = list(model_metadata._endpoint_probe_path_cache.items())
        model_metadata._endpoint_probe_path_cache[key] = (
            val, _time.monotonic() - model_metadata._ENDPOINT_PROBE_TTL_SECONDS - 1,
        )
        # Age the disk L2 entry too. Its TTL (300s) is much shorter than the
        # in-proc TTL (1h), so in real time-flow it always expires first —
        # this test compresses both expiries into one instant.
        import json as _json
        _disk = model_metadata._local_probe_disk_cache_path()
        if _disk.exists():
            _data = _json.loads(_disk.read_text(encoding="utf-8"))
            for _entry in _data.values():
                if isinstance(_entry, dict):
                    _entry["ts"] = (
                        _time.time() - model_metadata._LOCAL_PROBE_DISK_TTL_SECONDS - 1
                    )
            _disk.write_text(_json.dumps(_data), encoding="utf-8")

        lmstudio_resp = MagicMock()
        lmstudio_resp.status_code = 200
        lmstudio_resp.json.return_value = {"data": []}
        swap_client = MagicMock()
        swap_client.__enter__ = lambda s: swap_client
        swap_client.__exit__ = MagicMock(return_value=False)

        def _get(url, *a, **k):
            if url.endswith("/api/v1/models"):
                return lmstudio_resp
            miss = MagicMock(); miss.status_code = 404
            return miss

        swap_client.get.side_effect = _get
        with patch("httpx.Client", return_value=swap_client):
            assert detect_local_server_type("http://127.0.0.1:11434") == "lm-studio"


class TestLocalhostIPv4SiblingSites:
    """#37595 widened: every probe helper rewrites localhost→127.0.0.1,
    not just detect_local_server_type."""

    def test_rewrite_is_host_only_not_substring(self):
        """A URL that merely EMBEDS 'http://localhost' in its path/query must
        not be corrupted — only the URL's own host is rewritten."""
        from agent.model_metadata import _localhost_to_ipv4

        proxied = "https://proxy.example.com/route?upstream=http://localhost:11434"
        assert _localhost_to_ipv4(proxied) == proxied
        # Host must be a full label: localhost.example.com is NOT localhost.
        assert _localhost_to_ipv4("http://localhost.example.com/v1") == (
            "http://localhost.example.com/v1"
        )

    def test_ollama_api_show_probes_ipv4(self):
        from agent.model_metadata import _query_ollama_api_show

        client = _client_mock(_mock_show_response(131072))
        with patch("httpx.Client", return_value=client):
            _query_ollama_api_show("llama3", "http://localhost:11434")

        assert client.post.call_args[0][0].startswith("http://127.0.0.1:11434")

    @pytest.mark.parametrize("llamacpp", [False, True])
    def test_endpoint_and_props_followup_use_ipv4(self, metadata_transport, llamacpp):
        import httpx
        from agent import model_metadata as mm

        mm._endpoint_model_metadata_cache.clear()
        mm._endpoint_model_metadata_cache_time.clear()
        responses, requests = metadata_transport
        models = [{"id": "llama-3-8b", "owned_by": "llamacpp"}] if llamacpp else []
        responses.extend([
            httpx.Response(200, json={"data": models}),
            httpx.Response(200, json={"default_generation_settings": {"n_ctx": 32768}, "model_alias": "llama-3-8b"}),
        ])
        result = mm.fetch_endpoint_model_metadata("http://localhost:8000/v1", force_refresh=True)
        assert len(requests) == (2 if llamacpp else 1)
        assert all(request.url.host == "127.0.0.1" for request in requests)
        if llamacpp:
            assert requests[1].url.path == "/v1/props"
            assert result["llama-3-8b"]["context_length"] == 32768


class TestContextCacheKeyNormalization:
    def test_trailing_slash_variants_share_one_entry(self, tmp_path, monkeypatch):
        from agent import model_metadata

        monkeypatch.setattr(
            model_metadata, "_get_context_cache_path",
            lambda: tmp_path / "context_lengths.yaml",
        )

        model_metadata.save_context_length("m1", "http://host/v1/", 200_000)
        # Both slash variants resolve to the same row.
        assert model_metadata.get_cached_context_length("m1", "http://host/v1") == 200_000
        assert model_metadata.get_cached_context_length("m1", "http://host/v1/") == 200_000

        cache = model_metadata._load_context_cache()
        assert list(cache.keys()) == ["m1@http://host/v1"]



    def test_invalidate_clears_both_key_shapes(self, tmp_path, monkeypatch):
        import hermes_yaml as yaml
        from agent import model_metadata

        path = tmp_path / "context_lengths.yaml"
        monkeypatch.setattr(model_metadata, "_get_context_cache_path", lambda: path)
        path.write_text(yaml.safe_dump({"context_lengths": {
            "m1@http://host/v1": 128_000,
            "m1@http://host/v1/": 64_000,
        }}))

        model_metadata._invalidate_cached_context_length("m1", "http://host/v1/")
        cache = model_metadata._load_context_cache()
        assert "m1@http://host/v1" not in cache
        assert "m1@http://host/v1/" not in cache


class TestDetectServerTypeNegativeCaching:
    """A failed detect_local_server_type verdict is cached briefly (#89863).

    Previously only positive verdicts were memoized, so a remote endpoint
    that answered the whole waterfall with 401s (no recognizable server
    type) was re-probed — 5 requests — on every image-bearing turn.
    """

    @staticmethod
    def _client_all_401():
        client = MagicMock()
        client.__enter__ = lambda s: client
        client.__exit__ = MagicMock(return_value=False)
        resp = MagicMock()
        resp.status_code = 401
        client.get.return_value = resp
        return client

    def test_negative_verdict_is_cached_in_memory(self):
        from agent.model_metadata import detect_local_server_type

        client = self._client_all_401()
        with patch("httpx.Client", return_value=client):
            assert detect_local_server_type("http://remote:8080/v1") is None
            after_first = client.get.call_count
            assert detect_local_server_type("http://remote:8080/v1") is None

        # Second call served from the in-memory negative entry: the
        # waterfall ran exactly once, not twice.
        assert after_first > 0
        assert client.get.call_count == after_first


    def test_negative_verdict_expires_quickly(self):
        """The short failure TTL keeps a transient failure recoverable."""
        import time as _time
        from agent.model_metadata import detect_local_server_type
        from agent import model_metadata

        client = self._client_all_401()
        with patch("httpx.Client", return_value=client):
            assert detect_local_server_type("http://remote3:8080/v1") is None
            after_first = client.get.call_count
            # Age the entry past the failure TTL.
            model_metadata._endpoint_probe_path_cache["http://remote3:8080"] = (
                None,
                _time.monotonic()
                - model_metadata._ENDPOINT_PROBE_FAILURE_TTL_SECONDS
                - 1,
            )
            assert detect_local_server_type("http://remote3:8080/v1") is None

        assert client.get.call_count == 2 * after_first  # waterfall re-ran after expiry