Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
import asyncio
import json
import sqlite3
import threading
from contextlib import closing, suppress
from unittest.mock import AsyncMock, Mock, patch
import pytest
import pytest_asyncio
from free_claude_code.messaging.models import IncomingMessage, MessageScope
from free_claude_code.messaging.trees import MessagingStorageError, TreeQueueManager
from free_claude_code.messaging.trees.snapshot import TreeSnapshot
from free_claude_code.messaging.workflow import MessagingWorkflow
from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStore
from free_claude_code.runtime.messaging_import import import_legacy
from free_claude_code.runtime.messaging_sqlite import SQLiteMessagingStore
from free_claude_code.runtime.sqlite_database import SQLiteDatabase
pytestmark = pytest.mark.asyncio
def tree(platform="telegram", chat="chat", root="root"):
return TreeSnapshot(
scope=MessageScope(platform=platform, chat_id=chat),
root_id=root,
nodes={
root: {
"node_id": root,
"status_message_id": f"status-{root}",
"state": "completed",
"parent_id": None,
"parent_reference_id": None,
"session_id": "native-session",
}
},
)
@pytest_asyncio.fixture
async def storage(tmp_path):
database = SQLiteDatabase(tmp_path / "fcc.db", tmp_path / "code.lock")
await database.start()
try:
yield SQLiteMessagingStore(database, managed_message_cap=2)
finally:
await database.close()
async def test_tree_and_managed_messages_are_durable_and_scope_isolated(storage):
first, second = tree(), tree("discord")
await storage.commit_trees((first, second))
for message in ("one", "two", "two", "three"):
await storage.record_message_id("telegram", "chat", message, "in", "prompt")
assert await storage.get_tracked_message_ids_for_chat("telegram", "chat") == [
"two",
"three",
]
await storage.commit_trees((), clear_scope=first.scope)
loaded = await storage.load_conversation_snapshot()
assert list(loaded.trees) == [second.identity]
assert loaded.trees[second.identity].nodes["root"]["session_id"] == "native-session"
assert not await storage.get_tracked_message_ids_for_chat("telegram", "chat")
async def test_reference_collision_rolls_back_whole_write(storage):
original = tree()
await storage.commit_trees((original,))
collision = tree(root="status-root")
with pytest.raises(MessagingStorageError) as failure:
await storage.commit_trees((collision,))
assert isinstance(failure.value.__cause__, sqlite3.IntegrityError)
assert (await storage.load_conversation_snapshot()).trees == {
original.identity: original
}
@pytest.mark.parametrize("damaged", [False, True])
async def test_import_keeps_valid_data_and_never_replays_after_clear(
storage, tmp_path, damaged
):
source = tmp_path / "sessions.json"
valid = tree()
source.write_text(
json.dumps(
{
"conversation": {
"trees": [valid.to_json(), *([{"broken": True}] if damaged else [])]
}
}
)
)
warning = await import_legacy(storage.database, source)
assert bool(warning) is damaged
assert source.exists() is damaged
assert (await storage.load_conversation_snapshot()).trees == {valid.identity: valid}
await storage.commit_trees((), clear_scope=valid.scope)
assert await import_legacy(storage.database, source) is None
assert (await storage.load_conversation_snapshot()).is_empty
async def test_unreadable_json_does_not_block_new_conversations(storage, tmp_path):
source = tmp_path / "sessions.json"
source.write_text('{"conversation":')
assert await import_legacy(storage.database, source)
assert source.read_text() == '{"conversation":'
await storage.commit_trees((tree(),))
assert not (await storage.load_conversation_snapshot()).is_empty
assert await import_legacy(storage.database, source) is None
async def test_pending_import_keeps_restart_repair_information(storage, tmp_path):
pending = tree()
pending.nodes["root"]["state"] = "in_progress"
source = tmp_path / "sessions.json"
source.write_text(json.dumps(pending_to_legacy(pending)))
await import_legacy(storage.database, source)
assert (await storage.load_conversation_snapshot()).trees[pending.identity].nodes[
"root"
]["state"] == "in_progress"
def pending_to_legacy(snapshot):
return {"trees": {snapshot.root_id: snapshot.to_json()}}
async def test_new_schema_preserves_foreign_keys(storage):
await storage.commit_trees((tree(),))
with closing(sqlite3.connect(storage.database.path)) as connection:
assert connection.execute("PRAGMA foreign_key_check").fetchall() == []
async def test_sqlite_prevents_deleting_a_root_without_its_tree(storage):
original = tree()
await storage.commit_trees((original,))
with pytest.raises(sqlite3.IntegrityError):
await storage.database.run(
lambda connection: connection.execute("DELETE FROM messaging_nodes")
)
assert (await storage.load_conversation_snapshot()).trees == {
original.identity: original
}
@pytest.mark.parametrize("wrapped", [False, True])
@pytest.mark.parametrize("dictionary", [False, True])
async def test_historical_formats_and_message_log_preserve_resume_and_order(
storage, tmp_path, wrapped, dictionary
):
original = tree()
legacy = original.to_json()
del legacy["scope"]
legacy["nodes"]["root"]["incoming"] = {"platform": "telegram", "chat_id": "chat"}
trees = {"old": legacy} if dictionary else [legacy]
conversation = {"trees": trees}
payload = {"conversation": conversation} if wrapped else conversation
payload["message_log"] = {
"telegram:chat": [
{"message_id": value, "direction": "out", "kind": "notice"}
for value in (1, 2, 2, 3)
]
}
source = tmp_path / "sessions.json"
source.write_text(json.dumps(payload))
assert await import_legacy(storage.database, source) is None
assert not source.exists()
loaded = (await storage.load_conversation_snapshot()).trees[original.identity]
assert loaded.nodes["root"]["session_id"] == "native-session"
await storage.trim()
assert await storage.get_tracked_message_ids_for_chat("telegram", "chat") == [
"2",
"3",
]
async def test_cleanup_failure_cannot_resurrect_cleared_history(storage, tmp_path):
source = tmp_path / "sessions.json"
original = tree()
source.write_text(json.dumps(pending_to_legacy(original)))
with patch.object(type(source), "unlink", side_effect=PermissionError("busy")):
assert await import_legacy(storage.database, source)
assert source.exists()
await storage.commit_trees((), clear_scope=original.scope)
assert await import_legacy(storage.database, source) is None
assert not source.exists()
assert (await storage.load_conversation_snapshot()).is_empty
async def test_invalid_graph_and_invalid_log_entry_do_not_discard_good_records(
storage, tmp_path
):
original, invalid = tree(), tree(root="bad")
invalid.nodes["bad"]["parent_id"] = "missing"
source = tmp_path / "sessions.json"
source.write_text(
json.dumps(
{
"trees": [original.to_json(), invalid.to_json()],
"managed_messages": {
"discord:other": [
{"message_id": "good", "direction": "in", "kind": "prompt"},
{"message_id": "bad"},
]
},
}
)
)
assert await import_legacy(storage.database, source)
assert source.exists()
assert list((await storage.load_conversation_snapshot()).trees) == [
original.identity
]
assert await storage.get_tracked_message_ids_for_chat("discord", "other") == [
"good"
]
async def test_failed_import_transaction_keeps_source_and_allows_retry(
storage, tmp_path
):
from free_claude_code.runtime.messaging_sqlite import write_tree
source = tmp_path / "sessions.json"
source.write_text(
json.dumps({"trees": [tree().to_json(), tree(root="second").to_json()]})
)
def fail_second_tree(connection, snapshot):
write_tree(connection, snapshot)
if snapshot.root_id == "second":
raise sqlite3.OperationalError("disk failure")
with (
patch(
"free_claude_code.runtime.messaging_import.write_tree",
side_effect=fail_second_tree,
),
pytest.raises(sqlite3.OperationalError),
):
await import_legacy(storage.database, source)
assert source.exists()
assert (await storage.load_conversation_snapshot()).is_empty
assert (
await storage.database.run(
lambda connection: connection.execute(
"SELECT count(*) FROM messaging_legacy_import"
).fetchone()[0],
write=False,
)
== 0
)
assert await import_legacy(storage.database, source) is None
assert not source.exists()
def incoming(node, *, text="prompt"):
return IncomingMessage(
platform="telegram", chat_id="chat", message_id=node, user_id="user", text=text
)
async def import_receipt(database):
return await database.run(
lambda connection: dict(
connection.execute("SELECT * FROM messaging_legacy_import").fetchone()
),
write=False,
)
@pytest.mark.parametrize(
"field,value",
[
("platform", "\ud800"),
("chat_id", "\ud800"),
("root_id", "\ud800"),
("root_id", "\0root"),
("node_id", "\ud800"),
("node_id", "\0child"),
("status_message_id", "\ud800"),
("status_message_id", "\0status"),
("session_id", "\ud800"),
],
)
async def test_import_rejects_storage_invalid_tree_without_reserving_references(
storage, tmp_path, field, value
):
before, after = tree(root="before"), tree(root="after")
invalid = tree(root=value if field == "root_id" else "bad").to_json()
root = invalid["root_id"]
child = value if field == "node_id" else "child"
invalid["nodes"][child] = {
"node_id": child,
"parent_id": root,
"parent_reference_id": invalid["nodes"][root]["status_message_id"],
"status_message_id": "shared-reference",
"state": "completed",
"session_id": "native-child",
}
if field in {"platform", "chat_id"}:
invalid["scope"][field] = value
elif field not in {"root_id", "node_id"}:
invalid["nodes"][child][field] = value
# A rejected tree must not claim a reference needed by a later valid tree.
after.nodes["after"]["status_message_id"] = "shared-reference"
source = tmp_path / "sessions.json"
original = json.dumps({"trees": [before.to_json(), invalid, after.to_json()]})
source.write_text(original)
assert await import_legacy(storage.database, source)
assert (await storage.load_conversation_snapshot()).trees == {
before.identity: before,
after.identity: after,
}
assert source.read_text() == original
assert await import_receipt(storage.database) == {
"source": "sessions.json",
"outcome": "partial",
"trees": 2,
"messages": 0,
"skipped": 1,
"cleanup_pending": 0,
}
with closing(sqlite3.connect(storage.database.path)) as connection:
assert connection.execute("PRAGMA foreign_key_check").fetchall() == []
assert (
connection.execute("SELECT count(*) FROM messaging_references").fetchone()[
0
]
== 4
)
assert (
connection.execute("SELECT count(*) FROM messaging_trees").fetchone()[0]
== 2
)
@pytest.mark.parametrize("field", ["platform", "chat_id", "message_id", "ts", "kind"])
@pytest.mark.parametrize("value", ["\ud800", "\0kind"])
async def test_import_message_storage_validation_and_successful_duplicate_ownership(
storage, tmp_path, field, value
):
bad = {"message_id": "same", "direction": "in", "kind": "prompt", "ts": "old"}
key = "telegram:chat"
if field == "platform":
key = f"{value}:chat"
elif field == "chat_id":
key = f"telegram:{value}"
else:
bad[field] = value
good = {"message_id": "same", "direction": "out", "kind": "notice", "ts": "new"}
messages = {key: [bad]}
messages.setdefault("telegram:chat", []).extend([good, {**good, "ts": "duplicate"}])
source = tmp_path / "sessions.json"
source.write_text(json.dumps({"managed_messages": messages}))
rejected = value == "\ud800" or field == "kind"
assert bool(await import_legacy(storage.database, source)) is rejected
assert source.exists() is rejected
rows = await storage.database.run(
lambda connection: [
tuple(row)
for row in connection.execute(
"SELECT platform,chat_id,message_id,ts,direction,kind FROM messaging_managed_messages ORDER BY sequence"
)
],
write=False,
)
if rejected:
assert rows == [("telegram", "chat", "same", "new", "out", "notice")]
else:
# NUL is legal in fields without a length CHECK. Preserve accepted text.
assert rows[0] == (
*key.split(":", 1),
bad["message_id"],
bad["ts"],
"in",
bad["kind"],
)
assert len(rows) == (1 if field == "ts" else 2)
receipt = await import_receipt(storage.database)
assert receipt["messages"] == len(rows)
assert receipt["skipped"] == int(rejected)
@pytest.mark.parametrize("last_invalid", [False, True])
async def test_import_last_tree_identity_wins_even_when_unrecoverable(
storage, tmp_path, last_invalid
):
first, last = tree(), tree()
last.nodes["root"]["session_id"] = "\ud800" if last_invalid else "last-session"
source = tmp_path / "sessions.json"
source.write_text(json.dumps({"trees": [first.to_json(), last.to_json()]}))
assert await import_legacy(storage.database, source)
assert (await storage.load_conversation_snapshot()).trees == (
{} if last_invalid else {last.identity: last}
)
assert (await import_receipt(storage.database))["skipped"] == 1 + int(last_invalid)
await storage.commit_trees((tree(root="fresh"),))
async def test_partial_import_survives_reopen_and_clear_without_replay(
storage, tmp_path
):
source = tmp_path / "sessions.json"
source.write_text(
json.dumps(
{
"trees": [tree().to_json()],
"managed_messages": {
"telegram:chat": [
{"message_id": "bad", "direction": "in", "kind": "\0"}
]
},
}
)
)
assert await import_legacy(storage.database, source)
receipt = await import_receipt(storage.database)
await storage.database.close()
for restart in range(2):
database = SQLiteDatabase(storage.database.path, tmp_path / "code.lock")
await database.start()
try:
reopened = SQLiteMessagingStore(database)
assert await import_legacy(database, source) is None
assert await import_receipt(database) == receipt
assert (await reopened.load_conversation_snapshot()).is_empty is bool(
restart
)
await reopened.commit_trees((), clear_scope=tree().scope)
finally:
await database.close()
assert source.exists()
@pytest.mark.parametrize("failure_stage", ["receipt", "commit"])
async def test_import_outer_failure_rolls_back_released_units(
storage, tmp_path, failure_stage
):
source = tmp_path / "sessions.json"
source.write_text(
json.dumps(
{
"trees": [tree().to_json()],
"managed_messages": {
"telegram:chat": [
{"message_id": "one", "direction": "in", "kind": "prompt"}
]
},
}
)
)
transaction = storage.database._transaction
inserted = []
def faulting_transaction(pool, operation, *, write):
def authorize(action, arg1, arg2, database_name, trigger):
if action == sqlite3.SQLITE_INSERT:
inserted.append(arg1)
if failure_stage == "receipt" and arg1 == "messaging_legacy_import":
return sqlite3.SQLITE_DENY
if (
failure_stage == "commit"
and action == sqlite3.SQLITE_TRANSACTION
and arg1 == "COMMIT"
and "messaging_managed_messages" in inserted
):
return sqlite3.SQLITE_DENY
return sqlite3.SQLITE_OK
observed = []
def faulting(connection):
observed.append(connection)
connection.set_authorizer(authorize)
return operation(connection)
result = transaction(pool, faulting, write=write)
# Failed transactions discard their connection; only successful leases
# need the injected connection state restored before another checkout.
for connection in observed:
connection.set_authorizer(None)
return result
await storage.database.run(
lambda connection: connection.execute("SELECT 1").close()
)
with (
patch.object(storage.database, "_transaction", faulting_transaction),
pytest.raises(sqlite3.DatabaseError, match="not authorized"),
):
await import_legacy(storage.database, source)
assert "messaging_nodes" in inserted and "messaging_managed_messages" in inserted
assert source.exists()
assert (await storage.load_conversation_snapshot()).is_empty
assert not await storage.get_tracked_message_ids_for_chat("telegram", "chat")
assert (
await storage.database.run(
lambda connection: connection.execute(
"SELECT count(*) FROM messaging_legacy_import"
).fetchone()[0],
write=False,
)
== 0
)
assert await import_legacy(storage.database, source) is None
assert (await import_receipt(storage.database))["trees"] == 1
assert (await import_receipt(storage.database))["messages"] == 1
@pytest.mark.parametrize("platform", ["none", "telegram"])
async def test_startup_partial_import_preserves_links_scopes_and_code(
storage, tmp_path, platform
):
from free_claude_code.application.code_sessions.models import CodeSession
from free_claude_code.config.settings import Settings
from free_claude_code.runtime.application import ApplicationRuntime
from free_claude_code.runtime.configuration import ConfigurationService
from free_claude_code.runtime.provider_manager import ProviderRuntimeManager
code = SQLiteCodeStore(storage.database)
await code.start()
session = await code.create(
CodeSession(id="saved-code", cwd=str(tmp_path), model="provider/model")
)
valid = tree(root="root-\U0001f600\0suffix")
parent = valid.root_id
for node_id in ("child", "grandchild"):
valid.nodes[node_id] = {
"node_id": node_id,
"status_message_id": f"status-{node_id}",
"parent_id": parent,
"parent_reference_id": valid.nodes[parent]["status_message_id"],
"state": "in_progress",
"session_id": "native-\U0001f600",
}
parent = node_id
inactive = tree("discord", root=valid.root_id)
conflict = tree(root="status-child")
source = tmp_path / "sessions.json"
source.write_text(
json.dumps(
{
"trees": [valid.to_json(), conflict.to_json(), inactive.to_json()],
"managed_messages": {
"telegram:chat": [
{
"message_id": str(index),
"direction": "in",
"kind": "\0" if index == 0 else "prompt",
}
for index in range(4)
]
},
}
)
)
manager = ProviderRuntimeManager(
Settings().model_copy(
update={
"messaging_platform": platform,
"max_message_log_entries_per_chat": 2,
}
)
)
runtime = ApplicationRuntime(
manager,
configuration=AsyncMock(spec=ConfigurationService),
transcriber=None,
database=storage.database,
)
try:
with patch(
"free_claude_code.runtime.messaging_service.messaging_state_dir_path",
return_value=str(tmp_path),
):
await runtime._messaging._initialize_messaging_storage()
assert runtime._messaging._messaging_storage_error is None
assert runtime._messaging._messaging_warning
assert (await storage.load_conversation_snapshot()).trees == {
valid.identity: valid,
inactive.identity: inactive,
}
assert await storage.get_tracked_message_ids_for_chat("telegram", "chat") == [
"2",
"3",
]
assert (await import_receipt(storage.database))["skipped"] == 2
assert (await import_receipt(storage.database))["messages"] == 3
assert await code.get_session(session.id) == session
assert (
await storage.database.run(
lambda connection: connection.execute(
"PRAGMA foreign_key_check"
).fetchall(),
write=False,
)
== []
)
finally:
await manager.close()
await code.close()
async def test_failed_admission_never_launches_harness_or_publishes_memory(storage):
processor = AsyncMock()
manager = TreeQueueManager(processor, store=storage)
with (
patch.object(
storage, "commit_trees", side_effect=sqlite3.OperationalError("disk full")
),
pytest.raises(sqlite3.OperationalError),
):
await manager.admit(incoming("new"), "status-new")
assert manager.get_tree_count() == 0
assert manager.task_count() == 0
processor.assert_not_awaited()
assert (await storage.load_conversation_snapshot()).is_empty
async def test_failed_clear_restores_runtime_prompts_queue_and_claim(storage):
started, release = asyncio.Event(), asyncio.Event()
prompts = []
async def process(claim):
prompts.append(claim.prompt)
started.set()
await release.wait()
await manager.complete_claim(claim, "resumable")
manager = TreeQueueManager(process, store=storage)
root = await manager.admit(incoming("root", text="first"), "status-root")
assert root.claim is not None
await started.wait()
await manager.admit(
incoming("child", text="second"),
"status-child",
parent_reference_id="status-root",
)
try:
with (
patch.object(
storage,
"commit_trees",
side_effect=sqlite3.OperationalError("disk full"),
),
pytest.raises(sqlite3.OperationalError),
):
await manager.clear_scope(root.claim.identity.scope)
assert manager.task_count() == 1
assert (
len(
(await storage.load_conversation_snapshot())
.trees[root.claim.identity]
.nodes
)
== 2
)
finally:
release.set()
await asyncio.wait_for(manager.wait_idle(), 5)
assert prompts == ["first", "second"]
child = await manager.get_node(root.claim.identity.scope, "child")
assert child is not None and child.session_id == "resumable"
async def test_status_subtree_delete_preserves_prompt_sibling_branch(storage):
original = tree()
for node, reference in (("status-reply", "status-root"), ("prompt-reply", "root")):
original.nodes[node] = {
"node_id": node,
"status_message_id": f"status-{node}",
"state": "completed",
"parent_id": "root",
"parent_reference_id": reference,
"session_id": node,
}
await storage.commit_trees((original,))
manager = TreeQueueManager.from_snapshot(
await storage.load_conversation_snapshot(), AsyncMock(), store=storage
)
await manager.remove_message_subtree(original.scope, "status-root")
persisted = (await storage.load_conversation_snapshot()).trees[original.identity]
assert set(persisted.nodes) == {"root", "prompt-reply"}
assert persisted.nodes["root"]["status_message_id"] is None
assert persisted.nodes["root"]["session_id"] is None
assert persisted.nodes["prompt-reply"]["parent_reference_id"] == "root"
async def test_failure_after_scope_delete_rolls_back_both_trees_and_message_log(
storage,
):
original = tree()
await storage.commit_trees((original,))
await storage.record_message_id("telegram", "chat", "tracked", "out", "notice")
invalid = tree(root="invalid")
invalid.nodes["invalid"]["state"] = "not-a-state"
with pytest.raises(ValueError):
await storage.commit_trees((invalid,), clear_scope=original.scope)
assert (await storage.load_conversation_snapshot()).trees == {
original.identity: original
}
assert await storage.get_tracked_message_ids_for_chat("telegram", "chat") == [
"tracked"
]
async def test_code_close_does_not_release_shared_database(storage, tmp_path):
code = SQLiteCodeStore(storage.database)
await code.start()
await code.close()
other = SQLiteDatabase(tmp_path / "fcc.db", tmp_path / "code.lock")
try:
with pytest.raises(sqlite3.OperationalError, match="another FCC"):
await other.start()
await storage.commit_trees((tree(),))
assert not (await storage.load_conversation_snapshot()).is_empty
finally:
await other.close()
async def test_cancellation_during_commit_preserves_memory_and_database_agreement(
storage,
):
entered, release = threading.Event(), threading.Event()
execute = storage.database.execute
def blocked(operation, *, write=True):
entered.set()
if not release.wait(5):
raise TimeoutError("test commit barrier")
return execute(operation, write=write)
manager = TreeQueueManager(AsyncMock(), store=storage)
with patch.object(storage.database, "execute", blocked):
admission = asyncio.create_task(manager.admit(incoming("new"), "status-new"))
try:
assert await asyncio.to_thread(entered.wait, 3)
admission.cancel()
finally:
release.set()
decision = await admission
assert decision.accepted
await asyncio.wait_for(manager.wait_idle(), 5)
assert (await manager.snapshot()).trees == (
await storage.load_conversation_snapshot()
).trees
async def test_restore_does_not_consume_inactive_platform_status_repairs(storage):
telegram, discord = tree(), tree("discord")
telegram.nodes["root"]["state"] = "in_progress"
discord.nodes["root"]["state"] = "pending"
await storage.commit_trees((telegram, discord))
workflow = MessagingWorkflow(
AsyncMock(), AsyncMock(), storage, platform_name="telegram"
)
await workflow.restore()
await workflow.close()
loaded = await storage.load_conversation_snapshot()
assert loaded.trees[telegram.identity].nodes["root"]["state"] == "error"
assert loaded.trees[discord.identity].nodes["root"]["state"] == "pending"
next_workflow = MessagingWorkflow(
AsyncMock(), AsyncMock(), storage, platform_name="discord"
)
await next_workflow.restore()
assert any(
target.scope.platform == "discord"
for target in next_workflow.tree_queue.restored_stale_targets
)
@pytest.mark.parametrize("boundary", ["session", "terminal", "failure", "successor"])
async def test_worker_write_failure_interrupts_queue_and_new_reply_recovers(
storage, boundary
):
started, release = asyncio.Event(), asyncio.Event()
processed, interrupted = [], []
async def process(claim):
processed.append(claim.node.node_id)
if claim.node.node_id == "root":
started.set()
await release.wait()
if boundary == "session":
await manager.record_session(claim, "native")
elif boundary == "failure":
await manager.fail_claim(claim)
await manager.complete_claim(claim, "native")
manager = TreeQueueManager(
process, store=storage, unexpected_failure_callback=interrupted.append
)
root = await manager.admit(incoming("root"), "status-root")
assert root.claim is not None
await started.wait()
await manager.admit(incoming("child"), "status-child", parent_reference_id="root")
condition = {
"session": "NEW.node_id='root' AND NEW.session_id='native'",
"terminal": "NEW.node_id='root' AND NEW.state='completed'",
"failure": "NEW.node_id='root' AND NEW.state='error'",
"successor": "NEW.node_id='child' AND NEW.state='in_progress'",
}[boundary]
await storage.database.run(
lambda connection: connection.execute(
f"CREATE TRIGGER reject_transition BEFORE UPDATE ON messaging_nodes WHEN {condition} "
"BEGIN SELECT RAISE(ABORT, 'test storage failure'); END"
)
)
release.set()
await asyncio.wait_for(manager.wait_idle(), 5)
assert processed == ["root"]
assert manager.task_count() == 0
assert interrupted
assert "child" in {
node.node_id for result in interrupted for node in result.affected
}
saved = await storage.load_conversation_snapshot()
assert (await manager.snapshot()).trees == saved.trees
await storage.database.run(
lambda connection: connection.execute("DROP TRIGGER reject_transition")
)
await manager.admit(incoming("later"), "status-later", parent_reference_id="root")
await asyncio.wait_for(manager.wait_idle(), 5)
assert processed == ["root", "later"]
nodes = (
(await storage.load_conversation_snapshot()).trees[root.claim.identity].nodes
)
assert nodes["root"]["state"] == (
"completed" if boundary == "successor" else "error"
)
assert nodes["child"]["state"] == "error"
assert nodes["later"]["state"] == "completed"
async def test_shutdown_drains_workers_even_when_interruption_cannot_be_saved(
storage, mock_platform
):
started, stopped = asyncio.Event(), asyncio.Event()
cli = AsyncMock()
workflow = MessagingWorkflow(mock_platform, cli, storage, platform_name="telegram")
async def process(claim):
started.set()
try:
await asyncio.Event().wait()
finally:
await manager.fail_claim(claim)
stopped.set()
manager = TreeQueueManager(process, store=storage)
workflow._tree_queue = manager
await manager.admit(incoming("root"), "status-root")
await started.wait()
await manager.admit(incoming("child"), "status-child", parent_reference_id="root")
execute = storage.database.execute
writes = 0
def broken(operation, *, write=True):
nonlocal writes
if write:
writes += 1
raise sqlite3.OperationalError("disk full")
return execute(operation, write=write)
try:
with patch.object(storage.database, "execute", broken):
await asyncio.wait_for(workflow.close(), 5)
assert writes == 1
assert stopped.is_set()
assert manager.task_count() == 0
cli.stop_all.assert_awaited()
assert any(
call.args[1] == "status-child"
for call in mock_platform.queue_edit_message.call_args_list
)
finally:
await manager.shutdown()
await manager.wait_idle()
async def test_persistent_failure_has_no_retries_and_failed_recovery_keeps_history(
storage,
):
started, release = asyncio.Event(), asyncio.Event()
processed = []
# An outbound failure must not prevent task retirement.
notify = Mock(side_effect=RuntimeError("platform unavailable"))
async def process(claim):
processed.append(claim.node.node_id)
started.set()
await release.wait()
await manager.complete_claim(claim, "native")
manager = TreeQueueManager(
process, store=storage, unexpected_failure_callback=notify
)
root = await manager.admit(incoming("root"), "status-root")
await started.wait()
await manager.admit(incoming("child"), "status-child", parent_reference_id="root")
original = await storage.load_conversation_snapshot()
writes = 0
execute = storage.database.execute
def broken(operation, *, write=True):
nonlocal writes
if write:
writes += 1
raise sqlite3.OperationalError("disk full")
return execute(operation, write=False)
with patch.object(storage.database, "execute", broken):
release.set()
await asyncio.wait_for(manager.wait_idle(), 5)
assert writes == 1
assert processed == ["root"]
assert manager.task_count() == 0
with pytest.raises(MessagingStorageError):
await manager.admit(
incoming("new"), "status-new", parent_reference_id="root"
)
assert writes == 2
assert (await manager.snapshot()) == original
assert (await storage.load_conversation_snapshot()) == original
notify.assert_called_once()
await manager.admit(incoming("new"), "status-new", parent_reference_id="root")
await asyncio.wait_for(manager.wait_idle(), 5)
assert processed == ["root", "new"]
nodes = (
(await storage.load_conversation_snapshot()).trees[root.claim.identity].nodes
)
assert nodes["root"]["state"] == nodes["child"]["state"] == "error"
assert nodes["new"]["state"] == "completed"
async def test_gated_tree_can_be_cleared_and_replaced_before_old_cleanup_finishes(
storage, monkeypatch
):
monkeypatch.setattr(
"free_claude_code.messaging.trees.manager.CANCEL_TASK_DRAIN_TIMEOUT_S", 0.01
)
faulted, cleanup_release = asyncio.Event(), asyncio.Event()
new_started, new_release = asyncio.Event(), asyncio.Event()
claims = []
notifications = []
async def process(claim):
claims.append(claim)
if len(claims) == 1:
try:
with patch.object(
storage.database,
"execute",
side_effect=sqlite3.OperationalError("disk full"),
):
await manager.record_session(claim, "old-session")
except MessagingStorageError:
faulted.set()
while not cleanup_release.is_set():
with suppress(asyncio.CancelledError):
await cleanup_release.wait()
# This late update must not affect the same-ID replacement.
await manager.complete_claim(claim, "old-session")
raise
new_started.set()
await new_release.wait()
await manager.complete_claim(claim, "new-session")
manager = TreeQueueManager(
process, store=storage, unexpected_failure_callback=notifications.append
)
old = await manager.admit(incoming("root"), "status-root")
assert old.claim is not None
await faulted.wait()
try:
with pytest.raises(MessagingStorageError, match="cleaning up"):
await manager.admit(
incoming("child"), "status-child", parent_reference_id="root"
)
await manager.clear_scope(old.claim.identity.scope)
replacement = await manager.admit(incoming("root"), "status-root")
assert replacement.claim is not None
await new_started.wait()
assert replacement.claim.claim_id != old.claim.claim_id
assert manager.task_count() == 2
finally:
cleanup_release.set()
new_release.set()
await asyncio.wait_for(manager.wait_idle(), 5)
nodes = (await storage.load_conversation_snapshot()).trees[old.claim.identity].nodes
assert list(nodes) == ["root"]
assert nodes["root"]["session_id"] == "new-session"
assert not notifications