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
improve test coverage
Alishahryar142bfb2da9b5d
diff --git a/api/request_utils.py b/api/request_utils.pyindex 73b32360..30e1f4bc 100644--- a/api/request_utils.py+++ b/api/request_utils.py@@ -80,7 +80,9 @@ def extract_command_prefix(command: str) -> str:return "command_injection_detected"try:- parts = shlex.split(command)+ # On Windows, shlex(posix=True) treats backslashes as escapes (e.g. \t),+ # which corrupts paths like C:\tmp\a.txt. posix=False preserves them.+ parts = shlex.split(command, posix=False)if not parts:return "none"@@ -257,7 +259,8 @@ def extract_filepaths_from_command(command: str, output: str) -> str:reading_commands = {"cat", "head", "tail", "less", "more", "bat", "type"}try:- parts = shlex.split(command)+ # Use Windows-style splitting to preserve backslashes in paths (e.g. C:\tmp\a.txt).+ parts = shlex.split(command, posix=False)if not parts:return "<filepaths>\n</filepaths>"@@ -285,22 +288,31 @@ def extract_filepaths_from_command(command: str, output: str) -> str:# grep with file argumentif base_cmd == "grep":- filepaths = []+ # Basic parsing:+ # - Skip flags (and args for flags that take an argument)+ # - If -e/-f is used, pattern is provided via flag so all remaining+ # positional args are treated as file paths.+ # - Otherwise, first positional arg is pattern, remainder are file paths.+ flags_with_args = {"-e", "-f", "-m", "-A", "-B", "-C"}+ pattern_provided_via_flag = False+ positional: list[str] = []+skip_next = False- for i, part in enumerate(parts[1:], 1):+ for part in parts[1:]:if skip_next:skip_next = Falsecontinue- # Skip flags and their arguments+if part.startswith("-"):- # Flags that take an argument- if part in {"-e", "-f", "-m", "-A", "-B", "-C"}:+ if part in flags_with_args:+ if part in {"-e", "-f"}:+ pattern_provided_via_flag = Trueskip_next = Truecontinue- # First non-flag is pattern, rest are files- if i > 1: # Skip the pattern- filepaths.append(part)+ positional.append(part)++ filepaths = positional if pattern_provided_via_flag else positional[1:]if filepaths:paths_str = "\n".join(filepaths)return f"<filepaths>\n{paths_str}\n</filepaths>"diff --git a/messaging/handler.py b/messaging/handler.pyindex 290d9ab1..450296f7 100644--- a/messaging/handler.py+++ b/messaging/handler.py@@ -105,10 +105,13 @@ def render_markdown_to_mdv2(text: str) -> str:elif t == "link_open":href = ""if tok.attrs:- for key, val in tok.attrs:- if key == "href":- href = val- break+ if isinstance(tok.attrs, dict):+ href = tok.attrs.get("href", "")+ else:+ for key, val in tok.attrs:+ if key == "href":+ href = val+ breakinner_tokens = []i += 1while i < len(children) and children[i].type != "link_close":@@ -127,10 +130,13 @@ def render_markdown_to_mdv2(text: str) -> str:href = ""alt = tok.content or ""if tok.attrs:- for key, val in tok.attrs:- if key == "src":- href = val- break+ if isinstance(tok.attrs, dict):+ href = tok.attrs.get("src", "")+ else:+ for key, val in tok.attrs:+ if key == "src":+ href = val+ breakif alt:out.append(f"{escape_md_v2(alt)} ({escape_md_v2_link_url(href)})")else:@@ -174,13 +180,21 @@ def render_markdown_to_mdv2(text: str) -> str:elif t == "ordered_list_open":start = 1if tok.attrs:- for key, val in tok.attrs:- if key == "start":+ if isinstance(tok.attrs, dict):+ val = tok.attrs.get("start")+ if val is not None:try:start = int(val)- except ValueError:+ except (TypeError, ValueError):start = 1- break+ else:+ for key, val in tok.attrs:+ if key == "start":+ try:+ start = int(val)+ except (TypeError, ValueError):+ start = 1+ breaklist_stack.append({"type": "ordered", "index": start})elif t == "ordered_list_close":if list_stack:diff --git a/tests/test_app_lifespan_and_errors.py b/tests/test_app_lifespan_and_errors.pynew file mode 100644index 00000000..3a97a34f--- /dev/null+++ b/tests/test_app_lifespan_and_errors.py@@ -0,0 +1,148 @@+from types import SimpleNamespace+from unittest.mock import AsyncMock, MagicMock, patch++import importlib+import pytest+from fastapi.testclient import TestClient+++def test_create_app_provider_error_handler_returns_anthropic_format():+ from api.app import create_app+ from providers.exceptions import AuthenticationError++ app = create_app()++ @app.get("/raise_provider")+ async def _raise_provider():+ raise AuthenticationError("bad key")++ api_app_mod = importlib.import_module("api.app")+ settings = SimpleNamespace(+ messaging_platform="telegram",+ telegram_bot_token=None,+ allowed_telegram_user_id=None,+ allowed_dir="",+ claude_workspace="./agent_workspace",+ host="127.0.0.1",+ port=8082,+ max_cli_sessions=1,+ log_file="server.log",+ )+ with patch.object(api_app_mod, "get_settings", return_value=settings), patch.object(+ api_app_mod, "cleanup_provider", new=AsyncMock()+ ):+ with TestClient(app) as client:+ resp = client.get("/raise_provider")+ assert resp.status_code == 401+ body = resp.json()+ assert body["type"] == "error"+ assert body["error"]["type"] == "authentication_error"+++def test_create_app_general_exception_handler_returns_500():+ from api.app import create_app++ app = create_app()++ @app.get("/raise_general")+ async def _raise_general():+ raise RuntimeError("boom")++ api_app_mod = importlib.import_module("api.app")+ settings = SimpleNamespace(+ messaging_platform="telegram",+ telegram_bot_token=None,+ allowed_telegram_user_id=None,+ allowed_dir="",+ claude_workspace="./agent_workspace",+ host="127.0.0.1",+ port=8082,+ max_cli_sessions=1,+ log_file="server.log",+ )+ with patch.object(api_app_mod, "get_settings", return_value=settings), patch.object(+ api_app_mod, "cleanup_provider", new=AsyncMock()+ ):+ with TestClient(app, raise_server_exceptions=False) as client:+ resp = client.get("/raise_general")+ assert resp.status_code == 500+ body = resp.json()+ assert body["type"] == "error"+ assert body["error"]["type"] == "api_error"++[email protected]("messaging_enabled", [True, False], ids=["with_platform", "no_platform"])+def test_app_lifespan_sets_state_and_cleans_up(tmp_path, messaging_enabled):+ from api.app import create_app++ app = create_app()++ settings = SimpleNamespace(+ messaging_platform="telegram",+ telegram_bot_token="token" if messaging_enabled else None,+ allowed_telegram_user_id="123",+ allowed_dir=str(tmp_path / "workspace"),+ claude_workspace=str(tmp_path / "data"),+ host="127.0.0.1",+ port=8082,+ max_cli_sessions=2,+ 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 = [{"t": 1}] if messaging_enabled else []+ session_store.get_node_mapping.return_value = {"n": "t"}+ session_store.sync_from_tree_data = MagicMock()++ fake_queue = MagicMock()+ fake_queue.cleanup_stale_nodes.return_value = 1+ fake_queue.to_dict.return_value = {+ "trees": [{"t": 1}],+ "node_to_tree": {"n": "t"},+ }++ 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 if messaging_enabled else None,+ ) as create_platform, patch(+ "messaging.session.SessionStore", return_value=session_store+ ), patch(+ "cli.manager.CLISessionManager", return_value=cli_manager+ ), patch(+ "messaging.tree_queue.TreeQueueManager.from_dict", return_value=fake_queue+ ):+ with TestClient(app):+ pass++ if messaging_enabled:+ create_platform.assert_called_once()+ fake_platform.on_message.assert_called_once()+ fake_platform.start.assert_awaited_once()+ fake_platform.stop.assert_awaited_once()+ cli_manager.stop_all.assert_awaited_once()+ assert getattr(app.state, "message_handler", None) is not None+ session_store.sync_from_tree_data.assert_called_once_with(+ [{"t": 1}],+ {"n": "t"},+ )+ else:+ fake_platform.start.assert_not_awaited()+ fake_platform.stop.assert_not_awaited()+ cli_manager.stop_all.assert_not_awaited()+ assert getattr(app.state, "messaging_platform", "missing") is None++ cleanup_provider.assert_awaited_once()diff --git a/tests/test_cli_manager_edge_cases.py b/tests/test_cli_manager_edge_cases.pynew file mode 100644index 00000000..3a24ac5f--- /dev/null+++ b/tests/test_cli_manager_edge_cases.py@@ -0,0 +1,143 @@+import pytest+from unittest.mock import AsyncMock, MagicMock, patch+++async def test_register_real_session_id_moves_pending_to_active_and_maps():+ from cli.manager import CLISessionManager++ with patch("cli.manager.CLISession") as mock_session_cls:+ mock_session = MagicMock()+ mock_session.is_busy = False+ mock_session.stop = AsyncMock(return_value=True)+ mock_session_cls.return_value = mock_session++ manager = CLISessionManager(workspace_path="/tmp", api_url="http://x/v1")+ session, temp_id, is_new = await manager.get_or_create_session()+ assert session is mock_session+ assert is_new is True++ ok = await manager.register_real_session_id(temp_id, "real_1")+ assert ok is True++ real = await manager.get_real_session_id(temp_id)+ assert real == "real_1"++ # Lookup via temp id should resolve to the real session id.+ s2, sid2, is_new2 = await manager.get_or_create_session(session_id=temp_id)+ assert s2 is mock_session+ assert sid2 == "real_1"+ assert is_new2 is False+++async def test_register_real_session_id_missing_temp_id_returns_false():+ from cli.manager import CLISessionManager++ manager = CLISessionManager(workspace_path="/tmp", api_url="http://x/v1")+ ok = await manager.register_real_session_id("missing", "real_1")+ assert ok is False+++async def test_remove_session_pending_stops_and_returns_true():+ from cli.manager import CLISessionManager++ with patch("cli.manager.CLISession") as mock_session_cls:+ mock_session = MagicMock()+ mock_session.is_busy = False+ mock_session.stop = AsyncMock(return_value=True)+ mock_session_cls.return_value = mock_session++ manager = CLISessionManager(workspace_path="/tmp", api_url="http://x/v1")+ _, temp_id, _ = await manager.get_or_create_session()++ removed = await manager.remove_session(temp_id)+ assert removed is True+ mock_session.stop.assert_awaited_once()+++async def test_remove_session_active_removes_temp_mapping():+ from cli.manager import CLISessionManager++ with patch("cli.manager.CLISession") as mock_session_cls:+ mock_session = MagicMock()+ mock_session.is_busy = False+ mock_session.stop = AsyncMock(return_value=True)+ mock_session_cls.return_value = mock_session++ manager = CLISessionManager(workspace_path="/tmp", api_url="http://x/v1")+ _, temp_id, _ = await manager.get_or_create_session()+ await manager.register_real_session_id(temp_id, "real_1")++ removed = await manager.remove_session("real_1")+ assert removed is True++ real = await manager.get_real_session_id(temp_id)+ assert real is None+++async def test_get_or_create_session_cleans_up_idle_sessions_when_at_limit():+ from cli.manager import CLISessionManager++ manager = CLISessionManager(workspace_path="/tmp", api_url="http://x/v1", max_sessions=1)++ idle_session = MagicMock()+ idle_session.is_busy = False+ idle_session.stop = AsyncMock(return_value=True)+ manager._sessions["s1"] = idle_session++ with patch("cli.manager.CLISession") as mock_session_cls:+ new_session = MagicMock()+ new_session.is_busy = False+ new_session.stop = AsyncMock(return_value=True)+ mock_session_cls.return_value = new_session++ s2, sid2, is_new2 = await manager.get_or_create_session()+ assert s2 is new_session+ assert sid2.startswith("pending_")+ assert is_new2 is True++ idle_session.stop.assert_awaited_once()+++async def test_get_or_create_session_raises_when_max_sessions_reached_with_busy_sessions():+ from cli.manager import CLISessionManager++ manager = CLISessionManager(workspace_path="/tmp", api_url="http://x/v1", max_sessions=1)++ busy_session = MagicMock()+ busy_session.is_busy = True+ busy_session.stop = AsyncMock(return_value=True)+ manager._sessions["s1"] = busy_session++ with pytest.raises(RuntimeError):+ await manager.get_or_create_session()+++async def test_stop_all_handles_stop_exceptions():+ from cli.manager import CLISessionManager++ manager = CLISessionManager(workspace_path="/tmp", api_url="http://x/v1")++ s1 = MagicMock()+ s1.stop = AsyncMock(side_effect=RuntimeError("boom"))+ s1.is_busy = False++ s2 = MagicMock()+ s2.stop = AsyncMock(return_value=True)+ s2.is_busy = False++ manager._sessions["a"] = s1+ manager._pending_sessions["b"] = s2++ await manager.stop_all()+ s1.stop.assert_awaited_once()+ s2.stop.assert_awaited_once()+ assert manager.get_stats()["active_sessions"] == 0+ assert manager.get_stats()["pending_sessions"] == 0+diff --git a/tests/test_handler_markdown_and_status_edges.py b/tests/test_handler_markdown_and_status_edges.pynew file mode 100644index 00000000..18673737--- /dev/null+++ b/tests/test_handler_markdown_and_status_edges.py@@ -0,0 +1,197 @@+import pytest+from unittest.mock import AsyncMock, MagicMock++from messaging.handler import ClaudeMessageHandler, render_markdown_to_mdv2+from messaging.models import IncomingMessage+from messaging.tree_data import MessageNode, MessageState+++def test_render_markdown_to_mdv2_empty_returns_empty():+ assert render_markdown_to_mdv2("") == ""+++def test_render_markdown_to_mdv2_covers_common_structures():+ md = (+ "# Heading\n\n"+ "Text with *em* and **strong** and ~~strike~~ and `code`.\n\n"+ "- item1\n"+ "- item2\n\n"+ "3. third\n\n"+ "> quote\n\n"+ "[link](http://example.com/a\\)b)\n\n"+ "\n\n"+ "```python\nprint('x')\n```\n"+ )+ out = render_markdown_to_mdv2(md)+ assert "*Heading*" in out+ assert "_em_" in out+ assert "*strong*" in out+ assert "~strike~" in out+ assert "`code`" in out+ assert "\\- item1" in out+ assert "3\\." in out+ assert "> quote" in out+ assert "[link]" in out+ assert "alt (http://example.com/img.png)" in out+ assert "```" in out+++def test_get_initial_status_branches():+ platform = MagicMock()+ cli_manager = MagicMock()+ session_store = MagicMock()+ handler = ClaudeMessageHandler(platform, cli_manager, session_store)++ handler.tree_queue.is_node_tree_busy = MagicMock(return_value=True)+ handler.tree_queue.get_queue_size = MagicMock(return_value=2)+ s1 = handler._get_initial_status(tree=object(), parent_node_id="p")+ assert "Queued" in s1+ assert "position 3" in s1 or "position 3" in s1.replace("\\", "")++ handler.tree_queue.is_node_tree_busy = MagicMock(return_value=False)+ s2 = handler._get_initial_status(tree=object(), parent_node_id="p")+ assert "Continuing" in s2++ cli_manager.get_stats.return_value = {"active_sessions": 10, "max_sessions": 10}+ s3 = handler._get_initial_status(tree=None, parent_node_id=None)+ assert "Waiting for slot" in s3++ cli_manager.get_stats.return_value = {"active_sessions": 1, "max_sessions": 10}+ s4 = handler._get_initial_status(tree=None, parent_node_id=None)+ assert "Launching" in s4+++async def test_update_queue_positions_handles_snapshot_error_and_skips_non_pending():+ 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()+ handler = ClaudeMessageHandler(platform, cli_manager, session_store)++ # Snapshot error is swallowed.+ tree = MagicMock()+ tree.get_queue_snapshot = AsyncMock(side_effect=RuntimeError("boom"))+ await handler._update_queue_positions(tree)+ platform.fire_and_forget.assert_not_called()++ # Normal path: only PENDING nodes get an update.+ node_pending = MagicMock()+ node_pending.state = MessageState.PENDING+ node_pending.incoming.chat_id = "c"+ node_pending.status_message_id = "s"++ node_done = MagicMock()+ node_done.state = MessageState.COMPLETED++ tree.get_queue_snapshot = AsyncMock(return_value=["n1", "n2"])+ tree.get_node = MagicMock(side_effect=[node_pending, node_done])++ await handler._update_queue_positions(tree)+ assert platform.fire_and_forget.call_count == 1+++async def test_process_node_session_limit_marks_error_and_updates_ui():+ platform = MagicMock()+ platform.queue_edit_message = AsyncMock()+ platform.fire_and_forget = MagicMock(+ side_effect=lambda c: getattr(c, "close", lambda: None)()+ )++ cli_manager = MagicMock()+ cli_manager.get_or_create_session = AsyncMock(side_effect=RuntimeError("limit"))+ cli_manager.get_stats.return_value = {"active_sessions": 0, "max_sessions": 10}++ session_store = MagicMock()+ handler = ClaudeMessageHandler(platform, cli_manager, session_store)++ fake_tree = MagicMock()+ fake_tree.update_state = AsyncMock()+ handler.tree_queue.get_tree_for_node = MagicMock(return_value=fake_tree)++ 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)+ assert platform.queue_edit_message.await_count >= 1+ fake_tree.update_state.assert_awaited()+++async def test_stop_all_tasks_saves_tree_for_cancelled_nodes():+ platform = MagicMock()+ platform.queue_edit_message = AsyncMock()+ platform.fire_and_forget = MagicMock(+ side_effect=lambda c: getattr(c, "close", lambda: None)()+ )++ cli_manager = MagicMock()+ cli_manager.stop_all = AsyncMock()+ cli_manager.get_stats.return_value = {"active_sessions": 0, "max_sessions": 10}++ session_store = MagicMock()+ handler = ClaudeMessageHandler(platform, cli_manager, session_store)++ 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")++ handler.tree_queue.cancel_all = AsyncMock(return_value=[node])+ tree = MagicMock()+ tree.root_id = "root"+ tree.to_dict = MagicMock(return_value={"root": "ok"})+ handler.tree_queue.get_tree_for_node = MagicMock(return_value=tree)++ count = await handler.stop_all_tasks()+ assert count == 1+ cli_manager.stop_all.assert_awaited_once()+ session_store.save_tree.assert_called_once_with("root", {"root": "ok"})+++async def test_handle_message_reply_with_tree_but_no_parent_treated_as_new():+ 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)++ # Force "tree exists but parent can't be resolved" branch.+ handler.tree_queue = MagicMock()+ handler.tree_queue.get_tree_for_node.return_value = object()+ 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=False)++ incoming = IncomingMessage(+ text="reply",+ chat_id="c",+ user_id="u",+ message_id="m1",+ platform="telegram",+ reply_to_message_id="some_reply",+ )++ await handler.handle_message(incoming)+ handler.tree_queue.create_tree.assert_awaited_once()diff --git a/tests/test_logging_utils_edge_cases.py b/tests/test_logging_utils_edge_cases.pynew file mode 100644index 00000000..8020472b--- /dev/null+++ b/tests/test_logging_utils_edge_cases.py@@ -0,0 +1,99 @@+from unittest.mock import MagicMock++from providers.logging_utils import (+ generate_request_fingerprint,+ get_last_user_message_preview,+ get_tool_names,+ log_request_compact,+)+++def test_generate_request_fingerprint_handles_mixed_message_shapes():+ class TextBlock:+ def __init__(self, text: str):+ self.text = text++ class TypeBlock:+ def __init__(self, t: str):+ self.type = t++ class MsgWithContent:+ def __init__(self, content):+ self.content = content++ class MsgWithRole:+ def __init__(self, role: str):+ self.role = role++ msg1 = MsgWithContent([TextBlock("hello"), TypeBlock("tool_use")])+ msg2 = MsgWithRole("assistant")++ fp = generate_request_fingerprint([msg1, msg2])+ assert fp.startswith("fp_")+ assert len(fp) == 11 # fp_ + 8 chars+++def test_get_last_user_message_preview_sanitizes_newlines_and_truncates():+ msg1 = MagicMock()+ msg1.role = "assistant"+ msg1.content = "ignore"++ msg2 = MagicMock()+ msg2.role = "user"+ msg2.content = "line1\r\nline2\nline3"++ preview = get_last_user_message_preview([msg1, msg2], max_len=10)+ assert "\n" not in preview+ assert "\r" not in preview+ assert preview.endswith("...")+++def test_get_tool_names_supports_objects_dicts_and_overflow():+ tools = [{"name": "t0"}] + [MagicMock(name=f"t{i}") for i in range(1, 8)]+ for i, t in enumerate(tools[1:], 1):+ t.name = f"t{i}"+ names = get_tool_names(tools, max_count=5)+ assert names[:2] == ["t0", "t1"]+ assert names[-1].startswith("+")+++def test_log_request_compact_logs_summary_and_full_payload():+ logger = MagicMock()+ request_data = MagicMock()+ request_data.model = "m"+ request_data.messages = []+ request_data.tools = []+ request_data.system = None+ request_data.thinking = None+ request_data.max_tokens = 1+ request_data.model_dump.return_value = {"model": "m"}++ log_request_compact(logger, "req_1", request_data)+ assert logger.info.call_count == 1+ assert logger.debug.call_count >= 1 # full payload+++def test_log_request_compact_handles_model_dump_failures():+ logger = MagicMock()+ request_data = MagicMock()+ request_data.model = "m"+ request_data.messages = []+ request_data.tools = []+ request_data.system = None+ request_data.thinking = None+ request_data.max_tokens = 1+ request_data.model_dump.side_effect = RuntimeError("nope")++ from providers import logging_utils as logging_utils_mod++ module_logger = MagicMock()+ old_logger = logging_utils_mod.logger+ logging_utils_mod.logger = module_logger+ try:+ log_request_compact(logger, "req_1", request_data)+ finally:+ logging_utils_mod.logger = old_logger++ # We should still log a compact summary even if payload dump fails.+ assert logger.info.call_count == 1+ assert module_logger.debug.call_count >= 1diff --git a/tests/test_request_utils_filepaths_and_suggestions.py b/tests/test_request_utils_filepaths_and_suggestions.pynew file mode 100644index 00000000..c3302f3a--- /dev/null+++ b/tests/test_request_utils_filepaths_and_suggestions.py@@ -0,0 +1,114 @@+import pytest+from unittest.mock import MagicMock++from api.models.anthropic import MessagesRequest, Message+from api.request_utils import (+ is_suggestion_mode_request,+ is_filepath_extraction_request,+ extract_filepaths_from_command,+)+++def _mk_req(messages, tools=None):+ req = MagicMock(spec=MessagesRequest)+ req.messages = messages+ req.tools = tools+ return req+++def _mk_msg(role: str, content):+ msg = MagicMock(spec=Message)+ msg.role = role+ msg.content = content+ return msg+++class TestSuggestionMode:+ def test_detects_suggestion_mode_in_any_user_message(self):+ req = _mk_req(+ [+ _mk_msg("assistant", "ignore"),+ _mk_msg("user", "Hello\n[SUGGESTION MODE: on]\nworld"),+ ]+ )+ assert is_suggestion_mode_request(req) is True++ def test_suggestion_mode_ignores_non_user_messages(self):+ req = _mk_req([_mk_msg("assistant", "[SUGGESTION MODE: on]")])+ assert is_suggestion_mode_request(req) is False+++class TestFilepathExtractionDetection:+ def test_rejects_when_tools_present(self):+ msg = _mk_msg(+ "user",+ "Command: cat foo.txt\nOutput: hi\n\nPlease extract <filepaths>.",+ )+ req = _mk_req([msg], tools=[{"name": "search"}])+ ok, cmd, out = is_filepath_extraction_request(req)+ assert (ok, cmd, out) == (False, "", "")++ def test_rejects_when_missing_output_marker(self):+ msg = _mk_msg(+ "user",+ "Command: cat foo.txt\n(no output marker)\n<filepaths>",+ )+ req = _mk_req([msg], tools=None)+ ok, cmd, out = is_filepath_extraction_request(req)+ assert (ok, cmd, out) == (False, "", "")++ def test_rejects_when_not_asking_for_filepaths(self):+ msg = _mk_msg("user", "Command: cat foo.txt\nOutput: hi")+ req = _mk_req([msg], tools=None)+ ok, cmd, out = is_filepath_extraction_request(req)+ assert (ok, cmd, out) == (False, "", "")++ def test_extracts_command_and_output_and_cleans_output(self):+ msg = _mk_msg(+ "user",+ "Command: cat foo.txt\n"+ "Output: line1\nline2\n\n"+ "Please extract <filepaths>.\n"+ "<next_section>ignore me</next_section>",+ )+ req = _mk_req([msg], tools=None)+ ok, cmd, out = is_filepath_extraction_request(req)+ assert ok is True+ assert cmd == "cat foo.txt"+ assert out == "line1\nline2"+++class TestExtractFilepathsFromCommand:+ @pytest.mark.parametrize(+ "command,expected_paths",+ [+ ("ls -la", []),+ ("dir .", []),+ ("cat foo.txt", ["foo.txt"]),+ ("cat -n foo.txt bar.md", ["foo.txt", "bar.md"]),+ ("type C:\\tmp\\a.txt", ["C:\\tmp\\a.txt"]),+ ("grep pattern file1.txt file2.txt", ["file1.txt", "file2.txt"]),+ ("grep -n pattern file.txt", ["file.txt"]),+ ("grep -e pattern file.txt", ["file.txt"]),+ ("unknowncmd arg1 arg2", []),+ ("", []),+ ],+ ids=[+ "listing_ls",+ "listing_dir",+ "read_cat",+ "read_cat_flags",+ "read_type_windows_path",+ "grep_simple",+ "grep_with_flag",+ "grep_with_e",+ "unknown",+ "empty",+ ],+ )+ def test_extracts_expected_paths(self, command, expected_paths):+ result = extract_filepaths_from_command(command, output="(ignored)")+ for p in expected_paths:+ assert p in result+ if not expected_paths:+ assert result.strip() == "<filepaths>\n</filepaths>"diff --git a/tests/test_server_module.py b/tests/test_server_module.pynew file mode 100644index 00000000..8f1f602d--- /dev/null+++ b/tests/test_server_module.py@@ -0,0 +1,32 @@+def test_server_module_exports_app_and_create_app():+ import server++ assert server.app is not None+ assert callable(server.create_app)+++def test_server_main_invokes_uvicorn_run(monkeypatch):+ import runpy+ from types import SimpleNamespace+ from unittest.mock import MagicMock++ import config.settings as settings_mod+ import uvicorn as uvicorn_mod++ # Patch settings used by server.__main__ block.+ old_get_settings = settings_mod.get_settings+ settings_mod.get_settings = lambda: SimpleNamespace(host="127.0.0.1", port=9999)++ old_run = uvicorn_mod.run+ uvicorn_mod.run = MagicMock()++ try:+ runpy.run_module("server", run_name="__main__")+ uvicorn_mod.run.assert_called_once()+ _, kwargs = uvicorn_mod.run.call_args+ assert kwargs["host"] == "127.0.0.1"+ assert kwargs["port"] == 9999+ assert kwargs["log_level"] == "debug"+ finally:+ uvicorn_mod.run = old_run+ settings_mod.get_settings = old_get_settingsdiff --git a/tests/test_telegram_edge_cases.py b/tests/test_telegram_edge_cases.pynew file mode 100644index 00000000..65a8404f--- /dev/null+++ b/tests/test_telegram_edge_cases.py@@ -0,0 +1,216 @@+import asyncio+from datetime import timedelta+from unittest.mock import AsyncMock, MagicMock, patch++import pytest+++def test_telegram_platform_init_raises_when_dependency_missing():+ from messaging import telegram as telegram_mod++ with patch.object(telegram_mod, "TELEGRAM_AVAILABLE", False):+ from messaging.telegram import TelegramPlatform++ with pytest.raises(ImportError):+ TelegramPlatform(bot_token="x")+++async def test_telegram_platform_start_requires_token():+ with patch.dict("os.environ", {}, clear=True), patch(+ "messaging.telegram.TELEGRAM_AVAILABLE", True+ ):+ from messaging.telegram import TelegramPlatform++ platform = TelegramPlatform(bot_token=None)+ with pytest.raises(ValueError):+ await platform.start()+++async def test_telegram_platform_stop_no_application_is_noop():+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):+ from messaging.telegram import TelegramPlatform++ platform = TelegramPlatform(bot_token="t")+ platform._application = None+ platform._connected = True+ await platform.stop()+ assert platform.is_connected is False+++async def test_with_retry_returns_none_when_message_not_modified_network_error():+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):+ from messaging.telegram import TelegramPlatform, NetworkError++ platform = TelegramPlatform(bot_token="t")++ async def _f():+ raise NetworkError("Message is not modified")++ assert await platform._with_retry(_f) is None+++async def test_with_retry_retries_network_error_then_succeeds(monkeypatch):+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):+ from messaging.telegram import TelegramPlatform, NetworkError++ platform = TelegramPlatform(bot_token="t")++ monkeypatch.setattr(asyncio, "sleep", AsyncMock())++ calls = {"n": 0}++ async def _f():+ calls["n"] += 1+ if calls["n"] == 1:+ raise NetworkError("temporary")+ return "ok"++ assert await platform._with_retry(_f) == "ok"+ assert calls["n"] == 2+++async def test_with_retry_honors_retry_after_timedelta(monkeypatch):+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):+ from messaging.telegram import TelegramPlatform, RetryAfter++ platform = TelegramPlatform(bot_token="t")++ monkeypatch.setattr(asyncio, "sleep", AsyncMock())++ calls = {"n": 0}++ async def _f():+ calls["n"] += 1+ if calls["n"] == 1:+ raise RetryAfter(retry_after=timedelta(seconds=0.01))+ return "ok"++ assert await platform._with_retry(_f) == "ok"+ assert calls["n"] == 2+++async def test_with_retry_drops_parse_mode_on_markdown_entity_error():+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):+ from messaging.telegram import TelegramPlatform, TelegramError++ platform = TelegramPlatform(bot_token="t")++ calls = []++ async def _f(parse_mode=None):+ calls.append(parse_mode)+ if len(calls) == 1:+ raise TelegramError("Can't parse entities: bad markdown")+ return "ok"++ assert await platform._with_retry(_f, parse_mode="MarkdownV2") == "ok"+ assert calls == ["MarkdownV2", None]+++async def test_queue_send_message_without_limiter_calls_send_message():+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):+ from messaging.telegram import TelegramPlatform++ platform = TelegramPlatform(bot_token="t")+ platform._limiter = None+ platform.send_message = AsyncMock(return_value="1")+ assert await platform.queue_send_message("c", "t") == "1"+ platform.send_message.assert_awaited_once()+++async def test_queue_edit_message_without_limiter_calls_edit_message():+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):+ from messaging.telegram import TelegramPlatform++ platform = TelegramPlatform(bot_token="t")+ platform._limiter = None+ platform.edit_message = AsyncMock()+ await platform.queue_edit_message("c", "1", "t")+ platform.edit_message.assert_awaited_once()+++def test_fire_and_forget_non_coroutine_uses_ensure_future(monkeypatch):+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):+ from messaging.telegram import TelegramPlatform++ platform = TelegramPlatform(bot_token="t")++ ef = MagicMock()+ monkeypatch.setattr(asyncio, "ensure_future", ef)++ platform.fire_and_forget(MagicMock())+ ef.assert_called_once()+++async def test_on_start_command_replies_and_forwards():+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):+ from messaging.telegram import TelegramPlatform++ platform = TelegramPlatform(bot_token="t")+ platform._on_telegram_message = AsyncMock()++ update = MagicMock()+ update.message.reply_text = AsyncMock()++ await platform._on_start_command(update, MagicMock())+ update.message.reply_text.assert_awaited_once()+ platform._on_telegram_message.assert_awaited_once()+++async def test_on_telegram_message_handler_error_sends_error_message():+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):+ from messaging.telegram import TelegramPlatform++ platform = TelegramPlatform(bot_token="t", allowed_user_id="123")+ platform.send_message = AsyncMock()++ async def _boom(_incoming):+ raise RuntimeError("bad")++ platform.on_message(_boom)++ update = MagicMock()+ update.message.text = "hello"+ 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())+ platform.send_message.assert_awaited_once()+++async def test_telegram_start_retries_on_network_error(monkeypatch):+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):+ from messaging.telegram import TelegramPlatform, NetworkError++ platform = TelegramPlatform(bot_token="token", allowed_user_id=None)++ monkeypatch.setattr(asyncio, "sleep", AsyncMock())++ with patch("telegram.ext.Application.builder") as mock_builder, patch(+ "messaging.limiter.MessagingRateLimiter.get_instance", AsyncMock()+ ):+ mock_app = MagicMock()+ mock_app.initialize = AsyncMock(side_effect=[NetworkError("no"), None])+ mock_app.start = AsyncMock()+ mock_app.updater = None++ mock_builder.return_value.token.return_value.request.return_value.build.return_value = (+ mock_app+ )++ await platform.start()+ assert platform.is_connected is True+