Import AITURK IDE 1.0.0-beta.1 from Hermes 63279301; preserve MIT license

tests/state/test_append_message_after_close_94736.py

@@ -0,0 +1,125 @@
+"""Regression tests for #94736 — append_message after close() raced a live writer.
+
+Subagent/cron sessions were dying mid-run with ``Session DB append_message
+failed: 'NoneType' object has no attribute 'execute'``: a teardown owner
+(cron ``run_job``'s ``finally`` block, a delegate timeout owner abandoning
+its worker, ``AIAgent.close()``) called ``SessionDB.close()`` — which nulls
+``_conn`` — while a still-unwinding worker thread had one more transcript
+flush to land. ``_execute_write`` then hit ``None.execute`` and the
+conversation loop force-ended the turn as ``session_persistence_failed``,
+silently dropping the tail of the session.
+
+The fix self-heals at the shared persistence boundary: when ``_conn`` is
+``None`` (only possible after an explicit ``close()``), the writer reopens
+a connection to the same database file with a loud WARNING, and the write
+lands. These tests exercise the REAL SessionDB against a real sqlite file —
+no mocks of the code under test.
+"""
+
+import logging
+import threading
+
+import pytest
+
+from hermes_state import SessionDB
+
+
+@pytest.fixture
+def db(tmp_path):
+    d = SessionDB(db_path=tmp_path / "state.db")
+    yield d
+    d.close()
+
+
+class TestAppendAfterClose:
+    def test_append_message_after_close_reopens_and_lands(self, db, caplog):
+        """The exact #94736 shape: close() then one more transcript flush."""
+        db.create_session("s1", "cli")
+        db.append_message("s1", "user", content="hello")
+
+        db.close()
+        assert db._conn is None
+
+        with caplog.at_level(logging.WARNING, logger="hermes_state"):
+            msg_id = db.append_message(
+                "s1", "assistant", content="flushed after teardown"
+            )
+
+        assert isinstance(msg_id, int) and msg_id > 0
+        rows = db.get_messages("s1")
+        assert [r["role"] for r in rows] == ["user", "assistant"]
+        assert rows[-1]["content"] == "flushed after teardown"
+        # The recovery is loud, not silent.
+        assert any("reopening" in r.message for r in caplog.records)
+
+    def test_reopened_connection_survives_subsequent_writes_and_close(self, db):
+        """The reopened handle is a full writer: more appends work, and a
+        second close() releases it cleanly (idempotent contract)."""
+        db.create_session("s1", "cli")
+        db.close()
+
+        db.append_message("s1", "user", content="a")
+        db.append_message("s1", "assistant", content="b")
+        assert len(db.get_messages("s1")) == 2
+
+        db.close()
+        assert db._conn is None
+        db.close()  # idempotent
+
+    def test_read_after_close_recovers_too(self, db):
+        """The locked-read fallback path shares the same guard: a read that
+        lands after close() must not die on None.execute either."""
+        db.create_session("s1", "cli")
+        db.append_message("s1", "user", content="hello")
+        db.close()
+
+        rows = db.get_messages("s1")
+        assert len(rows) == 1
+
+    def test_concurrent_close_during_flush_loses_no_writes(self, tmp_path):
+        """Race a teardown close() against a worker mid-flush (the cron
+        inactivity-timeout shape): every append must land or raise loudly —
+        never vanish into a swallowed NoneType error."""
+        db = SessionDB(db_path=tmp_path / "state.db")
+        db.create_session("s1", "cli")
+
+        n_writes = 40
+        start = threading.Event()
+        errors: list = []
+
+        def _worker():
+            start.wait()
+            for i in range(n_writes):
+                try:
+                    db.append_message("s1", "tool", content=f"result {i}")
+                except Exception as exc:  # pragma: no cover - failure path
+                    errors.append(exc)
+
+        t = threading.Thread(target=_worker)
+        t.start()
+        start.set()
+        # Teardown owner closes mid-flight, twice for good measure.
+        db.close()
+        db.close()
+        t.join(timeout=30)
+        assert not t.is_alive()
+
+        assert errors == [], f"appends died during teardown race: {errors!r}"
+        rows = db.get_messages("s1")
+        assert len(rows) == n_writes
+        db.close()
+
+    def test_read_only_handle_still_refuses_after_close(self, tmp_path):
+        """A read-only cross-profile handle must NOT silently reopen — it
+        raises an explicit error naming the closed handle."""
+        # Initialise a real DB first with a writable handle.
+        writer = SessionDB(db_path=tmp_path / "state.db")
+        writer.create_session("s1", "cli")
+        writer.append_message("s1", "user", content="hello")
+        writer.close()
+
+        ro = SessionDB(db_path=tmp_path / "state.db", read_only=True)
+        ro.close()
+        with pytest.raises(Exception) as excinfo:
+            ro.get_messages("s1")
+        assert "closed" in str(excinfo.value).lower()