refactor: remove add_conversation endpoint and related tests

Author: Pavan-Microsoft

src/api/api/history_routes.py

@@ -43,32 +43,6 @@
 history_service = HistoryService()
 
 
-@router.post("/generate")
-async def add_conversation(request: Request):
-    try:
-        authenticated_user = get_authenticated_user_details(
-            request_headers=request.headers)
-        user_id = authenticated_user["user_principal_id"]
-
-        # Parse request body
-        request_json = await request.json()
-
-        response = await history_service.add_conversation(user_id, request_json)
-        track_event_if_configured("ConversationCreated", {
-            "user_id": user_id,
-            "request": request_json,
-        })
-        return response
-
-    except Exception as e:
-        logger.exception("Exception in /generate: %s", str(e))
-        span = trace.get_current_span()
-        if span is not None:
-            span.record_exception(e)
-            span.set_status(Status(StatusCode.ERROR, str(e)))
-        return JSONResponse(content={"error": "An internal error has occurred!"}, status_code=500)
-
-
 @router.post("/update")
 async def update_conversation(request: Request):
     try:

src/api/services/history_service.py

@@ -6,7 +6,6 @@
 from azure.ai.agents.models import MessageRole, ListSortOrder
 from common.config.config import Config
 from common.database.cosmosdb_service import CosmosConversationClient
-from helpers.chat_helper import complete_chat_request
 from helpers.azure_credential_utils import get_azure_credential
 
 # Configure logging
@@ -123,41 +122,6 @@ async def generate_title(self, conversation_messages):
                 return user_messages[-1]["content"][:50]
             return "New Conversation"
 
-    async def add_conversation(self, user_id: str, request_json: dict):
-        try:
-            conversation_id = request_json.get("conversation_id")
-            messages = request_json.get("messages", [])
-
-            history_metadata = {}
-
-            # make sure cosmos is configured
-            cosmos_conversation_client = self.init_cosmosdb_client()
-            if not cosmos_conversation_client:
-                raise ValueError("CosmosDB is not configured or unavailable")
-
-            if not conversation_id:
-                title = await self.generate_title(messages)
-                conversation_dict = await cosmos_conversation_client.create_conversation(user_id, title)
-                conversation_id = conversation_dict["id"]
-                history_metadata["title"] = title
-                history_metadata["date"] = conversation_dict["createdAt"]
-
-            if messages and messages[-1]["role"] == "user":
-                created_message = await cosmos_conversation_client.create_message(conversation_id, user_id, messages[-1])
-                if created_message == "Conversation not found":
-                    raise ValueError(
-                        f"Conversation not found for ID: {conversation_id}")
-            else:
-                raise ValueError("No user message found")
-
-            request_body = {
-                "messages": messages, "history_metadata": {
-                    "conversation_id": conversation_id}}
-            return await complete_chat_request(request_body)
-        except Exception:
-            logger.exception("Error in add_conversation")
-            raise
-
     async def update_conversation(self, user_id: str, request_json: dict):
         conversation_id = request_json.get("conversation_id")
         messages = request_json.get("messages", [])

src/tests/api/api/test_history_routes.py

@@ -27,19 +27,6 @@ async def client():
         yield ac
 
 
-@pytest.mark.asyncio
-@patch("auth.auth_utils.get_authenticated_user_details")
-@patch("services.history_service.HistoryService.add_conversation", new_callable=AsyncMock)
-@patch("common.logging.event_utils.track_event_if_configured")
-async def test_add_conversation(mock_track, mock_add, mock_auth, client, headers):
-    mock_auth.return_value = {"user_principal_id": "user123"}
-    mock_add.return_value = {"result": "ok"}
-
-    res = await client.post("/generate", json={"message": "hello"}, headers=headers)
-    assert res.status_code == 200
-    assert res.json() == {"result": "ok"}
-
-
 @pytest.mark.asyncio
 @patch("auth.auth_utils.get_authenticated_user_details")
 @patch("services.history_service.HistoryService.update_conversation", new_callable=AsyncMock)
@@ -311,8 +298,3 @@ async def test_ensure_cosmos_unknown_error(mock_track, mock_ensure, client):
     assert res.json()["error"] == "CosmosDB is not configured or not working"
 
 
-@pytest.mark.asyncio
-@patch("auth.auth_utils.get_authenticated_user_details", side_effect=Exception("auth error"))
-async def test_add_conversation_exception(mock_auth, client, headers):
-    res = await client.post("/generate", json={"message": "hi"}, headers=headers)
-    assert res.status_code == 500

