Skip to content

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.py
index 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 argument
if 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 = False
continue
- # 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 = True
skip_next = True
continue
- # 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.py
index 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
+ break
inner_tokens = []
i += 1
while 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
+ break
if 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 = 1
if 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
+ break
list_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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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"
+ "![alt](http://example.com/img.png)\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.py
new file mode 100644
index 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 >= 1
diff --git a/tests/test_request_utils_filepaths_and_suggestions.py b/tests/test_request_utils_filepaths_and_suggestions.py
new file mode 100644
index 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.py
new file mode 100644
index 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_settings
diff --git a/tests/test_telegram_edge_cases.py b/tests/test_telegram_edge_cases.py
new file mode 100644
index 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
+