Skip to content
Repos

blackcat

Python 9.8 KB270 lines Opens in site

Directory Raw Download

"""Committed tests for cooperative Ctrl+C cancellation.

One press cancels the running tool and the turn continues with the next
step; three presses abort the turn and hand control back to input. Every
cancelled tool reports ``code == "cancelled"`` to the model and the
message history stays wire-valid (no dangling assistant ``tool_calls``).
"""

from __future__ import annotations

# retoor <retoor@molodetz.nl>
import asyncio
import os
import tempfile
import time
import unittest

from blackcat.agent import BlackCatBot
from blackcat.cancel import (
    ABORT_PRESSES,
    CANCEL_CODE,
    CancelTracker,
    cancelled_result,
    settle,
)
from blackcat.fstate import FileState
from blackcat.tools import BashTools

try:
    from blackcat.tui.app import BlackCatApp
    from blackcat.tui.bridge import TUIBot
    from blackcat.tui.chrome import StatusLine
    HAS_TEXTUAL = True
except ImportError:
    HAS_TEXTUAL = False


class TestCancelTracker(unittest.TestCase):
    def test_press_counts_inside_window(self):
        tracker = CancelTracker(window=60.0, threshold=3)
        self.assertEqual(tracker.press(), 1)
        self.assertEqual(tracker.press(), 2)
        self.assertFalse(tracker.aborted)
        self.assertEqual(tracker.press(), 3)
        self.assertTrue(tracker.aborted)

    def test_window_expiry_restarts_count(self):
        tracker = CancelTracker(window=0.05, threshold=3)
        self.assertEqual(tracker.press(), 1)
        time.sleep(0.08)
        self.assertEqual(tracker.press(), 1)
        self.assertFalse(tracker.aborted)

    def test_abort_and_reset(self):
        tracker = CancelTracker(window=60.0, threshold=2)
        tracker.press()
        tracker.abort()
        self.assertTrue(tracker.aborted)
        tracker.reset()
        self.assertFalse(tracker.aborted)
        self.assertEqual(tracker.presses, 0)
        self.assertEqual(tracker.press(), 1)

    def test_threshold_matches_triple_press(self):
        self.assertEqual(ABORT_PRESSES, 3)


class TestCancelledResult(unittest.TestCase):
    def test_shape_and_user_mention(self):
        result = cancelled_result("bash")
        self.assertFalse(result["ok"])
        self.assertEqual(result["code"], CANCEL_CODE)
        self.assertIn("bash", result["error"])
        self.assertIn("user", result["error"].lower())
        self.assertIn("Ctrl+C", result["error"])


class TestSettle(unittest.TestCase):
    def test_no_task_is_safe(self):
        settle()

    def test_suppressed_cancel_keeps_result(self):
        async def sample():
            try:
                await asyncio.sleep(30)
            except asyncio.CancelledError:
                settle()
                await asyncio.sleep(0)
                return "continued"
            return "unreached"

        async def main():
            task = asyncio.ensure_future(sample())
            await asyncio.sleep(0.05)
            task.cancel()
            return await task

        self.assertEqual(asyncio.run(main()), "continued")


class CancelCase(unittest.IsolatedAsyncioTestCase):
    async def asyncSetUp(self):
        self.bot = BlackCatBot(provider="echo")
        self.addAsyncCleanup(self.bot.aclose)


class TestRunToolCancel(CancelCase):
    async def test_cancel_converts_to_result(self):
        async def slow():
            await asyncio.sleep(30)
            return {"ok": True}

        self.bot._extra_tools["slow"] = slow
        task = asyncio.ensure_future(self.bot.run_tool("slow"))
        await asyncio.sleep(0.05)
        task.cancel()
        result = await task
        self.assertFalse(result["ok"])
        self.assertEqual(result["code"], "cancelled")
        self.assertIn("user", result["error"].lower())
        self.assertIsNone(BlackCatBot.validate_wire(self.bot.messages))

    async def test_cancel_names_tool_in_error(self):
        async def slow():
            await asyncio.sleep(30)
            return {"ok": True}

        self.bot._extra_tools["slow"] = slow
        self.bot.messages.append(
            {"role": "assistant", "content": None,
             "tool_calls": [{"id": "call-1",
                             "function": {"name": "slow",
                                          "arguments": "{}"}}]})
        task = asyncio.ensure_future(
            self.bot.run_tool("slow", _tool_call_id="call-1"))
        await asyncio.sleep(0.05)
        task.cancel()
        result = await task
        self.assertEqual(result["code"], "cancelled")
        self.assertIn("slow", result["error"])
        kinds = [msg.get("role") for msg in self.bot.messages]
        self.assertIn("tool", kinds)
        self.assertIsNone(BlackCatBot.validate_wire(self.bot.messages))


