claude-proxy / tests /application /test_code_sessions.py
dheraingoud's picture
Copilot App
Sync upstream v6.19.35 and preserve custom addons
a9e27c0
Raw History Blame Contribute Delete
92.9 kB
import asyncio import uuid from types import SimpleNamespace from unittest.mock import AsyncMock, Mock import pytest import pytest_asyncio from free_claude_code.application.code_sessions import CodeConflictError, CodeService from free_claude_code.application.code_sessions import service as service_module from free_claude_code.application.code_sessions.models import ( CodeItem, CodeRun, CodeSession, CodeUnavailableError, CodeValidationError, HarnessEvent, ItemUpdate, PromptRequest, ) from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStore from free_claude_code.runtime.codex_protocol import CodexProtocol from tests.code_sessions_support import ( CodexPackets, FakeConnection, FakeHarness, close_code_database, ) def new_id(): return str(uuid.uuid4()) @pytest_asyncio.fixture async def code(database_factory, tmp_path): harness = FakeHarness() store = SQLiteCodeStore( database_factory(tmp_path / "code.db", tmp_path / "code.lock") ) service = CodeService(store, harness) await service.start() try: yield service, harness, tmp_path finally: await service.close() await close_code_database(service) async def session_for(code): service, _, directory = code return await service.create_session(new_id(), str(directory)) @pytest.mark.asyncio async def test_history_pages_do_not_create_execution_owners(code, monkeypatch): service, harness, directory = code session = await service._store.create( CodeSession(id=new_id(), cwd=str(directory), model=harness.model) ) run = CodeRun(id=new_id(), session_id=session.id, text="old", model=harness.model) user = CodeItem( id=run.id, run_id=run.id, session_id=session.id, sequence=1, kind="user" ) session, run = await service._store.admit_run(session, run, user, session.revision) await service._store.save_progress( session, session.revision, run=run.model_copy(update={"status": "completed"}), items=tuple( CodeItem( id=new_id(), run_id=run.id, session_id=session.id, sequence=n, kind="text", text="saved" * 100, complete=True, ) for n in range(2, 202) ), ) monkeypatch.setattr( service._store, "items", AsyncMock(side_effect=AssertionError("full history")) ) monkeypatch.setattr( service._store, "runs", AsyncMock(side_effect=AssertionError("all runs")) ) page = await service.get_detail(session.id) assert len(page.items) == 50 assert page.next_before is not None older = await service.get_detail(session.id, before=page.next_before) assert len(older.items) == 50 assert older.items[-1].sequence < page.items[0].sequence assert not service._owners assert not service._gates assert not harness.connections @pytest.mark.asyncio async def test_completed_turn_releases_bodies_but_keeps_connection(code): service, harness, _ = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "Work", expected_epoch=service.epoch ) await harness.wait_inputs(1) connection = harness.connections[0] await harness.started.wait() await connection.text("turn-1", "answer", "saved output", complete=True) await connection.finish("turn-1") await service.wait_idle(session.id) owner = service._owners[session.id] assert not owner.state.items assert not owner.state.prompts assert len(owner.state.runs) == 1 assert not connection.closed assert any( item.text == "saved output" for item in (await service.get_detail(session.id)).items ) @pytest.mark.asyncio async def test_many_turns_release_history_and_preserve_prompt_receipts(code): service, harness, _ = code session = await session_for(code) previous_sequence = 0 receipts = [] for number in range(1, 13): harness.started.clear() await service.send( session.id, new_id(), session.revision, f"Work {number}", expected_epoch=service.epoch, ) await harness.started.wait() connection = harness.connections[0] turn = f"turn-{number}" for kind in ("text", "tool", "reasoning"): await connection.text( turn, kind, f"{kind} output {number}", complete=True, kind=kind ) await connection.prompt(number, turn) prompt = next( prompt for prompt in (await service.get_detail(session.id)).prompts if prompt.request_id == number ) response_id = new_id() await service.answer(session.id, prompt.id, response_id, {"decision": "accept"}) await connection.finish(turn) await service.wait_idle(session.id) receipts.append((prompt.id, response_id)) detail = await service.get_detail(session.id) assert detail.items[-1].sequence > previous_sequence previous_sequence = detail.items[-1].sequence session = detail.session owner = service._owners[session.id] assert not owner.state.items and not owner.state.prompts assert tuple(owner.state.runs) == (detail.run.id,) assert len(harness.connections) == 1 and not connection.closed for prompt_id, response_id in receipts: receipt = await service.answer( session.id, prompt_id, response_id, {"decision": "accept"} ) assert receipt.response_id == response_id assert not service._owners[session.id].state.prompts all_items = await service._store.items(session.id, None, None) assert [item.sequence for item in all_items] == list(range(1, 61)) @pytest.mark.asyncio async def test_cold_history_gate_serializes_owner_creation_without_blocking_other_sessions( code, monkeypatch ): service, harness, directory = code sessions = [ await service._store.create( CodeSession(id=new_id(), cwd=str(directory), model=harness.model) ) for _ in range(2) ] entered, release = asyncio.Event(), asyncio.Event() read = service._store.read_history async def gated_read(session_id, *args): if session_id == sessions[0].id: entered.set() await release.wait() return await read(session_id, *args) monkeypatch.setattr(service._store, "read_history", gated_read) reading = asyncio.create_task(service.get_detail(sessions[0].id)) await entered.wait() changing = asyncio.create_task( service.update_settings( sessions[0].id, sessions[0].revision, {"title": "Updated"} ) ) cancelled = asyncio.create_task(service.get_detail(sessions[0].id)) try: other = await asyncio.wait_for(service.get_detail(sessions[1].id), 2) assert other.session.id == sessions[1].id assert not changing.done() and not service._owners cancelled.cancel() with pytest.raises(asyncio.CancelledError): await cancelled release.set() before = await reading await changing after = await service.get_detail(sessions[0].id) assert before.session.title != after.session.title == "Updated" assert after.version > before.version assert set(service._gates) == {sessions[0].id} assert service._gates[sessions[0].id].users == 0 finally: release.set() await asyncio.gather(reading, changing, cancelled, return_exceptions=True) @pytest.mark.asyncio async def test_execution_seed_resumes_sequence_without_hydrating_old_transcript( code, monkeypatch ): service, harness, directory = code session = await service._store.create( CodeSession(id=new_id(), cwd=str(directory), model=harness.model) ) run = CodeRun(id=new_id(), session_id=session.id, text="old", model=harness.model) item = CodeItem( id=run.id, run_id=run.id, session_id=session.id, sequence=900, kind="user" ) session, run = await service._store.admit_run(session, run, item, session.revision) await service._store.save_progress( session, session.revision, run=run.model_copy(update={"status": "completed"}) ) monkeypatch.setattr( service._store, "items", AsyncMock(side_effect=AssertionError("full history")) ) monkeypatch.setattr( service._store, "prompts", AsyncMock(side_effect=AssertionError("all prompts")) ) await service.send( session.id, new_id(), session.revision, "Next", expected_epoch=service.epoch ) await harness.started.wait() detail = await service.get_detail(session.id) assert detail.items[-1].sequence == 901 assert run.id not in service._owners[session.id].state.runs await harness.connections[0].finish("turn-1") @pytest.mark.asyncio async def test_catalog_wait_releases_session_lock_and_revalidates_before_admission( code, monkeypatch ): service, harness, _ = code session = await session_for(code) entered, release = asyncio.Event(), asyncio.Event() prepare = harness.prepare async def held_prepare(*args): entered.set() await release.wait() return await prepare(*args) monkeypatch.setattr(harness, "prepare", held_prepare) sending = asyncio.create_task( service.send( session.id, new_id(), session.revision, "Work", expected_epoch=service.epoch ) ) try: await entered.wait() detail = await asyncio.wait_for(service.get_detail(session.id), 1) assert detail.run is None updated = await asyncio.wait_for( service.update_settings( session.id, session.revision, {"title": "Renamed during initialization"} ), 1, ) release.set() with pytest.raises(CodeConflictError): await sending assert updated.title == "Renamed during initialization" assert not harness.connections assert (await service.get_detail(session.id)).run is None finally: release.set() await asyncio.gather(sending, return_exceptions=True) @pytest.fixture def flush_timer(monkeypatch): sleeping, release = asyncio.Event(), asyncio.Event() async def sleep(delay): assert delay == 0.25 sleeping.set() await release.wait() monkeypatch.setattr( service_module, "asyncio", SimpleNamespace(**(vars(asyncio) | {"sleep": sleep})) ) yield sleeping, release release.set() @pytest.mark.asyncio @pytest.mark.parametrize( ("failure", "finished", "status"), [(BrokenPipeError, False, "failed"), (ConnectionResetError, True, "completed")], ) async def test_child_lookup_pipe_failure_delivers_queued_close( code, monkeypatch, failure, finished, status ): service, harness, _ = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch ) await asyncio.wait_for(harness.started.wait(), 3) connection = harness.connections[0] packets = CodexPackets(connection) await packets.spawn() await packets.review() if finished: await connection.finish("turn-1") native = packets.native monkeypatch.delattr(native, "rpc") native._alive = True native._process = Mock( stdin=Mock(drain=AsyncMock(side_effect=failure("Pipe closed"))) ) await native._packet( { "method": "guardianWarning", "params": {"threadId": "unregistered-child", "message": "Child warning"}, } ) native._queue.put_nowait( HarnessEvent( connection.generation, connection.thread_id, "closed", message="Native process ended", ) ) native._queue.put_nowait(None) try: await native._dispatch() detail = await service.get_detail(session.id) assert detail.active_review_ids == () assert detail.run.status == status assert [item.kind for item in detail.items] == ["user", "subagent_auto_review"] assert not detail.items[-1].complete finally: for _, future in native._pending.values(): future.cancel() @pytest.mark.asyncio async def test_pending_child_review_outside_page_keeps_its_run_and_history_cursor(code): service, harness, _ = code session = await session_for(code) first = await service.send( session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch ) await asyncio.wait_for(harness.started.wait(), 3) connection = harness.connections[0] packets = CodexPackets(connection) await packets.spawn() await packets.review() review = (await service.get_detail(session.id)).items[-1] await connection.finish("turn-1") session = (await service.get_detail(session.id)).session await service.send( session.id, new_id(), session.revision, "Continue", expected_epoch=service.epoch ) await asyncio.wait_for(harness.wait_inputs(2), 3) for index in range(55): await connection.text("turn-2", str(index), f"Output {index}", complete=True) await connection.finish("turn-2") newest = await service.get_detail(session.id) assert len(newest.items) == 51 assert newest.items[0].id == review.id and newest.items[0].run_id == first.id assert first.id in {run.id for run in newest.runs} assert newest.active_review_ids == (review.id,) assert newest.next_before == (2, 9) await packets.review(status="approved") resolved = await service.get_detail(session.id) assert resolved.active_review_ids == () assert review.id not in {item.id for item in resolved.items} assert resolved.next_before == newest.next_before refreshed = await service.get_detail( session.id, include_item_ids=(review.id, review.id, "missing") ) assert len(refreshed.items) == 51 assert refreshed.items[0].id == review.id and refreshed.items[0].complete assert first.id in {run.id for run in refreshed.runs} assert refreshed.next_before == newest.next_before older = await service.get_detail(session.id, before=newest.next_before) saved = next(item for item in older.items if item.id == review.id) assert saved.complete and saved.title == "Sub-agent Auto-review: Approved" assert saved.sequence == review.sequence and saved.run_id == first.id merged = {item.id: item for item in (*older.items, *resolved.items)} assert sorted(item.sequence for item in merged.values()) == list(range(1, 59)) @pytest.mark.asyncio @pytest.mark.parametrize("ownership", ["notification", "metadata"]) async def test_owned_child_reviews_and_warnings_reach_saved_parent_transcript( code, ownership ): service, harness, _ = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch ) await asyncio.wait_for(harness.started.wait(), 3) connection = harness.connections[0] packets = CodexPackets(connection) if ownership == "notification": await packets.spawn() await packets.spawn("grandchild", "child") await packets.spawn("unrelated", "outside") else: packets.parents.update( { "child": connection.thread_id, "grandchild": "child", "unrelated": "outside", } ) for child in (connection.thread_id, "child", "grandchild", "unrelated"): await packets.review(child, status="approved", turn="turn-1") await packets.warning(child) detail = await service.get_detail(session.id) assert [item.kind for item in detail.items] == [ "user", "auto_review", "notice", "subagent_auto_review", "notice", "subagent_auto_review", "notice", ] reviews = [item for item in detail.items if item.kind == "subagent_auto_review"] assert len({item.native_item_id for item in reviews}) == 2 assert [item.raw["threadId"] for item in reviews] == ["child", "grandchild"] assert all(item.title == "Sub-agent Auto-review: Approved" for item in reviews) assert detail.items[-1].text == "Sub-agent: Native warning" assert detail.items[-1].raw == { "threadId": "grandchild", "message": "Native warning", } assert await service._store.items(session.id, None, None) == detail.items assert detail.run.status == "running" @pytest.mark.asyncio async def test_child_review_stays_with_first_entry_after_next_turn_begins(code): service, harness, _ = code session = await session_for(code) first = await service.send( session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch ) await asyncio.wait_for(harness.started.wait(), 3) connection = harness.connections[0] packets = CodexPackets(connection) await packets.spawn() await packets.review() before = await service.get_detail(session.id) assert len(before.items) == 2 review = before.items[-1] assert before.active_review_ids == (review.id,) await connection.finish("turn-1") await packets.send( "turn/completed", {"threadId": "child", "turn": {"id": "child-turn", "status": "completed"}}, ) assert (await service.get_detail(session.id)).active_review_ids == (review.id,) subscription, ready = await service.subscribe() events = aiter(subscription) try: assert ready["sessions"][0]["active_review_ids"] == [review.id] session = (await service.get_detail(session.id)).session harness.start_gate.clear() harness.started.clear() second = await service.send( session.id, new_id(), session.revision, "Continue", expected_epoch=service.epoch, ) await asyncio.wait_for(harness.wait_inputs(2), 3) await packets.review(status="denied") await packets.review(status="denied") await packets.review() await packets.warning() await packets.review(review_id="next", status="approved", turn="turn-2") await packets.send( "turn/started", {"threadId": "child", "turn": {"id": "turn-2"}} ) await packets.send( "turn/completed", {"threadId": "child", "turn": {"id": "turn-2", "status": "completed"}}, ) detail = await service.get_detail(session.id) saved = next(item for item in detail.items if item.id == review.id) assert (saved.run_id, saved.sequence, saved.native_turn_id) == ( first.id, review.sequence, "child-turn", ) assert saved.title == "Sub-agent Auto-review: Denied" and saved.complete assert detail.active_review_ids == () assert detail.run.id == second.id and detail.run.native_turn_id is None assert all(item.run_id == second.id for item in detail.items[-3:]) while (event := await asyncio.wait_for(anext(events), 3)).data.get( "item", {} ).get("id") != review.id: pass assert event.data["runs"][0]["id"] == first.id assert event.data["run"]["id"] == second.id harness.start_gate.set() await asyncio.wait_for(harness.started.wait(), 3) assert (await service.get_detail(session.id)).run.native_turn_id == "turn-2" await connection.finish("turn-2") finally: harness.start_gate.set() await subscription.aclose() @pytest.mark.asyncio @pytest.mark.parametrize("closure", ["native", "service"]) async def test_pending_child_review_becomes_unavailable_when_idle_connection_ends( database_factory, code, closure ): service, harness, directory = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch ) await asyncio.wait_for(harness.started.wait(), 3) connection = harness.connections[0] packets = CodexPackets(connection) await packets.spawn() await connection.finish("turn-1") await packets.review() before = await service.get_detail(session.id) assert len(before.items) == 2 review = before.items[-1] assert before.active_review_ids == (review.id,) subscription, _ = await service.subscribe() events = aiter(subscription) try: if closure == "native": await connection.close() else: await service._close_connection(await service._owner(session.id)) event = await asyncio.wait_for(anext(events), 3) assert event.data["active_review_ids"] == [] await packets.review(status="approved") detail = await service.get_detail(session.id) assert detail.items == before.items assert detail.active_review_ids == () assert detail.run.status == "completed" await service.close() await close_code_database(service) restarted = CodeService( SQLiteCodeStore( database_factory(directory / "code.db", directory / "code.lock") ), harness, ) await restarted.start() try: restored = await restarted.get_detail(session.id) assert restored.items == before.items assert restored.active_review_ids == () finally: await restarted.close() finally: await subscription.aclose() @pytest.mark.asyncio async def test_mode_is_captured_per_turn_and_does_not_recreate_native_process(code): service, harness, _ = code session = await session_for(code) modes = ["full_access", "config", "ask", "auto_review"] for ordinal, mode in enumerate(modes, 1): session = await service.update_settings( session.id, session.revision, {"mode": mode} ) run = await service.send( session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch, ) assert run.mode == mode await asyncio.wait_for(harness.wait_inputs(ordinal), 3) current = (await service.get_detail(session.id)).session with pytest.raises(CodeConflictError): await service.update_settings(current.id, current.revision, {"mode": "ask"}) await harness.connections[0].finish(f"turn-{ordinal}") await service.wait_idle(session.id) session = (await service.get_detail(session.id)).session assert len(harness.connections) == 1 assert harness.connections[0].modes == modes assert session.native_permission_defaults == harness.permission_defaults @pytest.mark.asyncio @pytest.mark.parametrize("pending_output", [False, True]) async def test_reobserved_child_review_publishes_liveness_on_new_native_connection( code, pending_output, ): service, harness, _ = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch ) await asyncio.wait_for(harness.started.wait(), 3) first = harness.connections[0] packets = CodexPackets(first) await packets.spawn() await packets.review() review = (await service.get_detail(session.id)).items[-1] await first.finish("turn-1") harness.configurations[harness.model] = "replacement" session = (await service.get_detail(session.id)).session await service.send( session.id, new_id(), session.revision, "Continue", expected_epoch=service.epoch ) await asyncio.wait_for(harness.wait_inputs(2), 3) second = harness.connections[1] if not pending_output: await second.finish("turn-2") assert (await service.get_detail(session.id)).active_review_ids == () packets = CodexPackets(second) await packets.spawn() subscription, _ = await service.subscribe() try: if pending_output: await second.text("turn-2", "reply", "In progress") await packets.review() event = await asyncio.wait_for(anext(aiter(subscription)), 3) while event.data["active_review_ids"] != [review.id]: event = await asyncio.wait_for(anext(aiter(subscription)), 3) assert event.data["active_review_ids"] == [review.id] assert event.data.get("item", {}).get("id") == review.id assert event.data["runs"][0]["id"] == review.run_id detail = await service.get_detail(session.id) assert next(item for item in detail.items if item.id == review.id) == review assert detail.run.status == ("running" if pending_output else "completed") finally: await subscription.aclose() @pytest.mark.asyncio async def test_forced_interrupt_clears_pending_child_review_liveness(code, monkeypatch): service, harness, _ = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch ) await asyncio.wait_for(harness.started.wait(), 3) connection = harness.connections[0] packets = CodexPackets(connection) await packets.spawn() await packets.review() assert (await service.get_detail(session.id)).active_review_ids async def unavailable(_turn_id): raise CodeUnavailableError("Native interrupt transport failed") monkeypatch.setattr(connection, "interrupt", unavailable) await service.stop(session.id, (await service.get_detail(session.id)).run.id) await asyncio.wait_for(service.wait_idle(session.id), 3) detail = await service.get_detail(session.id) assert detail.active_review_ids == () assert detail.run.status == "interrupted" assert not detail.items[-1].complete @pytest.mark.asyncio async def test_mode_change_and_send_compete_for_one_revision(code): service, harness, _ = code session = await session_for(code) results = await asyncio.gather( service.update_settings(session.id, session.revision, {"mode": "full_access"}), service.send( session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch, ), return_exceptions=True, ) assert sum(isinstance(result, CodeConflictError) for result in results) == 1 detail = await service.get_detail(session.id) if detail.run: assert detail.run.mode == "config" await asyncio.wait_for(harness.started.wait(), 3) await harness.connections[0].finish("turn-1") else: assert detail.session.mode == "full_access" @pytest.mark.asyncio @pytest.mark.parametrize("mode", [None, "plan", "never", {}, 1]) async def test_invalid_mode_is_rejected_without_changing_session(code, mode): service, _, _ = code session = await session_for(code) with pytest.raises(CodeValidationError): await service.update_settings(session.id, session.revision, {"mode": mode}) assert (await service.get_detail(session.id)).session == session @pytest.mark.asyncio async def test_native_defaults_are_saved_before_input_and_preserved_on_resume(code): service, harness, _ = code session = await session_for(code) original = {"policy": "configured-original"} harness.permission_defaults = original session = await service.update_settings( session.id, session.revision, {"mode": "full_access"} ) await service.send( session.id, new_id(), session.revision, "first", expected_epoch=service.epoch ) await asyncio.wait_for(harness.started.wait(), 3) saved = await service._store.get_session(session.id) assert saved.native_permission_defaults == original assert harness.connections[0].defaults == [original] await harness.connections[0].finish("turn-1") await service.wait_idle(session.id) harness.permission_defaults = {"policy": "current-override"} harness.configurations[harness.model] = "recreate-process" session = (await service.get_detail(session.id)).session session = await service.update_settings( session.id, session.revision, {"mode": "config"} ) await service.send( session.id, new_id(), session.revision, "second", expected_epoch=service.epoch ) await asyncio.wait_for(harness.wait_inputs(2), 3) assert len(harness.connections) == 2 assert harness.connections[1].defaults == [original] await harness.connections[1].finish("turn-2") @pytest.mark.asyncio async def test_failure_saving_native_defaults_never_submits_input(code, monkeypatch): service, harness, _ = code session = await session_for(code) save = service._store.save_progress async def reject_defaults(session, *args, **kwargs): if session.native_permission_defaults is not None: raise CodeUnavailableError("Unable to save permission defaults") await save(session, *args, **kwargs) monkeypatch.setattr(service._store, "save_progress", reject_defaults) await service.send( session.id, new_id(), session.revision, "first", expected_epoch=service.epoch ) await asyncio.wait_for(service.wait_idle(session.id), 3) assert not any(connection.inputs for connection in harness.connections) assert not (await service._store.latest_run(session.id)).submission_started @pytest.mark.asyncio async def test_native_reviews_and_notices_keep_identity_order_and_survive_restart( database_factory, code ): service, harness, directory = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch ) await asyncio.wait_for(harness.started.wait(), 3) connection = harness.connections[0] protocol = CodexProtocol(connection.generation) payload = { "threadId": connection.thread_id, "turnId": "turn-1", "targetItemId": "same-command", "action": {"command": "echo test"}, "review": {"status": "inProgress"}, } for review_id in ("one", "two"): await connection.sink( protocol.notification( "item/autoApprovalReview/started", {**payload, "reviewId": review_id} ) ) await connection.text("turn-1", "reply", "After reviews", complete=True) before = await service.get_detail(session.id) for review_id in ("two", "one"): await connection.sink( protocol.notification( "item/autoApprovalReview/completed", { **payload, "reviewId": review_id, "review": {"status": "denied", "rationale": "Native refusal"}, }, ) ) await connection.sink( protocol.notification( "guardianWarning", {"threadId": connection.thread_id, "message": "Native warning"}, ) ) await connection.sink( HarnessEvent("old-generation", connection.thread_id, "notice", message="stale") ) await connection.finish("turn-1") await service.wait_idle(session.id) detail = await service.get_detail(session.id) assert [item.id for item in detail.items[:4]] == [item.id for item in before.items] assert [item.kind for item in detail.items] == [ "user", "auto_review", "auto_review", "text", "notice", ] assert all(item.title == "Auto-review: Denied" for item in detail.items[1:3]) assert detail.run.status == "completed" assert detail.items[-1].text == "Native warning" await service.close() await close_code_database(service) restarted = CodeService( SQLiteCodeStore( database_factory(directory / "code.db", directory / "code.lock") ), harness, ) await restarted.start() try: assert (await restarted.get_detail(session.id)).items == detail.items finally: await restarted.close() @pytest.mark.asyncio async def test_selected_model_and_effort_are_session_settings_captured_on_send(code): service, harness, _ = code harness.configurations["provider/other"] = "other" session = await session_for(code) for effort in (None, "high", None): session = await service.update_settings( session.id, session.revision, {"model": "provider/other", "reasoning_effort": effort}, ) run = await service.send( session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch, ) await harness.wait_inputs(run.ordinal) connection = harness.connections[0] with pytest.raises(CodeConflictError): await service.update_settings( session.id, session.revision + 1, {"reasoning_effort": "low"} ) await connection.finish(f"turn-{run.ordinal}") session = (await service.get_detail(session.id)).session assert connection.efforts == ["medium", "high", "medium"] assert {value[2] for value in connection.inputs} == {"provider/other"} assert len(harness.connections) == 1 harness.configurations.pop("provider/other") with pytest.raises(CodeValidationError, match="unavailable"): await service.send( session.id, new_id(), session.revision, "kept draft", expected_epoch=service.epoch, ) assert (await service.get_detail(session.id)).session.model == "provider/other" @pytest.mark.asyncio async def test_catalog_effort_removal_requires_choice_but_model_change_resolves_default( code, ): service, harness, _ = code session = await session_for(code) session = await service.update_settings( session.id, session.revision, {"reasoning_effort": "xhigh"} ) harness.efforts = ("low", "medium") with pytest.raises(CodeValidationError, match="effort"): await service.send( session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch, ) harness.configurations["provider/other"] = "other" session = await service.update_settings( session.id, session.revision, {"model": "provider/other"} ) assert session.reasoning_effort is None assert session.model == "provider/other" @pytest.mark.asyncio async def test_failed_outcome_is_durable_once_after_partial_output_and_older_pagination( code, ): service, harness, _ = code session = await session_for(code) run = await service.send( session.id, new_id(), session.revision, "first", expected_epoch=service.epoch ) await harness.started.wait() connection = harness.connections[0] for kind in ("text", "reasoning", "tool"): await connection.text("turn-1", kind, f"partial {kind}", kind=kind) await connection.finish("turn-1", "failed", "Provider rejected the request") await connection.finish("turn-1", "failed", "duplicate") detail = await service.get_detail(session.id) assert detail.session.error is None assert detail.runs == (detail.run,) assert detail.run.error == "Provider rejected the request" assert [item.text for item in detail.items] == [ "first", "partial text", "partial reasoning", "partial tool", ] await service.send( session.id, new_id(), detail.session.revision, "second", expected_epoch=service.epoch, ) await harness.wait_inputs(2) for index in range(55): await connection.text("turn-2", str(index), str(index), complete=True) active = await service.get_detail(session.id) assert active.items[0].text == "first" assert len(active.items) == 60 await connection.finish("turn-2") latest = await service.get_detail(session.id) assert run.id not in {value.id for value in latest.runs} older = await service.get_detail(session.id, before=latest.next_before) assert ( next(value for value in older.runs if value.id == run.id).error == detail.run.error ) @pytest.mark.asyncio async def test_retry_notice_does_not_finish_run_and_stale_error_is_ignored( database_factory, code ): service, harness, directory = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch ) await harness.started.wait() connection = harness.connections[0] await connection.text("turn-1", "before", "Before retry", complete=True) await connection.sink( HarnessEvent( connection.generation, connection.thread_id, "error", turn_id="turn-1", message="retry", will_retry=True, ) ) detail = await service.get_detail(session.id) assert detail.run.status == "running" assert [item.kind for item in detail.items] == ["user", "text", "notice"] assert detail.items[-1].text == "Retrying… retry" assert detail.items[-1].sequence > detail.items[-2].sequence await connection.sink( HarnessEvent( connection.generation, connection.thread_id, "error", turn_id="turn-1" ) ) detail = await service.get_detail(session.id) assert detail.run.status == "running" assert detail.items[-1].text == "Codex reported an error." await connection.text("turn-1", "text", "success", complete=True) await connection.finish("turn-1") subscription, _ = await service.subscribe() cursor = service.cursor await connection.sink( HarnessEvent( connection.generation, connection.thread_id, "error", turn_id="turn-1", message="stale", ) ) assert service.cursor == cursor await subscription.aclose() assert (await service.get_detail(session.id)).run.error is None detail = await service.get_detail(session.id) await service.close() await close_code_database(service) restarted = CodeService( SQLiteCodeStore( database_factory(directory / "code.db", directory / "code.lock") ), harness, ) await restarted.start() try: assert (await restarted.get_detail(session.id)).items == detail.items finally: await restarted.close() @pytest.mark.asyncio @pytest.mark.parametrize("client_id", [True, False]) async def test_acknowledgement_loss_recovers_old_turn_before_newer_send( code, client_id ): service, harness, _ = code session = await session_for(code) harness.start_gate.clear() first = await service.send( session.id, new_id(), session.revision, "first", expected_epoch=service.epoch ) await harness.submitted.wait() connection = harness.connections[0] harness.histories[connection.thread_id] = [ ItemUpdate( "turn-1", "native-user", "user", text="first", complete=True, client_id=first.id if client_id else None, ), ItemUpdate("turn-1", "tail", "text", text="recovered tail", complete=True), ] await connection.close() await service.wait_idle(session.id) detail = await service.get_detail(session.id) assert detail.run.status == "failed" await service.send( session.id, new_id(), detail.session.revision, "second", expected_epoch=service.epoch, ) await harness.wait_inputs(2) recovered = await service.get_detail(session.id) assert [item.text for item in recovered.items] == [ "first", "recovered tail", "second", ] assert recovered.runs[0].status == "failed" assert recovered.items[0].id == first.id @pytest.mark.asyncio async def test_prompt_membership_and_deleted_subscription_are_authoritative(code): service, harness, _ = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "first", expected_epoch=service.epoch ) await harness.started.wait() connection = harness.connections[0] await connection.prompt(0, turn_id=None) detail = await service.get_detail(session.id) assert detail.active_prompt_ids == (detail.prompts[0].id,) await connection.resolve(0) assert (await service.get_detail(session.id)).active_prompt_ids == () await connection.finish("turn-1") session = (await service.get_detail(session.id)).session await service.delete_session(session.id, session.revision) await service.wait_idle(session.id) subscription, ready = await service.subscribe() assert ready["sessions"] == [] assert session.id not in service._owners await subscription.aclose() @pytest.mark.asyncio async def test_ambiguous_native_history_fails_recovery_without_resending_input(code): service, harness, _ = code session = await session_for(code) harness.start_gate.clear() await service.send( session.id, new_id(), session.revision, "first", expected_epoch=service.epoch ) await harness.submitted.wait() connection = harness.connections[0] harness.histories[connection.thread_id] = [ ItemUpdate(turn_id, "item", "text", text="unmatched", complete=True) for turn_id in ("unknown-1", "unknown-2") ] await connection.close() await service.wait_idle(session.id) detail = await service.get_detail(session.id) await service.send( session.id, new_id(), detail.session.revision, "second", expected_epoch=service.epoch, ) await service.wait_idle(session.id) detail = await service.get_detail(session.id) assert detail.run.status == "failed" assert "could not be matched" in detail.run.error assert [item.text for item in detail.items] == ["first", "second"] assert sum(len(connection.inputs) for connection in harness.connections) == 1 @pytest.mark.asyncio async def test_settings_and_send_compete_for_the_same_revision(code): service, harness, _ = code session = await session_for(code) outcomes = await asyncio.gather( service.update_settings( session.id, session.revision, {"reasoning_effort": "high"} ), service.send( session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch, ), return_exceptions=True, ) assert sum(isinstance(result, CodeConflictError) for result in outcomes) == 1 detail = await service.get_detail(session.id) assert detail.session.revision == session.revision + 1 if detail.run: assert detail.run.reasoning_effort == "medium" else: assert detail.session.reasoning_effort == "high" assert harness.connections == [] @pytest.mark.asyncio async def test_old_service_epoch_cannot_admit_a_new_send_but_can_read_receipt(code): service, harness, _ = code session = await session_for(code) with pytest.raises(CodeConflictError, match="restarted"): await service.send( session.id, new_id(), session.revision, "stale", expected_epoch="previous" ) assert harness.connections == [] run = await service.send( session.id, new_id(), session.revision, "accepted", expected_epoch=service.epoch ) repeated = await service.send( session.id, run.id, session.revision, "accepted", expected_epoch="previous" ) assert repeated.id == run.id @pytest.mark.asyncio async def test_poorer_native_history_keeps_captured_source_and_reasoning(code): service, harness, _ = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "first", expected_epoch=service.epoch ) await harness.started.wait() connection = harness.connections[0] original = ItemUpdate( "turn-1", "reasoning", "reasoning", text="Full captured reasoning", complete=True, raw={ "item": { "id": "reasoning", "summary": ["original"], "opaque": {"signature": "retained"}, }, "stream": {"reasoning": {"0": "full"}}, }, ) await connection.sink( HarnessEvent( connection.generation, connection.thread_id, "item", turn_id="turn-1", item=original, ) ) await connection.finish("turn-1") harness.histories[connection.thread_id] = [ ItemUpdate( "turn-1", "reasoning", "reasoning", text="Shorter native history", complete=True, raw={"item": {"id": "reasoning", "summary": []}, "stream": {}}, ) ] harness.configurations[harness.model] = "changed" detail = await service.get_detail(session.id) await service.send( session.id, new_id(), detail.session.revision, "next", expected_epoch=service.epoch, ) await harness.wait_inputs(2) retained = next( item for item in (await service.get_detail(session.id)).items if item.native_item_id == "reasoning" ) assert retained.text == original.text assert retained.raw == original.raw @pytest.mark.asyncio async def test_storage_start_failure_is_isolated_to_code(database_factory, tmp_path): class BrokenStore(SQLiteCodeStore): async def start(self): raise CodeUnavailableError("Code disk unavailable") service = CodeService( BrokenStore(database_factory(tmp_path / "code.db", tmp_path / "code.lock")), FakeHarness(), ) try: await service.start() assert service.availability() == (False, "Code disk unavailable") finally: await service.close() await close_code_database(service) @pytest.mark.asyncio async def test_shutdown_settles_run_when_native_interrupt_never_acknowledges(code): service, harness, _ = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "stop on shutdown", expected_epoch=service.epoch, ) await harness.started.wait() harness.interrupt_gate.clear() await asyncio.wait_for(service.close(), 8) assert harness.connections[0].closed @pytest.mark.asyncio async def test_storage_failure_retires_native_work_even_with_pending_prompt( code, monkeypatch, caplog ): service, harness, _ = code session = await session_for(code) run = await service.send( session.id, new_id(), session.revision, "prompt", expected_epoch=service.epoch ) await harness.started.wait() connection = harness.connections[0] await connection.prompt(1) error = CodeUnavailableError("Code disk unavailable") async def fail_save(*args, **kwargs): raise error monkeypatch.setattr(service._store, "save_progress", fail_save) await connection.text("turn-1", "text", "unsaved", complete=True) await asyncio.wait_for(service.wait_idle(session.id), 3) assert connection.closed with pytest.raises(CodeUnavailableError): await service.get_detail(session.id) await service.close() failures = [record for record in caplog.records if record.levelname == "ERROR"] assert len(failures) == 1 assert failures[0].extra == { "event": "code.storage_failed", "operation": "save_progress", "session_id": session.id, "run_id": run.id, } assert failures[0].exc_info[1] is error assert "fail_save" in caplog.text @pytest.mark.asyncio async def test_shutdown_storage_read_failure_logs_original_cause( code, monkeypatch, caplog ): service, harness, _ = code session = await session_for(code) run = await service.send( session.id, new_id(), session.revision, "work", expected_epoch=service.epoch ) await harness.started.wait() error = CodeUnavailableError("Cannot read run during shutdown") monkeypatch.setattr(service._store, "get_run", AsyncMock(side_effect=error)) await service.close() assert harness.connections[0].closed failures = [record for record in caplog.records if record.levelname == "ERROR"] assert len(failures) == 1 assert failures[0].extra["operation"] == "stop_run" assert failures[0].extra["session_id"] == session.id assert failures[0].extra["run_id"] == run.id assert failures[0].exc_info[1] is error @pytest.mark.asyncio @pytest.mark.parametrize("conflict", [False, True]) async def test_delete_before_first_run_logs_only_terminal_storage_failure( code, monkeypatch, caplog, conflict ): service, _, _ = code session = await session_for(code) error = ( CodeConflictError("Revision changed") if conflict else CodeUnavailableError("Cannot save deletion") ) save = service._store.save_progress monkeypatch.setattr(service._store, "save_progress", AsyncMock(side_effect=error)) with pytest.raises(type(error)): await service.delete_session(session.id, session.revision) if conflict: monkeypatch.setattr(service._store, "save_progress", save) assert (await service.get_detail(session.id)).session == session else: await asyncio.wait_for(service.wait_idle(session.id), 3) await service.close() failures = [record for record in caplog.records if record.levelname == "ERROR"] assert len(failures) == (0 if conflict else 1) if not conflict: assert failures[0].extra["session_id"] == session.id assert failures[0].extra["run_id"] is None assert failures[0].extra["operation"] == "save_progress" assert failures[0].exc_info[1] is error @pytest.mark.asyncio async def test_same_send_id_in_two_sessions_has_independent_receipts(code, monkeypatch): service, harness, _ = code first, second = await session_for(code), await session_for(code) original = service._store.get_run looked_up = 0 barrier = asyncio.Event() async def simultaneous_lookup(session_id, run_id): nonlocal looked_up result = await original(session_id, run_id) looked_up += 1 if looked_up == 2: barrier.set() await barrier.wait() return result monkeypatch.setattr(service._store, "get_run", simultaneous_lookup) operation = new_id() outcomes = await asyncio.gather( *( service.send( session.id, operation, session.revision, "once", expected_epoch=service.epoch, ) for session in (first, second) ), return_exceptions=True, ) assert { value.session_id for value in outcomes if not isinstance(value, BaseException) } == {first.id, second.id} await harness.wait_inputs(2) assert sum(len(connection.inputs) for connection in harness.connections) == 2 async def idle_native(code): service, harness, _ = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "one", expected_epoch=service.epoch ) await harness.started.wait() await harness.connections[0].finish("turn-1") return (await service.get_detail(session.id)).session @pytest.mark.asyncio async def test_deletion_fences_commands_and_repeated_delete_has_one_native_call(code): service, harness, folder = code session = await idle_native(code) project = folder / "project.txt" project.write_text("keep") harness.delete_gate.clear() await service.delete_session(session.id, session.revision) await harness.deleting.wait() await service.delete_session(session.id, session.revision) with pytest.raises(CodeConflictError): await service.send( session.id, new_id(), session.revision, "late", expected_epoch=service.epoch ) with pytest.raises(CodeConflictError): await service.update_settings(session.id, session.revision, {"title": "late"}) harness.delete_gate.set() await service.wait_idle(session.id) assert harness.connections[0].deleted == [session.native_thread_id] assert project.read_text() == "keep" assert not (await service.list_sessions()).sessions @pytest.mark.asyncio async def test_lost_native_delete_ack_reconciles_without_repeating_delete(code): service, harness, _ = code session = await idle_native(code) harness.delete_before_error = True harness.delete_error = CodeUnavailableError("Delete acknowledgement lost") await service.delete_session(session.id, session.revision) await service.wait_idle(session.id) assert not (await service.list_sessions()).sessions assert sum(len(connection.deleted) for connection in harness.connections) == 1 @pytest.mark.asyncio async def test_local_delete_commit_failure_keeps_fence_and_can_reconcile( code, monkeypatch ): service, harness, _ = code session = await idle_native(code) original = service._store.delete async def failing_delete(session_id): raise CodeUnavailableError("Delete commit failed") monkeypatch.setattr(service._store, "delete", failing_delete) await service.delete_session(session.id, session.revision) await asyncio.wait_for(service.wait_idle(session.id), 3) detail = await service.get_detail(session.id) assert detail.session.status == "delete_uncertain" assert detail.items with pytest.raises(CodeConflictError): await service.send( session.id, new_id(), detail.session.revision, "late", expected_epoch=service.epoch, ) monkeypatch.setattr(service._store, "delete", original) await service.delete_session(session.id, detail.session.revision) await service.wait_idle(session.id) assert not (await service.list_sessions()).sessions assert sum(len(connection.deleted) for connection in harness.connections) == 1 @pytest.mark.asyncio async def test_late_old_native_events_cannot_claim_a_new_turn_before_ack(code): service, harness, _ = code session = await idle_native(code) connection = harness.connections[0] harness.start_gate.clear() harness.started.clear() await service.send( session.id, new_id(), session.revision, "next", expected_epoch=service.epoch ) await harness.wait_inputs(2) await connection.sink( HarnessEvent( connection.generation, connection.thread_id, "turn_started", turn_id="turn-1", ) ) await connection.text("turn-1", "late", "obsolete", complete=True) await connection.finish("turn-1") detail = await service.get_detail(session.id) assert detail.run.status == "preparing" assert not any(item.text == "obsolete" for item in detail.items) harness.start_gate.set() await harness.started.wait() detail = await service.get_detail(session.id) assert detail.run.native_turn_id == "turn-2" @pytest.mark.asyncio async def test_creation_identity_received_during_cleanup_is_saved(code, monkeypatch): service, harness, _ = code session = await session_for(code) original_close = FakeConnection.close async def failed_create(connection): raise CodeUnavailableError("Native creation acknowledgement timed out") async def close_with_late_reply(connection): connection.thread_id = "late-native-id" harness.histories[connection.thread_id] = [] await original_close(connection) monkeypatch.setattr(FakeConnection, "create_thread", failed_create) monkeypatch.setattr(FakeConnection, "close", close_with_late_reply) await service.send( session.id, new_id(), session.revision, "uncertain create", expected_epoch=service.epoch, ) await service.wait_idle(session.id) detail = await service.get_detail(session.id) assert detail.session.native_thread_id == "late-native-id" assert detail.run.status == "failed" assert not harness.connections[0].inputs @pytest.mark.asyncio async def test_failed_stop_persistence_closes_work_without_waiting_for_more_output( code, monkeypatch ): service, harness, _ = code session = await session_for(code) run = await service.send( session.id, new_id(), session.revision, "quiet work", expected_epoch=service.epoch, ) await harness.started.wait() async def failed_save(*args, **kwargs): raise CodeUnavailableError("Disk failed") monkeypatch.setattr(service._store, "save_progress", failed_save) with pytest.raises(CodeUnavailableError): await service.stop(session.id, run.id) await asyncio.wait_for(service.wait_idle(session.id), 3) assert harness.connections[0].closed @pytest.mark.asyncio async def test_create_is_lazy_and_retry_does_not_duplicate(code): service, harness, directory = code session = await session_for(code) repeated = await service.create_session(session.id, str(directory)) assert repeated == session assert harness.connections == [] assert len((await service.list_sessions()).sessions) == 1 @pytest.mark.asyncio async def test_competing_sends_admit_only_one_and_repeat_returns_receipt(code): service, harness, _ = code session = await session_for(code) command = new_id() results = await asyncio.gather( service.send( session.id, command, session.revision, "first", expected_epoch=service.epoch ), service.send( session.id, new_id(), session.revision, "second", expected_epoch=service.epoch, ), return_exceptions=True, ) assert sum(isinstance(result, CodeConflictError) for result in results) == 1 run = results[0] assert not isinstance(run, BaseException) await harness.started.wait() repeat = await service.send( session.id, command, session.revision, "first", expected_epoch=service.epoch ) assert repeat.id == run.id assert harness.connections[0].inputs == [(command, "first", "provider/model")] with pytest.raises(CodeConflictError): await service.send( session.id, command, session.revision, "changed", expected_epoch=service.epoch, ) @pytest.mark.asyncio async def test_http_cancellation_does_not_cancel_native_creation(code): service, harness, _ = code session = await session_for(code) harness.creation_gate.clear() command = new_id() await service.send( session.id, command, session.revision, "continue", expected_epoch=service.epoch ) await harness.creating.wait() # There is no HTTP-owned native waiter left to cancel after admission. detail = await service.get_detail(session.id) assert detail.run.id == command harness.creation_gate.set() await harness.started.wait() detail = await service.get_detail(session.id) assert detail.session.native_thread_id == "native-1" assert harness.connections[0].inputs[0][0] == command @pytest.mark.asyncio async def test_stop_before_native_ack_targets_that_run_only(code): service, harness, _ = code session = await session_for(code) harness.start_gate.clear() run = await service.send( session.id, new_id(), session.revision, "first", expected_epoch=service.epoch ) await harness.submitted.wait() await service.stop(session.id, run.id) harness.start_gate.set() await harness.interrupted.wait() connection = harness.connections[0] assert connection.interrupts == ["turn-1"] await connection.finish("turn-1", "interrupted") detail = await service.get_detail(session.id) assert detail.run.status == "interrupted" second = await service.send( session.id, new_id(), detail.session.revision, "second", expected_epoch=service.epoch, ) await harness.wait_inputs(2) await service.stop(session.id, run.id) assert second.id != run.id assert connection.interrupts == ["turn-1"] @pytest.mark.asyncio async def test_stop_during_creation_prevents_native_submission(code): service, harness, _ = code session = await session_for(code) harness.creation_gate.clear() run = await service.send( session.id, new_id(), session.revision, "do not run", expected_epoch=service.epoch, ) await harness.creating.wait() await service.stop(session.id, run.id) harness.creation_gate.set() await service.wait_idle(session.id) detail = await service.get_detail(session.id) assert detail.run.status == "interrupted" assert detail.session.native_thread_id == "native-1" assert harness.connections[0].inputs == [] @pytest.mark.asyncio async def test_browser_observers_are_independent_of_work(code): service, harness, _ = code session = await session_for(code) first, _ = await service.subscribe() second, _ = await service.subscribe() await service.send( session.id, new_id(), session.revision, "keep running", expected_epoch=service.epoch, ) await harness.started.wait() await first.aclose() await second.aclose() connection = harness.connections[0] await connection.text("turn-1", "answer", "Still running", complete=True) await connection.finish("turn-1") detail = await service.get_detail(session.id) assert detail.items[-1].text == "Still running" assert detail.run.status == "completed" assert not connection.closed @pytest.mark.asyncio async def test_idle_delete_removes_both_histories_and_blocks_late_create(code): service, harness, directory = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch ) await harness.started.wait() with pytest.raises(CodeConflictError): await service.delete_session(session.id, session.revision) assert harness.connections[0].deleted == [] await harness.connections[0].finish("turn-1") detail = await service.get_detail(session.id) await service.delete_session(session.id, detail.session.revision) await service.wait_idle(session.id) assert harness.connections[0].deleted == ["native-1"] assert (await service.list_sessions()).sessions == () with pytest.raises(CodeConflictError): await service.create_session(session.id, str(directory)) @pytest.mark.asyncio async def test_restart_preserves_receipt_and_does_not_replay_input( database_factory, tmp_path ): harness = FakeHarness() database, lock = tmp_path / "code.db", tmp_path / "code.lock" first = CodeService(SQLiteCodeStore(database_factory(database, lock)), harness) await first.start() session = await first.create_session(new_id(), str(tmp_path)) run = await first.send( session.id, new_id(), session.revision, "once", expected_epoch=first.epoch ) await harness.started.wait() await first.close() await close_code_database(first) second = CodeService(SQLiteCodeStore(database_factory(database, lock)), harness) await second.start() try: repeat = await second.send( session.id, run.id, session.revision, "once", expected_epoch=second.epoch ) assert repeat.id == run.id assert repeat.status == "interrupted" assert len(harness.connections) == 1 assert harness.connections[0].inputs == [(run.id, "once", "provider/model")] finally: await second.close() await close_code_database(second) @pytest.mark.asyncio async def test_two_answers_claim_one_native_prompt(code): service, harness, _ = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "approval", expected_epoch=service.epoch ) await harness.started.wait() connection = harness.connections[0] await connection.prompt(0) prompt = (await service.get_detail(session.id)).prompts[0] harness.answer_gate.clear() results = await asyncio.gather( service.answer(session.id, prompt.id, new_id(), {"choice": "accept"}), service.answer(session.id, prompt.id, new_id(), {"choice": "decline"}), return_exceptions=True, ) assert sum(isinstance(result, CodeConflictError) for result in results) == 1 await harness.answering.wait() harness.answer_gate.set() await harness.answered.wait() assert len(connection.answers) == 1 assert (await service.get_detail(session.id)).prompts[0].status == "resolved" @pytest.mark.asyncio async def test_prompt_arrival_has_one_durable_position_despite_repeated_native_item( database_factory, code, ): service, harness, directory = code session = await session_for(code) run = await service.send( session.id, new_id(), session.revision, "Work", expected_epoch=service.epoch ) await harness.started.wait() connection = harness.connections[0] await connection.text("turn-1", "shared-tool", "Before approval", kind="tool") subscription, _ = await service.subscribe() try: for request_id in (1, 1, "1"): prompt = PromptRequest( request_id, "approval", {}, {}, "turn-1", "shared-tool" ) connection.requests[request_id] = prompt await connection.sink( HarnessEvent( connection.generation, connection.thread_id, "prompt", turn_id="turn-1", prompt=prompt, ) ) detail = await service.get_detail(session.id) entries = [item for item in detail.items if item.kind == "prompt"] assert len(entries) == len(detail.prompts) == 2 assert [item.sequence for item in entries] == [3, 4] assert {item.id for item in entries} == {prompt.id for prompt in detail.prompts} events = subscription.__aiter__() async with asyncio.timeout(2): for _ in range(2): event = await anext(events) if event.event == "item.updated": event = await anext(events) assert event.event == "prompt.updated" assert event.data["item"]["id"] == event.data["prompt"]["id"] assert event.data["runs"][0]["id"] == run.id for request_id in (1, "1"): await connection.resolve(request_id) await connection.text( "turn-1", "shared-tool", "Complete output", kind="tool", complete=True ) await connection.text("turn-1", "after", "After approvals", complete=True) await connection.finish("turn-1") await service.close() await close_code_database(service) restored = CodeService( SQLiteCodeStore( database_factory(directory / "code.db", directory / "code.lock") ), harness, ) await restored.start() try: saved = await restored.get_detail(session.id) assert [item for item in saved.items if item.kind == "prompt"] == entries assert [item.sequence for item in saved.items] == [1, 2, 3, 4, 5] assert all(prompt.status == "resolved" for prompt in saved.prompts) await restored.send( session.id, new_id(), saved.session.revision, "Continue", expected_epoch=restored.epoch, ) await harness.wait_inputs(2) await harness.connections[-1].finish("turn-2") recovered = await restored.get_detail(session.id) assert [ item for item in recovered.items if item.kind == "prompt" ] == entries assert ( len( [ item for item in recovered.items if item.native_item_id == "shared-tool" ] ) == 1 ) finally: await restored.close() finally: await subscription.aclose() @pytest.mark.asyncio async def test_active_prompt_outside_page_keeps_its_entry_run_and_older_cursor(code): service, harness, _ = code session = await session_for(code) run = await service.send( session.id, new_id(), session.revision, "Work", expected_epoch=service.epoch ) await harness.started.wait() connection = harness.connections[0] await connection.prompt(0, turn_id=None) prompt = (await service.get_detail(session.id)).prompts[0] for index in range(55): await connection.text("turn-1", str(index), f"Output {index}", complete=True) await connection.finish("turn-1") newest = await service.get_detail(session.id) assert newest.next_before is not None assert len(newest.items) == 51 assert newest.items[0].id == prompt.id assert newest.items[0].run_id == run.id assert newest.active_prompt_ids == (prompt.id,) await connection.resolve(0) resolved = await service.get_detail(session.id) assert resolved.active_prompt_ids == () and resolved.prompts == () assert resolved.next_before == newest.next_before older = await service.get_detail(session.id, before=newest.next_before) assert older.prompts[0].id == prompt.id and older.prompts[0].status == "resolved" by_id = {item.id: item for item in (*older.items, *newest.items)} assert sorted(item.sequence for item in by_id.values()) == list(range(1, 58)) @pytest.mark.asyncio async def test_prompt_during_thread_creation_has_a_saved_run_without_native_ids(code): service, harness, _ = code session = await session_for(code) harness.creation_gate.clear() run = await service.send( session.id, new_id(), session.revision, "Start", expected_epoch=service.epoch ) await harness.creating.wait() connection = harness.connections[0] try: await connection.prompt(0, turn_id=None) detail = await service.get_detail(session.id) assert detail.run.native_turn_id is None assert detail.items[-1].id == detail.prompts[0].id assert detail.items[-1].run_id == run.id assert detail.items[-1].sequence == 2 assert detail.prompts[0].native_turn_id is None await connection.resolve(0) finally: harness.creation_gate.set() @pytest.mark.asyncio async def test_native_resolution_while_answer_is_waiting_never_resurrects_prompt(code): service, harness, _ = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "approval", expected_epoch=service.epoch ) await harness.started.wait() connection = harness.connections[0] await connection.prompt(0) prompt = (await service.get_detail(session.id)).prompts[0] harness.answer_gate.clear() await service.answer(session.id, prompt.id, new_id(), {"choice": "accept"}) await harness.answering.wait() await connection.resolve(0) harness.answer_gate.set() await harness.answered.wait() assert connection.answers == [] assert (await service.get_detail(session.id)).prompts[0].status == "resolved" @pytest.mark.asyncio async def test_streaming_does_not_invalidate_rename_revision(code): service, harness, _ = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch ) await harness.started.wait() before = await service.get_detail(session.id) await harness.connections[0].text("turn-1", "answer", "partial") after = await service.get_detail(session.id) assert after.version > before.version assert after.session.revision == before.session.revision await service.update_settings( session.id, before.session.revision, {"title": "My code"} ) assert (await service.get_detail(session.id)).session.title == "My code" @pytest.mark.asyncio async def test_context_usage_is_an_absolute_deduplicated_session_snapshot(code): service, harness, _ = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch ) await harness.started.wait() connection = harness.connections[0] before = await service.get_detail(session.id) subscription, _ = await service.subscribe() events = subscription.__aiter__() try: await connection.context_usage("turn-1", 90_000) async with asyncio.timeout(2): event = await anext(events) after = await service.get_detail(session.id) assert event.event == "session.updated" assert event.data["session"]["context_used_tokens"] == 90_000 assert after.session.context_used_tokens == 90_000 assert after.session.revision == before.session.revision assert after.session.updated_at == before.session.updated_at assert ( await service._store.get_session(session.id) ).context_used_tokens == 90_000 await connection.context_usage("turn-1", 90_000) duplicate = await service.get_detail(session.id) assert duplicate.version == after.version await connection.context_usage("turn-1", 25_000) compacted = await service.get_detail(session.id) assert compacted.session.context_used_tokens == 25_000 assert compacted.session.revision == after.session.revision assert compacted.session.updated_at == after.session.updated_at await connection.finish("turn-1") finally: await subscription.aclose() @pytest.mark.asyncio async def test_context_usage_is_retained_across_model_changes(code): service, harness, _ = code harness.configurations["provider/other"] = "other" session = await session_for(code) await service.send( session.id, new_id(), session.revision, "first", expected_epoch=service.epoch ) await harness.started.wait() connection = harness.connections[0] await connection.context_usage("turn-1", 40_000) await connection.finish("turn-1") detail = await service.get_detail(session.id) changed = await service.update_settings( session.id, detail.session.revision, {"model": "provider/other"} ) assert changed.context_used_tokens == 40_000 restored = await service.update_settings( session.id, changed.revision, {"model": "provider/model"} ) assert restored.context_used_tokens == 40_000 assert (await service._store.get_session(session.id)).context_used_tokens == 40_000 await service.send( session.id, new_id(), restored.revision, "second", expected_epoch=service.epoch, ) await harness.wait_inputs(2) await connection.context_usage("turn-2", 7_500) current = await service.get_detail(session.id) assert current.session.context_used_tokens == 7_500 await connection.finish("turn-2") @pytest.mark.asyncio async def test_resumed_context_usage_is_accepted_after_the_next_run_is_admitted(code): service, harness, _ = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "first", expected_epoch=service.epoch ) await harness.started.wait() original = harness.connections[0] await original.context_usage("turn-1", 10_000) await original.finish("turn-1") session = (await service.get_detail(session.id)).session harness.configurations[harness.model] = "replacement" harness.start_gate.clear() harness.started.clear() harness.submitted.clear() await service.send( session.id, new_id(), session.revision, "second", expected_epoch=service.epoch ) await harness.submitted.wait() resumed = harness.connections[1] assert original.closed assert resumed.resumed == [session.native_thread_id] await resumed.context_usage("turn-1", 11_000) await resumed.context_usage("turn-1", 12_000, generation=original.generation) await resumed.context_usage("turn-1", 13_000, thread_id="another-thread") replayed = await service.get_detail(session.id) assert replayed.session.context_used_tokens == 11_000 assert (await service._store.get_session(session.id)).context_used_tokens == 11_000 harness.start_gate.set() await harness.started.wait() await resumed.context_usage("turn-2", 20_000) current = await service.get_detail(session.id) assert current.session.context_used_tokens == 20_000 await resumed.finish("turn-2") @pytest.mark.asyncio async def test_catalog_replacement_is_limited_to_selected_entry_and_session(code): service, harness, _ = code harness.configurations["provider/other"] = "other-1" session = await session_for(code) await service.send( session.id, new_id(), session.revision, "first", expected_epoch=service.epoch ) await harness.started.wait() original = harness.connections[0] await original.finish("turn-1") harness.model = "provider/other" detail = await service.get_detail(session.id) selected = await service.update_settings( session.id, detail.session.revision, {"model": harness.model} ) await service.send( session.id, new_id(), selected.revision, "second", expected_epoch=service.epoch, ) await harness.wait_inputs(2) await original.finish("turn-2") assert len(harness.connections) == 1 harness.configurations["unrelated/model"] = "new" harness.configurations["provider/other"] = "changed" detail = await service.get_detail(session.id) await service.send( session.id, new_id(), detail.session.revision, "third", expected_epoch=service.epoch, ) await harness.wait_inputs(3) assert len(harness.connections) == 2 assert original.closed assert harness.connections[1].resumed == ["native-1"] @pytest.mark.asyncio async def test_cancelled_http_admission_still_commits_and_executes_once( database_factory, tmp_path ): committed = asyncio.Event() release = asyncio.Event() class GatedStore(SQLiteCodeStore): async def admit_run(self, session, run, item, expected_revision): result = await super().admit_run(session, run, item, expected_revision) committed.set() await release.wait() return result harness = FakeHarness() service = CodeService( GatedStore(database_factory(tmp_path / "code.db", tmp_path / "code.lock")), harness, ) await service.start() try: session = await service.create_session(new_id(), str(tmp_path)) operation_id = new_id() http = asyncio.create_task( service.send( session.id, operation_id, session.revision, "once", expected_epoch=service.epoch, ) ) await committed.wait() http.cancel() with pytest.raises(asyncio.CancelledError): await http release.set() await harness.started.wait() repeat = await service.send( session.id, operation_id, session.revision, "once", expected_epoch=service.epoch, ) assert repeat.id == operation_id assert len(harness.connections[0].inputs) == 1 finally: release.set() await service.close() await close_code_database(service) @pytest.mark.asyncio @pytest.mark.parametrize("trigger", ["timer", "size", "complete", "detail"]) async def test_buffer_staging_and_each_flush_preserve_commit_and_observer_order( code, monkeypatch, flush_timer, trigger ): service, harness, _ = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch ) await harness.started.wait() before = await service.get_detail(session.id) connection = harness.connections[0] subscription, _ = await service.subscribe() save = service._store.save_progress writes = [] async def observe_save(session, revision, **values): if values.get("items"): assert service.cursor == before.cursor await save(session, revision, **values) if values.get("items"): assert service.cursor == before.cursor writes.append(tuple(values["items"])) monkeypatch.setattr(service._store, "save_progress", observe_save) try: text = "x" * 4095 await connection.text("turn-1", "answer", text) await asyncio.wait_for(flush_timer[0].wait(), 3) await connection.text("turn-1", "answer", text) observer, snapshot = await service.subscribe() await observer.aclose() assert snapshot["sessions"][0]["version"] == before.version + 1 assert snapshot["cursor"] == before.cursor assert await service._store.items(session.id, None, None) == before.items assert writes == [] if trigger == "timer": flush_timer[1].set() elif trigger == "size": await connection.text("turn-1", "answer", text + "x") elif trigger == "complete": await connection.text("turn-1", "answer", text, complete=True) else: await service.get_detail(session.id) event = await asyncio.wait_for(anext(aiter(subscription)), 3) assert event.event == "item.updated" assert event.id == before.cursor + 1 assert event.data["version"] == before.version + ( 3 if trigger in {"size", "complete"} else 2 ) assert len(writes) == 1 and len(writes[0]) == 1 saved = (await service._store.items(session.id, None, None))[-1] assert saved == writes[0][0] assert event.data["item"] == saved.model_dump(mode="json") assert saved.text == text + ("x" if trigger == "size" else "") assert saved.complete == (trigger == "complete") finally: flush_timer[1].set() await subscription.aclose() @pytest.mark.asyncio async def test_failed_terminal_bundle_retains_committed_records_and_staged_output( code, monkeypatch, flush_timer ): service, harness, _ = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch ) await harness.started.wait() connection = harness.connections[0] await connection.prompt(1) before = await service.get_detail(session.id) await connection.text("turn-1", "answer", "unsaved") await asyncio.wait_for(flush_timer[0].wait(), 3) save, publish = service._store.save_progress, service._events.publish attempted, published = [], [] async def reject_terminal(session, revision, **values): run = values.get("run") if run is not None and run.status == "completed": attempted.append((session, values)) raise CodeUnavailableError("Terminal commit failed") await save(session, revision, **values) def observe(event, data): published.append((event, data)) return publish(event, data) monkeypatch.setattr(service._store, "save_progress", reject_terminal) monkeypatch.setattr(service._events, "publish", observe) await connection.finish("turn-1") await asyncio.wait_for(service.wait_idle(session.id), 3) assert len(attempted) == 1 candidate_session, values = attempted[0] assert candidate_session.revision == before.session.revision + 1 assert [item.text for item in values["items"]] == ["unsaved"] assert [prompt.status for prompt in values["prompts"]] == ["expired"] assert await service._store.get_session(session.id) == before.session assert await service._store.latest_run(session.id) == before.run assert await service._store.items(session.id, None, None) == before.items assert await service._store.prompts(session.id) == before.prompts owner = service._owners[session.id] assert owner.state.session == before.session and owner.state.run == before.run assert owner.state.runs[before.run.id] == before.run assert tuple(owner.state.prompts.values()) == before.prompts assert [item.text for item in owner.state.pending_items] == ["unsaved"] assert connection.closed assert published and all(event == "session.notice" for event, _ in published) assert all( data["run"] == before.run.model_dump(mode="json") for _, data in published ) with pytest.raises(CodeUnavailableError): await service.get_detail(session.id) @pytest.mark.asyncio @pytest.mark.parametrize("fail", [False, True]) async def test_review_liveness_flush_includes_pending_output_and_keeps_staging_version( code, monkeypatch, flush_timer, fail ): service, harness, _ = code session = await session_for(code) await service.send( session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch ) await harness.started.wait() first = harness.connections[0] packets = CodexPackets(first) await packets.spawn() await packets.review() review = (await service.get_detail(session.id)).items[-1] await first.finish("turn-1") harness.configurations[harness.model] = "replacement" session = (await service.get_detail(session.id)).session harness.started.clear() await service.send( session.id, new_id(), session.revision, "Continue", expected_epoch=service.epoch ) await asyncio.wait_for(harness.started.wait(), 3) second = harness.connections[1] before = await service.get_detail(session.id) packets = CodexPackets(second) await packets.spawn() await second.text("turn-2", "reply", "pending") await asyncio.wait_for(flush_timer[0].wait(), 3) save, publish = service._store.save_progress, service._events.publish writes, published = [], [] async def observe_save(session, revision, **values): assert service._version == before.version + 1 assert service.cursor == before.cursor writes.append(tuple(values["items"])) if fail: raise CodeUnavailableError("Review flush failed") await save(session, revision, **values) def observe(event, data): published.append((event, data)) return publish(event, data) monkeypatch.setattr(service._store, "save_progress", observe_save) monkeypatch.setattr(service._events, "publish", observe) await packets.review() assert len(writes) == 1 assert {item.id for item in writes[0]} == { review.id, next(item.id for item in writes[0] if item.text == "pending"), } if fail: await asyncio.wait_for(service.wait_idle(session.id), 3) assert second.closed assert all(event != "item.updated" for event, _ in published) assert published[-1][1]["active_review_ids"] == [] assert { item.id for item in service._owners[session.id].state.pending_items } == {item.id for item in writes[0]} else: assert [event for event, _ in published] == ["item.updated", "item.updated"] assert [data["version"] for _, data in published] == [ before.version + 2, before.version + 3, ] assert all(data["active_review_ids"] == [review.id] for _, data in published) assert next(item for item in writes[0] if item.id == review.id) == review monkeypatch.setattr(service._store, "save_progress", save) @pytest.mark.asyncio @pytest.mark.parametrize("native_exists", [False, True]) async def test_startup_reconciles_persisted_deletion_without_another_native_delete( database_factory, code, native_exists ): service, harness, directory = code session = await idle_native(code) await service._store.save_progress( session.model_copy( update={"status": "deleting", "revision": session.revision + 1} ), session.revision, ) await service.close() await close_code_database(service) if not native_exists: harness.histories.pop(session.native_thread_id) restarted = CodeService( SQLiteCodeStore( database_factory(directory / "code.db", directory / "code.lock") ), harness, ) try: await restarted.start() await asyncio.wait_for(restarted.wait_idle(session.id), 3) if native_exists: detail = await restarted.get_detail(session.id) assert detail.session.status == "ready" and detail.items else: assert not (await restarted.list_sessions()).sessions assert await restarted._store.is_deleted(session.id) assert all(connection.deleted == [] for connection in harness.connections) finally: await restarted.close() @pytest.mark.asyncio @pytest.mark.parametrize("may_have_input", [False, True]) async def test_missing_native_history_is_recreated_only_before_possible_input( database_factory, code, may_have_input ): service, harness, directory = code session = await session_for(code) await service._store.save_progress( session.model_copy( update={ "native_thread_id": "missing", "native_may_have_input": may_have_input, } ), session.revision, ) await service.close() await close_code_database(service) restarted = CodeService( SQLiteCodeStore( database_factory(directory / "code.db", directory / "code.lock") ), harness, ) try: await restarted.start() await restarted.send( session.id, new_id(), session.revision, "next", expected_epoch=restarted.epoch, ) if not may_have_input: await asyncio.wait_for(harness.started.wait(), 3) await harness.connections[-1].finish("turn-1") await asyncio.wait_for(restarted.wait_idle(session.id), 3) detail = await restarted.get_detail(session.id) assert detail.run is not None assert detail.run.status == ("failed" if may_have_input else "completed") assert len(harness.connections[-1].inputs) == (0 if may_have_input else 1) finally: await restarted.close() @pytest.mark.asyncio async def test_cancelled_close_waiter_does_not_cancel_owned_shutdown(code, monkeypatch): service, harness, _ = code session = await idle_native(code) connection = harness.connections[0] entered, release = asyncio.Event(), asyncio.Event() close = connection.close async def gated_close(): entered.set() await release.wait() await close() monkeypatch.setattr(connection, "close", gated_close) waiter = asyncio.create_task(service.close()) try: await asyncio.wait_for(entered.wait(), 3) waiter.cancel() with pytest.raises(asyncio.CancelledError): await waiter with pytest.raises(CodeUnavailableError): await service.send( session.id, new_id(), session.revision, "late", expected_epoch=service.epoch, ) release.set() await asyncio.wait_for(asyncio.gather(service.close(), service.close()), 3) assert connection.closed and service.availability()[0] is False finally: release.set() await service.close() await close_code_database(service)
import asyncio
import uuid
from types import SimpleNamespace
from unittest.mock import AsyncMock, Mock
import pytest
import pytest_asyncio
from free_claude_code.application.code_sessions import CodeConflictError, CodeService
from free_claude_code.application.code_sessions import service as service_module
from free_claude_code.application.code_sessions.models import (
CodeItem,
CodeRun,
CodeSession,
CodeUnavailableError,
CodeValidationError,
HarnessEvent,
ItemUpdate,
PromptRequest,
)
from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStore
from free_claude_code.runtime.codex_protocol import CodexProtocol
from tests.code_sessions_support import (
CodexPackets,
FakeConnection,
FakeHarness,
close_code_database,
)
def new_id():
return str(uuid.uuid4())
@pytest_asyncio.fixture
async def code(database_factory, tmp_path):
harness = FakeHarness()
store = SQLiteCodeStore(
database_factory(tmp_path / "code.db", tmp_path / "code.lock")
)
service = CodeService(store, harness)
await service.start()
try:
yield service, harness, tmp_path
finally:
await service.close()
await close_code_database(service)
async def session_for(code):
service, _, directory = code
return await service.create_session(new_id(), str(directory))
@pytest.mark.asyncio
async def test_history_pages_do_not_create_execution_owners(code, monkeypatch):
service, harness, directory = code
session = await service._store.create(
CodeSession(id=new_id(), cwd=str(directory), model=harness.model)
)
run = CodeRun(id=new_id(), session_id=session.id, text="old", model=harness.model)
user = CodeItem(
id=run.id, run_id=run.id, session_id=session.id, sequence=1, kind="user"
)
session, run = await service._store.admit_run(session, run, user, session.revision)
await service._store.save_progress(
session,
session.revision,
run=run.model_copy(update={"status": "completed"}),
items=tuple(
CodeItem(
id=new_id(),
run_id=run.id,
session_id=session.id,
sequence=n,
kind="text",
text="saved" * 100,
complete=True,
)
for n in range(2, 202)
),
)
monkeypatch.setattr(
service._store, "items", AsyncMock(side_effect=AssertionError("full history"))
)
monkeypatch.setattr(
service._store, "runs", AsyncMock(side_effect=AssertionError("all runs"))
)
page = await service.get_detail(session.id)
assert len(page.items) == 50
assert page.next_before is not None
older = await service.get_detail(session.id, before=page.next_before)
assert len(older.items) == 50
assert older.items[-1].sequence < page.items[0].sequence
assert not service._owners
assert not service._gates
assert not harness.connections
@pytest.mark.asyncio