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
"""Answer-cache lifecycle: upsert on re-synthesis, commit/TTL invalidation.
Regression coverage for the silent-failure mode where the cache write was a
plain INSERT under ``suppress(Exception)``: every bypass-and-resynthesize
round (hedged rows, schema bumps) violated ``uq_answer_cache_q`` and failed
silently, so a bad cached row was permanent. The write is now a
delete-then-insert upsert, and reads invalidate on indexed-commit change or
hard TTL.
"""
from __future__ import annotations
import json as _json
from datetime import UTC, datetime, timedelta
from types import SimpleNamespace
import pytest
from sqlalchemy import select
from repowise.core.persistence.models import AnswerCache, Repository
QUESTION = "how does the auth service work"
# Top score >= 3.0 with an absolute gap >= 0.5 → dominant → synthesis runs.
_HITS = [
{"page_id": "file_page:src/auth/service.py", "score": 5.0},
{"page_id": "file_page:src/auth/middleware.py", "score": 4.0},
]
def _patch_retrieval(monkeypatch, answer_mod):
async def _fake_retrieve(question, ctx):
return [dict(h) for h in _HITS]
async def _fake_hydrate(hits, ctx, *, scope=None):
for h in hits:
h["target_path"] = h["page_id"].removeprefix("file_page:")
h["title"] = h["target_path"]
h["summary"] = ""
h["snippet"] = ""
h["page_type"] = "file_page"
return hits
monkeypatch.setattr(answer_mod, "_hybrid_retrieve", _fake_retrieve)
monkeypatch.setattr(answer_mod, "_hydrate_hits", _fake_hydrate)
class _Provider:
provider_name = "mock"
model_name = "mock-1"
def __init__(self, content: str) -> None:
self.content = content
self.calls = 0
async def generate(self, **kwargs):
self.calls += 1
return SimpleNamespace(content=self.content)
def _patch_provider(monkeypatch, answer_mod, provider: _Provider) -> None:
monkeypatch.setattr(answer_mod, "_resolve_provider_for_answer", lambda _p: provider)
async def _cache_rows(factory) -> list[AnswerCache]:
from repowise.core.persistence.database import get_session
async with get_session(factory) as session:
res = await session.execute(select(AnswerCache))
return list(res.scalars().all())
@pytest.mark.asyncio
async def test_hedged_row_is_upgraded_on_resynthesis(setup_mcp, factory, monkeypatch):
"""Hedged cached answer → bypass → re-synthesis → row UPGRADED, not orphaned."""
import repowise.server.mcp_server.tool_answer.answer as answer_mod
from repowise.server.mcp_server import get_answer
_patch_retrieval(monkeypatch, answer_mod)
hedged = _Provider("The provided excerpts do not contain the implementation details.")
_patch_provider(monkeypatch, answer_mod, hedged)
first = await get_answer(QUESTION)
assert first["confidence"] == "low"
rows = await _cache_rows(factory)
assert len(rows) == 1
assert "do not contain" in _json.loads(rows[0].payload_json)["answer"]
direct = _Provider("Auth flows through src/auth/service.py via AuthService.check().")
_patch_provider(monkeypatch, answer_mod, direct)
second = await get_answer(QUESTION)
assert direct.calls == 1, "hedged cache entry must be bypassed, not returned"
assert "AuthService.check" in second["answer"]
rows = await _cache_rows(factory)
assert len(rows) == 1, "upsert must replace the hedged row, not duplicate or fail"
upgraded = _json.loads(rows[0].payload_json)
assert "AuthService.check" in upgraded["answer"], "row must carry the upgraded answer"
# Third call: the upgraded row is a normal cache hit — no synthesis.
third = await get_answer(QUESTION)
assert direct.calls == 1, "upgraded row must serve from cache"
assert third["_meta"].get("cached") is True
assert "_indexed_commit" not in third
@pytest.mark.asyncio
async def test_cached_empty_answer_row_is_bypassed(setup_mcp, factory, session, monkeypatch):
"""A legacy cached gated payload (empty answer) never serves from cache.
Older versions cached the gated best_guesses payload, pinning a retrieval
miss until TTL and hiding every later improvement to the miss path. The
write side no longer stores empty answers; the read side must retire the
rows that predate that fix.
"""
import repowise.server.mcp_server.tool_answer.answer as answer_mod
from repowise.server.mcp_server import get_answer
from repowise.server.mcp_server.tool_answer.answer import _hash_question
from repowise.server.mcp_server.tool_answer.config import _ANSWER_SCHEMA_VERSION
_patch_retrieval(monkeypatch, answer_mod)
res = await session.execute(select(Repository))
repo = res.scalars().first()
# Legacy row: current schema version (so the schema gate passes) but the
# old empty-answer gated shape.
session.add(
AnswerCache(
repository_id=repo.id,
question_hash=_hash_question(QUESTION),
question=QUESTION,
payload_json=_json.dumps(
{
"answer": "",
"confidence": "low",
"fallback_targets": ["src/auth/service.py"],
"_schema_version": _ANSWER_SCHEMA_VERSION,
}
),
provider_name="mock",
model_name="mock-1",
)
)
await session.commit()
direct = _Provider("Auth flows through src/auth/service.py via AuthService.check().")
_patch_provider(monkeypatch, answer_mod, direct)
result = await get_answer(QUESTION)
assert direct.calls == 1, "empty-answer cache row must be bypassed"
assert "AuthService.check" in result["answer"]
@pytest.mark.asyncio
async def test_cache_bypassed_when_indexed_commit_changes(setup_mcp, factory, session, monkeypatch):
"""A row stamped at commit A is bypassed once the repo is indexed at B."""
import repowise.server.mcp_server.tool_answer.answer as answer_mod
from repowise.server.mcp_server import get_answer
_patch_retrieval(monkeypatch, answer_mod)
repo = (await session.execute(select(Repository))).scalars().first()
repo.head_commit = "a" * 40
await session.commit()
v1 = _Provider("Answer synthesised at commit A (src/auth/service.py).")
_patch_provider(monkeypatch, answer_mod, v1)
await get_answer(QUESTION)
assert v1.calls == 1
# Same commit → cache hit, no new synthesis.
await get_answer(QUESTION)
assert v1.calls == 1
repo.head_commit = "b" * 40
await session.commit()
v2 = _Provider("Answer synthesised at commit B (src/auth/service.py).")
_patch_provider(monkeypatch, answer_mod, v2)
result = await get_answer(QUESTION)
assert v2.calls == 1, "commit change must bypass the cached row"
assert "commit B" in result["answer"]
rows = await _cache_rows(factory)
assert len(rows) == 1
assert _json.loads(rows[0].payload_json)["_indexed_commit"] == "b" * 40
@pytest.mark.asyncio
async def test_cache_row_past_ttl_is_bypassed(setup_mcp, factory, session, monkeypatch):
"""Rows older than the hard TTL re-synthesise even without commit metadata."""
import repowise.server.mcp_server.tool_answer.answer as answer_mod
from repowise.server.mcp_server import get_answer
_patch_retrieval(monkeypatch, answer_mod)
v1 = _Provider("Original answer (src/auth/service.py).")
_patch_provider(monkeypatch, answer_mod, v1)
await get_answer(QUESTION)
rows = await _cache_rows(factory)
assert len(rows) == 1
from repowise.core.persistence.database import get_session
async with get_session(factory) as s:
row = (await s.execute(select(AnswerCache))).scalars().one()
row.created_at = datetime.now(UTC) - timedelta(days=30)
await s.commit()
v2 = _Provider("Fresh answer (src/auth/service.py).")
_patch_provider(monkeypatch, answer_mod, v2)
result = await get_answer(QUESTION)
assert v2.calls == 1, "expired row must be bypassed"
assert "Fresh answer" in result["answer"]
@pytest.mark.asyncio
async def test_cache_write_failure_logs_instead_of_silencing(setup_mcp, monkeypatch, caplog):
"""A failing cache write must not block the response — and must be logged."""
import repowise.server.mcp_server.tool_answer.answer as answer_mod
from repowise.server.mcp_server import get_answer
_patch_retrieval(monkeypatch, answer_mod)
_patch_provider(monkeypatch, answer_mod, _Provider("Answer text (src/auth/service.py)."))
real_dumps = answer_mod._json.dumps
def _boom(obj, *a, **k):
if isinstance(obj, dict) and "_schema_version" in obj:
raise RuntimeError("simulated serialization failure")
return real_dumps(obj, *a, **k)
monkeypatch.setattr(answer_mod._json, "dumps", _boom)
with caplog.at_level("WARNING", logger="repowise.mcp.answer"):
result = await get_answer(QUESTION)
assert result["answer"], "response must survive a cache-write failure"
assert any("cache write failed" in r.message for r in caplog.records)
@pytest.mark.asyncio
@pytest.mark.parametrize(
("first_scope", "second_scope"),
[(None, "src/auth"), ("src/auth", None)],
)
async def test_scoped_and_unscoped_answers_never_cross_contaminate(
setup_mcp, factory, monkeypatch, first_scope, second_scope
):
import repowise.server.mcp_server.tool_answer.answer as answer_mod
from repowise.server.mcp_server import get_answer
_patch_retrieval(monkeypatch, answer_mod)
provider = _Provider("Scoped cache identity answer (src/auth/service.py).")
_patch_provider(monkeypatch, answer_mod, provider)
await get_answer(QUESTION, scope=first_scope)
await get_answer(QUESTION, scope=second_scope)
assert provider.calls == 2
assert len(await _cache_rows(factory)) == 2
@pytest.mark.asyncio
async def test_distinct_scopes_never_cross_contaminate(setup_mcp, factory, monkeypatch):
import repowise.server.mcp_server.tool_answer.answer as answer_mod
from repowise.server.mcp_server import get_answer
_patch_retrieval(monkeypatch, answer_mod)
provider = _Provider("Scoped answer (src/auth/service.py).")
_patch_provider(monkeypatch, answer_mod, provider)
await get_answer(QUESTION, scope="src/auth")
await get_answer(QUESTION, scope="src/billing")
assert provider.calls == 2
assert len(await _cache_rows(factory)) == 2
def test_literal_unscoped_scope_cannot_collide_with_absent_scope() -> None:
from repowise.server.mcp_server.tool_answer.synthesis import _hash_answer_identity
assert _hash_answer_identity(QUESTION, None) != _hash_answer_identity(QUESTION, "<unscoped>")
@pytest.mark.asyncio
async def test_equivalent_normalized_scopes_share_one_row(setup_mcp, factory, monkeypatch):
import repowise.server.mcp_server.tool_answer.answer as answer_mod
from repowise.server.mcp_server import get_answer
seen_scopes: list[str | None] = []
async def _fake_hydrate(hits, ctx, *, scope=None):
seen_scopes.append(scope)
for hit in hits:
hit.update(
target_path=hit["page_id"].removeprefix("file_page:"),
title="auth",
summary="",
snippet="",
page_type="file_page",
)
return hits
_patch_retrieval(monkeypatch, answer_mod)
monkeypatch.setattr(answer_mod, "_hydrate_hits", _fake_hydrate)
provider = _Provider("Normalized scope answer (src/auth/service.py).")
_patch_provider(monkeypatch, answer_mod, provider)
await get_answer(QUESTION, scope="./src\\auth//")
cached = await get_answer(QUESTION, scope="src/auth")
assert provider.calls == 1
assert seen_scopes == ["src/auth"]
assert cached["_meta"]["cached"] is True
assert len(await _cache_rows(factory)) == 1
@pytest.mark.asyncio
async def test_cached_answer_preserves_retrieval_degradation_metadata(
setup_mcp, factory, monkeypatch
):
import repowise.server.mcp_server.tool_answer.answer as answer_mod
from repowise.server.mcp_server import get_answer
_patch_retrieval(monkeypatch, answer_mod)
monkeypatch.setattr(answer_mod, "_retrieval_legs", lambda: {"vector": "timeout"})
monkeypatch.setattr(answer_mod, "_degraded_legs", lambda _legs: ["vector"])
provider = _Provider("Degraded retrieval answer (src/auth/service.py).")
_patch_provider(monkeypatch, answer_mod, provider)
fresh = await get_answer(QUESTION)
cached = await get_answer(QUESTION)
assert provider.calls == 1
assert fresh["_meta"]["retrieval_degraded"] == ["vector"]
assert cached["_meta"]["retrieval_degraded"] == ["vector"]
assert cached["_meta"]["cached"] is True
@pytest.mark.asyncio
async def test_legacy_question_only_row_is_bypassed(setup_mcp, factory, session, monkeypatch):
import repowise.server.mcp_server.tool_answer.answer as answer_mod
from repowise.server.mcp_server import get_answer
from repowise.server.mcp_server.tool_answer.answer import _hash_question
from repowise.server.mcp_server.tool_answer.config import _ANSWER_SCHEMA_VERSION
_patch_retrieval(monkeypatch, answer_mod)
repo = (await session.execute(select(Repository))).scalars().first()
session.add(
AnswerCache(
repository_id=repo.id,
question_hash=_hash_question(QUESTION),
question=QUESTION,
payload_json=_json.dumps(
{
"answer": "Legacy answer must not be served.",
"confidence": "high",
"citations": ["src/legacy.py"],
"_schema_version": _ANSWER_SCHEMA_VERSION,
}
),
provider_name="mock",
model_name="mock-1",
)
)
await session.commit()
provider = _Provider("Fresh scoped identity answer (src/auth/service.py).")
_patch_provider(monkeypatch, answer_mod, provider)
result = await get_answer(QUESTION)
assert provider.calls == 1
assert "Fresh scoped identity" in result["answer"]
rows = await _cache_rows(factory)
assert len(rows) == 1
assert rows[0].question_hash != _hash_question(QUESTION)