class TestWireRepair(CancelCase):
    def _calls(self):
        return [{"id": "c1",
                 "function": {"name": "read", "arguments": "{}"}},
                {"id": "c2",
                 "function": {"name": "bash", "arguments": "{}"}}]

    async def test_reconcile_answers_every_call(self):
        calls = self._calls()
        self.bot.messages.append({"role": "user", "content": "go"})
        self.bot.messages.append({"role": "assistant", "content": None,
                                  "tool_calls": calls})
        self.assertIsNotNone(BlackCatBot.validate_wire(self.bot.messages))
        await self.bot._reconcile_pending_tools(calls)
        self.assertIsNone(BlackCatBot.validate_wire(self.bot.messages))
        answered = [msg for msg in self.bot.messages
                    if msg.get("role") == "tool"]
        self.assertEqual(len(answered), 2)
        for msg in answered:
            payload = msg["content"]
            self.assertIn("cancelled", payload)

    async def test_reconcile_skips_answered_calls(self):
        calls = self._calls()
        self.bot.messages.append({"role": "user", "content": "go"})
        self.bot.messages.append({"role": "assistant", "content": None,
                                  "tool_calls": calls})
        await self.bot._emit_tool_result("read", {"ok": True}, "c1",
                                         {"path": "f.txt"})
        await self.bot._reconcile_pending_tools(calls)
        self.assertIsNone(BlackCatBot.validate_wire(self.bot.messages))
        answered = [msg for msg in self.bot.messages
                    if msg.get("role") == "tool"]
        self.assertEqual(len(answered), 2)
        codes = sorted(msg["tool_call_id"] for msg in answered)
        self.assertEqual(codes, ["c1", "c2"])

    async def test_emit_is_idempotent_per_call_id(self):
        await self.bot._emit_tool_result("read", {"ok": True}, "dup",
                                         {"path": "f.txt"})
        await self.bot._emit_tool_result("read", cancelled_result("read"),
                                         "dup", {"cancelled": True})
        dupes = [msg for msg in self.bot.messages
                 if msg.get("tool_call_id") == "dup"]
        self.assertEqual(len(dupes), 1)

    async def test_pending_ids_detects_dangling(self):
        calls = self._calls()
        self.bot.messages.append({"role": "assistant", "content": None,
                                  "tool_calls": calls})
        pending = self.bot._pending_tool_ids()
        self.assertEqual(sorted(cid for cid, _ in pending), ["c1", "c2"])
        await self.bot._reconcile_pending_tools(calls)
        self.assertEqual(self.bot._pending_tool_ids(), [])


class TestInterruptApi(CancelCase):
    def test_note_interrupt_and_abort(self):
        self.assertEqual(self.bot.note_interrupt(), 1)
        self.assertFalse(self.bot._cancel_requested())
        self.bot.request_abort()
        self.assertTrue(self.bot._cancel_requested())


class TestBashCancel(unittest.IsolatedAsyncioTestCase):
    def setUp(self):
        self.tmp = tempfile.TemporaryDirectory()
        self.addCleanup(self.tmp.cleanup)
        self.root = os.path.join(self.tmp.name, "ws")
        os.mkdir(self.root)
        self.bash = BashTools(FileState(self.root))

    async def test_cancel_kills_process_group(self):
        started = time.monotonic()
        task = asyncio.ensure_future(
            self.bash.run("sleep 30", timeout_ms=60000))
        await asyncio.sleep(0.3)
        task.cancel()
        with self.assertRaises(asyncio.CancelledError):
            await task
        settle()
        self.assertLess(time.monotonic() - started, 15.0)
        again = await self.bash.run("echo alive")
        self.assertTrue(again["ok"])
        self.assertEqual(again["stdout"].strip(), "alive")


@unittest.skipUnless(HAS_TEXTUAL, "tui extra unavailable")
class TestTuiCancel(unittest.IsolatedAsyncioTestCase):
    async def test_bridge_run_tool_cancel_emits_done(self):
        events = []
        bot = TUIBot(provider="echo", emit=events.append)
        self.addAsyncCleanup(bot.aclose)

        async def slow():
            await asyncio.sleep(30)
            return {"ok": True}

        bot._extra_tools["slow"] = slow
        task = asyncio.ensure_future(bot.run_tool("slow"))
        await asyncio.sleep(0.05)
        task.cancel()
        result = await task
        self.assertEqual(result["code"], "cancelled")
        kinds = [event.kind for event in events]
        self.assertEqual(kinds, ["tool_start", "tool_done"])
        done = events[1].payload
        self.assertEqual(done["result"]["code"], "cancelled")
        self.assertIsNone(BlackCatBot.validate_wire(bot.messages))

    async def test_ctrl_c_binding_cancels_without_busy_stick(self):
        app = BlackCatApp(bot_kwargs={"provider": "echo"})
        async with app.run_test(size=(120, 40)) as pilot:
            await pilot.press("escape")
            await pilot.pause()
            self.assertFalse(app._busy)
            await pilot.press("ctrl+c")
            await pilot.pause()
            self.assertFalse(app._busy)
            status = app.query_one("#status", StatusLine).text
            self.assertIn("cancelled", status.lower())


if __name__ == "__main__":
    unittest.main()
21.3ms