"""Tests for the Textual TUI harness (skipped without the tui extra). Pilot tests drive :class:`BlackCatApp` headless; bridge tests assert the event stream without an app. Everything runs offline (echo provider, tmp files, synthetic events). """ from __future__ import annotations # retoor import asyncio import html import os import re import tempfile import unittest from contextlib import asynccontextmanager from pathlib import Path from types import SimpleNamespace from blackcat.tui.quality import RenderContract try: from blackcat.tui import cards as T from blackcat.tui.app import BlackCatApp, BlackCatCommands from blackcat.tui.bridge import TUIBot, UIEvent from blackcat.tui.chrome import ( CostsView, DiffView, PendingImages, PromptBox, SubmitPrompt, ) from blackcat.tui.theme import THEMES HAS_TEXTUAL = True except ImportError: HAS_TEXTUAL = False def _echo_kwargs(**extra): kwargs = {"provider": "echo"} kwargs.update(extra) return kwargs @asynccontextmanager async def booted_app(**bot_kwargs): """Yield (app, pilot) with the splash dismissed.""" app = BlackCatApp(bot_kwargs=_echo_kwargs(**bot_kwargs)) async with app.run_test(size=(120, 40)) as pilot: await pilot.press("escape") await pilot.pause() yield app, pilot async def wait_card(app, seq, timeout=10.0): """Wait until card ``seq`` reaches a terminal status.""" import time deadline = time.monotonic() + timeout while time.monotonic() < deadline: card = app._cards.get(seq) if card is not None and card.status in ("ok", "failed"): return card await asyncio.sleep(0.05) raise AssertionError("card %d never finished: %r" % ( seq, getattr(app._cards.get(seq), "status", None))) @unittest.skipUnless(HAS_TEXTUAL, "tui extra unavailable") class TestBridge(unittest.IsolatedAsyncioTestCase): async def test_prompt_emits_turn_events(self): events = [] bot = TUIBot(provider="echo", emit=events.append) self.addAsyncCleanup(bot.aclose) await bot.prompt("hi") kinds = [e.kind for e in events] self.assertEqual(kinds, ["turn_start", "turn_done"]) self.assertEqual(events[1].payload["reply"], "echo: hi") async def test_run_tool_emits_card_events(self): from blackcat.fstate import FileState from blackcat.tools import FileTools events = [] with tempfile.TemporaryDirectory() as tmp: path = os.path.join(tmp, "a.txt") with open(path, "w", encoding="utf-8") as fh: fh.write("hello\n") bot = TUIBot(provider="echo", tools=FileTools(FileState(tmp)), emit=events.append) self.addAsyncCleanup(bot.aclose) out = await bot.run_tool("read", path="a.txt") self.assertTrue(out["ok"]) kinds = [e.kind for e in events] self.assertEqual(kinds, ["tool_start", "tool_done"]) self.assertEqual(events[0].payload["name"], "read") self.assertTrue(events[1].payload["result"]["ok"]) self.assertGreaterEqual(events[1].payload["elapsed_ms"], 0.0) async def test_converge_sub_events(self): events = [] class _Chat: model = "m" async def chat(self, messages, **kwargs): return {"choices": [{"message": {"content": '{"claims": []}'}}], "usage": {}} class _RS: async def search(self, query, count=10): return {"results": [ {"title": "T", "url": "https://a.org", "summary": "s"}], "fallback_provider": "rsearch"} bot = TUIBot(provider="deepseek", api_key="k", emit=events.append) self.addAsyncCleanup(bot.aclose) bot._client = _Chat() bot._rsearch = _RS() out = await bot.run_tool("iterative_evidence_convergence", topic="t", max_iterations=1, min_iterations=1) self.assertTrue(out["ok"]) kinds = [e.kind for e in events] self.assertIn("converge_query", kinds) self.assertIn("converge_extract", kinds) self.assertEqual(kinds[0], "tool_start") self.assertEqual(kinds[-1], "tool_done") async def test_deep_research_sub_events(self): from blackcat.client import DeepSeekError events = [] bot = TUIBot(provider="echo", emit=events.append) self.addAsyncCleanup(bot.aclose) async def _search(query, count=10): return {"results": [ {"title": "T", "url": "https://a.org/x", "summary": "s"}]} async def _fetch(url): return {"url": url, "content": "word " * 200} async def _stealth_fail(url): raise DeepSeekError("stealthii down") bot.search = _search bot.fetch = _fetch bot._stealth.fetch = _stealth_fail out = await bot.run_tool("deep_research", topic="t", max_queries=1, max_sources=2) self.assertTrue(out["ok"]) kinds = [e.kind for e in events] self.assertEqual(kinds[0], "tool_start") self.assertEqual(kinds[-1], "tool_done") for kind in ("research_plan", "research_query", "research_ranked", "research_fetch", "research_fetch_attempt", "research_synth"): self.assertIn(kind, kinds) fetch_event = next(e for e in events if e.kind == "research_fetch") self.assertEqual(fetch_event.payload["seq"], 1) self.assertEqual(fetch_event.payload["method"], "provider") async def test_note_and_compact_events(self): events = [] bot = TUIBot(provider="echo", emit=events.append) self.addAsyncCleanup(bot.aclose) bot.note("remember this") await bot.prompt("hi") await bot.compact() kinds = [e.kind for e in events] self.assertIn("note", kinds) self.assertIn("compact", kinds) async def test_emit_never_breaks_bot(self): def _boom(event): raise RuntimeError("ui exploded") bot = TUIBot(provider="echo", emit=_boom) self.addAsyncCleanup(bot.aclose) self.assertEqual(await bot.prompt("hi"), "echo: hi") @unittest.skipUnless(HAS_TEXTUAL, "tui extra unavailable") class TestCardsUnit(unittest.TestCase): def test_factory_covers_every_tool(self): from blackcat.agent import TOOL_NAMES for name in TOOL_NAMES: card = T.make_card(name, 1, {}) self.assertIsInstance(card, T.ToolCard) self.assertIsNone(card.alias_for) self.assertIsInstance(T.make_card("write", 1, {}), T.WriteCard) self.assertEqual(T.make_card("write", 1, {}).alias_for, "write_file") converge = T.make_card("converge_on_claim", 1, {}) self.assertIsInstance(converge, T.ConvergeCard) self.assertEqual(converge.alias_for, "iterative_evidence_convergence") self.assertIsInstance(T.make_card("nope", 1, {}), T.GenericCard) def test_glyph_tables_complete(self): for key in T.GLYPHS: self.assertIn(key, T.ASCII_GLYPHS) def test_glyphset_owns_ascii_flag(self): self.assertFalse(T.GlyphSet.ascii_mode) try: self.assertTrue(T.GlyphSet.set_ascii(True)) self.assertTrue(T.GlyphSet.ascii_mode) self.assertEqual(T.GlyphSet.get("ok"), "[ok]") self.assertEqual(T.glyph("ok"), "[ok]") finally: T.GlyphSet.set_ascii(False) self.assertEqual(T.GlyphSet.get("ok"), "✔") def test_card_factory_registry(self): self.assertIn("deep_research", T.CardFactory.known_tools()) card = T.CardFactory.create("write", 1, {}) self.assertIsInstance(card, T.WriteCard) self.assertEqual(card.alias_for, "write_file") self.assertIsInstance( T.CardFactory.create("nope", 1, {}), T.GenericCard) def test_card_text_shorten(self): self.assertEqual( T.CardText.shorten(" a b ", 99), "a b") def test_card_text_plain_never_parses_markup(self): from textual.widgets import Static row = T.CardText.plain("[notice] [=weird, x=1]", "code-row") self.assertIsInstance(row, Static) self.assertIn("[notice]", str(row.render())) self.assertEqual(str(T.CardText.plain(None).render()), "") self.assertTrue( T.CardText.shorten("x" * 200, 10).endswith("…")) def test_chrome_helpers_are_classes(self): from blackcat.tui.chrome import Gradient, Thumbnail painted = Gradient.paint_text("AB") self.assertEqual(painted.plain, "AB") self.assertIsInstance(Thumbnail.for_path("pic.png"), T.Widget) def test_launcher_builds_bot_kwargs(self): from blackcat.tui import TuiLauncher launcher = TuiLauncher(provider="echo", initial_prompt="hi") self.assertEqual( launcher._bot_kwargs["provider"], "echo") self.assertEqual(launcher._initial_prompt, "hi") def test_themes_register(self): self.assertEqual(len(THEMES), 3) names = sorted(t.name for t in THEMES) self.assertEqual(names, ["alley-cat", "matrix-alley", "milk-bowl"]) def _card_cases(): read_result = {"ok": True, "path": "a.py", "offset": 1, "shown": 2, "total_lines": 2, "lines": ["1:ab|def f():", "2:cd| pass"], "truncated": False} grep_result = {"ok": True, "pattern": "f(", "backend": "rg", "hits": [{"file": "a.py", "line": 1, "text": "def f():"}], "truncated": False} outline_py = {"ok": True, "path": "a.py", "language": "python", "nodes": [ {"kind": "class", "name": "C", "line": 1, "end": 9}, {"kind": "function", "name": "C.m", "line": 2, "args": ["self"]}], "total": 2} outline_md = {"ok": True, "path": "r.md", "language": "markdown", "nodes": [{"name": "Title", "line": 1, "level": 1}], "total": 1} edit_result = {"ok": True, "path": "a.py", "matched": "x", "replacements": 1, "ranges": [[1, 1]]} multi_result = {"ok": True, "path": "a.py", "edits": 2, "summaries": [{"index": 0, "replacements": 1}, {"index": 1, "replacements": 1}]} write_result = {"ok": True, "path": "n.txt", "created": True, "lines": 2} patch_result = {"ok": True, "files": [ {"path": "a.py", "op": "update", "hunks": 1}]} search_result = {"ok": True, "query": "q", "results": [ {"title": "T", "url": "https://a.org", "summary": "s", "date": "2026-01-01", "source_provider": "brave"}], "fallback_provider": "rsearch", "fallback_source": "brave"} fetch_result = {"ok": True, "url": "https://a.org", "content": "# Hi\n\nok"} converge_result = {"ok": True, "topic": "t", "conclusion": "yes", "confidence": 0.91, "iterations": 2, "evidence_count": 3, "supporting_evidence": [ {"text": "e1", "reliability": 0.9}], "counter_evidence": [], "state_summary": {"claims": 1, "evidence_items": 3, "contradictions": 0}, "costs": {"total_usd": 0.001, "calls": 4}} scholar_result = {"ok": True, "query": "q", "results": [ {"title": "P", "url": "https://arxiv.org/a", "summary": "s", "date": "2025", "authors": ["Ann", "Bo"], "citations": 12, "source_provider": "arxiv"}]} repo_result = {"ok": True, "query": "q", "results": [ {"path": "a.py", "line": 3, "snippet": "x = 1", "score": 0.8}], "indexed_files": 9} return [ ("read", {"path": "a.py"}, read_result, T.ReadCard, "ok", "2 lines"), ("grep", {"pattern": "f("}, grep_result, T.GrepCard, "ok", "1 hit"), ("outline", {"path": "a.py"}, outline_py, T.OutlineCard, "ok", "2 symbol"), ("outline", {"path": "r.md"}, outline_md, T.OutlineCard, "ok", "markdown"), ("edit", {"path": "a.py", "old_string": "x", "new_string": "y"}, edit_result, T.EditCard, "ok", "1 replacement"), ("multi_edit", {"path": "a.py", "edits": [ {"old_string": "a", "new_string": "b"}, {"old_string": "c", "new_string": "d"}]}, multi_result, T.MultiEditCard, "ok", "2/2"), ("write_file", {"path": "n.txt", "content": "a\nb"}, write_result, T.WriteCard, "ok", "created"), ("apply_patch", {"patch_text": "*** Begin Patch\n"}, patch_result, T.PatchCard, "ok", "1 hunk"), ("search", {"query": "q"}, search_result, T.SearchCard, "ok", "1 result"), ("search", {"query": "q"}, dict(search_result, fallback_provider="searxng"), T.SearchCard, "ok", "1 result"), ("fetch", {"url": "https://a.org"}, fetch_result, T.FetchCard, "ok", "DeepSeek Fetch"), ("fetch", {"url": "https://a.org"}, dict(fetch_result, fallback_provider="jina"), T.FetchCard, "ok", "Jina"), ("fetch", {"url": "https://a.org"}, {"ok": True, "url": "https://a.org", "content": " "}, T.FetchCard, "ok", "empty page"), ("iterative_evidence_convergence", {"topic": "t"}, converge_result, T.ConvergeCard, "ok", "0.91"), ("converge_on_claim", {"topic": "t"}, converge_result, T.ConvergeCard, "ok", "0.91"), ("deep_research", {"topic": "t"}, {"ok": True, "topic": "t", "confidence": 0.72, "claims": [{"text": "c1", "sources": [1], "confidence": "high"}], "sources": [], "unknowns": [], "report": "# R", "stats": {"claims": 1, "fetched": 2}}, T.DeepResearchCard, "ok", "72%"), ("scholar", {"query": "q"}, scholar_result, T.ScholarCard, "ok", "1 paper"), ("repo_search", {"query": "q"}, repo_result, T.RepoCard, "ok", "1 hit"), ("bash", {"command": "echo hi"}, {"ok": True, "exit_code": 0, "code": "ok", "stdout": "hi\n", "stderr": "", "duration_ms": 12, "cwd": ".", "truncated": False, "stdout_bytes": 3, "stderr_bytes": 0, "timed_out": False, "redactions": []}, T.BashCard, "ok", "exit 0"), ("browse", {"task": "find the price", "url": "https://a.org/"}, {"ok": True, "task": "find the price", "answer": "42", "visited": ["https://a.org/"], "steps": 3, "headed": False}, T.BrowseCard, "ok", "1 page(s)"), ("browse", {"task": "find the price", "headed": True}, {"ok": False, "code": "browse_failed", "error": "no display"}, T.BrowseCard, "failed", "browse_failed"), ("download", {"urls": ["https://a.org/a.bin", "https://a.org/b.bin"], "dest": "dl"}, {"ok": True, "code": "ok", "dest": "dl", "files": [ {"ok": True, "code": "ok", "url": "https://a.org/a.bin", "path": "dl/a.bin", "bytes": 12, "method": "stealthii"}, {"ok": True, "code": "skipped", "url": "https://a.org/b.bin", "path": "dl/b.bin", "bytes": 7, "method": "direct", "note": "exists; pass overwrite=true to replace"}], "saved": 1, "skipped": 1, "failed": 0, "bytes": 19}, T.DownloadCard, "ok", "1 saved"), ("download", {"urls": []}, {"ok": False, "code": "bad_args", "error": "urls must be a non-empty list"}, T.DownloadCard, "failed", "bad_args"), ("bash", {"command": "exit 1"}, {"ok": False, "exit_code": 1, "code": "nonzero_exit", "stdout": "", "stderr": "boom", "duration_ms": 9, "cwd": ".", "truncated": False, "stdout_bytes": 0, "stderr_bytes": 4, "timed_out": False, "redactions": []}, T.BashCard, "failed", "exit 1"), ("bash", {"command": "sleep 99", "timeout_ms": 1000}, {"ok": False, "exit_code": -15, "code": "timed_out", "stdout": "part", "stderr": "", "duration_ms": 1000, "cwd": ".", "truncated": False, "stdout_bytes": 4, "stderr_bytes": 0, "timed_out": True, "redactions": [], "error": "timed out after 1000ms"}, T.BashCard, "failed", "timed out"), ("bash", {"command": "pwd", "cwd": "/tmp"}, {"ok": False, "code": "security", "error": "path escapes workspace root"}, T.BashCard, "failed", "security"), ("write", {"path": "n.txt", "content": "x"}, write_result, T.WriteCard, "ok", "created"), ("nope", {}, {"ok": False, "code": "unknown_tool", "error": "unknown tool 'nope'"}, T.GenericCard, "failed", "unknown_tool"), ("read", {"path": "missing.txt"}, {"ok": False, "code": "io", "error": "no such file"}, T.ReadCard, "failed", "io"), ("edit", {"path": "a.py", "old_string": "x", "new_string": "y"}, {"ok": False, "code": "no_match", "error": "not found", "suggestions": [{"lines": [1, 1]}]}, T.EditCard, "failed", "no_match"), ] @unittest.skipUnless(HAS_TEXTUAL, "tui extra unavailable") class TestCardMatrix(unittest.IsolatedAsyncioTestCase): async def test_every_card_renders(self): async with booted_app() as (app, pilot): for index, (name, args, result, cls, status, summary_bit) in enumerate(_card_cases()): with self.subTest(tool=name, status=status): seq = 100 + index app.post_message(UIEvent( "tool_start", {"seq": seq, "name": name, "args": args})) await pilot.pause() card = app._cards.get(seq) self.assertIsInstance(card, cls) self.assertEqual(card.status, "running") app.post_message(UIEvent( "tool_done", {"seq": seq, "name": name, "args": args, "result": result, "elapsed_ms": 3.0, "cost_usd": 0.0})) await pilot.pause() self.assertEqual(card.status, status) self.assertIn(summary_bit, card.summary) async def test_fetch_card_live_while_running(self): async with booted_app() as (app, pilot): app.post_message(UIEvent( "tool_start", {"seq": 77, "name": "fetch", "args": {"url": "https://example.org/slow"}})) await pilot.pause() await asyncio.sleep(0.25) await pilot.pause() card = app._cards[77] self.assertEqual(card.status, "running") self.assertGreaterEqual(len(card.body.children), 3) def body_text(): parts = [] for child in card.body.children: try: parts.append(str(child.render())) except Exception: parts.append("") return " ".join(parts) first = body_text() self.assertIn("https://example.org/slow", first) self.assertIn("awaiting response", first) await asyncio.sleep(0.25) await pilot.pause() self.assertNotEqual(first, body_text()) app.post_message(UIEvent( "tool_done", {"seq": 77, "name": "fetch", "args": {"url": "https://example.org/slow"}, "result": {"ok": True, "url": "https://example.org/slow", "content": "# Page\nhello fetch"}, "elapsed_ms": 5.0, "cost_usd": 0.0})) await pilot.pause() self.assertEqual(card.status, "ok") self.assertNotIn("awaiting response", body_text()) async def test_bash_card_streams_live(self): async with booted_app() as (app, pilot): app.post_message(UIEvent( "tool_start", {"seq": 78, "name": "bash", "args": {"command": "echo hi"}})) await pilot.pause() card = app._cards[78] self.assertIsInstance(card, T.BashCard) self.assertEqual(card.status, "running") app.post_message(UIEvent( "bash_chunk", {"seq": 78, "stream": "stdout", "text": "hel"})) app.post_message(UIEvent( "bash_chunk", {"seq": 78, "stream": "stdout", "text": "lo\n"})) await pilot.pause() self.assertEqual(card._live_text, "hello\n") self.assertIn("hello", str(card._live_row.render())) app.post_message(UIEvent( "tool_done", {"seq": 78, "name": "bash", "args": {"command": "echo hi"}, "result": {"ok": True, "exit_code": 0, "code": "ok", "stdout": "hello\n", "stderr": "", "duration_ms": 4, "cwd": ".", "truncated": False, "stdout_bytes": 6, "stderr_bytes": 0, "timed_out": False, "redactions": []}, "elapsed_ms": 4.0, "cost_usd": 0.0})) await pilot.pause() self.assertEqual(card.status, "ok") self.assertIn("exit 0", card.summary) async def test_bracket_payload_renders_literally(self): stdout = ('{"common_name":"leeuw008.nl",' '"name_value":"*.leeuw008.nl\\\\nleeuw008.nl",' '"id":29884906865,' '"issuer":"[=Google Trust Services, CN=WE1",' '"serial":"18fda3a3176097670eaa84ecd8123dc6"}\n' '[notice] [=Google Trust Services, CN=WE1]\n') args = {"command": "curl https://crt.sh/?q=leeuw008.nl"} result = {"ok": True, "exit_code": 0, "code": "ok", "stdout": stdout, "stderr": "", "duration_ms": 9, "cwd": ".", "truncated": False, "stdout_bytes": len(stdout), "stderr_bytes": 0, "timed_out": False, "redactions": []} async with booted_app() as (app, pilot): app.post_message(UIEvent( "tool_start", {"seq": 82, "name": "bash", "args": args})) app.post_message(UIEvent( "tool_done", {"seq": 82, "name": "bash", "args": args, "result": result, "elapsed_ms": 9.0, "cost_usd": 0.0})) await pilot.pause() await asyncio.sleep(0.5) await pilot.pause() card = app._cards[82] self.assertIsInstance(card, T.BashCard) self.assertEqual(card.status, "ok") texts = [str(child.render()) for child in card.body.children] self.assertTrue(any("leeuw008.nl" in text for text in texts)) self.assertTrue(any("[notice]" in text for text in texts)) async def test_bash_chunk_without_card_is_ignored(self): async with booted_app() as (app, pilot): app.post_message(UIEvent( "bash_chunk", {"seq": 999, "stream": "stdout", "text": "x"})) await pilot.pause() async def test_download_card_lands_files_live(self): async with booted_app() as (app, pilot): args = {"urls": ["https://a.org/a.bin", "https://a.org/b.bin"], "dest": "dl"} app.post_message(UIEvent( "tool_start", {"seq": 81, "name": "download", "args": args})) await pilot.pause() card = app._cards[81] self.assertIsInstance(card, T.DownloadCard) self.assertEqual(card.status, "running") app.post_message(UIEvent( "download_file", {"seq": 81, "url": "https://a.org/a.bin", "row": {"ok": True, "code": "ok", "url": "https://a.org/a.bin", "path": "dl/a.bin", "bytes": 12, "method": "stealthii"}})) await pilot.pause() texts = [str(child.render()) for child in card.body.children] self.assertTrue(any("a.bin" in text and "12B" in text for text in texts)) app.post_message(UIEvent( "tool_done", {"seq": 81, "name": "download", "args": args, "result": {"ok": True, "code": "ok", "dest": "dl", "files": [ {"ok": True, "code": "ok", "url": "https://a.org/a.bin", "path": "dl/a.bin", "bytes": 12, "method": "stealthii"}], "saved": 1, "skipped": 0, "failed": 0, "bytes": 12}, "elapsed_ms": 6.0, "cost_usd": 0.0})) await pilot.pause() self.assertEqual(card.status, "ok") self.assertIn("1 saved", card.summary) async def test_converge_live_queries(self): async with booted_app() as (app, pilot): app.post_message(UIEvent( "tool_start", {"seq": 5, "name": "iterative_evidence_convergence", "args": {"topic": "t", "max_iterations": 3}})) await pilot.pause() card = app._cards[5] self.assertIsInstance(card, T.ConvergeCard) app.post_message(UIEvent( "converge_query", {"seq": 5, "query": "q1", "count": 5, "results": 4})) app.post_message(UIEvent( "converge_extract", {"seq": 5, "fresh": 2, "claims": 1})) await pilot.pause() self.assertEqual(card._queries, 1) self.assertEqual(card._extracts, 1) self.assertIn("1 queries", card.summary) async def test_deep_research_live_events(self): async with booted_app() as (app, pilot): app.post_message(UIEvent( "tool_start", {"seq": 7, "name": "deep_research", "args": {"topic": "t"}})) await pilot.pause() card = app._cards[7] self.assertIsInstance(card, T.DeepResearchCard) app.post_message(UIEvent( "research_plan", {"seq": 7, "topic": "t", "queries": ["t", "t data"]})) app.post_message(UIEvent( "research_query", {"seq": 7, "query": "t", "results": 4})) app.post_message(UIEvent( "research_ranked", {"seq": 7, "dropped": 1, "sources": [ {"n": 1, "title": "S", "url": "https://a.org", "domain": "a.org", "tier": 2, "score": 3.5}]})) app.post_message(UIEvent( "research_fetch", {"seq": 7, "n": 1, "url": "https://a.org", "domain": "a.org", "ok": True, "method": "jina", "chars": 900, "claims": 2, "attempts": [{"method": "provider", "ok": False}, {"method": "jina", "ok": True}]})) app.post_message(UIEvent( "research_synth", {"seq": 7, "claims": 2, "confidence": 0.7})) await pilot.pause() self.assertEqual(card._n_queries, 1) self.assertEqual(card._n_fetched, 1) self.assertEqual(card._stage, 3) self.assertIn("writing report", card.summary) async def test_deep_research_attempt_is_live(self): async with booted_app() as (app, pilot): app.post_message(UIEvent( "tool_start", {"seq": 8, "name": "deep_research", "args": {"topic": "t"}})) await pilot.pause() card = app._cards[8] self.assertIn("planning subqueries", str(card._plan_hint.render())) app.post_message(UIEvent( "research_plan", {"seq": 8, "topic": "t", "queries": ["t"]})) app.post_message(UIEvent( "research_ranked", {"seq": 8, "dropped": 0, "sources": [ {"n": 1, "title": "S", "url": "https://a.org", "domain": "a.org", "tier": 2, "score": 3.5}]})) app.post_message(UIEvent( "research_fetch_attempt", {"seq": 8, "n": 1, "url": "https://a.org", "method": "jina", "state": "start"})) await pilot.pause() row = card._source_rows[1] self.assertIn("fetching via jina", str(row.render())) self.assertIn(1, card._inflight) app.post_message(UIEvent( "research_fetch_attempt", {"seq": 8, "n": 1, "url": "https://a.org", "method": "jina", "state": "done", "ok": False, "error": "jina timeout after 60s"})) await pilot.pause() self.assertIn("trying next", str(row.render())) async def test_ui_event_failure_is_visible(self): async with booted_app() as (app, pilot): def boom(payload): raise RuntimeError("kaboom") app._ev_research_plan = boom app.post_message(UIEvent( "research_plan", {"seq": 1, "queries": []})) await pilot.pause() texts = [str(w.render()) for w in app.query_one("#transcript").children] self.assertTrue(any("ui event research_plan failed" in t for t in texts), texts) async def test_read_more_button(self): lines = ["%d:hh|line %d" % (i, i) for i in range(1, 71)] result = {"ok": True, "path": "big.py", "offset": 1, "shown": 70, "total_lines": 70, "lines": lines, "truncated": False} async with booted_app() as (app, pilot): app.post_message(UIEvent( "tool_start", {"seq": 9, "name": "read", "args": {"path": "big.py"}})) app.post_message(UIEvent( "tool_done", {"seq": 9, "name": "read", "args": {"path": "big.py"}, "result": result, "elapsed_ms": 1.0, "cost_usd": 0.0})) card = None buttons = [] for _ in range(100): await pilot.pause(0.2) card = app._cards.get(9) if card is None: continue buttons = [b for b in card.query("Button") if (b.id or "").startswith("more-")] if len(buttons) == 1: break self.assertEqual(len(buttons), 1) app.query_one("#more-9").scroll_visible() await pilot.pause(0.5) before = len(list(card.body.children)) await pilot.click("#more-9") await pilot.pause() after = len(list(card.body.children)) self.assertGreater(after, before) @unittest.skipUnless(HAS_TEXTUAL, "tui extra unavailable") class TestTurn(unittest.IsolatedAsyncioTestCase): async def test_echo_turn(self): async with booted_app() as (app, pilot): app.post_message(SubmitPrompt("hello", [])) await pilot.pause(1.5) users = list(app.query("UserBubble")) bots = list(app.query("AssistantBubble")) self.assertEqual(len(users), 1) self.assertEqual(users[0]._text, "hello") self.assertEqual(len(bots), 1) self.assertEqual(bots[0]._full, "echo: hello") self.assertIn("done", app.query_one("#status").text) box = app.query_one("#prompt", PromptBox) self.assertEqual(box.prompt_history, ["hello"]) async def test_busy_rejects_second_turn(self): async with booted_app() as (app, pilot): app._busy = True app.post_message(SubmitPrompt("hello", [])) await pilot.pause() self.assertEqual(list(app.query("UserBubble")), []) async def test_prompt_keys(self): async with booted_app() as (app, pilot): box = app.query_one("#prompt", PromptBox) box.focus() await pilot.pause() await pilot.press(*"ab") await pilot.press("shift+tab") self.assertEqual(box.text, "ab\n") await pilot.press("enter") await pilot.pause(1.5) users = list(app.query("UserBubble")) self.assertEqual(len(users), 1) self.assertEqual(users[0]._text, "ab") await pilot.press(*"xy") await pilot.press("enter") await pilot.pause(1.5) box.focus() await pilot.pause() await pilot.press("up") self.assertEqual(box.text, "xy") await pilot.press("up") self.assertEqual(box.text, "ab") await pilot.press("down") self.assertEqual(box.text, "xy") @unittest.skipUnless(HAS_TEXTUAL, "tui extra unavailable") class TestFileToolFlow(unittest.IsolatedAsyncioTestCase): async def test_write_read_edit_grep_outline_patch(self): with tempfile.TemporaryDirectory() as tmp: async with booted_app(tools_root=tmp) as (app, pilot): app._approval_mode = "auto" app._tool_worker( "write_file", {"path": "calc.py", "content": "def f():\n return 1\n"}) card = await wait_card(app, 1) self.assertEqual(card.status, "ok") app._tool_worker("read", {"path": "calc.py"}) card = await wait_card(app, 2) self.assertEqual(card.status, "ok") self.assertIn("2 lines", card.summary) app._tool_worker( "edit", {"path": "calc.py", "old_string": " return 1", "new_string": " return 2"}) card = await wait_card(app, 3) self.assertEqual(card.status, "ok") app._tool_worker( "multi_edit", {"path": "calc.py", "edits": [{"old_string": "def f():", "new_string": "def g():"}, {"old_string": " return 2", "new_string": " return 3"}]}) card = await wait_card(app, 4) self.assertEqual(card.status, "ok") self.assertIn("2/2", card.summary) app._tool_worker("grep", {"pattern": "return", "path": "."}) card = await wait_card(app, 5) self.assertEqual(card.status, "ok") app._tool_worker("outline", {"path": "calc.py"}) card = await wait_card(app, 6) self.assertEqual(card.status, "ok") patch = ("*** Begin Patch\n" "*** Update File: calc.py\n" "@@\n" " def g():\n" "- return 3\n" "+ return 4\n" "*** End Patch\n") app._tool_worker("apply_patch", {"patch_text": patch}) card = await wait_card(app, 7) self.assertEqual(card.status, "ok") with open(os.path.join(tmp, "calc.py"), encoding="utf-8") as fh: self.assertIn("return 4", fh.read()) await pilot.pause() from blackcat.tui.chrome import LeftRail rail = app.query_one("#left-rail", LeftRail) self.assertIn("calc.py", rail.touched) async def test_tool_done_before_mount_settles(self): async with booted_app() as (app, pilot): app._ev_tool_start({"seq": 1, "name": "outline", "args": {"path": "calc.py"}}) app._ev_tool_done({"seq": 1, "name": "outline", "args": {"path": "calc.py"}, "result": {"ok": True, "nodes": [], "language": "python"}, "elapsed_ms": 1.0, "cost_usd": 0.0}) card = await wait_card(app, 1) self.assertEqual(card.status, "ok") self.assertIn("0 symbol(s)", card.summary) @unittest.skipUnless(HAS_TEXTUAL, "tui extra unavailable") class TestApproval(unittest.IsolatedAsyncioTestCase): async def _run_write(self, pilot, app, choice): task = asyncio.ensure_future( app._bot.run_tool("write_file", path="n.txt", content="hi")) for _ in range(200): card = app._cards.get(1) if card is not None and card.status == "confirming": break await asyncio.sleep(0.05) else: raise AssertionError("no approval card appeared") box = app.query_one("#prompt", PromptBox) self.assertTrue(box.disabled) await pilot.press(choice) return await asyncio.wait_for(task, 10.0) async def test_approve_writes_file(self): with tempfile.TemporaryDirectory() as tmp: async with booted_app(tools_root=tmp) as (app, pilot): result = await self._run_write(pilot, app, "y") self.assertTrue(result["ok"]) await pilot.pause() self.assertTrue(os.path.exists( os.path.join(tmp, "n.txt"))) self.assertEqual(app._cards[1].status, "ok") box = app.query_one("#prompt", PromptBox) self.assertFalse(box.disabled) async def test_deny_writes_nothing(self): with tempfile.TemporaryDirectory() as tmp: async with booted_app(tools_root=tmp) as (app, pilot): result = await self._run_write(pilot, app, "n") self.assertFalse(result["ok"]) self.assertEqual(result["code"], "rejected") self.assertFalse(os.path.exists( os.path.join(tmp, "n.txt"))) async def test_always_flips_mode(self): with tempfile.TemporaryDirectory() as tmp: async with booted_app(tools_root=tmp) as (app, pilot): result = await self._run_write(pilot, app, "a") self.assertTrue(result["ok"]) await pilot.pause() self.assertEqual(app._approval_mode, "auto") @unittest.skipUnless(HAS_TEXTUAL, "tui extra unavailable") class TestInitialPrompt(unittest.IsolatedAsyncioTestCase): async def test_initial_prompt_runs_first_turn(self): app = BlackCatApp(bot_kwargs=_echo_kwargs(), initial_prompt="hello tui") async with app.run_test(size=(120, 40)) as pilot: await pilot.press("escape") for _ in range(200): if len(app._bot.messages) >= 2 and not app._busy: break await asyncio.sleep(0.05) self.assertEqual(app._bot.messages[0]["content"], "hello tui") self.assertEqual(app._bot.messages[1]["content"], "echo: hello tui") async def test_initial_prompt_exits_when_turn_done(self): app = BlackCatApp(bot_kwargs=_echo_kwargs(), initial_prompt="hello tui") async with app.run_test(size=(120, 40)) as pilot: await pilot.press("escape") for _ in range(300): if not app.is_running: break await asyncio.sleep(0.05) self.assertFalse(app.is_running) self.assertEqual(app._bot.messages[1]["content"], "echo: hello tui") async def test_no_initial_prompt_stays_open(self): async with booted_app() as (app, pilot): app.post_message(SubmitPrompt("hi", [])) for _ in range(200): if len(app._bot.messages) >= 2 and not app._busy: break await asyncio.sleep(0.05) await asyncio.sleep(0.3) await pilot.pause() self.assertTrue(app.is_running) @unittest.skipUnless(HAS_TEXTUAL, "tui extra unavailable") class TestRunTuiWiring(unittest.TestCase): def test_run_tui_silences_streams_and_passes_prompt(self): import logging from unittest import mock as _mock from blackcat.tui import run_tui logger = logging.getLogger("blackcat") handler = logging.StreamHandler() logger.addHandler(handler) captured = {} class _FakeApp: def __init__(self, bot_kwargs=None, initial_prompt=None): captured["bot_kwargs"] = bot_kwargs captured["initial_prompt"] = initial_prompt def run(self): captured["ran"] = True try: with _mock.patch("blackcat.tui.app.BlackCatApp", _FakeApp): code = run_tui(provider="echo", initial_prompt="do the thing") finally: if handler in logger.handlers: logger.removeHandler(handler) self.assertEqual(code, 0) self.assertTrue(captured["ran"]) self.assertEqual(captured["initial_prompt"], "do the thing") streams = [h for h in logger.handlers if isinstance(h, logging.StreamHandler) and not isinstance(h, logging.FileHandler)] self.assertEqual(streams, []) @unittest.skipUnless(HAS_TEXTUAL, "tui extra unavailable") class TestYoloTui(unittest.IsolatedAsyncioTestCase): async def test_yolo_write_needs_no_approval(self): with tempfile.TemporaryDirectory() as tmp: async with booted_app(tools_root=tmp, yolo=True) as (app, pilot): self.assertTrue(app._bot.yolo) self.assertEqual(app._approval_mode, "auto") result = await asyncio.wait_for(asyncio.ensure_future( app._bot.run_tool("write_file", path="n.txt", content="hi")), 10.0) self.assertTrue(result["ok"]) self.assertTrue(os.path.exists( os.path.join(tmp, "n.txt"))) card = await wait_card(app, 1) self.assertEqual(card.status, "ok") @unittest.skipUnless(HAS_TEXTUAL, "tui extra unavailable") class TestChrome(unittest.IsolatedAsyncioTestCase): async def test_tab_keys(self): async with booted_app() as (app, pilot): await pilot.press("escape") await pilot.press("d") await pilot.pause() from textual.widgets import TabbedContent tabs = app.query_one("#right-panel", TabbedContent) self.assertEqual(tabs.active, app._tab_ids["Diff"]) await pilot.press("c") await pilot.pause() self.assertEqual(tabs.active, app._tab_ids["Costs"]) async def test_theme_and_ascii(self): async with booted_app() as (app, pilot): self.assertEqual(app.theme, "alley-cat") await pilot.press("escape") await pilot.press("t") await pilot.pause() self.assertEqual(app.theme, "milk-bowl") try: app.action_toggle_ascii() self.assertTrue(T.GlyphSet.ascii_mode) self.assertEqual(T.glyph("ok"), "[ok]") finally: app.action_toggle_ascii() self.assertFalse(T.GlyphSet.ascii_mode) async def test_slash_commands(self): async with booted_app() as (app, pilot): app.post_message(SubmitPrompt("/costs", [])) await pilot.pause() from textual.widgets import TabbedContent tabs = app.query_one("#right-panel", TabbedContent) self.assertEqual(tabs.active, app._tab_ids["Costs"]) app.post_message(SubmitPrompt("/scholar black holes", [])) await pilot.pause(1.5) scholars = [c for c in app._cards.values() if isinstance(c, T.ScholarCard)] self.assertEqual(len(scholars), 1) self.assertEqual(scholars[0].status, "ok") app.post_message(SubmitPrompt("/nope", [])) await pilot.pause() async def test_new_session_resets(self): async with booted_app() as (app, pilot): app.post_message(SubmitPrompt("hello", [])) await pilot.pause(1.5) self.assertTrue(list(app.query("UserBubble"))) from blackcat.tui.chrome import NewSession app.post_message(NewSession()) await pilot.pause() self.assertEqual(list(app.query("UserBubble")), []) self.assertEqual(list(app.query("AssistantBubble")), []) async def test_attach_flow(self): async with booted_app() as (app, pilot): app.action_attach() await pilot.pause() await pilot.press(*"/tmp/x.png") await pilot.press("enter") await pilot.pause() pending = app.query_one("#pending", PendingImages) self.assertEqual(pending.paths, ["/tmp/x.png"]) async def test_palette_commands(self): async with booted_app() as (app, pilot): provider = BlackCatCommands(app.screen) hits = [hit async for hit in provider.search("theme")] self.assertTrue(hits) for hit in hits: if "theme" in str(hit.match_display): hit.command() break await pilot.pause() self.assertEqual(app.theme, "milk-bowl") hits = [hit async for hit in provider.search("no-such-command-xyz")] self.assertEqual(hits, []) async def test_mascot_moods(self): async with booted_app() as (app, pilot): from blackcat.tui.chrome import HeaderBar mascot = app.query_one(HeaderBar).mascot mascot.set_mood("error") await pilot.pause() self.assertIn("✖", str(mascot.render())) mascot.set_mood("idle") await pilot.pause() self.assertNotIn("✖", str(mascot.render())) @unittest.skipUnless(HAS_TEXTUAL, "tui extra unavailable") class TestRenderContract(unittest.TestCase): def test_pure_helpers_need_no_app(self): self.assertTrue(RenderContract.is_blank(" ")) self.assertTrue(RenderContract.is_blank(None)) self.assertFalse(RenderContract.is_blank("x")) self.assertEqual(RenderContract.header_violations(None), ["missing header"]) self.assertEqual(RenderContract.body_violations(None), ["missing body"]) def test_bubble_contract_without_widgets(self): self.assertEqual(RenderContract.check_bubble( SimpleNamespace(_full="")), ["empty reply"]) self.assertEqual(RenderContract.check_bubble( SimpleNamespace(_full="hi")), []) def test_status_row_classes(self): self.assertTrue(RenderContract.is_fallback( SimpleNamespace(has_class=lambda name: name == "quality-fallback"))) self.assertFalse(RenderContract.is_fallback( SimpleNamespace(has_class=lambda name: False))) @unittest.skipUnless(HAS_TEXTUAL, "tui extra unavailable") class TestCardSeal(unittest.IsolatedAsyncioTestCase): async def test_mount_crash_still_renders(self): from blackcat.tui.chrome import Transcript async with booted_app() as (app, pilot): transcript = app.query_one(Transcript) mounted = [] for name in T.CardFactory.known_tools(): card = T.make_card(name, 1, {}) def _boom() -> None: raise RuntimeError("build blew up") card.build_running = _boom transcript.mount(card) mounted.append(card) await pilot.pause() await pilot.wait_for_scheduled_animations() await pilot.pause() for card in mounted: with self.subTest(tool=card.tool_name): self.assertEqual( RenderContract.check_card(card), []) async def test_running_cards_never_empty(self): args = {"read": {"path": "a.py"}, "grep": {"pattern": "x", "path": "."}, "outline": {"path": "a.py"}, "edit": {"path": "a.py", "old_string": "x", "new_string": "y"}, "multi_edit": {"path": "a.py", "edits": [ {"old_string": "a", "new_string": "b"}]}, "write_file": {"path": "n.txt", "content": "hi"}, "write": {"path": "n.txt", "content": "hi"}, "apply_patch": {"patch_text": "*** Begin Patch\n"}, "search": {"query": "q"}, "fetch": {"url": "https://example.org/slow"}, "iterative_evidence_convergence": {"topic": "t"}, "converge_on_claim": {"topic": "t"}, "deep_research": {"topic": "t"}, "scholar": {"query": "q"}, "repo_search": {"query": "q"}, "bash": {"command": "echo hi"}} async with booted_app() as (app, pilot): for seq, name in enumerate(T.CardFactory.known_tools(), start=1): app.post_message(UIEvent( "tool_start", {"seq": seq, "name": name, "args": args.get(name, {})})) await pilot.pause() for seq, name in enumerate(T.CardFactory.known_tools(), start=1): with self.subTest(tool=name): card = app._cards[seq] self.assertEqual( RenderContract.header_violations( card.header), []) self.assertEqual( RenderContract.body_violations( card.body), []) self.assertEqual(card.seal(), []) async def test_done_empty_results_stay_explicit(self): cases = [ ("grep", {"pattern": "x", "path": "."}, {"ok": True, "hits": [], "backend": "rg"}), ("search", {"query": "q"}, {"ok": True, "query": "q", "results": []}), ("fetch", {"url": "https://a.org"}, {"ok": True, "url": "https://a.org", "content": " "}), ("repo_search", {"query": "q"}, {"ok": True, "query": "q", "results": [], "indexed_files": 0}), ("read", {"path": "missing.txt"}, {"ok": False, "code": "io", "error": "nope"}), ] async with booted_app() as (app, pilot): for seq, (name, tool_args, _result) in enumerate( cases, start=1): app.post_message(UIEvent( "tool_start", {"seq": seq, "name": name, "args": tool_args})) await pilot.pause() for seq, (name, tool_args, result) in enumerate(cases, start=1): app.post_message(UIEvent( "tool_done", {"seq": seq, "name": name, "args": tool_args, "result": result, "elapsed_ms": 3.0, "cost_usd": 0.0})) for seq, (name, _a, _r) in enumerate(cases, start=1): with self.subTest(tool=name): card = await wait_card(app, seq) await asyncio.sleep(0.35) await pilot.pause() self.assertEqual( RenderContract.check_card(card), []) leftovers = [ c for c in card.body.children if c.has_class("quality-fallback") and c.display] self.assertEqual(leftovers, []) async def test_effect_chips_leave_no_trace(self): async with booted_app() as (app, pilot): mid = app.query_one("#middle").region.height app._rain("+$0.0001") await pilot.pause() self.assertEqual( app.query_one("#middle").region.height, mid) await asyncio.sleep(1.6) await pilot.pause() leftovers = [c for c in app.screen.children if type(c).__name__ == "Label"] self.assertEqual(leftovers, []) self.assertEqual( app.query_one("#middle").region.height, mid) async def test_confetti_leaves_no_trace(self): async with booted_app() as (app, pilot): mid = app.query_one("#middle").region.height app._confetti() await pilot.pause() bits = [c for c in app.screen.children if type(c).__name__ == "Label"] self.assertEqual(len(bits), 24) self.assertEqual( app.query_one("#middle").region.height, mid) await asyncio.sleep(2.8) await pilot.pause() leftovers = [c for c in app.screen.children if type(c).__name__ == "Label"] self.assertEqual(leftovers, []) self.assertEqual( app.query_one("#middle").region.height, mid) async def test_prompt_row_static_across_collapse(self): async with booted_app() as (app, pilot): for seq in range(1, 13): app.post_message(UIEvent( "tool_start", {"seq": seq, "name": "fetch", "args": {"url": "https://example.org/%d" % seq}})) await pilot.pause() await asyncio.sleep(0.5) await pilot.pause() prompt = app.query_one("#prompt-row") y_before = prompt.region.y mid_before = app.query_one("#middle").region.height for seq in range(1, 13): app.post_message(UIEvent( "tool_done", {"seq": seq, "name": "fetch", "args": {"url": "https://example.org/%d" % seq}, "result": { "ok": True, "url": "https://example.org/%d" % seq, "content": "# T\ntext"}, "elapsed_ms": 5.0, "cost_usd": 0.0})) await pilot.pause() await asyncio.sleep(0.6) await pilot.pause() self.assertEqual( app.query_one("#prompt-row").region.y, y_before) self.assertEqual( app.query_one("#middle").region.height, mid_before) async def test_watchdog_repairs_blanked_card(self): async with booted_app() as (app, pilot): app.post_message(UIEvent( "tool_start", {"seq": 1, "name": "grep", "args": {"pattern": "x", "path": "."}})) await pilot.pause() card = app._cards[1] card.header.update("") card.status_row.display = False self.assertEqual( RenderContract.check_card(card), ["empty header", "empty body"]) app._audit_cards() self.assertEqual(RenderContract.check_card(card), []) self.assertNotEqual( str(card.header.render()).strip(), "") @staticmethod def painted_words(path): texts = [] svg = Path(path).read_text() for chunk in re.findall(r"", svg, re.S): words = html.unescape( re.sub(r"<[^>]+>", "", chunk)).replace(" ", " ") words = " ".join(words.split()) if words: texts.append(words) return "\n".join(texts) @unittest.skipUnless(HAS_TEXTUAL, "tui extra unavailable") class TestPaintContract(unittest.IsolatedAsyncioTestCase): async def test_cards_paint_their_headers(self): kinds = { "read": {"path": "a.py"}, "grep": {"pattern": "x", "path": "."}, "search": {"query": "q"}, "fetch": {"url": "https://example.org/slow"}, } async with booted_app() as (app, pilot): seq = 0 for _round in range(3): for name, args in kinds.items(): seq += 1 app.post_message(UIEvent( "tool_start", {"seq": seq, "name": name, "args": args})) await pilot.pause() for done in range(seq - 3, seq + 1): name = list(kinds)[(done - 1) % 4] app.post_message(UIEvent( "tool_done", {"seq": done, "name": name, "args": kinds[name], "result": {"ok": True}, "elapsed_ms": 3.0, "cost_usd": 0.0})) await pilot.pause() await pilot.wait_for_scheduled_animations() await pilot.pause() handle, shot = tempfile.mkstemp(suffix=".svg") try: os.close(handle) app.save_screenshot(shot) words = TestCardSeal.painted_words(shot) finally: os.remove(shot) for name in kinds: with self.subTest(tool=name): self.assertIn(name, words) async def test_chrome_empty_states(self): from textual.widgets import TextArea async with booted_app() as (app, pilot): diff = app.query_one(DiffView) area = diff.query_one("#diff-area", TextArea) self.assertFalse(area.show_line_numbers) diff.add_diff("a.py", "x", "y") await pilot.pause() self.assertTrue(area.show_line_numbers) diff.clear() await pilot.pause() self.assertFalse(area.show_line_numbers) total = app.query_one(CostsView).query_one( "#costs-total") self.assertNotEqual( str(total.render()).strip(), "") if __name__ == "__main__": unittest.main()