feat: add backend unit tests with pytest (207 cases)

backend/tests/unit/controller/test_chat_controller.py

@@ -0,0 +1,348 @@
+import os
+from unittest.mock import MagicMock, patch
+
+import pytest
+from fastapi import Response
+from fastapi.responses import StreamingResponse
+from fastapi.testclient import TestClient
+
+from app.controller.chat_controller import improve, post, stop, supplement, human_reply, install_mcp
+from pydantic import ValidationError
+from app.exception.exception import UserException
+from app.model.chat import Chat, HumanReply, McpServers, Status, SupplementChat
+
+
+@pytest.mark.unit
+class TestChatController:
+    """Test cases for chat controller endpoints."""
+    
+    @pytest.mark.asyncio
+    async def test_post_chat_endpoint_success(self, sample_chat_data, mock_request, mock_task_lock, mock_environment_variables):
+        """Test successful chat initialization."""
+        chat_data = Chat(**sample_chat_data)
+        
+        with patch("app.controller.chat_controller.create_task_lock", return_value=mock_task_lock), \
+             patch("app.controller.chat_controller.step_solve") as mock_step_solve, \
+             patch("app.controller.chat_controller.load_dotenv"), \
+             patch("pathlib.Path.mkdir"), \
+             patch("pathlib.Path.home", return_value=MagicMock()):
+            
+            # Mock async generator
+            async def mock_generator():
+                yield "data: test_response\n\n"
+                yield "data: test_response_2\n\n"
+            
+            mock_step_solve.return_value = mock_generator()
+            
+            response = await post(chat_data, mock_request)
+            
+            assert isinstance(response, StreamingResponse)
+            assert response.media_type == "text/event-stream"
+            mock_step_solve.assert_called_once_with(chat_data, mock_request, mock_task_lock)
+
+    @pytest.mark.asyncio
+    async def test_post_chat_sets_environment_variables(self, sample_chat_data, mock_request, mock_task_lock):
+        """Test that environment variables are properly set."""
+        chat_data = Chat(**sample_chat_data)
+        
+        with patch("app.controller.chat_controller.create_task_lock", return_value=mock_task_lock), \
+             patch("app.controller.chat_controller.step_solve") as mock_step_solve, \
+             patch("app.controller.chat_controller.load_dotenv"), \
+             patch("pathlib.Path.mkdir"), \
+             patch("pathlib.Path.home", return_value=MagicMock()), \
+             patch.dict(os.environ, {}, clear=True):
+            
+            async def mock_generator():
+                yield "data: test_response\n\n"
+            
+            mock_step_solve.return_value = mock_generator()
+            
+            await post(chat_data, mock_request)
+            
+            # Check environment variables were set
+            assert os.environ.get("OPENAI_API_KEY") == "test_key"
+            assert os.environ.get("OPENAI_API_BASE_URL") == "https://api.openai.com/v1"
+            assert os.environ.get("CAMEL_MODEL_LOG_ENABLED") == "true"
+            assert os.environ.get("browser_port") == "8080"
+
+    def test_improve_chat_success(self, mock_task_lock):
+        """Test successful chat improvement."""
+        task_id = "test_task_123"
+        supplement_data = SupplementChat(question="Improve this code")
+        mock_task_lock.status = Status.processing
+        
+        with patch("app.controller.chat_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("asyncio.run") as mock_run:
+            
+            response = improve(task_id, supplement_data)
+            
+            assert isinstance(response, Response)
+            assert response.status_code == 201
+            mock_run.assert_called_once()
+            # put_queue is invoked when creating the coroutine passed to asyncio.run
+            mock_task_lock.put_queue.assert_called_once()
+
+    def test_improve_chat_task_done_error(self, mock_task_lock):
+        """Test improvement fails when task is done."""
+        task_id = "test_task_123"
+        supplement_data = SupplementChat(question="Improve this code")
+        mock_task_lock.status = Status.done
+        
+        with patch("app.controller.chat_controller.get_task_lock", return_value=mock_task_lock):
+            with pytest.raises(UserException):
+                improve(task_id, supplement_data)
+
+    def test_supplement_chat_success(self, mock_task_lock):
+        """Test successful chat supplementation."""
+        task_id = "test_task_123"
+        supplement_data = SupplementChat(question="Add more details")
+        mock_task_lock.status = Status.done
+        
+        with patch("app.controller.chat_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("asyncio.run") as mock_run:
+            
+            response = supplement(task_id, supplement_data)
+            
+            assert isinstance(response, Response)
+            assert response.status_code == 201
+            mock_run.assert_called_once()
+
+    def test_supplement_chat_task_not_done_error(self, mock_task_lock):
+        """Test supplementation fails when task is not done."""
+        task_id = "test_task_123"
+        supplement_data = SupplementChat(question="Add more details")
+        mock_task_lock.status = Status.processing
+        
+        with patch("app.controller.chat_controller.get_task_lock", return_value=mock_task_lock):
+            with pytest.raises(UserException):
+                supplement(task_id, supplement_data)
+
+    def test_stop_chat_success(self, mock_task_lock):
+        """Test successful chat stopping."""
+        task_id = "test_task_123"
+        
+        with patch("app.controller.chat_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("asyncio.run") as mock_run:
+            
+            response = stop(task_id)
+            
+            assert isinstance(response, Response)
+            assert response.status_code == 204
+            mock_run.assert_called_once()
+
+    def test_human_reply_success(self, mock_task_lock):
+        """Test successful human reply."""
+        task_id = "test_task_123"
+        reply_data = HumanReply(agent="test_agent", reply="This is my reply")
+        
+        with patch("app.controller.chat_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("asyncio.run") as mock_run:
+            
+            response = human_reply(task_id, reply_data)
+            
+            assert isinstance(response, Response)
+            assert response.status_code == 201
+            mock_run.assert_called_once()
+
+    def test_install_mcp_success(self, mock_task_lock):
+        """Test successful MCP installation."""
+        task_id = "test_task_123"
+        mcp_data: McpServers = {"mcpServers": {"test_server": {"config": "test"}}}
+        
+        with patch("app.controller.chat_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("asyncio.run") as mock_run:
+            
+            response = install_mcp(task_id, mcp_data)
+            
+            assert isinstance(response, Response)
+            assert response.status_code == 201
+            mock_run.assert_called_once()
+
+
+@pytest.mark.integration
+class TestChatControllerIntegration:
+    """Integration tests for chat controller."""
+    
+    def test_chat_endpoint_integration(self, client: TestClient, sample_chat_data):
+        """Test chat endpoint through FastAPI test client."""
+        with patch("app.controller.chat_controller.create_task_lock") as mock_create_lock, \
+             patch("app.controller.chat_controller.step_solve") as mock_step_solve, \
+             patch("app.controller.chat_controller.load_dotenv"), \
+             patch("pathlib.Path.mkdir"), \
+             patch("pathlib.Path.home", return_value=MagicMock()):
+            
+            mock_task_lock = MagicMock()
+            mock_create_lock.return_value = mock_task_lock
+            
+            async def mock_generator():
+                yield "data: test_response\n\n"
+            
+            mock_step_solve.return_value = mock_generator()
+            
+            response = client.post("/chat", json=sample_chat_data)
+            
+            assert response.status_code == 200
+            assert response.headers["content-type"] == "text/event-stream; charset=utf-8"
+
+    def test_improve_chat_endpoint_integration(self, client: TestClient):
+        """Test improve chat endpoint through FastAPI test client."""
+        task_id = "test_task_123"
+        supplement_data = {"question": "Improve this code"}
+        
+        with patch("app.controller.chat_controller.get_task_lock") as mock_get_lock, \
+             patch("asyncio.run"):
+            
+            mock_task_lock = MagicMock()
+            mock_task_lock.status = Status.processing
+            mock_get_lock.return_value = mock_task_lock
+            
+            response = client.post(f"/chat/{task_id}", json=supplement_data)
+            
+            assert response.status_code == 201
+
+    def test_supplement_chat_endpoint_integration(self, client: TestClient):
+        """Test supplement chat endpoint through FastAPI test client."""
+        task_id = "test_task_123"
+        supplement_data = {"question": "Add more details"}
+        
+        with patch("app.controller.chat_controller.get_task_lock") as mock_get_lock, \
+             patch("asyncio.run"):
+            
+            mock_task_lock = MagicMock()
+            mock_task_lock.status = Status.done
+            mock_get_lock.return_value = mock_task_lock
+            
+            response = client.put(f"/chat/{task_id}", json=supplement_data)
+            
+            assert response.status_code == 201
+
+    def test_stop_chat_endpoint_integration(self, client: TestClient):
+        """Test stop chat endpoint through FastAPI test client."""
+        task_id = "test_task_123"
+        
+        with patch("app.controller.chat_controller.get_task_lock") as mock_get_lock, \
+             patch("asyncio.run"):
+            
+            mock_task_lock = MagicMock()
+            mock_get_lock.return_value = mock_task_lock
+            
+            response = client.delete(f"/chat/{task_id}")
+            
+            assert response.status_code == 204
+
+    def test_human_reply_endpoint_integration(self, client: TestClient):
+        """Test human reply endpoint through FastAPI test client."""
+        task_id = "test_task_123"
+        reply_data = {"agent": "test_agent", "reply": "This is my reply"}
+        
+        with patch("app.controller.chat_controller.get_task_lock") as mock_get_lock, \
+             patch("asyncio.run"):
+            
+            mock_task_lock = MagicMock()
+            mock_get_lock.return_value = mock_task_lock
+            
+            response = client.post(f"/chat/{task_id}/human-reply", json=reply_data)
+            
+            assert response.status_code == 201
+
+    def test_install_mcp_endpoint_integration(self, client: TestClient):
+        """Test install MCP endpoint through FastAPI test client."""
+        task_id = "test_task_123"
+        mcp_data = {"mcpServers": {"test_server": {"config": "test"}}}
+        
+        with patch("app.controller.chat_controller.get_task_lock") as mock_get_lock, \
+             patch("asyncio.run"):
+            
+            mock_task_lock = MagicMock()
+            mock_get_lock.return_value = mock_task_lock
+            
+            response = client.post(f"/chat/{task_id}/install-mcp", json=mcp_data)
+            
+            assert response.status_code == 201
+
+
+@pytest.mark.model_backend
+class TestChatControllerWithLLM:
+    """Tests that require LLM backend (marked for selective running)."""
+    
+    @pytest.mark.asyncio
+    async def test_post_with_real_llm_model(self, sample_chat_data, mock_request):
+        """Test chat endpoint with real LLM model (slow test)."""
+        # This test would use actual LLM models and should be marked accordingly
+        chat_data = Chat(**sample_chat_data)
+        
+        # Test implementation would involve real model calls
+        # This is marked as model_backend test for selective execution
+        assert True  # Placeholder
+
+    @pytest.mark.very_slow
+    async def test_full_chat_workflow_with_llm(self, sample_chat_data, mock_request):
+        """Test complete chat workflow with LLM (very slow test)."""
+        # This test would run the complete workflow including actual agent interactions
+        # Marked as very_slow for execution only in full test mode
+        assert True  # Placeholder
+
+
+@pytest.mark.unit
+class TestChatControllerErrorCases:
+    """Test error cases and edge conditions."""
+    
+    @pytest.mark.asyncio
+    async def test_post_with_invalid_data(self, mock_request):
+        """Test chat endpoint with invalid data."""
+        # Construction itself should raise a validation error due to multiple invalid fields
+        with pytest.raises((ValueError, TypeError, ValidationError)):
+            Chat(
+                task_id="",  # Invalid empty task_id
+                email="invalid_email",  # Invalid email format
+                question="",  # Empty question
+                attaches=[],
+                model="invalid_model",  # Field not defined in model -> triggers error
+                model_platform="invalid_platform",
+                api_key="",
+                api_url="invalid_url",
+                new_agents=[],
+                env_path="nonexistent.env",
+                browser_port=-1,  # Invalid port
+                summary_prompt=""
+            )
+        # If future validation moves to endpoint level, keep logic placeholder below.
+        # (Intentionally not calling post with invalid Chat object since creation fails.)
+
+    def test_improve_with_nonexistent_task(self):
+        """Test improve endpoint with nonexistent task."""
+        task_id = "nonexistent_task"
+        supplement_data = SupplementChat(question="Improve this code")
+        
+        with patch("app.controller.chat_controller.get_task_lock", side_effect=KeyError("Task not found")):
+            with pytest.raises(KeyError):
+                improve(task_id, supplement_data)
+
+    def test_supplement_with_empty_question(self, mock_task_lock):
+        """Test supplement endpoint with empty question."""
+        task_id = "test_task_123"
+        supplement_data = SupplementChat(question="")
+        mock_task_lock.status = Status.done
+        
+        with patch("app.controller.chat_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("asyncio.run"):
+            
+            # Should handle empty question gracefully or raise appropriate error
+            response = supplement(task_id, supplement_data)
+            assert response.status_code == 201  # Or should it be an error?
+
+    @pytest.mark.asyncio
+    async def test_post_environment_setup_failure(self, sample_chat_data, mock_request):
+        """Test chat endpoint when environment setup fails."""
+        chat_data = Chat(**sample_chat_data)
+        
+        with patch("app.controller.chat_controller.create_task_lock") as mock_create_lock, \
+             patch("app.controller.chat_controller.load_dotenv", side_effect=Exception("Env load failed")), \
+             patch("pathlib.Path.mkdir", side_effect=Exception("Directory creation failed")):
+            
+            mock_task_lock = MagicMock()
+            mock_create_lock.return_value = mock_task_lock
+            
+            # Should handle environment setup failures gracefully
+            with pytest.raises(Exception):
+                await post(chat_data, mock_request)

backend/tests/unit/controller/test_model_controller.py

@@ -0,0 +1,282 @@
+from unittest.mock import MagicMock, patch
+import pytest
+from fastapi.testclient import TestClient
+
+from app.controller.model_controller import validate_model, ValidateModelRequest, ValidateModelResponse
+
+
+@pytest.mark.unit
+class TestModelController:
+    """Test cases for model controller endpoints."""
+    
+    @pytest.mark.asyncio
+    async def test_validate_model_success(self):
+        """Test successful model validation."""
+        request_data = ValidateModelRequest(
+            model_platform="OPENAI",
+            model_type="GPT_4O_MINI",
+            api_key="test_key",
+            url="https://api.openai.com/v1",
+            model_config_dict={"temperature": 0.7},
+            extra_params={"max_tokens": 1000}
+        )
+        
+        mock_agent = MagicMock()
+        mock_response = MagicMock()
+        tool_call = MagicMock()
+        tool_call.result = "Tool execution completed successfully for https://www.camel-ai.org, Website Content: Welcome to CAMEL AI!"
+        mock_response.info = {"tool_calls": [tool_call]}
+        mock_agent.step.return_value = mock_response
+        
+        with patch("app.controller.model_controller.create_agent", return_value=mock_agent):
+            response = await validate_model(request_data)
+            
+            assert isinstance(response, ValidateModelResponse)
+            assert response.is_valid is True
+            assert response.is_tool_calls is True
+            assert response.message == ""
+
+    @pytest.mark.asyncio
+    async def test_validate_model_creation_failure(self):
+        """Test model validation when agent creation fails."""
+        request_data = ValidateModelRequest(
+            model_platform="INVALID",
+            model_type="INVALID_MODEL",
+            api_key="invalid_key"
+        )
+        
+        with patch("app.controller.model_controller.create_agent", side_effect=Exception("Invalid model configuration")):
+            response = await validate_model(request_data)
+            
+            assert isinstance(response, ValidateModelResponse)
+            assert response.is_valid is False
+            assert response.is_tool_calls is False
+            assert "Invalid model configuration" in response.message
+
+    @pytest.mark.asyncio
+    async def test_validate_model_step_failure(self):
+        """Test model validation when agent step fails."""
+        request_data = ValidateModelRequest(
+            model_platform="OPENAI",
+            model_type="GPT_4O_MINI",
+            api_key="test_key"
+        )
+        
+        mock_agent = MagicMock()
+        mock_agent.step.side_effect = Exception("API call failed")
+        
+        with patch("app.controller.model_controller.create_agent", return_value=mock_agent):
+            response = await validate_model(request_data)
+            
+            assert isinstance(response, ValidateModelResponse)
+            assert response.is_valid is False
+            assert response.is_tool_calls is False
+            assert "API call failed" in response.message
+
+    @pytest.mark.asyncio
+    async def test_validate_model_tool_calls_false(self):
+        """Test model validation when tool calls fail."""
+        request_data = ValidateModelRequest(
+            model_platform="OPENAI",
+            model_type="GPT_4O_MINI",
+            api_key="test_key"
+        )
+        
+        mock_agent = MagicMock()
+        mock_response = MagicMock()
+        tool_call = MagicMock()
+        tool_call.result = "Different response"
+        mock_response.info = {"tool_calls": [tool_call]}
+        mock_agent.step.return_value = mock_response
+        
+        with patch("app.controller.model_controller.create_agent", return_value=mock_agent):
+            response = await validate_model(request_data)
+            
+            assert isinstance(response, ValidateModelResponse)
+            assert response.is_valid is True
+            assert response.is_tool_calls is False
+            assert response.message == ""
+
+    @pytest.mark.asyncio
+    async def test_validate_model_with_minimal_parameters(self):
+        """Test model validation with minimal parameters."""
+        request_data = ValidateModelRequest()  # Uses default values
+        
+        mock_agent = MagicMock()
+        mock_response = MagicMock()
+        tool_call = MagicMock()
+        tool_call.result = "Tool execution completed successfully for https://www.camel-ai.org, Website Content: Welcome to CAMEL AI!"
+        mock_response.info = {"tool_calls": [tool_call]}
+        mock_agent.step.return_value = mock_response
+        
+        with patch("app.controller.model_controller.create_agent", return_value=mock_agent):
+            response = await validate_model(request_data)
+            
+            assert isinstance(response, ValidateModelResponse)
+            assert response.is_valid is True
+            assert response.is_tool_calls is True
+
+    @pytest.mark.asyncio
+    async def test_validate_model_no_response(self):
+        """Test model validation when no response is returned."""
+        request_data = ValidateModelRequest(
+            model_platform="OPENAI",
+            model_type="GPT_4O_MINI"
+        )
+        
+        mock_agent = MagicMock()
+        mock_agent.step.return_value = None
+        
+        # Implementation tries to access response.info leading to AttributeError when response is None
+        with patch("app.controller.model_controller.create_agent", return_value=mock_agent):
+            with pytest.raises(AttributeError):
+                await validate_model(request_data)
+
+
+@pytest.mark.integration
+class TestModelControllerIntegration:
+    """Integration tests for model controller."""
+    
+    def test_validate_model_endpoint_integration(self, client: TestClient):
+        """Test validate model endpoint through FastAPI test client."""
+        request_data = {
+            "model_platform": "OPENAI",
+            "model_type": "GPT_4O_MINI",
+            "api_key": "test_key",
+            "url": "https://api.openai.com/v1",
+            "model_config_dict": {"temperature": 0.7},
+            "extra_params": {"max_tokens": 1000}
+        }
+        
+        mock_agent = MagicMock()
+        mock_response = MagicMock()
+        tool_call = MagicMock()
+        tool_call.result = "Tool execution completed successfully for https://www.camel-ai.org, Website Content: Welcome to CAMEL AI!"
+        mock_response.info = {"tool_calls": [tool_call]}
+        mock_agent.step.return_value = mock_response
+        
+        with patch("app.controller.model_controller.create_agent", return_value=mock_agent):
+            response = client.post("/model/validate", json=request_data)
+            
+            assert response.status_code == 200
+            response_data = response.json()
+            assert response_data["is_valid"] is True
+            assert response_data["is_tool_calls"] is True
+            assert response_data["message"] == ""
+
+    def test_validate_model_endpoint_error_integration(self, client: TestClient):
+        """Test validate model endpoint error handling through FastAPI test client."""
+        request_data = {
+            "model_platform": "INVALID",
+            "model_type": "INVALID_MODEL"
+        }
+        
+        with patch("app.controller.model_controller.create_agent", side_effect=Exception("Test error")):
+            response = client.post("/model/validate", json=request_data)
+            
+            assert response.status_code == 200  # Returns 200 with error in response body
+            response_data = response.json()
+            assert response_data["is_valid"] is False
+            assert response_data["is_tool_calls"] is False
+            assert "Test error" in response_data["message"]
+
+
+@pytest.mark.model_backend
+class TestModelControllerWithRealModels:
+    """Tests that require real model backends (marked for selective running)."""
+    
+    @pytest.mark.asyncio
+    async def test_validate_model_with_real_openai_model(self):
+        """Test model validation with real OpenAI model (requires API key)."""
+        request_data = ValidateModelRequest(
+            model_platform="OPENAI",
+            model_type="GPT_4O_MINI",
+            api_key=None,  # Would need real API key from environment
+        )
+        
+        # This test would validate against real OpenAI API
+        # Marked as model_backend for selective execution
+        assert True  # Placeholder
+
+    @pytest.mark.very_slow
+    async def test_validate_multiple_model_platforms(self):
+        """Test validation across multiple model platforms (very slow test)."""
+        # This test would validate multiple different model platforms
+        # Marked as very_slow for execution only in full test mode
+        assert True  # Placeholder
+
+
+@pytest.mark.unit
+class TestModelControllerErrorCases:
+    """Test error cases and edge conditions for model controller."""
+    
+    @pytest.mark.asyncio
+    async def test_validate_model_with_invalid_json_config(self):
+        """Test model validation with invalid JSON configuration."""
+        request_data = ValidateModelRequest(
+            model_platform="OPENAI",
+            model_type="GPT_4O_MINI",
+            model_config_dict={"invalid": float('inf')}  # Invalid JSON value
+        )
+        
+        with patch("app.controller.model_controller.create_agent", side_effect=ValueError("Invalid configuration")):
+            response = await validate_model(request_data)
+            
+            assert response.is_valid is False
+            assert "Invalid configuration" in response.message
+
+    @pytest.mark.asyncio
+    async def test_validate_model_with_network_error(self):
+        """Test model validation with network connectivity issues."""
+        request_data = ValidateModelRequest(
+            model_platform="OPENAI",
+            model_type="GPT_4O_MINI",
+            url="https://invalid-url.com"
+        )
+        
+        mock_agent = MagicMock()
+        mock_agent.step.side_effect = ConnectionError("Network unreachable")
+        
+        with patch("app.controller.model_controller.create_agent", return_value=mock_agent):
+            response = await validate_model(request_data)
+            
+            assert response.is_valid is False
+            assert "Network unreachable" in response.message
+
+    @pytest.mark.asyncio
+    async def test_validate_model_with_malformed_tool_calls_response(self):
+        """Test model validation with malformed tool calls in response."""
+        request_data = ValidateModelRequest(
+            model_platform="OPENAI",
+            model_type="GPT_4O_MINI"
+        )
+        
+        mock_agent = MagicMock()
+        mock_response = MagicMock()
+        mock_response.info = {
+            "tool_calls": []  # Empty tool calls
+        }
+        mock_agent.step.return_value = mock_response
+        
+        with patch("app.controller.model_controller.create_agent", return_value=mock_agent):
+            # Should handle missing tool calls gracefully
+            with pytest.raises(IndexError):
+                await validate_model(request_data)
+
+    @pytest.mark.asyncio
+    async def test_validate_model_with_missing_info_field(self):
+        """Test model validation with missing info field in response."""
+        request_data = ValidateModelRequest(
+            model_platform="OPENAI",
+            model_type="GPT_4O_MINI"
+        )
+        
+        mock_agent = MagicMock()
+        mock_response = MagicMock()
+        mock_response.info = {}  # Missing tool_calls
+        mock_agent.step.return_value = mock_response
+        
+        with patch("app.controller.model_controller.create_agent", return_value=mock_agent):
+            # Should handle missing info fields gracefully
+            with pytest.raises(KeyError):
+                await validate_model(request_data)

backend/tests/unit/controller/test_task_controller.py

@@ -0,0 +1,349 @@
+from unittest.mock import MagicMock, patch
+import pytest
+from fastapi import Response
+from fastapi.testclient import TestClient
+
+from app.controller.task_controller import start, put, take_control, add_agent, TakeControl
+from app.model.chat import NewAgent, UpdateData, TaskContent
+from app.service.task import Action
+
+
+@pytest.mark.unit
+class TestTaskController:
+    """Test cases for task controller endpoints."""
+    
+    def test_start_task_success(self, mock_task_lock):
+        """Test successful task start."""
+        task_id = "test_task_123"
+        
+        with patch("app.controller.task_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("asyncio.run") as mock_run:
+            
+            response = start(task_id)
+            
+            assert isinstance(response, Response)
+            assert response.status_code == 201
+            mock_run.assert_called_once()
+
+    def test_update_task_success(self, mock_task_lock):
+        """Test successful task update."""
+        task_id = "test_task_123"
+        update_data = UpdateData(
+            task=[
+                TaskContent(id="subtask_1", content="Updated content 1"),
+                TaskContent(id="subtask_2", content="Updated content 2")
+            ]
+        )
+        
+        with patch("app.controller.task_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("asyncio.run") as mock_run:
+            
+            response = put(task_id, update_data)
+            
+            assert isinstance(response, Response)
+            assert response.status_code == 201
+            mock_run.assert_called_once()
+
+    def test_take_control_pause_success(self, mock_task_lock):
+        """Test successful task pause control."""
+        task_id = "test_task_123"
+        control_data = TakeControl(action=Action.pause)
+        
+        with patch("app.controller.task_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("asyncio.run") as mock_run:
+            
+            response = take_control(task_id, control_data)
+            
+            assert isinstance(response, Response)
+            assert response.status_code == 204
+            mock_run.assert_called_once()
+
+    def test_take_control_resume_success(self, mock_task_lock):
+        """Test successful task resume control."""
+        task_id = "test_task_123"
+        control_data = TakeControl(action=Action.resume)
+        
+        with patch("app.controller.task_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("asyncio.run") as mock_run:
+            
+            response = take_control(task_id, control_data)
+            
+            assert isinstance(response, Response)
+            assert response.status_code == 204
+            mock_run.assert_called_once()
+
+    def test_add_agent_success(self, mock_task_lock):
+        """Test successful agent addition."""
+        task_id = "test_task_123"
+        new_agent = NewAgent(
+            name="Test Agent",
+            description="A test agent",
+            tools=["search", "code"],
+            mcp_tools=None,
+            env_path=".env"
+        )
+        
+        with patch("app.controller.task_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("app.controller.task_controller.load_dotenv"), \
+             patch("asyncio.run") as mock_run:
+            
+            response = add_agent(task_id, new_agent)
+            
+            assert isinstance(response, Response)
+            assert response.status_code == 204
+            mock_run.assert_called_once()
+
+    def test_start_task_nonexistent_task(self):
+        """Test start task with nonexistent task ID."""
+        task_id = "nonexistent_task"
+        
+        with patch("app.controller.task_controller.get_task_lock", side_effect=KeyError("Task not found")):
+            with pytest.raises(KeyError):
+                start(task_id)
+
+    def test_update_task_empty_data(self, mock_task_lock):
+        """Test update task with empty task list."""
+        task_id = "test_task_123"
+        update_data = UpdateData(task=[])
+        
+        with patch("app.controller.task_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("asyncio.run") as mock_run:
+            
+            response = put(task_id, update_data)
+            
+            assert isinstance(response, Response)
+            assert response.status_code == 201
+            mock_run.assert_called_once()
+
+    def test_add_agent_with_mcp_tools(self, mock_task_lock):
+        """Test adding agent with MCP tools."""
+        task_id = "test_task_123"
+        new_agent = NewAgent(
+            name="MCP Agent",
+            description="An agent with MCP tools",
+            tools=["search"],
+            mcp_tools={"mcpServers": {"notion": {"config": "test"}}},
+            env_path=".env"
+        )
+        
+        with patch("app.controller.task_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("app.controller.task_controller.load_dotenv"), \
+             patch("asyncio.run") as mock_run:
+            
+            response = add_agent(task_id, new_agent)
+            
+            assert isinstance(response, Response)
+            assert response.status_code == 204
+            mock_run.assert_called_once()
+
+
+@pytest.mark.integration
+class TestTaskControllerIntegration:
+    """Integration tests for task controller."""
+    
+    def test_start_task_endpoint_integration(self, client: TestClient):
+        """Test start task endpoint through FastAPI test client."""
+        task_id = "test_task_123"
+        
+        with patch("app.controller.task_controller.get_task_lock") as mock_get_lock, \
+             patch("asyncio.run"):
+            
+            mock_task_lock = MagicMock()
+            mock_get_lock.return_value = mock_task_lock
+            
+            response = client.post(f"/task/{task_id}/start")
+            
+            assert response.status_code == 201
+
+    def test_update_task_endpoint_integration(self, client: TestClient):
+        """Test update task endpoint through FastAPI test client."""
+        task_id = "test_task_123"
+        update_data = {
+            "task": [
+                {"id": "subtask_1", "content": "Updated content 1"},
+                {"id": "subtask_2", "content": "Updated content 2"}
+            ]
+        }
+        
+        with patch("app.controller.task_controller.get_task_lock") as mock_get_lock, \
+             patch("asyncio.run"):
+            
+            mock_task_lock = MagicMock()
+            mock_get_lock.return_value = mock_task_lock
+            
+            response = client.put(f"/task/{task_id}", json=update_data)
+            
+            assert response.status_code == 201
+
+    def test_take_control_pause_endpoint_integration(self, client: TestClient):
+        """Test take control pause endpoint through FastAPI test client."""
+        task_id = "test_task_123"
+        control_data = {"action": "pause"}
+        
+        with patch("app.controller.task_controller.get_task_lock") as mock_get_lock, \
+             patch("asyncio.run"):
+            
+            mock_task_lock = MagicMock()
+            mock_get_lock.return_value = mock_task_lock
+            
+            response = client.put(f"/task/{task_id}/take-control", json=control_data)
+            
+            assert response.status_code == 204
+
+    def test_take_control_resume_endpoint_integration(self, client: TestClient):
+        """Test take control resume endpoint through FastAPI test client."""
+        task_id = "test_task_123"
+        control_data = {"action": "resume"}
+        
+        with patch("app.controller.task_controller.get_task_lock") as mock_get_lock, \
+             patch("asyncio.run"):
+            
+            mock_task_lock = MagicMock()
+            mock_get_lock.return_value = mock_task_lock
+            
+            response = client.put(f"/task/{task_id}/take-control", json=control_data)
+            
+            assert response.status_code == 204
+
+    def test_add_agent_endpoint_integration(self, client: TestClient):
+        """Test add agent endpoint through FastAPI test client."""
+        task_id = "test_task_123"
+        agent_data = {
+            "name": "Test Agent",
+            "description": "A test agent",
+            "tools": ["search", "code"],
+            "mcp_tools": None,
+            "env_path": ".env"
+        }
+        
+        with patch("app.controller.task_controller.get_task_lock") as mock_get_lock, \
+             patch("app.controller.task_controller.load_dotenv"), \
+             patch("asyncio.run"):
+            
+            mock_task_lock = MagicMock()
+            mock_get_lock.return_value = mock_task_lock
+            
+            response = client.post(f"/task/{task_id}/add-agent", json=agent_data)
+            
+            assert response.status_code == 204
+
+
+@pytest.mark.unit
+class TestTaskControllerErrorCases:
+    """Test error cases and edge conditions for task controller."""
+    
+    def test_start_task_async_error(self, mock_task_lock):
+        """Test start task when async operation fails."""
+        task_id = "test_task_123"
+        
+        with patch("app.controller.task_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("asyncio.run", side_effect=Exception("Async error")):
+            
+            with pytest.raises(Exception, match="Async error"):
+                start(task_id)
+
+    def test_update_task_with_invalid_task_content(self, mock_task_lock):
+        """Test update task with invalid task content."""
+        task_id = "test_task_123"
+        # Create invalid update data that might cause validation errors
+        update_data = UpdateData(task=[
+            TaskContent(id="", content=""),  # Empty ID and content
+            TaskContent(id="valid_id", content="Valid content")
+        ])
+        
+        with patch("app.controller.task_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("asyncio.run") as mock_run:
+            
+            # Should handle invalid data gracefully or raise appropriate error
+            response = put(task_id, update_data)
+            assert response.status_code == 201
+
+    def test_take_control_invalid_action(self):
+        """Test take control with invalid action value."""
+        task_id = "test_task_123"
+        
+        # This should be caught by Pydantic validation
+        with pytest.raises((ValueError, TypeError)):
+            TakeControl(action="invalid_action")
+
+    def test_add_agent_env_load_failure(self, mock_task_lock):
+        """Test add agent when environment loading fails."""
+        task_id = "test_task_123"
+        new_agent = NewAgent(
+            name="Test Agent",
+            description="A test agent",
+            tools=["search"],
+            mcp_tools=None,
+            env_path="nonexistent.env"
+        )
+        
+        with patch("app.controller.task_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("app.controller.task_controller.load_dotenv", side_effect=Exception("Env load failed")), \
+             patch("asyncio.run"):
+            
+            # Should handle environment load failure gracefully or raise error
+            with pytest.raises(Exception, match="Env load failed"):
+                add_agent(task_id, new_agent)
+
+    def test_add_agent_with_empty_name(self, mock_task_lock):
+        """Test add agent with empty name."""
+        task_id = "test_task_123"
+        new_agent = NewAgent(
+            name="",  # Empty name
+            description="A test agent",
+            tools=["search"],
+            mcp_tools=None,
+            env_path=".env"
+        )
+        
+        with patch("app.controller.task_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("app.controller.task_controller.load_dotenv"), \
+             patch("asyncio.run"):
+            
+            # Should handle empty name appropriately
+            response = add_agent(task_id, new_agent)
+            assert response.status_code == 204
+
+    def test_task_operations_with_concurrent_access(self, mock_task_lock):
+        """Test task operations with concurrent access scenarios."""
+        task_id = "test_task_123"
+        
+        # Simulate concurrent access by having the task lock be modified during operation
+        def side_effect():
+            mock_task_lock.status = "modified_during_operation"
+            return None
+        
+        mock_task_lock.put_queue.side_effect = side_effect
+        
+        with patch("app.controller.task_controller.get_task_lock", return_value=mock_task_lock), \
+             patch("asyncio.run") as mock_run:
+            
+            response = start(task_id)
+            assert response.status_code == 201
+
+
+@pytest.mark.model_backend
+class TestTaskControllerWithLLM:
+    """Tests that require LLM backend (marked for selective running)."""
+    
+    def test_add_agent_with_real_model_integration(self, mock_task_lock):
+        """Test adding an agent that requires real model integration."""
+        task_id = "test_task_123"
+        new_agent = NewAgent(
+            name="Real Model Agent",
+            description="An agent that uses real models",
+            tools=["search", "code"],
+            mcp_tools=None,
+            env_path=".env"
+        )
+        
+        # This test would involve real model creation and configuration
+        # Marked as model_backend test for selective execution
+        assert True  # Placeholder
+
+    @pytest.mark.very_slow
+    def test_full_task_workflow_integration(self):
+        """Test complete task workflow from start to completion (very slow test)."""
+        # This test would run a complete task workflow including agent interactions
+        # Marked as very_slow for execution only in full test mode
+        assert True  # Placeholder

backend/tests/unit/controller/test_tool_controller.py

@@ -0,0 +1,196 @@
+from unittest.mock import AsyncMock, MagicMock, patch
+import pytest
+from fastapi.testclient import TestClient
+
+from app.controller.tool_controller import install_tool
+
+
+@pytest.mark.unit
+class TestToolController:
+    """Test cases for tool controller endpoints."""
+    
+    @pytest.mark.asyncio
+    async def test_install_notion_tool_success(self):
+        tool_name = "notion"
+        mock_toolkit = AsyncMock()
+        mock_tools = [MagicMock(), MagicMock()]
+        for tool, name in zip(mock_tools, ["create_page", "update_page"]):
+            tool.func.__name__ = name
+        mock_toolkit.get_tools = MagicMock(return_value=mock_tools)
+        with patch("app.controller.tool_controller.NotionMCPToolkit", return_value=mock_toolkit):
+            result = await install_tool(tool_name)
+        assert result == ["create_page", "update_page"]
+        mock_toolkit.connect.assert_called_once()
+        mock_toolkit.disconnect.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_install_unknown_tool(self):
+        result = await install_tool("unknown_tool")
+        assert result == {"error": "Tool not found"}
+
+    @pytest.mark.asyncio
+    async def test_install_notion_tool_connection_failure(self):
+        mock_toolkit = AsyncMock()
+        mock_toolkit.connect.side_effect = Exception("Connection failed")
+        with patch("app.controller.tool_controller.NotionMCPToolkit", return_value=mock_toolkit):
+            with pytest.raises(Exception, match="Connection failed"):
+                await install_tool("notion")
+
+    @pytest.mark.asyncio
+    async def test_install_notion_tool_get_tools_failure(self):
+        mock_toolkit = AsyncMock()
+        mock_toolkit.get_tools = MagicMock(side_effect=Exception("Failed to get tools"))
+        with patch("app.controller.tool_controller.NotionMCPToolkit", return_value=mock_toolkit):
+            with pytest.raises(Exception, match="Failed to get tools"):
+                await install_tool("notion")
+
+    @pytest.mark.asyncio
+    async def test_install_notion_tool_disconnect_failure(self):
+        mock_toolkit = AsyncMock()
+        mock_tools = [MagicMock()]
+        mock_tools[0].func.__name__ = "test_tool"
+        mock_toolkit.get_tools = MagicMock(return_value=mock_tools)
+        mock_toolkit.disconnect.side_effect = Exception("Disconnect failed")
+        with patch("app.controller.tool_controller.NotionMCPToolkit", return_value=mock_toolkit):
+            with pytest.raises(Exception, match="Disconnect failed"):
+                await install_tool("notion")
+
+    @pytest.mark.asyncio
+    async def test_install_notion_tool_empty_tools(self):
+        mock_toolkit = AsyncMock()
+        mock_toolkit.get_tools = MagicMock(return_value=[])
+        with patch("app.controller.tool_controller.NotionMCPToolkit", return_value=mock_toolkit):
+            result = await install_tool("notion")
+        assert result == []
+        mock_toolkit.connect.assert_called_once()
+        mock_toolkit.disconnect.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_install_notion_tool_with_complex_tools(self):
+        mock_toolkit = AsyncMock()
+        names = ["create_database", "query_database", "update_block", "delete_page"]
+        mock_tools = []
+        for name in names:
+            mt = MagicMock()
+            mt.func.__name__ = name
+            mock_tools.append(mt)
+        mock_toolkit.get_tools = MagicMock(return_value=mock_tools)
+        with patch("app.controller.tool_controller.NotionMCPToolkit", return_value=mock_toolkit):
+            result = await install_tool("notion")
+        assert result == names
+        mock_toolkit.connect.assert_called_once()
+        mock_toolkit.disconnect.assert_called_once()
+
+
+@pytest.mark.integration
+class TestToolControllerIntegration:
+    """Integration tests for tool controller."""
+    
+    def test_install_notion_tool_endpoint_integration(self, client: TestClient):
+        """Test install Notion tool endpoint through FastAPI test client."""
+        tool_name = "notion"
+        
+        mock_toolkit = AsyncMock()
+        mock_tools = [MagicMock(), MagicMock()]
+        mock_tools[0].func.__name__ = "create_page"
+        mock_tools[1].func.__name__ = "update_page"
+        mock_toolkit.get_tools = MagicMock(return_value=mock_tools)
+        
+        with patch("app.controller.tool_controller.NotionMCPToolkit", return_value=mock_toolkit):
+            response = client.post(f"/install/tool/{tool_name}")
+            
+            assert response.status_code == 200
+            assert response.json() == ["create_page", "update_page"]
+
+    def test_install_unknown_tool_endpoint_integration(self, client: TestClient):
+        """Test install unknown tool endpoint through FastAPI test client."""
+        tool_name = "unknown_tool"
+        
+        response = client.post(f"/install/tool/{tool_name}")
+        
+        assert response.status_code == 200
+        assert response.json() == {"error": "Tool not found"}
+
+    def test_install_notion_tool_endpoint_with_connection_error(self, client: TestClient):
+        """Test install Notion tool endpoint when connection fails."""
+        tool_name = "notion"
+        
+        mock_toolkit = AsyncMock()
+        mock_toolkit.connect.side_effect = Exception("Connection failed")
+        
+        with patch("app.controller.tool_controller.NotionMCPToolkit", return_value=mock_toolkit):
+            # The exception should be raised by the endpoint since there's no error handling
+            with pytest.raises(Exception, match="Connection failed"):
+                response = client.post(f"/install/tool/{tool_name}")
+
+
+@pytest.mark.model_backend
+class TestToolControllerWithRealMCP:
+    """Tests that require real MCP connections (marked for selective running)."""
+    
+    @pytest.mark.asyncio
+    async def test_install_notion_tool_with_real_connection(self):
+        """Test Notion tool installation with real MCP connection."""
+        tool_name = "notion"
+        
+        # This test would connect to real Notion MCP server
+        # Requires actual MCP server setup and credentials
+        # Marked as model_backend test for selective execution
+        assert True  # Placeholder
+
+    @pytest.mark.very_slow
+    async def test_install_and_test_all_notion_tools(self):
+        """Test installation and functionality of all Notion tools (very slow test)."""
+        # This test would install and test each Notion tool individually
+        # Marked as very_slow for execution only in full test mode
+        assert True  # Placeholder
+
+
+@pytest.mark.unit
+class TestToolControllerErrorCases:
+    """Test error and edge cases for tool installation."""
+
+    @pytest.mark.asyncio
+    async def test_install_tool_with_malformed_tool_response(self):
+        mock_toolkit = AsyncMock()
+        tools = [MagicMock(), object()]  # Second item lacks func
+        tools[0].func.__name__ = "valid_tool"
+        mock_toolkit.get_tools = MagicMock(return_value=tools)
+        with patch("app.controller.tool_controller.NotionMCPToolkit", return_value=mock_toolkit):
+            with pytest.raises(AttributeError):
+                await install_tool("notion")
+
+    @pytest.mark.asyncio
+    async def test_install_tool_with_none_toolkit(self):
+        with patch("app.controller.tool_controller.NotionMCPToolkit", return_value=None):
+            with pytest.raises(AttributeError):
+                await install_tool("notion")
+
+    @pytest.mark.asyncio
+    async def test_install_tool_with_special_characters_in_name(self):
+        result = await install_tool("notion@#$%")
+        assert result == {"error": "Tool not found"}
+
+    @pytest.mark.asyncio
+    async def test_install_tool_with_empty_string_name(self):
+        result = await install_tool("")
+        assert result == {"error": "Tool not found"}
+
+    @pytest.mark.asyncio
+    async def test_install_tool_with_none_name(self):
+        result = await install_tool(None)
+        assert result == {"error": "Tool not found"}
+
+    @pytest.mark.asyncio
+    async def test_install_notion_tool_partial_failure(self):
+        mock_toolkit = AsyncMock()
+        mock_toolkit.connect.return_value = None
+        tools = [MagicMock(), MagicMock(), MagicMock()]
+        tools[0].func.__name__ = "create_page"
+        tools[1].func.__name__ = "update_page"
+        tools[2].func = None
+        mock_toolkit.get_tools = MagicMock(return_value=tools)
+        mock_toolkit.disconnect.return_value = None
+        with patch("app.controller.tool_controller.NotionMCPToolkit", return_value=mock_toolkit):
+            with pytest.raises(AttributeError):
+                await install_tool("notion")