Files
mempalace/tests/test_palace.py
T
mvalentsev c933095a2f fix(palace): stratify state messages for empty/missing palace (#1498)
`mempalace status`, `search`, and `compress` printed the same misleading
"No palace found / Run: mempalace init" output for three distinct
palace states (no dir / no DB / no collection). Most user-visible on
the first-run state where `init` had run but `mine` had not: the hint
to re-run `init` is a no-op and wastes the user's time.

Backend gets a new typed exception `CollectionNotInitializedError`
(subclass of `PalaceNotFoundError`, transitively `FileNotFoundError`,
so legacy callers keep working). `ChromaBackend.get_collection(
create=False)` wraps chromadb's bare `NotFoundError` as the new typed
exception instead of leaking the chromadb-specific class to callers.

A new internal helper `_open_collection_or_explain` in `palace.py`
runs filesystem-first state checks before the backend call to avoid
chromadb's lazy `chroma.sqlite3` creation as a side-effect of a
read-only inspection, then catches the typed exceptions and prints a
state-specific actionable message. `BackendClosedError` is explicitly
re-raised so a programmer error is not masked as a UX hint.

Two CLI bug sites route through the helper: `miner.status` and
`cli.cmd_compress`. `searcher.search` catches the typed exceptions
directly so it can preserve the cause chain in `SearchError(...) from
e` for programmatic search-API consumers. `cli.cmd_sync` gained an
inline filesystem distinction (no helper needed: it does not use the
collection handle). `repair.status` (capacity check, which by design
must work on corrupted palaces without opening a chromadb client) got
the same distinction via `sqlite_drawer_count`-based empty detection.
The MCP `tool_status` is intentionally left alone: PR #831 already
fixed it there with a `create=True` bootstrap strategy appropriate
for programmatic clients.
2026-05-17 03:57:19 +05:00

171 lines
5.9 KiB
Python

"""Tests for mempalace.palace shared helpers."""
import chromadb
from mempalace.backends import CollectionNotInitializedError, PalaceNotFoundError
from mempalace.palace import _open_collection_or_explain, get_collection
def _capture():
"""Return (emit, lines) — emit appends to lines for inspection."""
lines: list[str] = []
return lines.append, lines
def test_open_collection_or_explain_state_a_missing_dir(tmp_path):
"""State A: palace dir does not exist."""
emit, lines = _capture()
missing = tmp_path / "no-such-palace"
result = _open_collection_or_explain(str(missing), out=emit)
assert result is None
assert any("No palace found" in line for line in lines)
assert any("mempalace init" in line for line in lines)
# Helper must not create the directory.
assert not missing.exists()
def test_open_collection_or_explain_state_b_no_db(tmp_path):
"""State B: dir exists but chroma.sqlite3 does not.
Critical invariant: the helper must NOT trigger chromadb's lazy DB
creation by reaching the backend. The dir must remain empty after
the call so a read-only inspection stays read-only.
"""
emit, lines = _capture()
palace = tmp_path / "palace"
palace.mkdir()
assert not (palace / "chroma.sqlite3").exists()
result = _open_collection_or_explain(str(palace), out=emit)
assert result is None
assert any("has no chroma.sqlite3 yet" in line for line in lines)
# No side-effect: backend was not invoked.
assert list(palace.iterdir()) == []
def test_open_collection_or_explain_state_c_no_collection(tmp_path):
"""State C: DB file exists but the collection has never been created."""
emit, lines = _capture()
palace = tmp_path / "palace"
palace.mkdir()
chromadb.PersistentClient(path=str(palace)) # creates DB, no collection
assert (palace / "chroma.sqlite3").is_file()
result = _open_collection_or_explain(str(palace), out=emit)
assert result is None
assert any("initialized but empty" in line for line in lines)
assert any("mempalace mine" in line for line in lines)
def test_open_collection_or_explain_state_d_healthy(tmp_path):
"""State D: healthy palace — returns the opened collection silently."""
emit, lines = _capture()
palace = tmp_path / "palace"
palace.mkdir()
get_collection(str(palace), create=True) # bootstrap collection
result = _open_collection_or_explain(str(palace), out=emit)
assert result is not None
assert lines == [] # healthy path is silent
def test_open_collection_or_explain_state_e_unexpected_error(tmp_path, monkeypatch):
"""State E: unexpected error opening the backend routes to repair hint."""
emit, lines = _capture()
palace = tmp_path / "palace"
palace.mkdir()
(palace / "chroma.sqlite3").touch() # pass the isfile guard
def boom(*args, **kwargs):
raise RuntimeError("disk on fire")
monkeypatch.setattr("mempalace.palace.get_collection", boom)
result = _open_collection_or_explain(str(palace), out=emit)
assert result is None
assert any("Error opening palace" in line for line in lines)
assert any("repair-status" in line for line in lines)
def test_open_collection_or_explain_default_sink_is_print(tmp_path, capsys):
"""When out is None, messages go through builtin print → stdout."""
missing = tmp_path / "no-such-palace"
result = _open_collection_or_explain(str(missing))
assert result is None
assert "No palace found" in capsys.readouterr().out
def test_open_collection_or_explain_propagates_palace_not_found_from_backend(tmp_path, monkeypatch):
"""If the backend raises bare PalaceNotFoundError after our filesystem
guards (rare race or backend-internal "not found"), the helper still
prints the State A message and returns None."""
emit, lines = _capture()
palace = tmp_path / "palace"
palace.mkdir()
(palace / "chroma.sqlite3").touch()
def raise_pnf(*args, **kwargs):
raise PalaceNotFoundError(str(palace))
monkeypatch.setattr("mempalace.palace.get_collection", raise_pnf)
result = _open_collection_or_explain(str(palace), out=emit)
assert result is None
assert any("No palace found" in line for line in lines)
def test_open_collection_or_explain_reraises_backend_closed_error(tmp_path, monkeypatch):
"""BackendClosedError is a programmer error (caller violated the backend
lifecycle), not a palace-state UX condition. The helper must propagate
it instead of swallowing it into the State E "repair-status" hint.
Without this re-raise, a closed default backend would silently mask
every call site as "Error opening palace ... Try: repair-status"
even when the actual fix is to stop using a closed backend handle.
"""
from mempalace.backends import BackendClosedError
palace = tmp_path / "palace"
palace.mkdir()
(palace / "chroma.sqlite3").touch()
def raise_closed(*args, **kwargs):
raise BackendClosedError("ChromaBackend has been closed")
monkeypatch.setattr("mempalace.palace.get_collection", raise_closed)
import pytest
with pytest.raises(BackendClosedError):
_open_collection_or_explain(str(palace))
def test_open_collection_or_explain_distinguishes_collection_subclass(tmp_path, monkeypatch):
"""The helper must surface CollectionNotInitializedError as the
'empty' message rather than the broader 'No palace found' message,
even though the former subclasses the latter."""
emit, lines = _capture()
palace = tmp_path / "palace"
palace.mkdir()
(palace / "chroma.sqlite3").touch()
def raise_cnie(*args, **kwargs):
raise CollectionNotInitializedError(str(palace))
monkeypatch.setattr("mempalace.palace.get_collection", raise_cnie)
result = _open_collection_or_explain(str(palace), out=emit)
assert result is None
assert any("initialized but empty" in line for line in lines)
assert not any("No palace found" in line for line in lines)