126 lines
4.7 KiB
Python
126 lines
4.7 KiB
Python
"""Tests for the state.db runtime connection self-heal (PR #82280 remainder).
|
|
|
|
Covers the two independently-valuable pieces salvaged from the state.db
|
|
hardening rollup:
|
|
|
|
* one-shot reconnect when a live write connection reports
|
|
``file is not a database`` (backing file replaced/truncated by a sibling
|
|
process — the connection is broken, the on-disk file may be healthy);
|
|
* transient ``disk i/o error`` retry in ``_on_disk_journal_mode`` so a
|
|
one-shot EIO doesn't push callers onto the fail-closed unknown-mode branch.
|
|
"""
|
|
|
|
import sqlite3
|
|
from unittest.mock import MagicMock
|
|
|
|
import pytest
|
|
|
|
from hermes_state import SessionDB, _is_not_a_database_error, _on_disk_journal_mode
|
|
|
|
|
|
class _NotADbOnce:
|
|
"""Connection proxy that raises 'file is not a database' on execute."""
|
|
|
|
def __init__(self, real_conn):
|
|
self._real = real_conn
|
|
|
|
def execute(self, *args, **kwargs):
|
|
raise sqlite3.DatabaseError("file is not a database")
|
|
|
|
def __getattr__(self, name):
|
|
return getattr(self._real, name)
|
|
|
|
|
|
class TestIsNotADatabaseError:
|
|
def test_matches_sqlite_message(self):
|
|
assert _is_not_a_database_error(
|
|
sqlite3.DatabaseError("file is not a database")
|
|
)
|
|
|
|
def test_rejects_other_database_errors(self):
|
|
assert not _is_not_a_database_error(
|
|
sqlite3.DatabaseError("database disk image is malformed")
|
|
)
|
|
|
|
def test_rejects_non_sqlite_exceptions(self):
|
|
assert not _is_not_a_database_error(ValueError("file is not a database"))
|
|
|
|
|
|
class TestReconnectAfterNotADb:
|
|
def test_write_self_heals_when_connection_breaks(self, tmp_path):
|
|
"""A broken connection over a healthy file reconnects and retries."""
|
|
db = SessionDB(db_path=tmp_path / "state.db")
|
|
try:
|
|
db.create_session(session_id="s1", source="cli", model="test")
|
|
# Simulate the runtime corruption class: the connection starts
|
|
# raising 'file is not a database' while the on-disk file is
|
|
# perfectly healthy (sibling replaced/truncated the old inode).
|
|
db._conn = _NotADbOnce(db._conn)
|
|
|
|
db.create_session(session_id="s2", source="cli", model="test")
|
|
|
|
assert db._notadb_reconnect_attempted is True
|
|
assert db.get_session("s2") is not None
|
|
# The pre-existing row survived (same on-disk file).
|
|
assert db.get_session("s1") is not None
|
|
finally:
|
|
db.close()
|
|
|
|
def test_reconnect_is_one_shot(self, tmp_path):
|
|
"""A second 'file is not a database' propagates instead of looping."""
|
|
db = SessionDB(db_path=tmp_path / "state.db")
|
|
try:
|
|
db._notadb_reconnect_attempted = True
|
|
db._conn = _NotADbOnce(db._conn)
|
|
with pytest.raises(sqlite3.DatabaseError, match="not a database"):
|
|
db.create_session(session_id="s3", source="cli", model="test")
|
|
finally:
|
|
db._conn = None
|
|
db.close()
|
|
|
|
def test_failed_reconnect_returns_false_and_original_error_propagates(
|
|
self, tmp_path, monkeypatch
|
|
):
|
|
"""If the reopen itself fails, the original write error surfaces."""
|
|
db = SessionDB(db_path=tmp_path / "state.db")
|
|
try:
|
|
monkeypatch.setattr(
|
|
"hermes_state._connect_tracked_db",
|
|
MagicMock(side_effect=sqlite3.DatabaseError("file is not a database")),
|
|
)
|
|
db._conn = _NotADbOnce(db._conn)
|
|
with pytest.raises(sqlite3.DatabaseError, match="not a database"):
|
|
db.create_session(session_id="s4", source="cli", model="test")
|
|
assert db._notadb_reconnect_attempted is True
|
|
finally:
|
|
db._conn = None
|
|
db.close()
|
|
|
|
|
|
class TestOnDiskJournalModeEioRetry:
|
|
def _conn_raising_then(self, failures, result_rows):
|
|
conn = MagicMock()
|
|
cursor = MagicMock()
|
|
cursor.fetchone.return_value = result_rows
|
|
conn.execute.side_effect = list(failures) + [cursor]
|
|
return conn
|
|
|
|
def test_transient_eio_clears_on_retry(self):
|
|
conn = self._conn_raising_then(
|
|
[sqlite3.OperationalError("disk i/o error")] * 2, ("wal",)
|
|
)
|
|
assert _on_disk_journal_mode(conn) == "wal"
|
|
|
|
def test_persistent_eio_returns_none(self):
|
|
conn = MagicMock()
|
|
conn.execute.side_effect = sqlite3.OperationalError("disk i/o error")
|
|
assert _on_disk_journal_mode(conn) is None
|
|
# Bounded: retried a handful of times, not forever.
|
|
assert conn.execute.call_count == 4
|
|
|
|
def test_non_eio_operational_error_fails_fast(self):
|
|
conn = MagicMock()
|
|
conn.execute.side_effect = sqlite3.OperationalError("database is locked")
|
|
assert _on_disk_journal_mode(conn) is None
|
|
assert conn.execute.call_count == 1
|