Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
Improved test coverage
Alishahryar1b8d1bfecbb42
diff --git a/tests/test_app_lifespan_and_errors.py b/tests/test_app_lifespan_and_errors.pyindex 1bfe650b..9019c759 100644--- a/tests/test_app_lifespan_and_errors.py+++ b/tests/test_app_lifespan_and_errors.py@@ -210,3 +210,146 @@ def test_app_lifespan_cleanup_continues_if_platform_stop_raises(tmp_path):fake_platform.stop.assert_awaited_once()cli_manager.stop_all.assert_awaited_once()cleanup_provider.assert_awaited_once()+++def test_app_lifespan_messaging_import_error_no_crash(tmp_path, caplog):+ """Messaging import failure logs warning and continues without crash."""+ from api.app import create_app++ app = create_app()++ settings = SimpleNamespace(+ messaging_platform="telegram",+ telegram_bot_token="token",+ allowed_telegram_user_id="123",+ discord_bot_token=None,+ allowed_discord_channels=None,+ allowed_dir=str(tmp_path / "workspace"),+ claude_workspace=str(tmp_path / "data"),+ host="127.0.0.1",+ port=8082,+ max_cli_sessions=1,+ log_file=str(tmp_path / "server.log"),+ )++ api_app_mod = importlib.import_module("api.app")+ cleanup_provider = AsyncMock()+ with (+ patch.object(api_app_mod, "get_settings", return_value=settings),+ patch.object(api_app_mod, "cleanup_provider", new=cleanup_provider),+ patch(+ "messaging.factory.create_messaging_platform",+ side_effect=ImportError("discord not installed"),+ ),+ ):+ with TestClient(app):+ pass++ assert getattr(app.state, "messaging_platform", None) is None+ cleanup_provider.assert_awaited_once()+++def test_app_lifespan_platform_start_exception_cleanup_still_runs(tmp_path):+ """Exception during platform.start() logs error, cleanup still runs."""+ from api.app import create_app++ app = create_app()++ settings = SimpleNamespace(+ messaging_platform="telegram",+ telegram_bot_token="token",+ allowed_telegram_user_id="123",+ discord_bot_token=None,+ allowed_discord_channels=None,+ allowed_dir=str(tmp_path / "workspace"),+ claude_workspace=str(tmp_path / "data"),+ host="127.0.0.1",+ port=8082,+ max_cli_sessions=1,+ log_file=str(tmp_path / "server.log"),+ )++ fake_platform = MagicMock()+ fake_platform.name = "fake"+ fake_platform.on_message = MagicMock()+ fake_platform.start = AsyncMock(side_effect=RuntimeError("start failed"))+ fake_platform.stop = AsyncMock()++ session_store = MagicMock()+ session_store.get_all_trees.return_value = []+ session_store.get_node_mapping.return_value = {}+ session_store.sync_from_tree_data = MagicMock()++ cli_manager = MagicMock()+ cli_manager.stop_all = AsyncMock()++ api_app_mod = importlib.import_module("api.app")+ cleanup_provider = AsyncMock()+ with (+ patch.object(api_app_mod, "get_settings", return_value=settings),+ patch.object(api_app_mod, "cleanup_provider", new=cleanup_provider),+ patch(+ "messaging.factory.create_messaging_platform",+ return_value=fake_platform,+ ),+ patch("messaging.session.SessionStore", return_value=session_store),+ patch("cli.manager.CLISessionManager", return_value=cli_manager),+ ):+ with TestClient(app):+ pass++ cleanup_provider.assert_awaited_once()+++def test_app_lifespan_flush_pending_save_exception_warning_only(tmp_path):+ """Session store flush exception on shutdown is logged as warning, no crash."""+ from api.app import create_app++ app = create_app()++ settings = SimpleNamespace(+ messaging_platform="telegram",+ telegram_bot_token="token",+ allowed_telegram_user_id="123",+ discord_bot_token=None,+ allowed_discord_channels=None,+ allowed_dir=str(tmp_path / "workspace"),+ claude_workspace=str(tmp_path / "data"),+ host="127.0.0.1",+ port=8082,+ max_cli_sessions=1,+ log_file=str(tmp_path / "server.log"),+ )++ fake_platform = MagicMock()+ fake_platform.name = "fake"+ fake_platform.on_message = MagicMock()+ fake_platform.start = AsyncMock()+ fake_platform.stop = AsyncMock()++ session_store = MagicMock()+ session_store.get_all_trees.return_value = []+ session_store.get_node_mapping.return_value = {}+ session_store.sync_from_tree_data = MagicMock()+ session_store.flush_pending_save = MagicMock(side_effect=IOError("disk full"))++ cli_manager = MagicMock()+ cli_manager.stop_all = AsyncMock()++ api_app_mod = importlib.import_module("api.app")+ cleanup_provider = AsyncMock()+ with (+ patch.object(api_app_mod, "get_settings", return_value=settings),+ patch.object(api_app_mod, "cleanup_provider", new=cleanup_provider),+ patch(+ "messaging.factory.create_messaging_platform",+ return_value=fake_platform,+ ),+ patch("messaging.session.SessionStore", return_value=session_store),+ patch("cli.manager.CLISessionManager", return_value=cli_manager),+ ):+ with TestClient(app):+ pass++ session_store.flush_pending_save.assert_called_once()+ cleanup_provider.assert_awaited_once()diff --git a/tests/test_detection.py b/tests/test_detection.pynew file mode 100644index 00000000..deed9140--- /dev/null+++ b/tests/test_detection.py@@ -0,0 +1,80 @@+"""Edge case tests for api/detection.py."""++from unittest.mock import patch++from api.detection import (+ is_prefix_detection_request,+ is_filepath_extraction_request,+)+from api.models.anthropic import MessagesRequest, Message+++def _make_request(content: str, **kwargs) -> MessagesRequest:+ return MessagesRequest(+ model="claude-3-sonnet",+ max_tokens=100,+ messages=[Message(role="user", content=content)],+ **kwargs,+ )+++class TestIsPrefixDetectionRequest:+ def test_output_marker_handling(self):+ """Content with Command: but Output: after cmd_start; output has < or \\n\\n."""+ content = "<policy_spec> Command:\nls -la\nOutput:\na.txt\nb.txt\n\nmore"+ req = _make_request(content)+ is_req, cmd = is_prefix_detection_request(req)+ assert is_req is True+ assert "ls -la" in cmd++ def test_prefix_detection_with_empty_command_section(self):+ """Command: at end with no content returns empty command."""+ req = _make_request("<policy_spec> Command: ")+ is_req, cmd = is_prefix_detection_request(req)+ assert is_req is True+ assert cmd == ""++ def test_exception_in_try_returns_false(self):+ """Exception in try block (e.g. content slice) returns False, ''."""+ req = _make_request("<policy_spec> Command: x")++ # Return object that raises when sliced - triggers except in is_prefix_detection_request+ class BadStr(str):+ def __getitem__(self, key):+ raise TypeError("bad slice")++ with patch(+ "api.detection.extract_text_from_content",+ return_value=BadStr("<policy_spec> Command: x"),+ ):+ is_req, cmd = is_prefix_detection_request(req)+ assert is_req is False+ assert cmd == ""+++class TestIsFilepathExtractionRequest:+ def test_output_marker_minus_one_returns_false(self):+ """Output: not found after Command: returns False."""+ content = "Command:\nls\nfilepaths"+ req = _make_request(content)+ is_fp, cmd, out = is_filepath_extraction_request(req)+ assert is_fp is False+ assert cmd == ""+ assert out == ""++ def test_output_has_angle_bracket_splits(self):+ """Output containing < is split and first part used."""+ content = "Command:\nls\nOutput:\na.txt b.txt <extra>\nfilepaths"+ req = _make_request(content)+ is_fp, cmd, out = is_filepath_extraction_request(req)+ assert is_fp is True+ assert "<" not in out+ assert out == "a.txt b.txt"++ def test_output_has_double_newline_splits(self):+ """Output containing \\n\\n is split and first part used."""+ content = "Command:\nls\nOutput:\na.txt\nb.txt\n\nmore text\nfilepaths"+ req = _make_request(content)+ is_fp, cmd, out = is_filepath_extraction_request(req)+ assert is_fp is True+ assert "more" not in outdiff --git a/tests/test_discord_markdown.py b/tests/test_discord_markdown.pynew file mode 100644index 00000000..b70a9d64--- /dev/null+++ b/tests/test_discord_markdown.py@@ -0,0 +1,201 @@+"""Tests for messaging/discord_markdown.py."""++from messaging.discord_markdown import (+ escape_discord,+ escape_discord_code,+ discord_bold,+ discord_code_inline,+ format_status_discord,+ format_status,+ render_markdown_to_discord,+ _is_gfm_table_header_line,+ _normalize_gfm_tables,+)+++class TestEscapeDiscord:+ """Tests for escape_discord."""++ def test_empty_string(self):+ assert escape_discord("") == ""++ def test_plain_text_unchanged(self):+ assert escape_discord("hello world") == "hello world"++ def test_special_chars_escaped(self):+ for ch in "\\*_`~|>":+ assert escape_discord(ch) == f"\\{ch}"++ def test_mixed_special_and_plain(self):+ assert escape_discord("a*b_c") == "a\\*b\\_c"++ def test_unicode_preserved(self):+ assert escape_discord("café 日本語") == "café 日本語"+++class TestEscapeDiscordCode:+ """Tests for escape_discord_code."""++ def test_empty_string(self):+ assert escape_discord_code("") == ""++ def test_backslash_escaped(self):+ assert escape_discord_code("\\") == "\\\\"++ def test_backtick_escaped(self):+ assert escape_discord_code("`") == "\\`"++ def test_both_escaped(self):+ assert escape_discord_code("`\\") == "\\`\\\\"+++class TestDiscordBold:+ """Tests for discord_bold."""++ def test_simple(self):+ assert discord_bold("hello") == "**hello**"++ def test_escapes_inner(self):+ assert discord_bold("a*b") == "**a\\*b**"+++class TestDiscordCodeInline:+ """Tests for discord_code_inline."""++ def test_simple(self):+ assert discord_code_inline("x") == "`x`"++ def test_escapes_backtick(self):+ assert discord_code_inline("`") == "`\\``"+++class TestFormatStatusDiscord:+ """Tests for format_status_discord."""++ def test_label_only(self):+ assert format_status_discord("Running") == "**Running**"++ def test_label_with_suffix(self):+ # Parentheses not in DISCORD_SPECIAL, so unchanged+ assert (+ format_status_discord("Queued", "(position 2)") == "**Queued** (position 2)"+ )+++class TestFormatStatus:+ """Tests for format_status."""++ def test_label_only(self):+ assert format_status("🔄", "Running") == "🔄 **Running**"++ def test_label_with_suffix(self):+ assert format_status("⏳", "Waiting", "5/10") == "⏳ **Waiting** 5/10"+++class TestIsGfmTableHeaderLine:+ """Tests for _is_gfm_table_header_line."""++ def test_no_pipe_returns_false(self):+ assert _is_gfm_table_header_line("hello world") is False++ def test_separator_only_returns_false(self):+ assert _is_gfm_table_header_line("|---|") is False+ assert _is_gfm_table_header_line("|:---|:---|") is False++ def test_valid_header(self):+ assert _is_gfm_table_header_line("| A | B |") is True+ assert _is_gfm_table_header_line("A | B") is True++ def test_single_column_returns_false(self):+ assert _is_gfm_table_header_line("| A |") is False+++class TestNormalizeGfmTables:+ """Tests for _normalize_gfm_tables."""++ def test_single_line_unchanged(self):+ assert _normalize_gfm_tables("hello") == "hello"++ def test_two_lines_no_table_unchanged(self):+ assert _normalize_gfm_tables("a\nb") == "a\nb"++ def test_table_gets_blank_line_before(self):+ text = "para\n| A | B |\n|---|\n| 1 | 2 |"+ result = _normalize_gfm_tables(text)+ assert "para" in result+ assert "| A | B |" in result++ def test_table_inside_fence_unchanged(self):+ text = "```\n| A | B |\n|---|\n```"+ result = _normalize_gfm_tables(text)+ assert result == text+++class TestRenderMarkdownToDiscord:+ """Tests for render_markdown_to_discord."""++ def test_empty_string(self):+ assert render_markdown_to_discord("") == ""++ def test_plain_paragraph(self):+ assert "hello" in render_markdown_to_discord("hello")++ def test_headings(self):+ result = render_markdown_to_discord("# Title\n## Sub")+ assert "Title" in result+ assert "Sub" in result++ def test_bold_italic(self):+ result = render_markdown_to_discord("**bold** *italic*")+ assert "bold" in result+ assert "italic" in result++ def test_strikethrough(self):+ result = render_markdown_to_discord("~~strike~~")+ assert "strike" in result++ def test_inline_code(self):+ result = render_markdown_to_discord("use `code` here")+ assert "`" in result+ assert "code" in result++ def test_code_block(self):+ result = render_markdown_to_discord("```\nprint(1)\n```")+ assert "print(1)" in result+ assert "```" in result++ def test_blockquote(self):+ result = render_markdown_to_discord("> quote")+ assert "quote" in result++ def test_bullet_list(self):+ result = render_markdown_to_discord("- a\n- b")+ assert "a" in result+ assert "b" in result++ def test_ordered_list(self):+ result = render_markdown_to_discord("1. first\n2. second")+ assert "first" in result+ assert "second" in result++ def test_link(self):+ result = render_markdown_to_discord("[text](https://example.com)")+ assert "text" in result+ assert "https://example.com" in result++ def test_image_with_alt(self):+ result = render_markdown_to_discord("")+ assert "alt" in result+ assert "https://img.png" in result++ def test_image_without_alt(self):+ result = render_markdown_to_discord("")+ assert "https://img.png" in result++ def test_gfm_table(self):+ text = "| A | B |\n|---|---|\n| 1 | 2 |"+ result = render_markdown_to_discord(text)+ assert "A" in result+ assert "B" in result+ assert "1" in result+ assert "2" in resultdiff --git a/tests/test_discord_platform.py b/tests/test_discord_platform.pyindex eb6e6750..674cd693 100644--- a/tests/test_discord_platform.py+++ b/tests/test_discord_platform.py@@ -1,15 +1,29 @@"""Tests for Discord platform adapter."""+import asyncioimport pytestfrom unittest.mock import AsyncMock, MagicMock, patchfrom messaging.discord import (DiscordPlatform,_parse_allowed_channels,+ _get_discord,DISCORD_AVAILABLE,)+class TestGetDiscord:+ """Tests for _get_discord helper."""++ def test_raises_when_discord_not_available(self):+ import messaging.discord as discord_mod++ with patch.object(discord_mod, "DISCORD_AVAILABLE", False):+ with patch.object(discord_mod, "_discord_module", None):+ with pytest.raises(ImportError, match="discord.py is required"):+ _get_discord()++class TestParseAllowedChannels:"""Tests for _parse_allowed_channels helper."""@@ -17,6 +31,9 @@ class TestParseAllowedChannels:assert _parse_allowed_channels("") == set()assert _parse_allowed_channels(None) == set()+ def test_whitespace_only_returns_empty_set(self):+ assert _parse_allowed_channels(" ") == set()+def test_single_channel(self):assert _parse_allowed_channels("123456789") == {"123456789"}@@ -66,6 +83,22 @@ class TestDiscordPlatform:short = "hello"assert platform._truncate(short) == short+ def test_truncate_exactly_at_limit_unchanged(self):+ platform = DiscordPlatform(bot_token="token")+ exact = "x" * 2000+ assert platform._truncate(exact) == exact++ def test_truncate_one_over_limit_truncates(self):+ platform = DiscordPlatform(bot_token="token")+ over = "x" * 2001+ result = platform._truncate(over)+ assert len(result) == 2000+ assert result.endswith("...")++ def test_truncate_empty_string(self):+ platform = DiscordPlatform(bot_token="token")+ assert platform._truncate("") == ""+@pytest.mark.asyncioasync def test_send_message_returns_message_id(self):platform = DiscordPlatform(bot_token="token")@@ -92,3 +125,237 @@ class TestDiscordPlatform:):await platform.edit_message("123", "456", "Updated text")mock_msg.edit.assert_called_once_with(content="Updated text")++ @pytest.mark.asyncio+ async def test_send_message_channel_not_found_raises(self):+ platform = DiscordPlatform(bot_token="token")+ platform._connected = True+ with patch.object(+ platform._client, "get_channel", MagicMock(return_value=None)+ ):+ with pytest.raises(RuntimeError, match="Channel"):+ await platform.send_message("123", "Hello")++ @pytest.mark.asyncio+ async def test_send_message_channel_no_send_raises(self):+ platform = DiscordPlatform(bot_token="token")+ platform._connected = True+ mock_channel = MagicMock(spec=[]) # No send attr+ with patch.object(+ platform._client, "get_channel", MagicMock(return_value=mock_channel)+ ):+ with pytest.raises(RuntimeError, match="Channel"):+ await platform.send_message("123", "Hello")++ @pytest.mark.asyncio+ async def test_queue_send_message_without_limiter_calls_send_message(self):+ platform = DiscordPlatform(bot_token="token")+ platform._limiter = None+ platform._connected = True+ mock_channel = AsyncMock()+ mock_msg = MagicMock()+ mock_msg.id = 42+ mock_channel.send = AsyncMock(return_value=mock_msg)+ with patch.object(+ platform._client, "get_channel", MagicMock(return_value=mock_channel)+ ):+ result = await platform.queue_send_message("123", "hi")+ assert result == "42"+ mock_channel.send.assert_awaited_once()++ @pytest.mark.asyncio+ async def test_queue_edit_message_without_limiter_calls_edit_message(self):+ platform = DiscordPlatform(bot_token="token")+ platform._limiter = None+ platform._connected = True+ mock_msg = AsyncMock()+ mock_channel = AsyncMock()+ mock_channel.fetch_message = AsyncMock(return_value=mock_msg)+ with patch.object(+ platform._client, "get_channel", MagicMock(return_value=mock_channel)+ ):+ await platform.queue_edit_message("123", "456", "Updated")+ mock_msg.edit.assert_called_once_with(content="Updated")++ @pytest.mark.asyncio+ async def test_on_discord_message_bot_ignored(self):+ platform = DiscordPlatform(bot_token="token", allowed_channel_ids="123")+ handler = AsyncMock()+ platform.on_message(handler)+ msg = MagicMock()+ msg.author.bot = True+ msg.content = "hello"+ msg.channel.id = 123+ await platform._on_discord_message(msg)+ handler.assert_not_called()++ @pytest.mark.asyncio+ async def test_on_discord_message_empty_content_ignored(self):+ platform = DiscordPlatform(bot_token="token", allowed_channel_ids="123")+ handler = AsyncMock()+ platform.on_message(handler)+ msg = MagicMock()+ msg.author.bot = False+ msg.content = ""+ msg.channel.id = 123+ await platform._on_discord_message(msg)+ handler.assert_not_called()++ @pytest.mark.asyncio+ async def test_on_discord_message_channel_not_allowed_ignored(self):+ platform = DiscordPlatform(bot_token="token", allowed_channel_ids="123")+ handler = AsyncMock()+ platform.on_message(handler)+ msg = MagicMock()+ msg.author.bot = False+ msg.content = "hello"+ msg.channel.id = 999+ await platform._on_discord_message(msg)+ handler.assert_not_called()++ @pytest.mark.asyncio+ async def test_on_discord_message_valid_calls_handler(self):+ platform = DiscordPlatform(bot_token="token", allowed_channel_ids="123")+ handler = AsyncMock()+ platform.on_message(handler)+ msg = MagicMock()+ msg.author.bot = False+ msg.author.id = 456+ msg.author.display_name = "User"+ msg.content = "hello"+ msg.channel.id = 123+ msg.id = 789+ msg.reference = None+ await platform._on_discord_message(msg)+ handler.assert_awaited_once()+ call = handler.call_args[0][0]+ assert call.text == "hello"+ assert call.chat_id == "123"+ assert call.user_id == "456"+ assert call.message_id == "789"+ assert call.platform == "discord"++ @pytest.mark.asyncio+ async def test_send_message_with_reply_to(self):+ platform = DiscordPlatform(bot_token="token")+ mock_msg = MagicMock()+ mock_msg.id = 999+ mock_channel = AsyncMock()+ mock_channel.send = AsyncMock(return_value=mock_msg)+ platform._connected = True+ with patch.object(+ platform._client, "get_channel", MagicMock(return_value=mock_channel)+ ):+ with patch("messaging.discord._get_discord") as mock_get:+ mock_discord = MagicMock()+ mock_get.return_value = mock_discord+ msg_id = await platform.send_message("123", "Hello", reply_to="456")+ assert msg_id == "999"+ mock_channel.send.assert_awaited_once()+ call_kw = mock_channel.send.call_args[1]+ assert call_kw.get("reference") is not None++ @pytest.mark.asyncio+ async def test_edit_message_not_found_returns_gracefully(self):+ import discord as discord_pkg++ platform = DiscordPlatform(bot_token="token")+ mock_channel = AsyncMock()+ mock_resp = MagicMock()+ mock_resp.status = 404+ mock_channel.fetch_message = AsyncMock(+ side_effect=discord_pkg.NotFound(mock_resp, "Not found")+ )+ platform._connected = True+ with patch.object(+ platform._client, "get_channel", MagicMock(return_value=mock_channel)+ ):+ await platform.edit_message("123", "456", "Updated")+ # Should not raise - NotFound is caught and we return++ @pytest.mark.asyncio+ async def test_delete_message(self):+ platform = DiscordPlatform(bot_token="token")+ mock_msg = AsyncMock()+ mock_channel = AsyncMock()+ mock_channel.fetch_message = AsyncMock(return_value=mock_msg)+ platform._connected = True+ with patch.object(+ platform._client, "get_channel", MagicMock(return_value=mock_channel)+ ):+ with patch("messaging.discord._get_discord") as mock_get:+ mock_get.return_value = MagicMock()+ await platform.delete_message("123", "456")+ mock_msg.delete.assert_awaited_once()++ @pytest.mark.asyncio+ async def test_fire_and_forget_with_coroutine(self):+ platform = DiscordPlatform(bot_token="token")++ async def _task():+ pass++ coro = _task()+ with patch("asyncio.create_task") as mock_create:++ def _run(c):+ return asyncio.ensure_future(c)++ mock_create.side_effect = _run+ platform.fire_and_forget(coro)+ mock_create.assert_called_once()+ await asyncio.sleep(0)++ def test_on_message_registers_handler(self):+ platform = DiscordPlatform(bot_token="token")+ handler = AsyncMock()+ platform.on_message(handler)+ assert platform._message_handler is handler++ @pytest.mark.asyncio+ async def test_start_requires_token(self):+ with patch.dict("os.environ", {"DISCORD_BOT_TOKEN": ""}, clear=False):+ platform = DiscordPlatform(bot_token="")+ with pytest.raises(ValueError, match="DISCORD_BOT_TOKEN"):+ await platform.start()++ @pytest.mark.asyncio+ async def test_start_connects(self):+ platform = DiscordPlatform(bot_token="token")++ async def _fake_start(_token):+ platform._connected = True++ with patch.object(+ platform._client, "start", new_callable=AsyncMock, side_effect=_fake_start+ ):+ with patch(+ "messaging.limiter.MessagingRateLimiter.get_instance",+ new_callable=AsyncMock,+ ):+ await platform.start()+ assert platform.is_connected is True++ @pytest.mark.asyncio+ async def test_stop_when_already_closed(self):+ platform = DiscordPlatform(bot_token="token")+ platform._connected = True+ with patch.object(+ platform._client, "is_closed", new_callable=MagicMock, return_value=True+ ):+ await platform.stop()+ assert platform.is_connected is False++ @pytest.mark.asyncio+ async def test_stop_closes_client(self):+ platform = DiscordPlatform(bot_token="token")+ platform._connected = True+ mock_close = AsyncMock()+ with patch.object(+ platform._client, "is_closed", new_callable=MagicMock, return_value=False+ ):+ with patch.object(platform._client, "close", mock_close):+ platform._start_task = None+ await platform.stop()+ mock_close.assert_awaited_once()+ assert platform.is_connected is Falsediff --git a/tests/test_handler.py b/tests/test_handler.pyindex 6b387a8f..3fa583d5 100644--- a/tests/test_handler.py+++ b/tests/test_handler.py@@ -11,6 +11,47 @@ def handler(mock_platform, mock_cli_manager, mock_session_store):return ClaudeMessageHandler(mock_platform, mock_cli_manager, mock_session_store)+def test_get_initial_status_new_conversation_with_slot(handler):+ """New conversation when slots available returns launching message."""+ handler.cli_manager.get_stats.return_value = {+ "active_sessions": 0,+ "max_sessions": 5,+ }+ result = handler._get_initial_status(None, None)+ assert "Launching" in result+++def test_get_initial_status_new_conversation_at_capacity(handler):+ """New conversation at capacity returns waiting message."""+ handler.cli_manager.get_stats.return_value = {+ "active_sessions": 5,+ "max_sessions": 5,+ }+ result = handler._get_initial_status(None, None)+ assert "Waiting" in result+ assert "5/5" in result+++def test_get_initial_status_reply_tree_busy_queued(handler):+ """Reply to tree when busy returns queued message."""+ mock_queue = MagicMock()+ mock_queue.is_node_tree_busy.return_value = True+ mock_queue.get_queue_size.return_value = 2+ handler.tree_queue = mock_queue+ result = handler._get_initial_status(MagicMock(), "parent_1")+ assert "Queued" in result+ assert "position 3" in result+++def test_get_initial_status_reply_tree_not_busy_continuing(handler):+ """Reply to tree when not busy returns continuing message."""+ mock_queue = MagicMock()+ mock_queue.is_node_tree_busy.return_value = False+ handler.tree_queue = mock_queue+ result = handler._get_initial_status(MagicMock(), "parent_1")+ assert "Continuing" in result++@pytest.mark.asyncioasync def test_handle_message_stop_command(handler, mock_platform, incoming_message_factorydiff --git a/tests/test_nvidia_nim_request.py b/tests/test_nvidia_nim_request.pynew file mode 100644index 00000000..5c273833--- /dev/null+++ b/tests/test_nvidia_nim_request.py@@ -0,0 +1,101 @@+"""Tests for providers/nvidia_nim/request.py."""++from unittest.mock import MagicMock++from providers.nvidia_nim.request import (+ _set_if_not_none,+ _set_extra,+ build_request_body,+)+from config.nim import NimSettings+++class TestSetIfNotNone:+ def test_value_not_none_sets(self):+ body = {}+ _set_if_not_none(body, "key", "value")+ assert body["key"] == "value"++ def test_value_none_skips(self):+ body = {}+ _set_if_not_none(body, "key", None)+ assert "key" not in body+++class TestSetExtra:+ def test_key_in_extra_body_skips(self):+ extra = {"top_k": 42}+ _set_extra(extra, "top_k", 10)+ assert extra["top_k"] == 42++ def test_value_none_skips(self):+ extra = {}+ _set_extra(extra, "top_k", None)+ assert "top_k" not in extra++ def test_value_equals_ignore_value_skips(self):+ extra = {}+ _set_extra(extra, "top_k", -1, ignore_value=-1)+ assert "top_k" not in extra++ def test_value_set_when_valid(self):+ extra = {}+ _set_extra(extra, "top_k", 10, ignore_value=-1)+ assert extra["top_k"] == 10+++class TestBuildRequestBody:+ def test_max_tokens_capped_by_nim(self):+ """Request max_tokens exceeds nim.max_tokens -> capped."""+ req = MagicMock()+ req.model = "test"+ req.messages = [MagicMock(role="user", content="hi")]+ req.max_tokens = 100000+ req.system = None+ req.temperature = None+ req.top_p = None+ req.stop_sequences = None+ req.tools = None+ req.tool_choice = None+ req.extra_body = None+ req.top_k = None++ nim = NimSettings(max_tokens=4096)+ body = build_request_body(req, nim)+ assert body["max_tokens"] == 4096++ def test_presence_penalty_included_when_nonzero(self):+ req = MagicMock()+ req.model = "test"+ req.messages = [MagicMock(role="user", content="hi")]+ req.max_tokens = 100+ req.system = None+ req.temperature = None+ req.top_p = None+ req.stop_sequences = None+ req.tools = None+ req.tool_choice = None+ req.extra_body = None+ req.top_k = None++ nim = NimSettings(presence_penalty=0.5)+ body = build_request_body(req, nim)+ assert body["presence_penalty"] == 0.5++ def test_parallel_tool_calls_included(self):+ req = MagicMock()+ req.model = "test"+ req.messages = [MagicMock(role="user", content="hi")]+ req.max_tokens = 100+ req.system = None+ req.temperature = None+ req.top_p = None+ req.stop_sequences = None+ req.tools = None+ req.tool_choice = None+ req.extra_body = None+ req.top_k = None++ nim = NimSettings(parallel_tool_calls=False)+ body = build_request_body(req, nim)+ assert body["parallel_tool_calls"] is Falsediff --git a/tests/test_open_router.py b/tests/test_open_router.pyindex 3d064193..7f3b58ce 100644--- a/tests/test_open_router.py+++ b/tests/test_open_router.py@@ -204,3 +204,152 @@ async def test_stream_response_reasoning_content(open_router_provider):if "Thinking..." in e:found_thinking = Trueassert found_thinking+++async def test_stream_response_empty_choices_skipped(open_router_provider):+ """Chunks with empty choices are skipped."""+ req = MockRequest()++ async def mock_stream():+ yield MagicMock(choices=[], usage=None)+ yield MagicMock(+ choices=[+ MagicMock(+ delta=MagicMock(content="ok", reasoning_content=None),+ finish_reason="stop",+ )+ ],+ usage=MagicMock(completion_tokens=2),+ )++ with patch.object(+ open_router_provider._client.chat.completions, "create", new_callable=AsyncMock+ ) as mock_create:+ mock_create.return_value = mock_stream()+ events = []+ async for event in open_router_provider.stream_response(req):+ events.append(event)+ assert any("content_block_delta" in e and "ok" in e for e in events)+++async def test_stream_response_delta_none_skipped(open_router_provider):+ """Chunks with delta=None are skipped."""+ req = MockRequest()++ async def mock_stream():+ yield MagicMock(+ choices=[MagicMock(delta=None, finish_reason=None)],+ usage=None,+ )+ yield MagicMock(+ choices=[+ MagicMock(+ delta=MagicMock(content="x", reasoning_content=None),+ finish_reason="stop",+ )+ ],+ usage=MagicMock(completion_tokens=1),+ )++ with patch.object(+ open_router_provider._client.chat.completions, "create", new_callable=AsyncMock+ ) as mock_create:+ mock_create.return_value = mock_stream()+ events = []+ async for event in open_router_provider.stream_response(req):+ events.append(event)+ assert any("x" in e for e in events)+++async def test_stream_response_reasoning_details(open_router_provider):+ """Streaming with reasoning_details (stepfun format)."""+ req = MockRequest()++ mock_chunk = MagicMock()+ mock_chunk.choices = [+ MagicMock(+ delta=MagicMock(+ content=None,+ reasoning_content=None,+ reasoning_details=[{"text": "Step 1"}],+ ),+ finish_reason=None,+ )+ ]+ mock_chunk.usage = None++ async def mock_stream():+ yield mock_chunk+ yield MagicMock(+ choices=[+ MagicMock(+ delta=MagicMock(+ content=None,+ reasoning_content=None,+ reasoning_details=None,+ ),+ finish_reason="stop",+ )+ ],+ usage=MagicMock(completion_tokens=5),+ )++ with patch.object(+ open_router_provider._client.chat.completions, "create", new_callable=AsyncMock+ ) as mock_create:+ mock_create.return_value = mock_stream()+ events = []+ async for event in open_router_provider.stream_response(req):+ events.append(event)+ assert any("Step 1" in e for e in events)+++async def test_stream_response_error_path(open_router_provider):+ """Stream raises exception -> error event emitted."""+ req = MockRequest()++ async def mock_stream():+ raise RuntimeError("API failed")+ yield # unreachable, makes it a generator++ with patch.object(+ open_router_provider._client.chat.completions, "create", new_callable=AsyncMock+ ) as mock_create:+ mock_create.return_value = mock_stream()+ events = []+ async for event in open_router_provider.stream_response(req):+ events.append(event)+ # Error is emitted; message_stop/done indicates stream completed+ assert any("API failed" in e for e in events)+ assert any("message_stop" in e for e in events)+++async def test_stream_response_finish_reason_only(open_router_provider):+ """Chunk with finish_reason but no content still completes."""+ req = MockRequest()++ async def mock_stream():+ yield MagicMock(+ choices=[+ MagicMock(+ delta=MagicMock(content=None, reasoning_content=None),+ finish_reason="stop",+ )+ ],+ usage=MagicMock(completion_tokens=0),+ )++ with patch.object(+ open_router_provider._client.chat.completions, "create", new_callable=AsyncMock+ ) as mock_create:+ mock_create.return_value = mock_stream()+ events = []+ async for event in open_router_provider.stream_response(req):+ events.append(event)+ assert any("message_delta" in e for e in events)+ assert any("message_stop" in e for e in events)diff --git a/tests/test_optimization_handlers.py b/tests/test_optimization_handlers.pynew file mode 100644index 00000000..b2d4c797--- /dev/null+++ b/tests/test_optimization_handlers.py@@ -0,0 +1,219 @@+"""Tests for api/optimization_handlers.py."""++from unittest.mock import patch++from api.optimization_handlers import (+ try_prefix_detection,+ try_quota_mock,+ try_title_skip,+ try_suggestion_skip,+ try_filepath_mock,+ try_optimizations,+)+from api.models.anthropic import MessagesRequest, Message, ContentBlockText+from config.settings import Settings+++def _make_request(+ messages_content: str, max_tokens: int | None = None+) -> MessagesRequest:+ """Create a MessagesRequest with a single user message."""+ return MessagesRequest(+ model="claude-3-sonnet",+ max_tokens=max_tokens if max_tokens is not None else 100,+ messages=[Message(role="user", content=messages_content)],+ )+++class TestTryPrefixDetection:+ def test_disabled_returns_none(self):+ settings = Settings()+ settings.fast_prefix_detection = False+ req = _make_request("x")+ with patch(+ "api.optimization_handlers.is_prefix_detection_request",+ return_value=(True, "/ask"),+ ):+ assert try_prefix_detection(req, settings) is None++ def test_enabled_and_match_returns_response(self):+ settings = Settings()+ settings.fast_prefix_detection = True+ req = _make_request("x")+ with patch(+ "api.optimization_handlers.is_prefix_detection_request",+ return_value=(True, "/ask"),+ ):+ with patch(+ "api.optimization_handlers.extract_command_prefix",+ return_value="/ask",+ ):+ result = try_prefix_detection(req, settings)+ assert result is not None+ block = result.content[0]+ assert isinstance(block, ContentBlockText)+ assert block.text == "/ask"++ def test_enabled_but_no_match_returns_none(self):+ settings = Settings()+ settings.fast_prefix_detection = True+ req = _make_request("x")+ with patch(+ "api.optimization_handlers.is_prefix_detection_request",+ return_value=(False, ""),+ ):+ assert try_prefix_detection(req, settings) is None+++class TestTryQuotaMock:+ def test_disabled_returns_none(self):+ settings = Settings()+ settings.enable_network_probe_mock = False+ req = _make_request("quota", max_tokens=1)+ with patch(+ "api.optimization_handlers.is_quota_check_request",+ return_value=True,+ ):+ assert try_quota_mock(req, settings) is None++ def test_enabled_and_match_returns_response(self):+ settings = Settings()+ settings.enable_network_probe_mock = True+ req = _make_request("quota", max_tokens=1)+ with patch(+ "api.optimization_handlers.is_quota_check_request",+ return_value=True,+ ):+ result = try_quota_mock(req, settings)+ assert result is not None+ block = result.content[0]+ assert isinstance(block, ContentBlockText)+ assert "Quota check passed" in block.text+++class TestTryTitleSkip:+ def test_disabled_returns_none(self):+ settings = Settings()+ settings.enable_title_generation_skip = False+ req = _make_request("write a 5-10 word title")+ with patch(+ "api.optimization_handlers.is_title_generation_request",+ return_value=True,+ ):+ assert try_title_skip(req, settings) is None++ def test_enabled_and_match_returns_response(self):+ settings = Settings()+ settings.enable_title_generation_skip = True+ req = _make_request("x")+ with patch(+ "api.optimization_handlers.is_title_generation_request",+ return_value=True,+ ):+ result = try_title_skip(req, settings)+ assert result is not None+ block = result.content[0]+ assert isinstance(block, ContentBlockText)+ assert block.text == "Conversation"+++class TestTrySuggestionSkip:+ def test_disabled_returns_none(self):+ settings = Settings()+ settings.enable_suggestion_mode_skip = False+ req = _make_request("[SUGGESTION MODE: x]")+ with patch(+ "api.optimization_handlers.is_suggestion_mode_request",+ return_value=True,+ ):+ assert try_suggestion_skip(req, settings) is None++ def test_enabled_and_match_returns_response(self):+ settings = Settings()+ settings.enable_suggestion_mode_skip = True+ req = _make_request("x")+ with patch(+ "api.optimization_handlers.is_suggestion_mode_request",+ return_value=True,+ ):+ result = try_suggestion_skip(req, settings)+ assert result is not None+ block = result.content[0]+ assert isinstance(block, ContentBlockText)+ assert block.text == ""+++class TestTryFilepathMock:+ def test_disabled_returns_none(self):+ settings = Settings()+ settings.enable_filepath_extraction_mock = False+ req = _make_request("Command:\nls\nOutput:\nfilepaths")+ with patch(+ "api.optimization_handlers.is_filepath_extraction_request",+ return_value=(True, "ls", "out"),+ ):+ assert try_filepath_mock(req, settings) is None++ def test_enabled_and_match_returns_response(self):+ settings = Settings()+ settings.enable_filepath_extraction_mock = True+ req = _make_request("x")+ with patch(+ "api.optimization_handlers.is_filepath_extraction_request",+ return_value=(True, "ls", "a.txt b.txt"),+ ):+ with patch(+ "api.optimization_handlers.extract_filepaths_from_command",+ return_value="a.txt\nb.txt",+ ):+ result = try_filepath_mock(req, settings)+ assert result is not None+ block = result.content[0]+ assert isinstance(block, ContentBlockText)+ assert block.text == "a.txt\nb.txt"++ def test_extract_filepaths_empty_list_still_returns_response(self):+ settings = Settings()+ settings.enable_filepath_extraction_mock = True+ req = _make_request("x")+ with patch(+ "api.optimization_handlers.is_filepath_extraction_request",+ return_value=(True, "ls", "out"),+ ):+ with patch(+ "api.optimization_handlers.extract_filepaths_from_command",+ return_value="",+ ):+ result = try_filepath_mock(req, settings)+ assert result is not None+ block = result.content[0]+ assert isinstance(block, ContentBlockText)+ assert block.text == ""+++class TestTryOptimizations:+ def test_first_match_wins(self):+ """Quota mock is first in OPTIMIZATION_HANDLERS; it should win over prefix."""+ settings = Settings()+ settings.enable_network_probe_mock = True+ settings.fast_prefix_detection = True+ req = _make_request("quota", max_tokens=1)+ with patch(+ "api.optimization_handlers.is_quota_check_request",+ return_value=True,+ ):+ result = try_optimizations(req, settings)+ assert result is not None+ block = result.content[0]+ assert isinstance(block, ContentBlockText)+ assert "Quota check passed" in block.text++ def test_no_match_returns_none(self):+ settings = Settings()+ settings.fast_prefix_detection = False+ settings.enable_network_probe_mock = False+ settings.enable_title_generation_skip = False+ settings.enable_suggestion_mode_skip = False+ settings.enable_filepath_extraction_mock = False+ req = _make_request("random user message")+ assert try_optimizations(req, settings) is Nonediff --git a/tests/test_process_registry.py b/tests/test_process_registry.pyindex b97b6366..36032032 100644--- a/tests/test_process_registry.py+++ b/tests/test_process_registry.py@@ -1,4 +1,48 @@import os+from unittest.mock import patch+++def test_process_registry_register_pid_zero_noop():+ """register_pid(0) is a no-op (early return)."""+ from cli import process_registry as pr++ before = len(pr._pids)+ pr.register_pid(0)+ assert len(pr._pids) == before+++def test_process_registry_unregister_pid_zero_noop():+ """unregister_pid(0) is a no-op."""+ from cli import process_registry as pr++ pr.register_pid(99999)+ pr.unregister_pid(0)+ assert 99999 in pr._pids+ pr.unregister_pid(99999)+++def test_process_registry_ensure_atexit_idempotent():+ """Second call to ensure_atexit_registered is idempotent."""+ from cli import process_registry as pr++ pr.ensure_atexit_registered()+ pr.ensure_atexit_registered()+ # Should not raise; atexit handler registered once+++def test_process_registry_kill_all_exception_logged_no_raise(monkeypatch):+ """Exception in os.kill/taskkill is logged but does not raise."""+ from cli import process_registry as pr++ monkeypatch.setattr(pr, "_pids", {99999})+ monkeypatch.setattr(os, "name", "posix", raising=False)++ def _kill_raises(pid, sig):+ raise ProcessLookupError("no such process")++ with patch("os.kill", _kill_raises):+ pr.kill_all_best_effort()+ # Should not raisedef test_process_registry_register_unregister_does_not_crash():diff --git a/tests/test_provider_rate_limit.py b/tests/test_provider_rate_limit.pyindex 9a328d53..3a2fa437 100644--- a/tests/test_provider_rate_limit.py+++ b/tests/test_provider_rate_limit.py@@ -183,3 +183,72 @@ class TestProviderRateLimiter:f"Rolling window violated at i={i}: "f"dt={acquired[i + rate_limit] - acquired[i]:.3f}s")++ @pytest.mark.asyncio+ async def test_init_rate_limit_zero_raises(self):+ """rate_limit <= 0 raises ValueError."""+ GlobalRateLimiter.reset_instance()+ with pytest.raises(ValueError, match="rate_limit must be > 0"):+ GlobalRateLimiter(rate_limit=0, rate_window=60)++ @pytest.mark.asyncio+ async def test_init_rate_window_zero_raises(self):+ """rate_window <= 0 raises ValueError."""+ GlobalRateLimiter.reset_instance()+ with pytest.raises(ValueError, match="rate_window must be > 0"):+ GlobalRateLimiter(rate_limit=10, rate_window=0)++ @pytest.mark.asyncio+ async def test_execute_with_retry_exhaust_retries_raises(self):+ """When all 429 retries exhausted, last exception is raised."""+ import openai+ from httpx import Response, Request++ GlobalRateLimiter.reset_instance()+ limiter = GlobalRateLimiter.get_instance(rate_limit=100, rate_window=60)++ def make_429():+ return openai.RateLimitError(+ "rate limited",+ response=Response(429, request=Request("POST", "http://x")),+ body={},+ )++ async def fail():+ raise make_429()++ with pytest.raises(openai.RateLimitError):+ await limiter.execute_with_retry(+ fail, max_retries=2, base_delay=0.01, max_delay=0.1, jitter=0+ )++ @pytest.mark.asyncio+ async def test_execute_with_retry_succeeds_on_retry(self):+ """429 then success returns result."""+ import openai+ from httpx import Response, Request++ GlobalRateLimiter.reset_instance()+ limiter = GlobalRateLimiter.get_instance(rate_limit=100, rate_window=60)++ def make_429():+ return openai.RateLimitError(+ "rate limited",+ response=Response(429, request=Request("POST", "http://x")),+ body={},+ )++ call_count = 0++ async def fail_then_ok():+ nonlocal call_count+ call_count += 1+ if call_count == 1:+ raise make_429()+ return "ok"++ result = await limiter.execute_with_retry(+ fail_then_ok, max_retries=2, base_delay=0.01, max_delay=0.1, jitter=0+ )+ assert result == "ok"+ assert call_count == 2diff --git a/tests/test_routes_optimizations.py b/tests/test_routes_optimizations.pyindex 2f165a25..eb281c00 100644--- a/tests/test_routes_optimizations.py+++ b/tests/test_routes_optimizations.py@@ -97,6 +97,20 @@ def test_count_tokens_endpoint(client):assert response.json()["input_tokens"] == 5+def test_count_tokens_error_returns_500(client):+ """When get_token_count raises, count_tokens returns 500."""+ payload = {+ "model": "claude-3-sonnet",+ "messages": [{"role": "user", "content": "hello"}],+ }++ with patch("api.routes.get_token_count", side_effect=RuntimeError("token error")):+ response = client.post("/v1/messages/count_tokens", json=payload)++ assert response.status_code == 500+ assert "token error" in response.json()["detail"]++def test_stop_cli_with_handler(client):mock_handler = MagicMock()# Mock the async method to return a completed future or just mock it since TestClient