Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.
Python aicode-complexitycode-healthcode-intelligencecode-qualitydead-codedeveloper-toolsdocumentationgit-analyticsmcpopen-sourcepythonrefactoringstatic-analysistechnical-debt
"""Unit tests for OllamaEmbedder.
All tests mock httpx.AsyncClient, so no local Ollama daemon is required.
"""
from __future__ import annotations
import math
from typing import Any, ClassVar
import pytest
from repowise.core.providers.embedding.ollama import OllamaEmbedder
def test_registry_keeps_mock_and_adds_ollama() -> None:
from repowise.core.providers.embedding.base import MockEmbedder
from repowise.core.providers.embedding.registry import get_embedder, list_embedders
embedders = list_embedders()
assert "mock" in embedders
assert "ollama" in embedders
assert isinstance(get_embedder("mock"), MockEmbedder)
assert isinstance(get_embedder("ollama", model="embeddinggemma"), OllamaEmbedder)
class _FakeResponse:
def __init__(self, data: dict[str, Any]) -> None:
self._data = data
def raise_for_status(self) -> None:
return None
def json(self) -> dict[str, Any]:
return self._data
class _FakeAsyncClient:
calls: ClassVar[list[dict[str, Any]]] = []
response_data: ClassVar[dict[str, Any]] = {"embeddings": [[1.0, 0.0]]}
def __init__(self, *, timeout: float) -> None:
self.timeout = timeout
async def __aenter__(self) -> _FakeAsyncClient:
return self
async def __aexit__(self, *args: object) -> None:
return None
async def post(self, url: str, *, json: dict[str, Any]) -> _FakeResponse:
self.calls.append({"url": url, "json": json, "timeout": self.timeout})
return _FakeResponse(self.response_data)
@pytest.fixture(autouse=True)
def _reset_fake_client(monkeypatch: pytest.MonkeyPatch):
_FakeAsyncClient.calls = []
_FakeAsyncClient.response_data = {"embeddings": [[1.0, 0.0]]}
monkeypatch.setattr(
"repowise.core.providers.embedding.ollama.httpx.AsyncClient",
_FakeAsyncClient,
)
async def test_embed_empty_returns_empty() -> None:
embedder = OllamaEmbedder(model="embeddinggemma")
assert await embedder.embed([]) == []
async def test_embed_posts_batch_to_native_endpoint() -> None:
# Response vectors must be 1024-wide to match the declared dimensions=1024.
_FakeAsyncClient.response_data = {
"embeddings": [
[1.0] + [0.0] * 1023,
[0.0, 1.0] + [0.0] * 1022,
]
}
embedder = OllamaEmbedder(
model="qwen3-embedding:0.6b",
base_url="http://localhost:11434/",
dimensions=1024,
)
vectors = await embedder.embed(["first", "second"])
assert _FakeAsyncClient.calls == [
{
"url": "http://localhost:11434/api/embed",
"json": {
"model": "qwen3-embedding:0.6b",
"input": ["first", "second"],
"dimensions": 1024,
},
"timeout": pytest.approx(30.0 + len("firstsecond") * 0.002),
}
]
assert len(vectors) == 2
assert all(abs(math.sqrt(sum(x * x for x in vec)) - 1.0) < 1e-6 for vec in vectors)
async def test_embed_supports_legacy_single_embedding_response() -> None:
# dimensions=2 so the declared width matches the 2-wide legacy response.
_FakeAsyncClient.response_data = {"embedding": [3.0, 4.0]}
embedder = OllamaEmbedder(model="embeddinggemma", dimensions=2)
result = await embedder.embed(["one"])
assert result == [[0.6, 0.8]]
def test_model_and_base_url_can_come_from_env(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setenv("OLLAMA_BASE_URL", "http://ollama.local:11434/")
monkeypatch.setenv("OLLAMA_EMBEDDING_MODEL", "all-minilm")
embedder = OllamaEmbedder()
assert embedder._base_url == "http://ollama.local:11434"
assert embedder._model == "all-minilm"
assert embedder.dimensions == 384
def test_qwen3_dimensions_are_inferred() -> None:
assert OllamaEmbedder(model="qwen3-embedding:0.6b").dimensions == 1024
assert OllamaEmbedder(model="qwen3-embedding:4b").dimensions == 2560
assert OllamaEmbedder(model="qwen3-embedding:8b").dimensions == 4096
def test_timeout_defaults_to_thirty_seconds(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.delenv("OLLAMA_EMBEDDING_TIMEOUT", raising=False)
monkeypatch.delenv("REPOWISE_EMBEDDING_TIMEOUT", raising=False)
assert OllamaEmbedder(model="embeddinggemma")._timeout == 30.0
def test_timeout_can_come_from_env(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setenv("OLLAMA_EMBEDDING_TIMEOUT", "120")
assert OllamaEmbedder(model="embeddinggemma")._timeout == 120.0
def test_repowise_embedding_timeout_is_a_fallback(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.delenv("OLLAMA_EMBEDDING_TIMEOUT", raising=False)
monkeypatch.setenv("REPOWISE_EMBEDDING_TIMEOUT", "90")
assert OllamaEmbedder(model="embeddinggemma")._timeout == 90.0
def test_explicit_timeout_overrides_env(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setenv("OLLAMA_EMBEDDING_TIMEOUT", "120")
assert OllamaEmbedder(model="embeddinggemma", timeout=5.0)._timeout == 5.0
async def test_env_timeout_is_applied_to_the_request(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setenv("OLLAMA_EMBEDDING_TIMEOUT", "300")
# dimensions=2 so the default 2-wide fixture response passes the width guard.
embedder = OllamaEmbedder(model="embeddinggemma", dimensions=2)
await embedder.embed(["one"])
assert _FakeAsyncClient.calls[0]["timeout"] == 300.0
async def test_default_timeout_grows_with_the_batch(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.delenv("OLLAMA_EMBEDDING_TIMEOUT", raising=False)
monkeypatch.delenv("REPOWISE_EMBEDDING_TIMEOUT", raising=False)
_FakeAsyncClient.response_data = {"embeddings": [[1.0, 0.0]] * 16}
embedder = OllamaEmbedder(model="embeddinggemma", dimensions=2)
# A full chunk of long pages measured 171.6s on a CPU-only Ollama.
await embedder.embed(["x" * 16_000] * 16)
assert _FakeAsyncClient.calls[0]["timeout"] > 171.6
assert _FakeAsyncClient.calls[0]["timeout"] == pytest.approx(30.0 + 16 * 16_000 * 0.002)
async def test_short_batch_keeps_about_the_default_timeout(
monkeypatch: pytest.MonkeyPatch,
) -> None:
monkeypatch.delenv("OLLAMA_EMBEDDING_TIMEOUT", raising=False)
monkeypatch.delenv("REPOWISE_EMBEDDING_TIMEOUT", raising=False)
embedder = OllamaEmbedder(model="embeddinggemma", dimensions=2)
await embedder.embed(["one"])
assert _FakeAsyncClient.calls[0]["timeout"] == pytest.approx(30.006)
async def test_configured_timeout_is_not_scaled(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.delenv("OLLAMA_EMBEDDING_TIMEOUT", raising=False)
monkeypatch.setenv("REPOWISE_EMBEDDING_TIMEOUT", "45")
_FakeAsyncClient.response_data = {"embeddings": [[1.0, 0.0]] * 4}
await OllamaEmbedder(model="embeddinggemma", dimensions=2).embed(["x" * 16_000] * 4)
await OllamaEmbedder(model="embeddinggemma", dimensions=2, timeout=5.0).embed(
["x" * 16_000] * 4
)
assert [call["timeout"] for call in _FakeAsyncClient.calls] == [45.0, 5.0]
async def test_invalid_env_timeout_still_scales(
monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
) -> None:
monkeypatch.setenv("OLLAMA_EMBEDDING_TIMEOUT", "soon")
monkeypatch.delenv("REPOWISE_EMBEDDING_TIMEOUT", raising=False)
embedder = OllamaEmbedder(model="embeddinggemma", dimensions=2)
await embedder.embed(["x" * 1_000])
assert _FakeAsyncClient.calls[0]["timeout"] == pytest.approx(32.0)
# ---------------------------------------------------------------------------
# Width verification — the check added in fix/embedder-width-verification
# ---------------------------------------------------------------------------
async def test_embed_raises_when_server_returns_wrong_width_inferred() -> None:
# embeddinggemma → _infer_dimensions() → 768.
# Server returns 3-wide vectors (ignores 'dimensions' parameter).
# Hint should reference OLLAMA_EMBEDDING_DIMS because the user never set it.
_FakeAsyncClient.response_data = {"embeddings": [[1.0, 0.0, 0.0]]}
embedder = OllamaEmbedder(model="embeddinggemma")
assert embedder.dimensions == 768
with pytest.raises(ValueError, match="768") as exc_info:
await embedder.embed(["hello"])
msg = str(exc_info.value)
assert "3" in msg # actual width named
assert "OLLAMA_EMBEDDING_DIMS" in msg # points at the env var fix
async def test_embed_raises_when_server_returns_wrong_width_explicit() -> None:
# User set dimensions=1024 explicitly; server returns 3-wide vectors.
# Hint should also reference OLLAMA_EMBEDDING_DIMS / REPOWISE_EMBEDDING_DIMS.
_FakeAsyncClient.response_data = {"embeddings": [[1.0, 0.0, 0.0]]}
embedder = OllamaEmbedder(model="qwen3-embedding:0.6b", dimensions=1024)
assert embedder.dimensions == 1024
with pytest.raises(ValueError, match="1024") as exc_info:
await embedder.embed(["hello"])
msg = str(exc_info.value)
assert "3" in msg
assert "OLLAMA_EMBEDDING_DIMS" in msg
async def test_embed_width_check_not_triggered_on_empty() -> None:
# embed([]) short-circuits and returns [] without calling the server.
embedder = OllamaEmbedder(model="embeddinggemma")
assert await embedder.embed([]) == []