dinos
01845f4311
* chore: add pytest-asyncio in auto mode * test: migrate channel and stream tests to native async Convert run_async() wrapper tests to plain 'async def test_*' under pytest-asyncio auto mode. collect_events() in stream_v3_fakes becomes a coroutine awaited at every call site. * test: migrate command and model/middleware tests to native async Convert run_async() wrappers (import, alias, and fixture forms) to plain 'async def test_*'. Multi-call tests merge onto one loop as sequential awaits; none asserted on loop identity. * test: migrate TUI, notifier, gateway, and session tests to native async TUI/notifier/gateway files convert run_async wrappers to plain async tests. test_sessions.py's unittest.TestCase classes move to unittest.IsolatedAsyncioTestCase (pytest-asyncio does not await async methods on plain TestCase; converting blindly would have made ~70 tests silently vacuous). Its setUpClass keeps a one-shot asyncio.run() since IsolatedAsyncioTestCase has no async class-level hook. TestLoadingWidget in test_tui_widgets.py drops its TestCase base for the same reason. * test: replace direct asyncio.run() calls with native async tests Convert tests that called asyncio.run() (directly or via a local _run helper) to plain 'async def test_*'; delete the local helpers. * test: drop undeclared anyio markers and delete run_async helper The @pytest.mark.anyio tests relied on anyio being a transitive dep of httpx; auto-mode pytest-asyncio collects them natively. run_async() and its fixture are unreferenced after the migration, so remove them — pytest-asyncio's per-test loop teardown covers the pending-task cancellation the helper existed for (verified: full suite runs with no 'Event loop is closed' errors or destroyed-task warnings). * test: add autouse fixture for watcher cleanup * refactor: remove redundant hasattr calls * refactor: add typed middleware event sink and thread through assembly Add MiddlewareEventSink protocol + NoOpSink in middleware/events.py with a documented any-thread non-blocking contract (contract test uses a deliberately-slow fake sink). Thread an optional `events` parameter through create_cli_agent -> _get_default_middleware -> tool selector / model fallback constructors; subagent stacks are always forced to NoOpSink. * refactor: inject a notifier port into async-watcher and background middleware Add public pre_cancel_watcher() and enqueue_task_notification() to cli/async_notifier.py and a small NotifierPort protocol (middleware/notifier.py) that the module satisfies structurally. AsyncWatcherMiddleware and BackgroundExecutionMiddleware now receive the port by constructor injection at the composition root, deleting the lazy 'from ..cli import async_notifier' imports and the private _watcher_by_thread / _enqueue pokes. * refactor: invert tool-selection ownership onto a frontend event sink The adaptive tool selector now reports on_tool_selection_started / on_tool_selection / on_tool_selection_ended to the injected sink instead of writing four process-global module variables. The frontend sink (stream/sink.py FrontendEventSink) owns the selected/total/active state with consume-once + dedup-vs-last-emitted semantics; stream/tool_selection.py reads that sink object (a ToolSelectionView) rather than reaching into tool_selector's globals. Deleted: the 4 module globals, the cross-module mutations in tool_selection.py, the track_stream_selection flag, the now-vestigial _ToolSelectionTrackerMiddleware, reset_tool_selection_state_for_tests, and the autouse conftest fixture. The sink is threaded from the two interactive frontends through create_runtime_gateways -> LocalGraphGateway (read side) and _load_agent -> create_cli_agent (write side); subagent / headless stacks get NoOpSink. * refactor: route model-fallback narration through the injected event sink Delete the _ui_emit_fn / set_ui_emit module global and the ..stream.console import from model_fallback.py. The fallback middleware now reports through its injected sink: the fallback transition via the structured on_model_fallback (the frontend formats the '-> Falling back to ...' line), and the surrounding narration (primary-failure header, per-attempt outcome, exhaustion, non-fallbackable rejection) via emit_fallback_notice, preserving the exact user-facing text. The TUI binds its _append_system as the sink's fallback display where it used to call set_ui_emit (cleared on exit); the Rich CLI's sink prints to the console. _try_fallbacks / _guard_and_fallback take the sink. * refactor: declare events on the GraphGateway protocol Both gateway implementations now carry an explicit events attribute (LangGraphServerGateway holds None — no frontend renders middleware events across the HTTP boundary), so the four call sites use plain attribute access instead of getattr probing an implicit contract. * refactor: bind fallback display via the closure-scoped concrete sink The App methods used gateway.events (typed as the read-side view) and hasattr-probed for the concrete FrontendEventSink API. The enclosing factory creates that sink two hundred lines up — close over it directly: no probing, fully typed, and it becomes a constructor parameter naturally when the App class is hoisted out of the factory. * fix: end tool selection before fallback handler * fix: keep fallback display errors non-fatal * fix: preserve selector suppression for default streams * fix: restore fallback notice console display * refactor: consolidate fallback narration events * refactor: clean middleware event sink plumbing * fix: type gateway session events * refactor: make all event protocols runtime-checkable MiddlewareEventSink already carried @runtime_checkable (the stream binding guard isinstance-checks it); ToolSelectionView and SessionEvents now match, so mirroring that pattern against any of the three protocols works instead of raising TypeError. * fix(cli): close QuickJS workers after one-shot failures * fix(cli): honor no-thinking in final output * fix(channels): report failed startup accurately * fix(channels): make Telegram cleanup idempotent * fix(tui): skip command sync during exit * fix(channels): preserve startup state during retries * refactor(channels): share pending startup status * refactor(cli): expose channel startup snapshot * fix(tui): move channel startup off event loop * test(channels): release retry gate on assertion failure --------- Co-authored-by: Xi Zhang <106144707+X-iZhang@users.noreply.github.com>
143 lines
4.3 KiB
Python
143 lines
4.3 KiB
Python
"""Tests for TUI command-completion state sync."""
|
|
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
|
|
from EvoScientist.commands.base import ChannelRuntime, CommandContext
|
|
|
|
pytest.importorskip("textual")
|
|
|
|
|
|
class _Loader:
|
|
def __init__(self) -> None:
|
|
self.adopt_calls: list[object] = []
|
|
self.agent: object | None = None
|
|
|
|
def adopt(self, agent: object) -> None:
|
|
self.adopt_calls.append(agent)
|
|
self.agent = agent
|
|
|
|
|
|
class _StubApp:
|
|
def __init__(self) -> None:
|
|
self._agent_loader = _Loader()
|
|
self._conversation_tid = "thread-1"
|
|
self._channel_runtime = ChannelRuntime()
|
|
self._exiting = False
|
|
self.model_updates: list[tuple[str, str | None]] = []
|
|
self.refresh_calls: list[bool] = []
|
|
|
|
def update_status_after_model_change(
|
|
self,
|
|
new_model: str,
|
|
new_provider: str | None = None,
|
|
) -> None:
|
|
self.model_updates.append((new_model, new_provider))
|
|
|
|
async def _refresh_status_snapshot(
|
|
self,
|
|
*,
|
|
reset_streaming_text: bool = True,
|
|
) -> None:
|
|
self.refresh_calls.append(reset_streaming_text)
|
|
|
|
|
|
async def test_sync_tui_command_completion_adopts_agent_swap(monkeypatch):
|
|
import EvoScientist.cli.tui_interactive as tui_mod
|
|
from EvoScientist import EvoScientist as evosci_mod
|
|
|
|
app = _StubApp()
|
|
ctx = CommandContext(
|
|
agent="new-agent",
|
|
thread_id="thread-1",
|
|
ui=SimpleNamespace(),
|
|
)
|
|
cmd = SimpleNamespace(name="/model")
|
|
|
|
monkeypatch.setattr(
|
|
evosci_mod,
|
|
"_ensure_config",
|
|
lambda: SimpleNamespace(model="gpt-5.5", provider="openai"),
|
|
)
|
|
monkeypatch.setattr(tui_mod, "_channels_is_running", lambda: True)
|
|
app._channel_runtime.bind("old-agent", "old-thread")
|
|
|
|
await tui_mod._sync_tui_command_completion(app, ctx, "old-agent", cmd)
|
|
|
|
assert app._agent_loader.adopt_calls == ["new-agent"]
|
|
assert app.model_updates == [("gpt-5.5", "openai")]
|
|
assert app.refresh_calls == [True]
|
|
assert app._channel_runtime.agent == "new-agent"
|
|
assert app._channel_runtime.thread_id == "thread-1"
|
|
|
|
|
|
async def test_sync_tui_command_completion_refreshes_without_agent_swap(monkeypatch):
|
|
import EvoScientist.cli.tui_interactive as tui_mod
|
|
|
|
app = _StubApp()
|
|
ctx = CommandContext(
|
|
agent="same-agent",
|
|
thread_id="thread-1",
|
|
ui=SimpleNamespace(),
|
|
)
|
|
cmd = SimpleNamespace(name="/compact")
|
|
|
|
monkeypatch.setattr(tui_mod, "_channels_is_running", lambda: False)
|
|
|
|
await tui_mod._sync_tui_command_completion(app, ctx, "same-agent", cmd)
|
|
|
|
assert app._agent_loader.adopt_calls == []
|
|
assert app.model_updates == []
|
|
assert app.refresh_calls == [True]
|
|
|
|
|
|
async def test_sync_tui_command_completion_skips_unmounted_app(monkeypatch):
|
|
import EvoScientist.cli.tui_interactive as tui_mod
|
|
|
|
app = _StubApp()
|
|
app._exiting = True
|
|
ctx = CommandContext(
|
|
agent="new-agent",
|
|
thread_id="thread-1",
|
|
ui=SimpleNamespace(),
|
|
)
|
|
cmd = SimpleNamespace(name="/exit")
|
|
|
|
monkeypatch.setattr(tui_mod, "_channels_is_running", lambda: True)
|
|
|
|
await tui_mod._sync_tui_command_completion(app, ctx, "old-agent", cmd)
|
|
|
|
assert app._agent_loader.adopt_calls == []
|
|
assert app.model_updates == []
|
|
assert app.refresh_calls == []
|
|
assert app._channel_runtime.agent is None
|
|
assert app._channel_runtime.thread_id is None
|
|
|
|
|
|
async def test_sync_tui_rebinds_runtime_on_thread_rotation_without_agent_swap(
|
|
monkeypatch,
|
|
):
|
|
"""Regression: ``/new`` and ``/resume`` rotate ``app._conversation_tid``
|
|
without swapping the agent. The runtime must still pick up the new
|
|
thread id so the bus contract stays consistent with serve mode."""
|
|
import EvoScientist.cli.tui_interactive as tui_mod
|
|
|
|
app = _StubApp()
|
|
app._conversation_tid = "rotated-thread"
|
|
app._agent_loader.agent = "same-agent"
|
|
app._channel_runtime.bind("same-agent", "old-thread")
|
|
ctx = CommandContext(
|
|
agent="same-agent",
|
|
thread_id="rotated-thread",
|
|
ui=SimpleNamespace(),
|
|
)
|
|
cmd = SimpleNamespace(name="/new")
|
|
|
|
monkeypatch.setattr(tui_mod, "_channels_is_running", lambda: True)
|
|
|
|
await tui_mod._sync_tui_command_completion(app, ctx, "same-agent", cmd)
|
|
|
|
assert app._channel_runtime.agent == "same-agent"
|
|
assert app._channel_runtime.thread_id == "rotated-thread"
|