Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

test: script the cancel and terminal clients by events, not wall time (#2403)

Call White0c2ba96448b4
diff --git a/tests/test_internal_server.py b/tests/test_internal_server.py
index 714cd350c..3126da91d 100644
--- a/tests/test_internal_server.py
+++ b/tests/test_internal_server.py
@@ -3006,6 +3006,7 @@ def test_cancel_waits_for_stale_dispatch_cleanup_before_releasing(tmp_path, monk
async def _go():
done_event = asyncio.Event()
+ sink_registered = asyncio.Event()
cleanup_started = asyncio.Event()
allow_cleanup = asyncio.Event()
@@ -3016,8 +3017,9 @@ def test_cancel_waits_for_stale_dispatch_cleanup_before_releasing(tmp_path, monk
done_event=done_event,
turn_token="old-turn",
)
+ sink_registered.set()
try:
- await asyncio.sleep(60)
+ await asyncio.Event().wait() # only the cancel ends this dispatch
finally:
cleanup_started.set()
await allow_cleanup.wait()
@@ -3030,11 +3032,9 @@ def test_cancel_waits_for_stale_dispatch_cleanup_before_releasing(tmp_path, monk
platform_specific={"agent_session_id": session_id},
)
task = asyncio.create_task(_stale_dispatch())
- for _ in range(200):
- if controller.get_turn_sink(resolve_turn_sink_key(controller, context)) is not None:
- break
- await asyncio.sleep(0.01)
- assert controller.get_turn_sink(resolve_turn_sink_key(controller, context)) is not None
+ registered = asyncio.create_task(sink_registered.wait())
+ await asyncio.wait({task, registered}, return_when=asyncio.FIRST_COMPLETED)
+ assert registered.done(), task.result() # a dispatch that died first surfaces its error
app.state.in_flight_dispatches[session_id] = session_turns.Turn(
task=task,
context=context,
@@ -3048,7 +3048,13 @@ def test_cancel_waits_for_stale_dispatch_cleanup_before_releasing(tmp_path, monk
controller.command_handler.handle_stop = AsyncMock(side_effect=_not_active)
async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
cancel_task = asyncio.create_task(client.post(f"/internal/cancel/{session_id}"))
- await asyncio.wait_for(cleanup_started.wait(), timeout=1)
+ # Ordering, not latency: the endpoint's database work before it cancels
+ # the dispatch may take any time, but it must not answer first.
+ cleanup_seen = asyncio.create_task(cleanup_started.wait())
+ first, _ = await asyncio.wait({cancel_task, cleanup_seen}, return_when=asyncio.FIRST_COMPLETED)
+ assert cleanup_seen in first and cancel_task not in first, (
+ "the cancel answered before it cancelled the stale dispatch"
+ )
await asyncio.sleep(0.02)
assert not cancel_task.done()
assert session_id in app.state.in_flight_dispatches
@@ -3056,7 +3062,8 @@ def test_cancel_waits_for_stale_dispatch_cleanup_before_releasing(tmp_path, monk
resp = await cancel_task
return resp, task
- resp, task = asyncio.run(_go())
+ # A hang guard only: the ordering above is decided by events, never by this bound.
+ resp, task = asyncio.run(asyncio.wait_for(_go(), timeout=30))
assert resp.status_code == 200
assert resp.json()["status"] == "stale_released"
assert task.cancelled()
diff --git a/tests/test_terminal_backend.py b/tests/test_terminal_backend.py
index 7c1b28156..51ffa780d 100644
--- a/tests/test_terminal_backend.py
+++ b/tests/test_terminal_backend.py
@@ -41,18 +41,25 @@ from vibe.ui_server import app
class _FakeWebSocket:
+ """A scripted client. A message naming ``after`` is received only once the server
+ has sent a text frame of that type, so the script follows the server, not a clock."""
+
def __init__(self, messages: list[dict]) -> None:
self._messages = list(messages)
self.sent_bytes: list[bytes] = []
self.sent_text: list[str] = []
+ self._sent_types: dict[str, asyncio.Event] = {}
+
+ def _sent(self, frame_type: str) -> asyncio.Event:
+ return self._sent_types.setdefault(frame_type, asyncio.Event())
async def receive(self) -> dict:
if not self._messages:
await asyncio.sleep(0.05)
return {"type": "websocket.disconnect", "code": 1000}
message = self._messages.pop(0)
- if delay := message.pop("delay", None):
- await asyncio.sleep(delay)
+ if after := message.pop("after", None):
+ await self._sent(after).wait()
return message
async def send_bytes(self, payload: bytes) -> None:
@@ -60,6 +67,7 @@ class _FakeWebSocket:
async def send_text(self, payload: str) -> None:
self.sent_text.append(payload)
+ self._sent(json.loads(payload)["type"]).set()
class _RecordingWebSocket:
@@ -108,12 +116,15 @@ async def _terminal_ephemeral_pty_round_trip(monkeypatch, tmp_path):
service = TerminalService(idle_timeout_seconds=60, max_sessions=2)
websocket = _FakeWebSocket(
[
- {"type": "websocket.receive", "bytes": b"printf READY\\\\n; exit 7\n", "delay": 0.1},
- {"type": "websocket.disconnect", "code": 1000, "delay": 0.5},
+ {"type": "websocket.receive", "bytes": b"printf READY\\\\n; exit 7\n", "after": "ready"},
+ # A client that hangs up only after it was told the shell exited, however
+ # long the shell took: one that hangs up first is owed no exit frame.
+ {"type": "websocket.disconnect", "code": 1000, "after": "exit"},
]
)
- await service.handle_websocket(websocket, "term_1")
+ # A hang guard only; the script waits on the server's frames, not on time.
+ await asyncio.wait_for(service.handle_websocket(websocket, "term_1"), timeout=30)
await service.shutdown()
assert json.loads(websocket.sent_text[0]) == {"type": "ready", "persistent": False}