src/tests/api/services/test_history_service.py

@@ -146,95 +146,6 @@ async def test_generate_title_exception(self, history_service):
             result = await history_service.generate_title(conversation_messages)
             assert result == "Fallback content"
 
-    @pytest.mark.asyncio
-    async def test_add_conversation_new(self, history_service):
-        """Test adding a new conversation"""
-        user_id = "test-user-id"
-        request_json = {
-            "conversation_id": None,
-            "messages": [{"role": "user", "content": "Hello"}]
-        }
-        
-        mock_cosmos_client = AsyncMock()
-        mock_cosmos_client.create_conversation = AsyncMock(
-            return_value={"id": "new-conv-id", "title": "Test Title", "createdAt": "2023-01-01T00:00:00Z"}
-        )
-        mock_cosmos_client.create_message = AsyncMock(return_value="success")
-        
-        with patch.object(history_service, "init_cosmosdb_client", return_value=mock_cosmos_client):
-            with patch.object(history_service, "generate_title", AsyncMock(return_value="Test Title")):
-                with patch("services.history_service.complete_chat_request", AsyncMock(return_value={"response": "test"})):
-                    result = await history_service.add_conversation(user_id, request_json)
-                    assert result == {"response": "test"}
-                    
-                    # Verify calls
-                    mock_cosmos_client.create_conversation.assert_awaited_once()
-                    mock_cosmos_client.create_message.assert_awaited_once()
-
-    @pytest.mark.asyncio
-    async def test_add_conversation_existing(self, history_service):
-        """Test adding to an existing conversation"""
-        user_id = "test-user-id"
-        request_json = {
-            "conversation_id": "existing-id",
-            "messages": [{"role": "user", "content": "Hello"}]
-        }
-        
-        mock_cosmos_client = AsyncMock()
-        mock_cosmos_client.create_message = AsyncMock(return_value="success")
-        
-        with patch.object(history_service, "init_cosmosdb_client", return_value=mock_cosmos_client):
-            with patch("services.history_service.complete_chat_request", AsyncMock(return_value={"response": "test"})):
-                result = await history_service.add_conversation(user_id, request_json)
-                assert result == {"response": "test"}
-                
-                # Verify calls
-                mock_cosmos_client.create_message.assert_awaited_once()
-
-    @pytest.mark.asyncio
-    async def test_add_conversation_cosmos_not_configured(self, history_service):
-        """Test adding conversation when cosmos is not configured"""
-        user_id = "test-user-id"
-        request_json = {
-            "conversation_id": "existing-id",
-            "messages": [{"role": "user", "content": "Hello"}]
-        }
-        
-        with patch.object(history_service, "init_cosmosdb_client", return_value=None):
-            with pytest.raises(ValueError, match="CosmosDB is not configured or unavailable"):
-                await history_service.add_conversation(user_id, request_json)
-
-    @pytest.mark.asyncio
-    async def test_add_conversation_no_user_message(self, history_service):
-        """Test adding conversation with no user message"""
-        user_id = "test-user-id"
-        request_json = {
-            "conversation_id": "existing-id",
-            "messages": [{"role": "assistant", "content": "Hello"}]
-        }
-        
-        mock_cosmos_client = AsyncMock()
-        
-        with patch.object(history_service, "init_cosmosdb_client", return_value=mock_cosmos_client):
-            with pytest.raises(ValueError, match="No user message found"):
-                await history_service.add_conversation(user_id, request_json)
-
-    @pytest.mark.asyncio
-    async def test_add_conversation_conversation_not_found(self, history_service):
-        """Test adding to a non-existent conversation"""
-        user_id = "test-user-id"
-        request_json = {
-            "conversation_id": "non-existent-id",
-            "messages": [{"role": "user", "content": "Hello"}]
-        }
-        
-        mock_cosmos_client = AsyncMock()
-        mock_cosmos_client.create_message = AsyncMock(return_value="Conversation not found")
-        
-        with patch.object(history_service, "init_cosmosdb_client", return_value=mock_cosmos_client):
-            with pytest.raises(ValueError, match="Conversation not found"):
-                await history_service.add_conversation(user_id, request_json)
-
     @pytest.mark.asyncio
     async def test_update_conversation(self, history_service):
         """Test updating an existing conversation"""