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
"""Batched vector-store operations: pgvector executemany + IN-filtered
summary lookups (pgvector, LanceDB)."""
from __future__ import annotations
import pytest
from repowise.core.persistence.vector_store.in_memory import InMemoryVectorStore
from repowise.core.persistence.vector_store.lancedb_store import (
_SUMMARY_PATH_BATCH_SIZE,
LanceDBVectorStore,
_page_ids_in_filter,
_paths_in_filter,
)
from repowise.core.persistence.vector_store.pgvector_store import (
PgVectorStore,
_summary_payload,
)
from repowise.core.providers.embedding.base import MockEmbedder
# ---------------------------------------------------------------------------
# Fake async-SQLAlchemy session plumbing
# ---------------------------------------------------------------------------
class _FakeResult:
def __init__(self, rows: list[tuple]) -> None:
self._rows = rows
def fetchall(self) -> list[tuple]:
return self._rows
def fetchone(self):
return self._rows[0] if self._rows else None
class _FakeSession:
"""Records every execute() call; serves canned rows."""
def __init__(self, rows: list[tuple] | None = None) -> None:
self.executed: list[tuple[str, object]] = []
self.commits = 0
self._rows = rows or []
async def __aenter__(self):
return self
async def __aexit__(self, *exc):
return False
async def execute(self, stmt, params=None):
self.executed.append((str(stmt), params))
return _FakeResult(self._rows)
async def commit(self):
self.commits += 1
def _factory(session: _FakeSession):
def make() -> _FakeSession:
return session
return make
# ---------------------------------------------------------------------------
# pgvector embed_batch — one executemany, not N round-trips
# ---------------------------------------------------------------------------
async def test_pg_embed_batch_single_executemany() -> None:
session = _FakeSession()
store = PgVectorStore(_factory(session), MockEmbedder())
await store.embed_batch([("p1", "alpha", {}), ("p2", "beta", {}), ("p3", "gamma", {})])
assert len(session.executed) == 1 # one statement, list-of-params
stmt, params = session.executed[0]
assert "UPDATE wiki_pages SET embedding" in stmt
assert isinstance(params, list) and len(params) == 3
assert [p["pid"] for p in params] == ["p1", "p2", "p3"]
assert all(p["emb"].startswith("[") for p in params)
assert session.commits == 1
async def test_pg_embed_batch_empty_is_noop() -> None:
session = _FakeSession()
store = PgVectorStore(_factory(session), MockEmbedder())
await store.embed_batch([])
assert session.executed == []
# ---------------------------------------------------------------------------
# pgvector get_page_summaries_by_paths — one IN query
# ---------------------------------------------------------------------------
async def test_pg_batch_summaries_single_query_first_row_wins() -> None:
rows = [
("a.py", "Summary of a", {"exports": ["A"]}),
("a.py", "duplicate row ignored", {}),
("b.py", "Summary of b", '{"exports": ["B1", "B2"]}'),
("c.py", "", {}), # empty summary dropped
]
session = _FakeSession(rows=rows)
store = PgVectorStore(_factory(session), MockEmbedder())
out = await store.get_page_summaries_by_paths(["a.py", "b.py", "c.py"])
assert len(session.executed) == 1
stmt, params = session.executed[0]
assert "target_path IN" in stmt
assert params == {"paths": ["a.py", "b.py", "c.py"]}
assert out == {
"a.py": {"summary": "Summary of a", "key_exports": ["A"]},
"b.py": {"summary": "Summary of b", "key_exports": ["B1", "B2"]},
}
async def test_pg_batch_summaries_empty_paths() -> None:
session = _FakeSession()
store = PgVectorStore(_factory(session), MockEmbedder())
assert await store.get_page_summaries_by_paths([]) == {}
assert session.executed == []
def test_summary_payload_matches_single_path_parsing() -> None:
assert _summary_payload("x" * 600, {"exports": ["E"]}) == {
"summary": "x" * 500,
"key_exports": ["E"],
}
assert _summary_payload(None, "not json") == {"summary": "", "key_exports": []}
# ---------------------------------------------------------------------------
# LanceDB IN-filter escaping + optional round-trip
# ---------------------------------------------------------------------------
def test_lancedb_paths_filter_escapes_quotes() -> None:
flt = _paths_in_filter(["a.py", "weird'name.py"])
assert flt == "target_path IN ('a.py', 'weird''name.py')"
@pytest.mark.asyncio
async def test_lancedb_batch_summaries_roundtrip(tmp_path) -> None:
pytest.importorskip("lancedb")
from repowise.core.persistence.vector_store import LanceDBVectorStore
store = LanceDBVectorStore(str(tmp_path / "lance"), MockEmbedder())
try:
await store.embed_batch(
[
("p1", "Summary text for module a", {"target_path": "a.py"}),
("p2", "Summary text for module b", {"target_path": "b.py"}),
("p3", "Summary text for module c", {"target_path": "c.py"}),
]
)
batch = await store.get_page_summaries_by_paths(["a.py", "c.py", "missing.py"])
singles = {p: await store.get_page_summary_by_path(p) for p in ("a.py", "c.py")}
assert set(batch) == {"a.py", "c.py"}
for p in ("a.py", "c.py"):
assert batch[p]["summary"] == singles[p]["summary"]
finally:
await store.close()
@pytest.mark.asyncio
async def test_lancedb_batch_summaries_bounds_in_filter_size(tmp_path) -> None:
class Query:
def __init__(self, filters: list[str]) -> None:
self.filters = filters
def where(self, expression: str):
self.filters.append(expression)
return self
def select(self, _columns: list[str]):
return self
async def to_list(self):
return []
class Table:
def __init__(self) -> None:
self.filters: list[str] = []
def query(self):
return Query(self.filters)
store = LanceDBVectorStore(str(tmp_path / "lance"), MockEmbedder())
table = Table()
store._table = table
async def connected() -> None:
return None
store._ensure_connected = connected # type: ignore[method-assign]
count = _SUMMARY_PATH_BATCH_SIZE * 2 + 7
await store.get_page_summaries_by_paths([f"src/{index}.py" for index in range(count)])
assert len(table.filters) == 3
assert all(expression.count("'src/") <= _SUMMARY_PATH_BATCH_SIZE for expression in table.filters)
# ---------------------------------------------------------------------------
# delete_many — bulk removal of swept page embeddings
# ---------------------------------------------------------------------------
async def test_in_memory_delete_many_removes_only_listed_ids() -> None:
store = InMemoryVectorStore(MockEmbedder())
await store.embed_batch([("p1", "a", {}), ("p2", "b", {}), ("p3", "c", {})])
await store.delete_many(["p1", "p3"])
assert await store.list_page_ids() == {"p2"}
async def test_in_memory_delete_many_empty_is_noop() -> None:
store = InMemoryVectorStore(MockEmbedder())
await store.embed_batch([("p1", "a", {})])
await store.delete_many([])
assert await store.list_page_ids() == {"p1"}
async def test_pg_delete_many_single_update_with_in_params() -> None:
session = _FakeSession()
store = PgVectorStore(_factory(session), MockEmbedder())
await store.delete_many(["p1", "p2", "p3"])
assert len(session.executed) == 1
stmt, params = session.executed[0]
assert "UPDATE wiki_pages SET embedding = NULL" in stmt
assert "id IN" in stmt
assert params == {"ids": ["p1", "p2", "p3"]}
assert session.commits == 1
async def test_pg_delete_many_empty_is_noop() -> None:
session = _FakeSession()
store = PgVectorStore(_factory(session), MockEmbedder())
await store.delete_many([])
assert session.executed == []
assert session.commits == 0
def test_lancedb_page_ids_filter_escapes_quotes() -> None:
flt = _page_ids_in_filter(["module_page:c-1", "weird'id"])
assert flt == "page_id IN ('module_page:c-1', 'weird''id')"
@pytest.mark.asyncio
async def test_lancedb_delete_many_roundtrip(tmp_path) -> None:
pytest.importorskip("lancedb")
from repowise.core.persistence.vector_store import LanceDBVectorStore
store = LanceDBVectorStore(str(tmp_path / "lance"), MockEmbedder())
try:
await store.embed_batch(
[
("p1", "module a", {"target_path": "a.py"}),
("p2", "module b", {"target_path": "b.py"}),
("p3", "module c", {"target_path": "c.py"}),
]
)
await store.delete_many(["p1", "p3"])
assert await store.list_page_ids() == {"p2"}
# empty list is a no-op
await store.delete_many([])
assert await store.list_page_ids() == {"p2"}
finally:
await store.close()