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

improved test suite and fixed error propagation bug in telegram

Alishahryar13f8b9af2c3bc
diff --git a/messaging/tree_processor.py b/messaging/tree_processor.py
index ca48b810..30cf74d7 100644
--- a/messaging/tree_processor.py
+++ b/messaging/tree_processor.py
@@ -26,6 +26,15 @@ class TreeQueueProcessor:
processor: Callable[[str, MessageNode], Awaitable[None]],
) -> None:
"""Process a single node and then check the queue."""
+ # Skip if already in terminal state (e.g. from error propagation)
+ if node.state.value == MessageState.ERROR.value:
+ logger.info(
+ f"Skipping node {node.node_id} as it is already in state {node.state}"
+ )
+ # Still need to check for next messages
+ await self._process_next(tree, processor)
+ return
+
try:
await processor(node.node_id, node)
except asyncio.CancelledError:
diff --git a/tests/conftest.py b/tests/conftest.py
index 9c6a284f..e4bb8a06 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -9,8 +9,12 @@ os.environ.setdefault("MODEL", "test-model")
# Add project root to path
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+from unittest.mock import AsyncMock, MagicMock
from providers.base import ProviderConfig
from providers.nvidia_nim import NvidiaNimProvider
+from messaging.base import CLISession, SessionManagerInterface, MessagingPlatform
+from messaging.models import IncomingMessage
+from messaging.session import SessionStore
@pytest.fixture
@@ -26,3 +30,59 @@ def provider_config():
@pytest.fixture
def nim_provider(provider_config):
return NvidiaNimProvider(provider_config)
+
+
+def mock_cli_session():
+ session = MagicMock(spec=CLISession)
+ session.start_task = MagicMock() # This will return an async generator
+ session.is_busy = False
+ return session
+
+
+def mock_cli_manager():
+ manager = MagicMock(spec=SessionManagerInterface)
+ manager.get_or_create_session = AsyncMock()
+ manager.register_real_session_id = AsyncMock(return_value=True)
+ manager.stop_all = AsyncMock()
+ manager.get_stats = MagicMock(
+ return_value={"active_sessions": 0, "max_sessions": 5}
+ )
+ return manager
+
+
+def mock_platform():
+ platform = MagicMock(spec=MessagingPlatform)
+ platform.send_message = AsyncMock(return_value="msg_123")
+ platform.edit_message = AsyncMock()
+ platform.queue_send_message = AsyncMock(return_value="msg_123")
+ platform.queue_edit_message = AsyncMock()
+ platform.fire_and_forget = MagicMock()
+ return platform
+
+
+def mock_session_store():
+ store = MagicMock(spec=SessionStore)
+ store.save_tree = MagicMock()
+ store.get_tree = MagicMock(return_value=None)
+ store.register_node = MagicMock()
+ return store
+
+
+def incoming_message_factory():
+ def _create(**kwargs):
+ defaults = {
+ "text": "hello",
+ "chat_id": "chat_1",
+ "user_id": "user_1",
+ "message_id": "msg_1",
+ "platform": "telegram",
+ }
+ defaults.update(kwargs)
+ return IncomingMessage(**defaults)
+
+ return _create
diff --git a/tests/test_dependencies.py b/tests/test_dependencies.py
new file mode 100644
index 00000000..983933ea
--- /dev/null
+++ b/tests/test_dependencies.py
@@ -0,0 +1,66 @@
+import pytest
+import asyncio
+from unittest.mock import AsyncMock, MagicMock, patch
+from api.dependencies import get_provider, get_settings, cleanup_provider
+from providers.nvidia_nim import NvidiaNimProvider
+
+
[email protected](autouse=True)
+def reset_provider():
+ """Reset the global _provider singleton between tests."""
+ with patch("api.dependencies._provider", None):
+ yield
+
+
+async def test_get_provider_singleton():
+ with patch("api.dependencies.get_settings") as mock_settings:
+ mock_settings.return_value = MagicMock()
+ mock_settings.return_value.nvidia_nim_api_key = "test_key"
+
+ p1 = get_provider()
+ p2 = get_provider()
+
+ assert isinstance(p1, NvidiaNimProvider)
+ assert p1 is p2
+
+
+async def test_get_settings():
+ settings = get_settings()
+ assert settings is not None
+ # Verify it calls the internal _get_settings
+ with patch("api.dependencies._get_settings") as mock_get:
+ get_settings()
+ mock_get.assert_called_once()
+
+
+async def test_cleanup_provider():
+ with patch("api.dependencies.get_settings") as mock_settings:
+ mock_settings.return_value = MagicMock()
+ mock_settings.return_value.nvidia_nim_api_key = "test_key"
+
+ provider = get_provider()
+ provider._client = AsyncMock()
+
+ await cleanup_provider()
+
+ provider._client.aclose.assert_called_once()
+ # The singleton should be None now, but since we patched the local _provider
+ # we need to be careful how we verify.
+ # Actually within the same test session without the patch, it would be None.
+
+
+async def test_cleanup_provider_no_client():
+ with patch("api.dependencies.get_settings") as mock_settings:
+ mock_settings.return_value = MagicMock()
+ mock_settings.return_value.nvidia_nim_api_key = "test_key"
+
+ provider = get_provider()
+ if hasattr(provider, "_client"):
+ del provider._client
+
+ await cleanup_provider()
+ # Should not raise
diff --git a/tests/test_event_parser.py b/tests/test_event_parser.py
new file mode 100644
index 00000000..b26a04eb
--- /dev/null
+++ b/tests/test_event_parser.py
@@ -0,0 +1,107 @@
+import pytest
+from messaging.event_parser import parse_cli_event
+
+
+def test_parse_cli_event_assistant_content():
+ event = {
+ "type": "assistant",
+ "message": {
+ "content": [
+ {"type": "thinking", "thinking": "Internal thought"},
+ {"type": "text", "text": "Hello user"},
+ ]
+ },
+ }
+ results = parse_cli_event(event)
+ assert len(results) == 2
+ assert results[0] == {"type": "thinking", "text": "Internal thought"}
+ assert results[1] == {"type": "content", "text": "Hello user"}
+
+
+def test_parse_cli_event_assistant_tools():
+ event = {
+ "type": "assistant",
+ "message": {
+ "content": [{"type": "tool_use", "name": "ls", "input": {"path": "."}}]
+ },
+ }
+ results = parse_cli_event(event)
+ assert len(results) == 1
+ assert results[0]["type"] == "tool_start"
+ assert results[0]["tools"][0]["name"] == "ls"
+
+
+def test_parse_cli_event_assistant_subagent():
+ event = {
+ "type": "assistant",
+ "message": {
+ "content": [
+ {
+ "type": "tool_use",
+ "name": "Task",
+ "input": {"description": "Fix bug"},
+ }
+ ]
+ },
+ }
+ results = parse_cli_event(event)
+ assert len(results) == 1
+ assert results[0]["type"] == "subagent_start"
+ assert results[0]["tasks"] == ["Fix bug"]
+
+
+def test_parse_cli_event_content_block_delta():
+ # Text delta
+ event_text = {
+ "type": "content_block_delta",
+ "delta": {"type": "text_delta", "text": " more"},
+ }
+ results_text = parse_cli_event(event_text)
+ assert results_text == [{"type": "content", "text": " more"}]
+
+ # Thinking delta
+ event_think = {
+ "type": "content_block_delta",
+ "delta": {"type": "thinking_delta", "thinking": " more thought"},
+ }
+ results_think = parse_cli_event(event_think)
+ assert results_think == [{"type": "thinking", "text": " more thought"}]
+
+
+def test_parse_cli_event_content_block_start():
+ event = {
+ "type": "content_block_start",
+ "content_block": {
+ "type": "tool_use",
+ "name": "Task",
+ "input": {"description": "deploy"},
+ },
+ }
+ results = parse_cli_event(event)
+ assert results == [{"type": "subagent_start", "tasks": ["deploy"]}]
+
+
+def test_parse_cli_event_error():
+ event = {"type": "error", "error": {"message": "something failed"}}
+ results = parse_cli_event(event)
+ assert results == [{"type": "error", "message": "something failed"}]
+
+
+def test_parse_cli_event_exit_success():
+ event = {"type": "exit", "code": 0}
+ results = parse_cli_event(event)
+ assert results == [{"type": "complete", "status": "success"}]
+
+
+def test_parse_cli_event_exit_failure():
+ event = {"type": "exit", "code": 1, "stderr": "fatal error"}
+ results = parse_cli_event(event)
+ assert len(results) == 2
+ assert results[0] == {"type": "error", "message": "fatal error"}
+ assert results[1] == {"type": "complete", "status": "failed"}
+
+
+def test_parse_cli_event_invalid_input():
+ assert parse_cli_event(None) == []
+ assert parse_cli_event("not a dict") == []
+ assert parse_cli_event({"type": "unknown"}) == []
diff --git a/tests/test_handler.py b/tests/test_handler.py
new file mode 100644
index 00000000..ae96efc4
--- /dev/null
+++ b/tests/test_handler.py
@@ -0,0 +1,222 @@
+import pytest
+import asyncio
+from unittest.mock import AsyncMock, MagicMock, patch
+from messaging.handler import ClaudeMessageHandler
+from messaging.models import IncomingMessage
+from messaging.tree_queue import MessageState
+
+
+def handler(mock_platform, mock_cli_manager, mock_session_store):
+ return ClaudeMessageHandler(mock_platform, mock_cli_manager, mock_session_store)
+
+
+async def test_handle_message_stop_command(
+ handler, mock_platform, incoming_message_factory
+):
+ incoming = incoming_message_factory(text="/stop")
+
+ # Mock stop_all_tasks
+ handler.stop_all_tasks = AsyncMock(return_value=5)
+
+ await handler.handle_message(incoming)
+
+ handler.stop_all_tasks.assert_called_once()
+ mock_platform.queue_send_message.assert_called_once_with(
+ incoming.chat_id, "⏹ **Stopped.** Cancelled 5 pending or active requests."
+ )
+
+
+async def test_handle_message_stats_command(
+ handler, mock_platform, mock_cli_manager, incoming_message_factory
+):
+ incoming = incoming_message_factory(text="/stats")
+ mock_cli_manager.get_stats.return_value = {"active_sessions": 2, "max_sessions": 5}
+
+ await handler.handle_message(incoming)
+
+ mock_platform.queue_send_message.assert_called_once()
+ args, _ = mock_platform.queue_send_message.call_args
+ assert "Active CLI: 2" in args[1]
+ assert "Max CLI: 5" in args[1]
+
+
+async def test_handle_message_filters_status_messages(
+ handler, mock_platform, incoming_message_factory
+):
+ incoming = incoming_message_factory(text="⏳ Thinking...")
+
+ await handler.handle_message(incoming)
+
+ mock_platform.queue_send_message.assert_not_called()
+
+
+async def test_handle_message_new_conversation(
+ handler, mock_platform, mock_session_store, incoming_message_factory
+):
+ incoming = incoming_message_factory(text="hello")
+ mock_platform.queue_send_message.return_value = "status_123"
+
+ # We need to mock tree_queue methods
+ with (
+ patch.object(handler.tree_queue, "create_tree", AsyncMock()) as mock_create,
+ patch.object(
+ handler.tree_queue, "enqueue", AsyncMock(return_value=False)
+ ) as mock_enqueue,
+ ):
+ mock_tree = MagicMock()
+ mock_tree.root_id = "root_1"
+ mock_tree.to_dict.return_value = {"data": "tree"}
+ mock_create.return_value = mock_tree
+
+ await handler.handle_message(incoming)
+
+ mock_create.assert_called_once()
+ mock_enqueue.assert_called_once()
+ mock_session_store.save_tree.assert_called_once_with("root_1", {"data": "tree"})
+
+
+async def test_handle_message_queued(handler, mock_platform, incoming_message_factory):
+ incoming = incoming_message_factory(text="hello", message_id="msg_1")
+ mock_platform.queue_send_message.return_value = "status_123"
+
+ with (
+ patch.object(handler.tree_queue, "create_tree", AsyncMock()) as mock_create,
+ patch.object(
+ handler.tree_queue, "enqueue", AsyncMock(return_value=True)
+ ) as mock_enqueue,
+ patch.object(handler.tree_queue, "get_queue_size", MagicMock(return_value=3)),
+ ):
+ mock_tree = MagicMock()
+ mock_tree.root_id = "root_1"
+ mock_tree.to_dict.return_value = {}
+ mock_create.return_value = mock_tree
+
+ await handler.handle_message(incoming)
+
+ mock_platform.queue_edit_message.assert_called_once_with(
+ incoming.chat_id,
+ "status_123",
+ "📋 **Queued** (position 3) - waiting...",
+ parse_mode="markdown",
+ )
+
+
+async def test_stop_all_tasks(handler, mock_cli_manager, mock_platform):
+ mock_node = MagicMock()
+ mock_node.incoming.chat_id = "chat_1"
+ mock_node.status_message_id = "status_1"
+
+ with patch.object(
+ handler.tree_queue, "cancel_all", AsyncMock(return_value=[mock_node])
+ ):
+ count = await handler.stop_all_tasks()
+
+ assert count == 1
+ mock_cli_manager.stop_all.assert_called_once()
+ mock_platform.fire_and_forget.assert_called_once()
+
+
+async def mock_async_gen(events):
+ for e in events:
+ yield e
+
+
+async def test_process_node_success_flow(handler, mock_cli_manager, mock_platform):
+ # Setup
+ node_id = "node_1"
+ mock_node = MagicMock()
+ mock_node.incoming.chat_id = "chat_1"
+ mock_node.incoming.text = "hello"
+ mock_node.status_message_id = "status_1"
+ mock_node.parent_id = None
+
+ mock_session = MagicMock()
+ # Mock start_task to return our async generator
+ events = [
+ {
+ "type": "assistant",
+ "message": {"content": [{"type": "thinking", "thinking": "Let me think"}]},
+ },
+ {
+ "type": "assistant",
+ "message": {"content": [{"type": "text", "text": "Hello world"}]},
+ },
+ {"type": "exit", "code": 0},
+ ]
+ mock_session.start_task.return_value = mock_async_gen(events)
+
+ mock_cli_manager.get_or_create_session.return_value = (
+ mock_session,
+ "session_1",
+ False,
+ )
+
+ mock_tree = MagicMock()
+ mock_tree.update_state = AsyncMock()
+ mock_tree.root_id = "root_1"
+ mock_tree.to_dict.return_value = {}
+
+ with patch.object(
+ handler.tree_queue, "get_tree_for_node", MagicMock(return_value=mock_tree)
+ ):
+ await handler._process_node(node_id, mock_node)
+
+ # Verify state updates
+ mock_tree.update_state.assert_any_call(node_id, MessageState.IN_PROGRESS)
+ mock_tree.update_state.assert_any_call(
+ node_id, MessageState.COMPLETED, session_id="session_1"
+ )
+
+ # Verify UI updates (at least the final one)
+ # Note: update_ui is debounced, but COMPLETED/ERROR/CANCELLED are forced
+ mock_platform.queue_edit_message.assert_called()
+ last_call = mock_platform.queue_edit_message.call_args_list[-1]
+ assert "✅ **Complete**" in last_call[0][2]
+ assert "Hello world" in last_call[0][2]
+
+
+async def test_process_node_error_flow(handler, mock_cli_manager, mock_platform):
+ node_id = "node_1"
+ mock_node = MagicMock()
+ mock_node.incoming.chat_id = "chat_1"
+ mock_node.incoming.text = "hello"
+ mock_node.status_message_id = "status_1"
+
+ mock_session = MagicMock()
+ events = [{"type": "error", "error": {"message": "CLI crashed"}}]
+ mock_session.start_task.return_value = mock_async_gen(events)
+ mock_cli_manager.get_or_create_session.return_value = (
+ mock_session,
+ "session_1",
+ False,
+ )
+
+ mock_tree = MagicMock()
+ mock_tree.update_state = AsyncMock()
+
+ with (
+ patch.object(
+ handler.tree_queue, "get_tree_for_node", MagicMock(return_value=mock_tree)
+ ),
+ patch.object(
+ handler.tree_queue, "mark_node_error", AsyncMock(return_value=[mock_node])
+ ),
+ ):
+ await handler._process_node(node_id, mock_node)
+
+ handler.tree_queue.mark_node_error.assert_called_once_with(
+ node_id, "CLI crashed", propagate_to_children=True
+ )
+
+ last_call = mock_platform.queue_edit_message.call_args_list[-1]
+ assert "❌ **Error**" in last_call[0][2]
+ assert "CLI crashed" in last_call[0][2]
diff --git a/tests/test_handler_integration.py b/tests/test_handler_integration.py
new file mode 100644
index 00000000..9954941e
--- /dev/null
+++ b/tests/test_handler_integration.py
@@ -0,0 +1,179 @@
+import pytest
+import asyncio
+from unittest.mock import AsyncMock, MagicMock, patch
+from messaging.handler import ClaudeMessageHandler
+from messaging.tree_queue import TreeQueueManager
+from messaging.tree_data import MessageState
+from messaging.models import IncomingMessage
+
+
+def handler_integration(mock_platform, mock_cli_manager, mock_session_store):
+ # Use real TreeQueueManager
+ handler = ClaudeMessageHandler(mock_platform, mock_cli_manager, mock_session_store)
+ return handler
+
+
+async def mock_async_gen(events):
+ for e in events:
+ yield e
+
+
+async def test_full_conversation_flow_single_user(
+ handler_integration, mock_platform, mock_cli_manager, incoming_message_factory
+):
+ # 1. First message
+ msg1 = incoming_message_factory(text="message 1", message_id="m1")
+ mock_platform.queue_send_message.return_value = "s1"
+
+ # Mock CLI session for m1
+ mock_session1 = MagicMock()
+ mock_session1.start_task.return_value = mock_async_gen(
+ [
+ {
+ "type": "assistant",
+ "message": {"content": [{"type": "text", "text": "Reply 1"}]},
+ },
+ {"type": "exit", "code": 0},
+ ]
+ )
+ mock_cli_manager.get_or_create_session.return_value = (
+ mock_session1,
+ "sess1",
+ False,
+ )
+
+ await handler_integration.handle_message(msg1)
+
+ # Wait for processing
+ tree = handler_integration.tree_queue.get_tree_for_node("m1")
+ for _ in range(10):
+ if tree.get_node("m1").state.value == MessageState.COMPLETED.value:
+ break
+ await asyncio.sleep(0.01)
+
+ assert tree.get_node("m1").state.value == MessageState.COMPLETED.value
+ assert tree.get_node("m1").session_id == "sess1"
+
+ # 2. Reply to m1
+ msg2 = incoming_message_factory(
+ text="message 2", message_id="m2", reply_to_message_id="m1"
+ )
+ mock_platform.queue_send_message.return_value = "s2"
+
+ # Mock CLI session for m2
+ mock_session2 = MagicMock()
+ mock_session2.start_task.return_value = mock_async_gen(
+ [
+ {
+ "type": "assistant",
+ "message": {"content": [{"type": "text", "text": "Reply 2"}]},
+ },
+ {"type": "exit", "code": 0},
+ ]
+ )
+ mock_cli_manager.get_or_create_session.reset_mock()
+ mock_cli_manager.get_or_create_session.return_value = (
+ mock_session2,
+ "sess2",
+ False,
+ )
+
+ await handler_integration.handle_message(msg2)
+
+ # Wait for processing
+ for _ in range(10):
+ if tree.get_node("m2").state.value == MessageState.COMPLETED.value:
+ break
+ await asyncio.sleep(0.01)
+
+ assert tree.get_node("m2").state.value == MessageState.COMPLETED.value
+ assert tree.get_node("m2").parent_id == "m1"
+ mock_cli_manager.get_or_create_session.assert_called_with(session_id="sess1")
+
+
+async def test_error_propagation_chain(
+ handler_integration, mock_platform, mock_cli_manager, incoming_message_factory
+):
+ msg1 = incoming_message_factory(text="m1", message_id="m1")
+ mock_platform.queue_send_message.return_value = "s1"
+
+ mock_session1 = MagicMock()
+ mock_session1.start_task.return_value = mock_async_gen(
+ [{"type": "error", "error": {"message": "failed"}}]
+ )
+ mock_cli_manager.get_or_create_session.return_value = (
+ mock_session1,
+ "sess1",
+ False,
+ )
+
+ await handler_integration.handle_message(msg1)
+ tree = handler_integration.tree_queue.get_tree_for_node("m1")
+
+ msg2 = incoming_message_factory(
+ text="m2", message_id="m2", reply_to_message_id="m1"
+ )
+ await handler_integration.handle_message(msg2)
+
+ # Wait for m1 to fail
+ for _ in range(20):
+ if tree.get_node("m1").state.value == MessageState.ERROR.value:
+ break
+ await asyncio.sleep(0.01)
+
+ # Give a tiny bit of time for propagation and skipping in processor
+ await asyncio.sleep(0.05)
+
+ assert tree.get_node("m1").state.value == MessageState.ERROR.value
+ assert tree.get_node("m2").state.value == MessageState.ERROR.value
+ assert "Parent failed" in tree.get_node("m2").error_message
+
+
+async def test_concurrent_replies_to_different_trees(
+ handler_integration, mock_platform, mock_cli_manager, incoming_message_factory
+):
+ msg1 = incoming_message_factory(text="t1", message_id="t1")
+ msg2 = incoming_message_factory(text="t2", message_id="t2")
+
+ mock_session1 = MagicMock()
+ mock_session1.start_task.return_value = mock_async_gen(
+ [{"type": "exit", "code": 0}]
+ )
+ mock_session2 = MagicMock()
+ mock_session2.start_task.return_value = mock_async_gen(
+ [{"type": "exit", "code": 0}]
+ )
+
+ mock_cli_manager.get_or_create_session.side_effect = [
+ (mock_session1, "s1", False),
+ (mock_session2, "s2", False),
+ ]
+
+ await handler_integration.handle_message(msg1)
+ await handler_integration.handle_message(msg2)
+
+ # Wait for both
+ for _ in range(20):
+ node1 = handler_integration.tree_queue.get_node("t1")
+ node2 = handler_integration.tree_queue.get_node("t2")
+ if (
+ node1
+ and node2
+ and node1.state.value == MessageState.COMPLETED.value
+ and node2.state.value == MessageState.COMPLETED.value
+ ):
+ break
+ await asyncio.sleep(0.01)
+
+ assert (
+ handler_integration.tree_queue.get_node("t1").state.value
+ == MessageState.COMPLETED.value
+ )
+ assert (
+ handler_integration.tree_queue.get_node("t2").state.value
+ == MessageState.COMPLETED.value
+ )
diff --git a/tests/test_model_utils.py b/tests/test_model_utils.py
new file mode 100644
index 00000000..d0f6c28a
--- /dev/null
+++ b/tests/test_model_utils.py
@@ -0,0 +1,47 @@
+import pytest
+from providers.model_utils import (
+ strip_provider_prefixes,
+ is_claude_model,
+ normalize_model_name,
+ get_original_model,
+)
+
+
+def test_strip_provider_prefixes():
+ assert strip_provider_prefixes("anthropic/claude-3") == "claude-3"
+ assert strip_provider_prefixes("openai/gpt-4") == "gpt-4"
+ assert strip_provider_prefixes("gemini/gemini-pro") == "gemini-pro"
+ assert strip_provider_prefixes("no-prefix") == "no-prefix"
+
+
+def test_is_claude_model():
+ assert is_claude_model("claude-3-sonnet") is True
+ assert is_claude_model("claude-3-opus") is True
+ assert is_claude_model("claude-3-haiku") is True
+ assert is_claude_model("claude-2.1") is True
+ assert is_claude_model("gpt-4") is False
+ assert is_claude_model("gemini-pro") is False
+
+
+def test_normalize_model_name_claude_maps_to_default():
+ default = "target-model"
+ # Strips prefix AND maps to default
+ assert normalize_model_name("anthropic/claude-3-sonnet", default) == default
+ assert normalize_model_name("claude-3-opus", default) == default
+
+
+def test_normalize_model_name_non_claude_unchanged():
+ default = "target-model"
+ assert normalize_model_name("gpt-4", default) == "gpt-4"
+ assert (
+ normalize_model_name("openai/gpt-3.5-turbo", default) == "openai/gpt-3.5-turbo"
+ )
+
+
+def test_get_original_model():
+ assert get_original_model("any-model") == "any-model"
+
+
+def test_normalize_model_name_without_default(monkeypatch):
+ monkeypatch.setenv("MODEL", "env-default-model")
+ assert normalize_model_name("claude-3") == "env-default-model"
diff --git a/tests/test_models_validators.py b/tests/test_models_validators.py
new file mode 100644
index 00000000..e35b8b60
--- /dev/null
+++ b/tests/test_models_validators.py
@@ -0,0 +1,73 @@
+import pytest
+from unittest.mock import patch
+from api.models import MessagesRequest, TokenCountRequest, Message
+from config.settings import Settings
+
+
+def mock_settings():
+ settings = Settings()
+ settings.model = "target-model-from-settings"
+ return settings
+
+
+def test_messages_request_map_model_claude_to_default(mock_settings):
+ with patch("api.models.get_settings", return_value=mock_settings):
+ request = MessagesRequest(
+ model="claude-3-opus",
+ max_tokens=100,
+ messages=[Message(role="user", content="hello")],
+ )
+
+ assert request.model == "target-model-from-settings"
+ assert request.original_model == "claude-3-opus"
+
+
+def test_messages_request_map_model_non_claude_unchanged(mock_settings):
+ with patch("api.models.get_settings", return_value=mock_settings):
+ request = MessagesRequest(
+ model="gpt-4",
+ max_tokens=100,
+ messages=[Message(role="user", content="hello")],
+ )
+
+ # normalize_model_name returns original if not Claude
+ assert request.model == "gpt-4"
+
+
+def test_messages_request_map_model_with_provider_prefix(mock_settings):
+ with patch("api.models.get_settings", return_value=mock_settings):
+ request = MessagesRequest(
+ model="anthropic/claude-3-haiku",
+ max_tokens=100,
+ messages=[Message(role="user", content="hello")],
+ )
+
+ assert request.model == "target-model-from-settings"
+
+
+def test_token_count_request_model_validation(mock_settings):
+ with patch("api.models.get_settings", return_value=mock_settings):
+ request = TokenCountRequest(
+ model="claude-3-sonnet", messages=[Message(role="user", content="hello")]
+ )
+
+ assert request.model == "target-model-from-settings"
+
+
+def test_messages_request_model_mapping_logs(mock_settings):
+ with (
+ patch("api.models.get_settings", return_value=mock_settings),
+ patch("api.models.logger.debug") as mock_log,
+ ):
+ MessagesRequest(
+ model="claude-2.1",
+ max_tokens=100,
+ messages=[Message(role="user", content="hello")],
+ )
+
+ mock_log.assert_called()
+ args = mock_log.call_args[0][0]
+ assert "MODEL MAPPING" in args
+ assert "claude-2.1" in args
+ assert "target-model-from-settings" in args
diff --git a/tests/test_routes_optimizations.py b/tests/test_routes_optimizations.py
new file mode 100644
index 00000000..c3fca877
--- /dev/null
+++ b/tests/test_routes_optimizations.py
@@ -0,0 +1,125 @@
+import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
+from fastapi.testclient import TestClient
+from api.app import app
+from api.dependencies import get_settings
+from config.settings import Settings
+
+
+def client():
+ return TestClient(app)
+
+
+def mock_settings():
+ settings = Settings()
+ settings.fast_prefix_detection = True
+ settings.enable_network_probe_mock = True
+ settings.enable_title_generation_skip = True
+ return settings
+
+
+def test_create_message_fast_prefix_detection(client, mock_settings):
+ app.dependency_overrides[get_settings] = lambda: mock_settings
+
+ payload = {
+ "model": "claude-3-sonnet",
+ "max_tokens": 100,
+ "messages": [{"role": "user", "content": "What is the prefix?"}],
+ }
+
+ with patch("api.routes.is_prefix_detection_request", return_value=(True, "/ask")):
+ response = client.post("/v1/messages", json=payload)
+
+ assert response.status_code == 200
+ data = response.json()
+ assert "/ask" in data["content"][0]["text"]
+
+ app.dependency_overrides.clear()
+
+
+def test_create_message_quota_check_mock(client, mock_settings):
+ app.dependency_overrides[get_settings] = lambda: mock_settings
+
+ payload = {
+ "model": "claude-3-sonnet",
+ "max_tokens": 100,
+ "messages": [{"role": "user", "content": "quota check"}],
+ }
+
+ with patch("api.routes.is_quota_check_request", return_value=True):
+ response = client.post("/v1/messages", json=payload)
+
+ assert response.status_code == 200
+ assert "Quota check passed" in response.json()["content"][0]["text"]
+
+ app.dependency_overrides.clear()
+
+
+def test_create_message_title_generation_skip(client, mock_settings):
+ app.dependency_overrides[get_settings] = lambda: mock_settings
+
+ payload = {
+ "model": "claude-3-sonnet",
+ "max_tokens": 100,
+ "messages": [{"role": "user", "content": "generate title"}],
+ }
+
+ with patch("api.routes.is_title_generation_request", return_value=True):
+ response = client.post("/v1/messages", json=payload)
+
+ assert response.status_code == 200
+ assert "Conversation" in response.json()["content"][0]["text"]
+
+ app.dependency_overrides.clear()
+
+
+def test_count_tokens_endpoint(client):
+ payload = {
+ "model": "claude-3-sonnet",
+ "messages": [{"role": "user", "content": "hello"}],
+ }
+
+ with patch("api.routes.get_token_count", return_value=5):
+ response = client.post("/v1/messages/count_tokens", json=payload)
+
+ assert response.status_code == 200
+ assert response.json()["input_tokens"] == 5
+
+
+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
+ # will run the app in a way that respects it?
+ # Actually, we need to mock it as an async function.
+ mock_handler.stop_all_tasks = AsyncMock(return_value=3)
+ app.state.message_handler = mock_handler
+
+ response = client.post("/stop")
+
+ assert response.status_code == 200
+ assert response.json()["cancelled_count"] == 3
+ mock_handler.stop_all_tasks.assert_called_once()
+
+ # Cleanup state
+ if hasattr(app.state, "message_handler"):
+ del app.state.message_handler
+
+
+def test_stop_cli_fallback_to_manager(client):
+ if hasattr(app.state, "message_handler"):
+ del app.state.message_handler
+
+ mock_manager = MagicMock()
+ mock_manager.stop_all = AsyncMock()
+ app.state.cli_manager = mock_manager
+
+ response = client.post("/stop")
+
+ assert response.status_code == 200
+ assert response.json()["source"] == "cli_manager"
+ mock_manager.stop_all.assert_called_once()
+
+ if hasattr(app.state, "cli_manager"):
+ del app.state.cli_manager
diff --git a/tests/test_telegram.py b/tests/test_telegram.py
new file mode 100644
index 00000000..a7ef59f4
--- /dev/null
+++ b/tests/test_telegram.py
@@ -0,0 +1,112 @@
+import pytest
+import asyncio
+from unittest.mock import AsyncMock, MagicMock, patch
+from messaging.telegram import TelegramPlatform, TELEGRAM_AVAILABLE
+from messaging.models import IncomingMessage
+
+
+def telegram_platform():
+ with patch("messaging.telegram.TELEGRAM_AVAILABLE", True):
+ platform = TelegramPlatform(bot_token="test_token", allowed_user_id="12345")
+ return platform
+
+
+def test_telegram_platform_init_no_token():
+ with patch.dict("os.environ", {}, clear=True):
+ platform = TelegramPlatform(bot_token=None)
+ assert platform.bot_token is None
+
+
+async def test_telegram_platform_start_success(telegram_platform):
+ with patch("telegram.ext.Application.builder") as mock_builder:
+ mock_app = MagicMock()
+ mock_app.initialize = AsyncMock()
+ mock_app.start = AsyncMock()
+ mock_app.updater.start_polling = AsyncMock()
+
+ mock_builder.return_value.token.return_value.request.return_value.build.return_value = mock_app
+
+ # Mock GlobalRateLimiter
+ with patch("messaging.limiter.GlobalRateLimiter.get_instance", AsyncMock()):
+ await telegram_platform.start()
+
+ assert telegram_platform._connected is True
+ mock_app.initialize.assert_called_once()
+ mock_app.start.assert_called_once()
+
+
+async def test_telegram_platform_send_message_success(telegram_platform):
+ mock_bot = AsyncMock()
+ mock_msg = MagicMock()
+ mock_msg.message_id = 999
+ mock_bot.send_message.return_value = mock_msg
+
+ telegram_platform._application = MagicMock()
+ telegram_platform._application.bot = mock_bot
+
+ msg_id = await telegram_platform.send_message("chat_1", "hello")
+
+ assert msg_id == "999"
+ mock_bot.send_message.assert_called_once_with(
+ chat_id="chat_1", text="hello", reply_to_message_id=None, parse_mode="Markdown"
+ )
+
+
+async def test_telegram_platform_edit_message_success(telegram_platform):
+ mock_bot = AsyncMock()
+ telegram_platform._application = MagicMock()
+ telegram_platform._application.bot = mock_bot
+
+ await telegram_platform.edit_message("chat_1", "999", "new text")
+
+ mock_bot.edit_message_text.assert_called_once_with(
+ chat_id="chat_1", message_id=999, text="new text", parse_mode="Markdown"
+ )
+
+
+async def test_telegram_platform_queue_send_message(telegram_platform):
+ mock_limiter = AsyncMock()
+ telegram_platform._limiter = mock_limiter
+
+ await telegram_platform.queue_send_message("chat_1", "hello", fire_and_forget=False)
+
+ mock_limiter.enqueue.assert_called_once()
+
+
+async def test_on_telegram_message_authorized(telegram_platform):
+ handler = AsyncMock()
+ telegram_platform.on_message(handler)
+
+ mock_update = MagicMock()
+ mock_update.message.text = "hello"
+ mock_update.message.message_id = 1
+ mock_update.effective_user.id = 12345
+ mock_update.effective_chat.id = 6789
+ mock_update.message.reply_to_message = None
+
+ await telegram_platform._on_telegram_message(mock_update, MagicMock())
+
+ handler.assert_called_once()
+ incoming = handler.call_args[0][0]
+ assert incoming.text == "hello"
+ assert incoming.user_id == "12345"
+
+
+async def test_on_telegram_message_unauthorized(telegram_platform):
+ handler = AsyncMock()
+ telegram_platform.on_message(handler)
+
+ mock_update = MagicMock()
+ mock_update.message.text = "hello"
+ mock_update.effective_user.id = 99999 # Unauthorized
+
+ await telegram_platform._on_telegram_message(mock_update, MagicMock())
+
+ handler.assert_not_called()
diff --git a/tests/test_tree_processor.py b/tests/test_tree_processor.py
new file mode 100644
index 00000000..b2218879
--- /dev/null
+++ b/tests/test_tree_processor.py
@@ -0,0 +1,159 @@
+import pytest
+import asyncio
+from unittest.mock import AsyncMock, MagicMock
+from messaging.tree_processor import TreeQueueProcessor
+from messaging.tree_data import MessageTree, MessageNode, MessageState
+from messaging.models import IncomingMessage
+
+
+def tree_processor():
+ return TreeQueueProcessor()
+
+
+def sample_incoming():
+ return IncomingMessage(
+ text="test message",
+ chat_id="chat123",
+ user_id="user456",
+ message_id="msg789",
+ platform="telegram",
+ )
+
+
+def sample_node(sample_incoming):
+ return MessageNode(
+ node_id="msg789", incoming=sample_incoming, status_message_id="status123"
+ )
+
+
+def sample_tree(sample_node):
+ return MessageTree(sample_node)
+
+
+async def test_process_node_success(tree_processor, sample_tree, sample_node):
+ processor = AsyncMock()
+
+ await tree_processor.process_node(sample_tree, sample_node, processor)
+
+ processor.assert_called_once_with(sample_node.node_id, sample_node)
+ assert sample_tree._current_node_id is None
+
+
+async def test_process_node_cancelled(tree_processor, sample_tree, sample_node):
+ processor = AsyncMock(side_effect=asyncio.CancelledError)
+
+ with pytest.raises(asyncio.CancelledError):
+ await tree_processor.process_node(sample_tree, sample_node, processor)
+
+ assert sample_tree._current_node_id is None
+
+
+async def test_process_node_exception(tree_processor, sample_tree, sample_node):
+ processor = AsyncMock(side_effect=Exception("Test error"))
+
+ # We need to mock update_state to verify it was called
+ sample_tree.update_state = AsyncMock()
+
+ await tree_processor.process_node(sample_tree, sample_node, processor)
+
+ sample_tree.update_state.assert_called_once_with(
+ sample_node.node_id, MessageState.ERROR, error_message="Test error"
+ )
+ assert sample_tree._current_node_id is None
+
+
+async def test_enqueue_and_start_when_free(tree_processor, sample_tree):
+ processor = AsyncMock()
+ node_id = "node1"
+
+ # Mock get_node to return a node
+ node = MagicMock(spec=MessageNode)
+ sample_tree.get_node = MagicMock(return_value=node)
+
+ was_queued = await tree_processor.enqueue_and_start(sample_tree, node_id, processor)
+
+ assert was_queued is False
+ assert sample_tree._is_processing is True
+ assert sample_tree._current_node_id == node_id
+ assert sample_tree._current_task is not None
+
+ # Clean up task
+ sample_tree._current_task.cancel()
+ try:
+ await sample_tree._current_task
+ except asyncio.CancelledError:
+ pass
+
+
+async def test_enqueue_and_start_when_busy(tree_processor, sample_tree):
+ processor = AsyncMock()
+ sample_tree._is_processing = True
+ node_id = "node1"
+
+ was_queued = await tree_processor.enqueue_and_start(sample_tree, node_id, processor)
+
+ assert was_queued is True
+ assert sample_tree._queue.qsize() == 1
+ assert await sample_tree._queue.get() == node_id
+
+
+def test_cancel_current_task(tree_processor, sample_tree):
+ mock_task = MagicMock(spec=asyncio.Task)
+ mock_task.done.return_value = False
+ sample_tree._current_task = mock_task
+
+ cancelled = tree_processor.cancel_current(sample_tree)
+
+ assert cancelled is True
+ mock_task.cancel.assert_called_once()
+
+
+def test_cancel_current_task_already_done(tree_processor, sample_tree):
+ mock_task = MagicMock(spec=asyncio.Task)
+ mock_task.done.return_value = True
+ sample_tree._current_task = mock_task
+
+ cancelled = tree_processor.cancel_current(sample_tree)
+
+ assert cancelled is False
+ mock_task.cancel.assert_not_called()
+
+
+async def test_process_next_queue_empty(tree_processor, sample_tree):
+ processor = AsyncMock()
+ sample_tree._is_processing = True
+
+ await tree_processor._process_next(sample_tree, processor)
+
+ assert sample_tree._is_processing is False
+
+
+async def test_process_next_with_item(tree_processor, sample_tree):
+ processor = AsyncMock()
+ await sample_tree._queue.put("next_node")
+
+ node = MagicMock(spec=MessageNode)
+ sample_tree.get_node = MagicMock(return_value=node)
+
+ await tree_processor._process_next(sample_tree, processor)
+
+ assert sample_tree._current_node_id == "next_node"
+ assert sample_tree._current_task is not None
+
+ # Clean up
+ sample_tree._current_task.cancel()
+ try:
+ await sample_tree._current_task
+ except asyncio.CancelledError:
+ pass
diff --git a/tests/test_tree_repository.py b/tests/test_tree_repository.py
new file mode 100644
index 00000000..048d8b44
--- /dev/null
+++ b/tests/test_tree_repository.py
@@ -0,0 +1,140 @@
+import pytest
+from unittest.mock import MagicMock
+from messaging.tree_repository import TreeRepository
+from messaging.tree_data import MessageTree, MessageNode, MessageState
+from messaging.models import IncomingMessage
+
+
+def repository():
+ return TreeRepository()
+
+
+def sample_tree():
+ incoming = IncomingMessage(
+ text="root",
+ chat_id="c1",
+ user_id="u1",
+ message_id="root_id",
+ platform="telegram",
+ )
+ node = MessageNode(node_id="root_id", incoming=incoming, status_message_id="s1")
+ return MessageTree(node)
+
+
+def test_add_and_get_tree(repository, sample_tree):
+ repository.add_tree("root_id", sample_tree)
+
+ assert repository.get_tree("root_id") == sample_tree
+ assert repository.get_tree_for_node("root_id") == sample_tree
+ assert repository._node_to_tree["root_id"] == "root_id"
+
+
+def test_get_tree_nonexistent(repository):
+ assert repository.get_tree("none") is None
+ assert repository.get_tree_for_node("none") is None
+
+
+def test_register_node(repository, sample_tree):
+ repository.add_tree("root_id", sample_tree)
+ repository.register_node("child_id", "root_id")
+
+ assert repository.get_tree_for_node("child_id") == sample_tree
+ assert repository._node_to_tree["child_id"] == "root_id"
+
+
+def test_get_node(repository, sample_tree):
+ repository.add_tree("root_id", sample_tree)
+ node = repository.get_node("root_id")
+
+ assert node is not None
+ assert node.node_id == "root_id"
+ assert repository.get_node("none") is None
+
+
+def test_is_tree_busy(repository, sample_tree):
+ repository.add_tree("root_id", sample_tree)
+ assert repository.is_tree_busy("root_id") is False
+
+ sample_tree._is_processing = True
+ assert repository.is_tree_busy("root_id") is True
+ assert repository.is_node_tree_busy("root_id") is True
+
+
+def test_get_queue_size(repository, sample_tree):
+ repository.add_tree("root_id", sample_tree)
+ assert repository.get_queue_size("root_id") == 0
+
+ # We can't easily put items in asyncio.Queue without async,
+ # but we can mock it for this unit test if needed, or just skip if it's too complex.
+ # Actually, we can use a mock queue since this is a unit test of the repository wrapper.
+ sample_tree._queue = MagicMock()
+ sample_tree._queue.qsize.return_value = 5
+
+ assert repository.get_queue_size("root_id") == 5
+
+
+def test_resolve_parent_node_id(repository, sample_tree):
+ repository.add_tree("root_id", sample_tree)
+ repository.register_node("s1", "root_id")
+
+ # 1. Direct node match
+ assert repository.resolve_parent_node_id("root_id") == "root_id"
+
+ # 2. Status message match
+ # find_node_by_status_message is used inside resolve_parent_node_id
+ # sample_tree has root_id node with status_message_id "s1"
+ assert repository.resolve_parent_node_id("s1") == "root_id"
+
+ # 3. No match
+ assert repository.resolve_parent_node_id("unknown") is None
+
+
+def test_get_pending_children(repository, sample_tree):
+ repository.add_tree("root_id", sample_tree)
+
+ # Create a child node
+ child_incoming = IncomingMessage(
+ text="child",
+ chat_id="c1",
+ user_id="u1",
+ message_id="child_id",
+ platform="telegram",
+ )
+ child_node = MessageNode(
+ node_id="child_id",
+ incoming=child_incoming,
+ status_message_id="s2",
+ parent_id="root_id",
+ state=MessageState.PENDING,
+ )
+
+ sample_tree._nodes["child_id"] = child_node
+ sample_tree.get_node("root_id").children_ids.append("child_id")
+ repository.register_node("child_id", "root_id")
+
+ pending = repository.get_pending_children("root_id")
+ assert len(pending) == 1
+ assert pending[0].node_id == "child_id"
+
+
+def test_to_from_dict(repository, sample_tree):
+ repository.add_tree("root_id", sample_tree)
+ data = repository.to_dict()
+
+ assert "trees" in data
+ assert "root_id" in data["trees"]
+ assert "node_to_tree" in data
+ assert data["node_to_tree"]["root_id"] == "root_id"
+
+ new_repo = TreeRepository.from_dict(data)
+ assert new_repo.get_tree("root_id") is not None
+ assert new_repo.get_tree("root_id").root_id == "root_id"
+ assert new_repo._node_to_tree["root_id"] == "root_id"
+
+
+def test_all_trees(repository, sample_tree):
+ repository.add_tree("root_id", sample_tree)
+ assert len(repository.all_trees()) == 1
+ assert repository.tree_ids() == ["root_id"]