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
Alishahryar19be994340155
diff --git a/messaging/handler.py b/messaging/handler.pyindex 3e17a876..ed19098d 100644--- a/messaging/handler.py+++ b/messaging/handler.py@@ -139,7 +139,8 @@ class ClaudeMessageHandler:return# Filter out status messages (our own messages)- if any(incoming.text.startswith(p) for p in STATUS_MESSAGE_PREFIXES):+ text = incoming.text or ""+ if any(text.startswith(p) for p in STATUS_MESSAGE_PREFIXES):return# Check if this is a reply to an existing node in a tree@@ -392,7 +393,11 @@ class ClaudeMessageHandler:last_ui_update = nowif status is not None:last_status = status- display = transcript.render(render_ctx, limit_chars=3900, status=status)+ try:+ display = transcript.render(render_ctx, limit_chars=3900, status=status)+ except Exception as e:+ logger.warning(f"Transcript render failed for node {node_id}: {e}")+ returnif display and display != last_displayed_text:logger.debug("TELEGRAM_EDIT: node_id=%s chat_id=%s msg_id=%s force=%s status=%r chars=%d",@@ -412,9 +417,14 @@ class ClaudeMessageHandler:if tail:logger.debug("TELEGRAM_EDIT_PREVIEW_TAIL:\n%s", tail)last_displayed_text = display- await self.platform.queue_edit_message(- chat_id, status_msg_id, display, parse_mode="MarkdownV2"- )+ try:+ await self.platform.queue_edit_message(+ chat_id, status_msg_id, display, parse_mode="MarkdownV2"+ )+ except Exception as e:+ logger.warning(+ f"Failed to update Telegram for node {node_id}: {e}"+ )try:try:diff --git a/providers/nvidia_nim/client.py b/providers/nvidia_nim/client.pyindex f646e99d..45f72158 100644--- a/providers/nvidia_nim/client.py+++ b/providers/nvidia_nim/client.py@@ -83,6 +83,8 @@ class NvidiaNimProvider(BaseProvider):choice = chunk.choices[0]delta = choice.delta+ if delta is None:+ continueif choice.finish_reason:finish_reason = choice.finish_reasondiff --git a/tests/test_event_parser.py b/tests/test_event_parser.pyindex b6545876..9bdadf13 100644--- a/tests/test_event_parser.py+++ b/tests/test_event_parser.py@@ -158,3 +158,35 @@ def test_parse_cli_event_result_with_content_directly():def test_parse_cli_event_result_with_result_content_directly():event = {"type": "result", "result": {"content": [{"type": "text", "text": "hi"}]}}assert parse_cli_event(event) == [{"type": "text_chunk", "text": "hi"}]+++def test_parse_cli_event_content_block_unknown_type_skipped():+ """Content block with unknown type is skipped; known blocks still parsed."""+ event = {+ "type": "assistant",+ "message": {+ "content": [+ {"type": "text", "text": "visible"},+ {"type": "unknown", "data": "ignored"},+ {"type": "thinking", "thinking": "thought"},+ ]+ },+ }+ results = parse_cli_event(event)+ assert len(results) == 2+ assert results[0] == {"type": "text_chunk", "text": "visible"}+ assert results[1] == {"type": "thinking_chunk", "text": "thought"}+++def test_parse_cli_event_error_non_dict():+ """Error event with error as string (not dict) is handled."""+ event = {"type": "error", "error": "plain string error"}+ results = parse_cli_event(event)+ assert results == [{"type": "error", "message": "plain string error"}]+++def test_parse_cli_event_exit_code_none():+ """Exit event with no code defaults to success."""+ event = {"type": "exit"}+ results = parse_cli_event(event)+ assert results == [{"type": "complete", "status": "success"}]diff --git a/tests/test_handler_markdown_and_status_edges.py b/tests/test_handler_markdown_and_status_edges.pyindex a5211a77..a2bef8e2 100644--- a/tests/test_handler_markdown_and_status_edges.py+++ b/tests/test_handler_markdown_and_status_edges.py@@ -244,3 +244,156 @@ async def test_handle_message_reply_with_tree_but_no_parent_treated_as_new():await handler.handle_message(incoming)handler.tree_queue.create_tree.assert_awaited_once()+++async def test_update_ui_handles_transcript_render_exception():+ """When transcript.render raises, update_ui catches and does not crash."""+ platform = MagicMock()+ platform.queue_edit_message = AsyncMock()+ platform.fire_and_forget = MagicMock(+ side_effect=lambda c: getattr(c, "close", lambda: None)()+ )++ cli_manager = MagicMock()+ session_store = MagicMock()++ async def _mock_start_task(*args, **kwargs):+ yield {"type": "content_block_delta", "index": 0, "delta": {"type": "text_delta", "text": "hi"}}+ yield {"type": "complete", "status": "success"}++ mock_session = MagicMock()+ mock_session.start_task = _mock_start_task+ cli_manager.get_or_create_session = AsyncMock(+ return_value=(mock_session, "s1", False)+ )+ cli_manager.remove_session = AsyncMock()+ cli_manager.get_stats.return_value = {"active_sessions": 0, "max_sessions": 10}++ handler = ClaudeMessageHandler(platform, cli_manager, session_store)+ handler.tree_queue = MagicMock()+ handler.tree_queue.get_tree_for_node.return_value = None++ incoming = IncomingMessage(+ text="hi",+ chat_id="c",+ user_id="u",+ message_id="n1",+ platform="telegram",+ )+ node = MessageNode(node_id="n1", incoming=incoming, status_message_id="s1")++ with patch.object(+ handler, "_create_transcript_and_render_ctx"+ ) as mock_create:+ transcript = MagicMock()+ transcript.render = MagicMock(side_effect=ValueError("render failed"))+ render_ctx = MagicMock()+ mock_create.return_value = (transcript, render_ctx)++ await handler._process_node("n1", node)++ assert transcript.render.call_count >= 1+++async def test_handle_message_incoming_text_none_safe():+ """handle_message does not crash when incoming.text is None (e.g. malformed adapter)."""+ platform = MagicMock()+ platform.queue_send_message = AsyncMock(return_value="status_1")+ platform.queue_edit_message = AsyncMock()++ cli_manager = MagicMock()+ cli_manager.get_stats.return_value = {"active_sessions": 0, "max_sessions": 10}++ session_store = MagicMock()+ handler = ClaudeMessageHandler(platform, cli_manager, session_store)+ handler.tree_queue = MagicMock()+ handler.tree_queue.get_tree_for_node.return_value = None+ handler.tree_queue.resolve_parent_node_id.return_value = None+ handler.tree_queue.create_tree = AsyncMock(+ return_value=MagicMock(root_id="root", to_dict=MagicMock(return_value={"t": 1}))+ )+ handler.tree_queue.register_node = MagicMock()+ handler.tree_queue.enqueue = AsyncMock(return_value=True)++ incoming = MagicMock()+ incoming.text = None+ incoming.chat_id = "c"+ incoming.user_id = "u"+ incoming.message_id = "m1"+ incoming.platform = "telegram"+ incoming.reply_to_message_id = None+ incoming.is_reply = MagicMock(return_value=False)++ await handler.handle_message(incoming)+ handler.tree_queue.create_tree.assert_awaited_once()+++async def test_process_parsed_event_malformed_content_continues():+ """Malformed/unknown parsed event does not crash _process_parsed_event."""+ platform = MagicMock()+ platform.queue_edit_message = AsyncMock()++ cli_manager = MagicMock()+ session_store = MagicMock()+ handler = ClaudeMessageHandler(platform, cli_manager, session_store)++ transcript = MagicMock()+ update_ui = AsyncMock()++ last_status, had = await handler._process_parsed_event(+ parsed={"type": "unknown_type"},+ transcript=transcript,+ update_ui=update_ui,+ last_status=None,+ had_transcript_events=False,+ tree=None,+ node_id="n1",+ captured_session_id=None,+ )+ assert last_status is None+ assert had is False+++async def test_handler_update_ui_edit_failure_does_not_crash():+ """When queue_edit_message raises during streaming, _process_node continues and completes."""+ platform = MagicMock()+ platform.queue_edit_message = AsyncMock(side_effect=RuntimeError("Telegram API error"))+ platform.fire_and_forget = MagicMock(+ side_effect=lambda c: getattr(c, "close", lambda: None)()+ )++ async def _mock_start_task(*args, **kwargs):+ yield {"type": "content_block_delta", "index": 0, "delta": {"type": "text_delta", "text": "Hello"}}+ yield {"type": "content_block_delta", "index": 0, "delta": {"type": "text_delta", "text": " world"}}+ yield {"type": "complete", "status": "success"}++ mock_session = MagicMock()+ mock_session.start_task = _mock_start_task+ cli_manager = MagicMock()+ cli_manager.get_or_create_session = AsyncMock(+ return_value=(mock_session, "s1", False)+ )+ cli_manager.remove_session = AsyncMock()+ cli_manager.get_stats.return_value = {"active_sessions": 0, "max_sessions": 10}++ session_store = MagicMock()+ handler = ClaudeMessageHandler(platform, cli_manager, session_store)+ handler.tree_queue = MagicMock()+ handler.tree_queue.get_tree_for_node.return_value = None++ incoming = IncomingMessage(+ text="hi",+ chat_id="c",+ user_id="u",+ message_id="n1",+ platform="telegram",+ )+ node = MessageNode(node_id="n1", incoming=incoming, status_message_id="s1")++ await handler._process_node("n1", node)++ cli_manager.remove_session.assert_awaited_once()diff --git a/tests/test_limiter.py b/tests/test_limiter.pyindex 3f3120bc..bcaa83de 100644--- a/tests/test_limiter.py+++ b/tests/test_limiter.py@@ -239,3 +239,41 @@ class TestMessagingRateLimiter:f"Sliding window violated at i={i}: "f"dt={acquired[i + rate_limit] - acquired[i]:.3f}s")++ @pytest.mark.asyncio+ async def test_compaction_last_task_fails_all_futures_get_exception(self):+ """When compacted task's last func fails, all futures get the exception."""+ MessagingRateLimiter._instance = None+ limiter = await MessagingRateLimiter.get_instance()++ async def ok_task():+ return "ok"++ async def fail_task():+ raise RuntimeError("last task failed")++ future1 = asyncio.create_task(+ limiter.enqueue(ok_task, dedup_key="fail_key")+ )+ future2 = asyncio.create_task(+ limiter.enqueue(fail_task, dedup_key="fail_key")+ )++ with pytest.raises(RuntimeError, match="last task failed"):+ await future1+ with pytest.raises(RuntimeError, match="last task failed"):+ await future2++ @pytest.mark.asyncio+ async def test_fire_and_forget_failure_logged(self, caplog):+ """fire_and_forget with failing task logs error and does not re-raise."""+ MessagingRateLimiter._instance = None+ limiter = await MessagingRateLimiter.get_instance()++ async def fail_task():+ raise ValueError("fire_and_forget failed")++ limiter.fire_and_forget(fail_task, dedup_key="fire_fail")+ await asyncio.sleep(1.5)++ assert any("fire_and_forget failed" in str(r) for r in caplog.records)diff --git a/tests/test_reliability.py b/tests/test_reliability.pyindex aafe4dd6..d947b004 100644--- a/tests/test_reliability.py+++ b/tests/test_reliability.py@@ -108,3 +108,31 @@ def test_handler_build_message_hardening():assert "Finishing..." in msgif "```" in msg:assert msg.count("```") % 2 == 0+++def test_render_output_never_exceeds_4096():+ """Transcript render with various status lengths never exceeds Telegram 4096 limit."""+ from messaging.transcript import TranscriptBuffer, RenderCtx+ from messaging.telegram_markdown import (+ escape_md_v2,+ escape_md_v2_code,+ mdv2_bold,+ mdv2_code_inline,+ render_markdown_to_mdv2,+ )++ ctx = RenderCtx(+ bold=mdv2_bold,+ code_inline=mdv2_code_inline,+ escape_code=escape_md_v2_code,+ escape_text=escape_md_v2,+ render_markdown=render_markdown_to_mdv2,+ )++ t = TranscriptBuffer()+ t.apply({"type": "thinking_chunk", "text": "x" * 500})+ t.apply({"type": "text_chunk", "text": "y" * 3500})++ for status in [None, "Done", "✅ *Complete*", "A" * 100]:+ msg = t.render(ctx, limit_chars=3900, status=status)+ assert len(msg) <= 4096, f"status={status!r} produced len={len(msg)}"diff --git a/tests/test_robust_formatting.py b/tests/test_robust_formatting.pyindex fe9ee9c0..6deddf1a 100644--- a/tests/test_robust_formatting.py+++ b/tests/test_robust_formatting.py@@ -68,3 +68,22 @@ def test_empty_components_with_status(handler):t = TranscriptBuffer()msg = t.render(_ctx(), limit_chars=3900, status=status)assert msg == "\n\nSimple Status"+++def test_render_markdown_unclosed_markdown():+ """Malformed markdown (e.g. unclosed *) does not crash and produces acceptable output."""+ from messaging.telegram_markdown import render_markdown_to_mdv2++ md = "*bold without close"+ out = render_markdown_to_mdv2(md)+ assert out is not None+ assert "bold" in out+++def test_escape_md_v2_unicode_emoji():+ """Unicode and emoji pass through correctly (no special char escaping needed)."""+ from messaging.telegram_markdown import escape_md_v2, escape_md_v2_code++ text = "Hello 世界 🎉 café"+ assert escape_md_v2(text) == text+ assert escape_md_v2_code(text) == textdiff --git a/tests/test_streaming_errors.py b/tests/test_streaming_errors.pyindex e3920a6e..f93a69f8 100644--- a/tests/test_streaming_errors.py+++ b/tests/test_streaming_errors.py@@ -392,3 +392,130 @@ class TestProcessToolCall:events = list(provider._process_tool_call(tc, sse))event_text = "".join(events)assert "input_json_delta" in event_text+++class TestStreamChunkEdgeCases:+ """Tests for edge cases in stream chunk handling."""++ @pytest.mark.asyncio+ async def test_stream_chunk_with_empty_choices_skipped(self):+ """Chunk with choices=[] is skipped without crashing."""+ provider = _make_provider()+ request = _make_request()++ empty_choices_chunk = MagicMock()+ empty_choices_chunk.choices = []+ empty_choices_chunk.usage = None++ finish_chunk = _make_chunk(finish_reason="stop")+ stream_mock = AsyncStreamMock([empty_choices_chunk, finish_chunk])++ with patch.object(+ provider._client.chat.completions,+ "create",+ new_callable=AsyncMock,+ return_value=stream_mock,+ ):+ with patch.object(+ provider._global_rate_limiter,+ "wait_if_blocked",+ new_callable=AsyncMock,+ return_value=False,+ ):+ events = await _collect_stream(provider, request)++ event_text = "".join(events)+ assert "message_start" in event_text+ assert "message_stop" in event_text+ assert "[DONE]" in event_text++ @pytest.mark.asyncio+ async def test_stream_chunk_with_none_delta_handled(self):+ """Chunk with choice.delta=None is handled defensively."""+ provider = _make_provider()+ request = _make_request()++ none_delta_chunk = MagicMock()+ none_delta_chunk.usage = None+ choice = MagicMock()+ choice.delta = None+ choice.finish_reason = None+ none_delta_chunk.choices = [choice]++ finish_chunk = _make_chunk(finish_reason="stop")+ stream_mock = AsyncStreamMock([none_delta_chunk, finish_chunk])++ with patch.object(+ provider._client.chat.completions,+ "create",+ new_callable=AsyncMock,+ return_value=stream_mock,+ ):+ with patch.object(+ provider._global_rate_limiter,+ "wait_if_blocked",+ new_callable=AsyncMock,+ return_value=False,+ ):+ events = await _collect_stream(provider, request)++ event_text = "".join(events)+ assert "message_start" in event_text+ assert "message_stop" in event_text+ assert "[DONE]" in event_text++ @pytest.mark.asyncio+ async def test_stream_generator_cleanup_on_exception(self):+ """When stream raises mid-iteration, message_stop and [DONE] still emitted."""+ provider = _make_provider()+ request = _make_request()++ chunk1 = _make_chunk(content="Partial")+ stream_mock = AsyncStreamMock(+ [chunk1], error=ConnectionResetError("Connection reset")+ )++ with patch.object(+ provider._client.chat.completions,+ "create",+ new_callable=AsyncMock,+ return_value=stream_mock,+ ):+ with patch.object(+ provider._global_rate_limiter,+ "wait_if_blocked",+ new_callable=AsyncMock,+ return_value=False,+ ):+ events = await _collect_stream(provider, request)++ event_text = "".join(events)+ assert "Partial" in event_text+ assert "Connection reset" in event_text+ assert "message_stop" in event_text+ assert "[DONE]" in event_text++ def test_stream_malformed_tool_args_chunked(self):+ """Chunked tool args that never form valid JSON are flushed with {}."""+ provider = _make_provider()+ from providers.nvidia_nim.utils import SSEBuilder++ sse = SSEBuilder("msg_test", "test-model")+ tc1 = {+ "index": 0,+ "id": "call_malformed",+ "function": {"name": "Task", "arguments": '{"broken":'},+ }+ tc2 = {+ "index": 0,+ "id": "call_malformed",+ "function": {"name": None, "arguments": ' never valid }'},+ }++ events1 = list(provider._process_tool_call(tc1, sse))+ events2 = list(provider._process_tool_call(tc2, sse))+ flushed = list(provider._flush_task_arg_buffers(sse))++ event_text = "".join(events1 + events2 + flushed)+ assert "tool_use" in event_text+ assert "{}" in event_textdiff --git a/tests/test_telegram_edge_cases.py b/tests/test_telegram_edge_cases.pyindex c82921ca..85ec9122 100644--- a/tests/test_telegram_edge_cases.py+++ b/tests/test_telegram_edge_cases.py@@ -221,3 +221,92 @@ async def test_telegram_start_retries_on_network_error(monkeypatch):await platform.start()assert platform.is_connected is True+++async def test_edit_message_with_text_exceeding_4096_raises():+ """edit_message with text > 4096 raises TelegramError (BadRequest)."""+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):+ from messaging.telegram import TelegramPlatform, TelegramError++ platform = TelegramPlatform(bot_token="t")+ platform._application = MagicMock()+ platform._application.bot = AsyncMock()+ platform._application.bot.edit_message_text = AsyncMock(+ side_effect=TelegramError("Bad Request: message is too long")+ )++ with pytest.raises(TelegramError):+ await platform.edit_message("c", "1", "x" * 5000)+++async def test_edit_message_empty_string():+ """edit_message with empty string - Telegram accepts (no-op edit)."""+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):+ from messaging.telegram import TelegramPlatform++ platform = TelegramPlatform(bot_token="t")+ platform._application = MagicMock()+ platform._application.bot = AsyncMock()+ platform._application.bot.edit_message_text = AsyncMock()++ await platform.edit_message("c", "1", "")+ platform._application.bot.edit_message_text.assert_awaited_once_with(+ chat_id="c", message_id=1, text="", parse_mode="MarkdownV2"+ )+++async def test_send_message_empty_string():+ """send_message with empty string - Telegram may reject; we pass through."""+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):+ from messaging.telegram import TelegramPlatform++ platform = TelegramPlatform(bot_token="t")+ platform._application = MagicMock()+ mock_msg = MagicMock()+ mock_msg.message_id = 1+ platform._application.bot = AsyncMock()+ platform._application.bot.send_message = AsyncMock(return_value=mock_msg)++ msg_id = await platform.send_message("c", "")+ assert msg_id == "1"+ platform._application.bot.send_message.assert_awaited_once()+++async def test_on_telegram_message_non_text_update_ignored():+ """Update with message.photo but no text returns early without calling handler."""+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):+ from messaging.telegram import TelegramPlatform++ platform = TelegramPlatform(bot_token="t", allowed_user_id="123")+ handler = AsyncMock()+ platform.on_message(handler)++ update = MagicMock()+ update.message.text = None+ update.message.photo = [MagicMock()]+ update.message.message_id = 7+ update.message.reply_to_message = None+ update.effective_user.id = 123+ update.effective_chat.id = 456++ await platform._on_telegram_message(update, MagicMock())+ handler.assert_not_called()+++async def test_with_retry_message_not_found_returns_none():+ """'message to edit not found' returns None without retry."""+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):+ from messaging.telegram import TelegramPlatform, TelegramError++ platform = TelegramPlatform(bot_token="t")++ async def _f():+ raise TelegramError("message to edit not found")++ result = await platform._with_retry(_f)+ assert result is Nonediff --git a/tests/test_transcript.py b/tests/test_transcript.pyindex d074e94e..2475a99b 100644--- a/tests/test_transcript.py+++ b/tests/test_transcript.py@@ -135,3 +135,34 @@ def test_transcript_reused_index_closes_previous_open_block():# Old open text should have been closed.assert 0 not in t._open_text_by_indexassert 0 in t._open_tools_by_index+++def test_transcript_render_segment_exception_skipped():+ """When a segment's render() raises, that segment is skipped and rest is rendered."""+ t = TranscriptBuffer()+ t.apply({"type": "thinking_chunk", "text": "before"})+ t.apply({"type": "text_chunk", "text": "middle"})+ t.apply({"type": "text_chunk", "text": "after"})++ bad_segment = t._segments[1]+ original_render = bad_segment.render++ def _raising_render(ctx):+ raise ValueError("render failed")++ bad_segment.render = _raising_render++ out = t.render(_ctx(), limit_chars=3900, status=None)+ assert "before" in out+ assert "after" in out+ assert "middle" not in out+++def test_transcript_render_status_only_exceeds_limit():+ """When all segments dropped, status-only output; long status returned as-is."""+ t = TranscriptBuffer()+ t.apply({"type": "text_chunk", "text": "x" * 5000})++ long_status = "A" * 500+ msg = t.render(_ctx(), limit_chars=100, status=long_status)+ assert "... (truncated)" in msg or long_status in msg