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.pyindex 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.pyindex 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 pathsys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))+from unittest.mock import AsyncMock, MagicMockfrom providers.base import ProviderConfigfrom 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.fixturedef 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 _creatediff --git a/tests/test_dependencies.py b/tests/test_dependencies.pynew file mode 100644index 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 raisediff --git a/tests/test_event_parser.py b/tests/test_event_parser.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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 argsdiff --git a/tests/test_routes_optimizations.py b/tests/test_routes_optimizations.pynew file mode 100644index 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_managerdiff --git a/tests/test_telegram.py b/tests/test_telegram.pynew file mode 100644index 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.pynew file mode 100644index 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:+ passdiff --git a/tests/test_tree_repository.py b/tests/test_tree_repository.pynew file mode 100644index 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"]