Skip to content
Repos

blackcat

Python 6.2 KB147 lines Opens in site

Directory Raw Download

"""Committed tests for the blackcat logging system (stdlib logging).

CLI configures the ``blackcat`` tree on stderr (+ optional file); library
modules only emit. These tests assert the important steps are visible
at INFO, detail at DEBUG, and stdout stays clean.
"""
# retoor <retoor@molodetz.nl>

import io
import json
import logging
import os
import tempfile
import unittest
from contextlib import redirect_stderr, redirect_stdout

from blackcat.cli import build_parser, main, resolve_log_level, setup_logging
from blackcat.converge import iterative_evidence_convergence
from tests.test_blackcat import _FakeSession, _json_handler
from tests.test_converge import TOPIC, extract, make_search


class TestCLIConfig(unittest.TestCase):
    def test_level_resolution(self):
        self.assertEqual(resolve_log_level(), "INFO")
        self.assertEqual(resolve_log_level(verbose=1), "DEBUG")
        self.assertEqual(resolve_log_level(quiet=1), "WARNING")
        self.assertEqual(resolve_log_level(verbose=1,
                                           log_level="ERROR"), "ERROR")

    def test_parser_flags(self):
        args = build_parser().parse_args(
            ["-v", "-q", "--log-level", "DEBUG", "--log-file", "x.log",
             "prompt", "hi"])
        self.assertEqual((args.verbose, args.quiet), (1, 1))
        self.assertEqual(args.log_level, "DEBUG")
        self.assertEqual(args.log_file, "x.log")

    def test_setup_idempotent_and_file(self):
        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "blackcat.log")
            logger = setup_logging(log_file=path)
            count = len(logger.handlers)
            self.assertGreaterEqual(count, 2)
            self.assertFalse(logger.propagate)
            logging.getLogger("blackcat.test").info("hello file")
            for handler in logger.handlers:
                handler.flush()
            again = setup_logging(log_file=path)
            self.assertEqual(len(again.handlers), count)
            with open(path, encoding="utf-8") as fh:
                self.assertIn("hello file", fh.read())
        setup_logging()

    def test_stdout_stays_clean_logs_on_stderr(self):
        out, err = io.StringIO(), io.StringIO()
        with redirect_stdout(out), redirect_stderr(err):
            code = main(["--provider", "echo", "prompt", "hello"])
        self.assertEqual(code, 0)
        self.assertEqual(out.getvalue().strip(), "echo: hello")
        self.assertIn("blackcat starting", err.getvalue())
        self.assertIn("blackcat.cli", err.getvalue())


class TestConvergeLogs(unittest.IsolatedAsyncioTestCase):
    async def test_round_by_round_logs(self):
        with self.assertLogs("blackcat.converge", level="INFO") as caught:
            out = await iterative_evidence_convergence(
                TOPIC, min_iterations=3, max_iterations=10,
                search_fn=make_search({}), extract_fn=extract)
        text = "\n".join(caught.output)
        self.assertTrue(out["ok"])
        for needle in ("convergence started", "round 0:", "search ",
                       "search done", "round 0 done", "top claims",
                       "stop check", "refinement for round",
                       "synthesis:", "conclusion:"):
            self.assertIn(needle, text, needle)
        self.assertIn("stopping early", text)

    async def test_debug_shows_per_item_detail(self):
        with self.assertLogs("blackcat.converge", level="DEBUG") as caught:
            await iterative_evidence_convergence(
                TOPIC, min_iterations=1, max_iterations=1,
                search_fn=make_search({}), extract_fn=extract)
        text = "\n".join(caught.output)
        self.assertIn("reliability=", text)
        self.assertIn("confidence update:", text)

    async def test_failure_reasons_logged_not_just_continuing(self):
        with self.assertLogs("blackcat.converge", level="INFO") as caught:
            await iterative_evidence_convergence(
                TOPIC, min_iterations=1, max_iterations=2,
                early_stop=False, search_fn=make_search({}),
                extract_fn=extract)
        self.assertIn("early_stop disabled", "\n".join(caught.output))


class TestAgentAndClientLogs(unittest.IsolatedAsyncioTestCase):
    async def test_agent_tool_loop_logs(self):
        import tempfile as _tf

        from blackcat.agent import BlackCatBot
        from blackcat.fstate import FileState
        from blackcat.tools import FileTools
        from tests.test_agent_tools import (
            StubClient,
            _call,
            _text_resp,
            _tool_resp,
        )
        with _tf.TemporaryDirectory() as tmp:
            bot = BlackCatBot(provider="deepseek", api_key="k", system="t",
                          tools=FileTools(FileState(tmp)))
            try:
                bot._client = StubClient([
                    _tool_resp(_call("c1", "write_file", json.dumps(
                        {"path": "aa.md", "content": "xx\n"}))),
                    _text_resp("done")])
                with self.assertLogs("blackcat.agent", level="INFO") as caught:
                    self.assertEqual(await bot.prompt("Write xx to aa.md"),
                                     "done")
            finally:
                await bot.aclose()
        text = "\n".join(caught.output)
        for needle in ("prompt:", "tool loop step 1/",
                       "model requested 1 tool call(s): write_file",
                       "tool write_file: starting", "tool write_file: done",
                       "model replied with final text"):
            self.assertIn(needle, text, needle)

    async def test_client_search_logs(self):
        from blackcat.rsearch import RSearchClient
        client = RSearchClient(base_url="https://example.invalid")
        payload = {"success": True, "source": "brave",
                   "results": [{"title": "T1"}, {"title": "T2"}]}
        client._http = _FakeSession(_json_handler(payload))
        self.addAsyncCleanup(client.aclose)
        with self.assertLogs("blackcat.rsearch",
                             level="INFO") as caught:
            await client.search("coffee focus")
        text = "\n".join(caught.output)
        self.assertIn("search: 'coffee focus'", text)
        self.assertIn("2 results", text)


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