bvandeusen
e6c89f6b88
execution_options() is a coroutine on AsyncConnection and must be awaited; the un-awaited call returned a coroutine, so exec_driver_sql() blew up with AttributeError and every table's VACUUM was skipped (Run-now reported 0/6). A prior change had wrongly dropped the await. Fix it and make the test mock execution_options async so this call shape is actually exercised. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
125 lines
4.9 KiB
Python
125 lines
4.9 KiB
Python
"""Tests for services/db_maintenance.py — mocks the engine (no real DB).
|
|
|
|
Verifies that VACUUM (ANALYZE) is issued once per allowlisted table, that the
|
|
allowlist is closed (an arbitrary name can't be vacuumed), and that a single
|
|
table failure doesn't abort the rest of the sweep.
|
|
"""
|
|
from unittest.mock import AsyncMock, MagicMock, patch
|
|
|
|
import pytest
|
|
|
|
from scribe.services.db_maintenance import MAINTENANCE_TABLES, run_maintenance
|
|
|
|
|
|
def _mock_engine(exec_side_effect=None):
|
|
"""An engine whose connect() yields a conn with a recording exec_driver_sql."""
|
|
conn = MagicMock()
|
|
autocommit = MagicMock()
|
|
autocommit.exec_driver_sql = AsyncMock(side_effect=exec_side_effect)
|
|
# On AsyncConnection, execution_options() is a coroutine — mock it as async
|
|
# so the test exercises the real (awaited) call shape.
|
|
conn.execution_options = AsyncMock(return_value=autocommit)
|
|
cm = AsyncMock()
|
|
cm.__aenter__ = AsyncMock(return_value=conn)
|
|
cm.__aexit__ = AsyncMock(return_value=False)
|
|
engine = MagicMock()
|
|
engine.connect.return_value = cm
|
|
return engine, autocommit
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_vacuums_each_allowlisted_table_once():
|
|
engine, autocommit = _mock_engine()
|
|
with patch("scribe.services.db_maintenance.engine", engine), \
|
|
patch("scribe.services.db_maintenance.set_admin_setting", AsyncMock()):
|
|
summary = await run_maintenance()
|
|
|
|
issued = [c.args[0] for c in autocommit.exec_driver_sql.await_args_list]
|
|
assert issued == [f"VACUUM (ANALYZE) {t}" for t in MAINTENANCE_TABLES]
|
|
assert all(r["ok"] for r in summary["tables"])
|
|
assert len(summary["tables"]) == len(MAINTENANCE_TABLES)
|
|
# AUTOCOMMIT was requested (and awaited) — VACUUM can't run in a transaction.
|
|
conn = engine.connect.return_value.__aenter__.return_value
|
|
conn.execution_options.assert_awaited_once_with(isolation_level="AUTOCOMMIT")
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_allowlist_is_closed():
|
|
"""A caller-supplied name not on the allowlist is silently ignored."""
|
|
engine, autocommit = _mock_engine()
|
|
with patch("scribe.services.db_maintenance.engine", engine), \
|
|
patch("scribe.services.db_maintenance.set_admin_setting", AsyncMock()):
|
|
summary = await run_maintenance(tables=["app_logs", "users; DROP TABLE notes"])
|
|
|
|
issued = [c.args[0] for c in autocommit.exec_driver_sql.await_args_list]
|
|
assert issued == ["VACUUM (ANALYZE) app_logs"]
|
|
assert [r["table"] for r in summary["tables"]] == ["app_logs"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_one_table_failure_does_not_abort_the_rest():
|
|
# First table raises, the remaining tables still get vacuumed.
|
|
calls = {"n": 0}
|
|
|
|
def flaky(_sql):
|
|
calls["n"] += 1
|
|
if calls["n"] == 1:
|
|
raise RuntimeError("boom")
|
|
return MagicMock()
|
|
|
|
engine, autocommit = _mock_engine(exec_side_effect=flaky)
|
|
with patch("scribe.services.db_maintenance.engine", engine), \
|
|
patch("scribe.services.db_maintenance.set_admin_setting", AsyncMock()):
|
|
summary = await run_maintenance()
|
|
|
|
assert autocommit.exec_driver_sql.await_count == len(MAINTENANCE_TABLES)
|
|
assert summary["tables"][0]["ok"] is False
|
|
assert summary["tables"][0]["error"] == "boom"
|
|
assert all(r["ok"] for r in summary["tables"][1:])
|
|
|
|
|
|
def _health_session(db_bytes, rows):
|
|
s = AsyncMock()
|
|
s.__aenter__ = AsyncMock(return_value=s)
|
|
s.__aexit__ = AsyncMock(return_value=False)
|
|
size_res = MagicMock()
|
|
size_res.scalar.return_value = db_bytes
|
|
rows_res = MagicMock()
|
|
rows_res.mappings.return_value.all.return_value = rows
|
|
s.execute = AsyncMock(side_effect=[size_res, rows_res])
|
|
return s
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_table_health_shapes_rows_and_db_size():
|
|
from datetime import datetime, timezone
|
|
|
|
from scribe.services.db_maintenance import get_table_health
|
|
vac = datetime(2026, 6, 14, 4, 0, tzinfo=timezone.utc)
|
|
rows = [
|
|
{"table_name": "notes", "live": 1000, "dead": 300, "dead_pct": 23.1,
|
|
"total_bytes": 5_000_000, "mod_since_analyze": 50,
|
|
"last_vacuum": vac, "last_analyze": None},
|
|
]
|
|
with patch("scribe.services.db_maintenance.async_session",
|
|
return_value=_health_session(42_000_000, rows)):
|
|
health = await get_table_health()
|
|
|
|
assert health["db_bytes"] == 42_000_000
|
|
t = health["tables"][0]
|
|
assert t["table"] == "notes"
|
|
assert t["dead_pct"] == 23.1
|
|
assert t["last_vacuum"] == vac.isoformat()
|
|
assert t["last_analyze"] is None # null timestamp passes through as None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_summary_is_persisted_as_admin_setting():
|
|
engine, _ = _mock_engine()
|
|
setter = AsyncMock()
|
|
with patch("scribe.services.db_maintenance.engine", engine), \
|
|
patch("scribe.services.db_maintenance.set_admin_setting", setter):
|
|
await run_maintenance()
|
|
setter.assert_awaited_once()
|
|
assert setter.await_args.args[0] == "db_maintenance_last_run"
|