♻️ Unit test: Refresh the tool list when backend service is initialized #1250

Author: WMC001

backend/main_service.py

@@ -29,7 +29,7 @@ async def startup_initialization():
         logger.info("Server initialization completed successfully!")
 
     except Exception as e:
-        logger.error(f"❌ Server initialization failed: {str(e)}")
+        logger.error(f"Server initialization failed: {str(e)}")
         # Don't raise the exception to allow server to start even if initialization fails
         logger.warning("Server will continue to start despite initialization issues")
 

test/backend/database/test_user_tenant_db.py

@@ -66,7 +66,8 @@
 # Now import the functions to be tested
 from backend.database.user_tenant_db import (
     get_user_tenant_by_user_id,
-    insert_user_tenant
+    insert_user_tenant,
+    get_all_tenant_ids
 )
 
 class MockUserTenant:
@@ -301,4 +302,50 @@ def test_get_user_tenant_by_user_id_with_deleted_record(monkeypatch, mock_sessio
 
     assert result is None
     # Verify that the filter was called with correct conditions
-    query.filter.assert_called_once() 
+    query.filter.assert_called_once()
+
+
+def test_get_all_tenant_ids_empty_database(monkeypatch, mock_session):
+    """Test get_all_tenant_ids when database is empty - should return only DEFAULT_TENANT_ID"""
+    session, query = mock_session
+    
+    # Mock empty database result
+    query.filter.return_value.distinct.return_value.all.return_value = []
+    
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.user_tenant_db.get_db_session", lambda: mock_ctx)
+    
+    result = get_all_tenant_ids()
+    
+    assert result == ["default_tenant"]  # DEFAULT_TENANT_ID from consts_mock
+    assert len(result) == 1
+
+
+def test_get_all_tenant_ids_with_existing_tenants(monkeypatch, mock_session):
+    """Test get_all_tenant_ids with existing tenants - should include all plus DEFAULT_TENANT_ID"""
+    session, query = mock_session
+    
+    # Mock database result with existing tenants
+    mock_tenants = [
+        ("tenant_1",),
+        ("tenant_2",),
+        ("tenant_3",)
+    ]
+    query.filter.return_value.distinct.return_value.all.return_value = mock_tenants
+    
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.user_tenant_db.get_db_session", lambda: mock_ctx)
+    
+    result = get_all_tenant_ids()
+    
+    assert len(result) == 4  # 3 existing + 1 default
+    assert "tenant_1" in result
+    assert "tenant_2" in result
+    assert "tenant_3" in result
+    assert "default_tenant" in result  # DEFAULT_TENANT_ID from consts_mock
+    # Should not duplicate DEFAULT_TENANT_ID
+    assert result.count("default_tenant") == 1

test/backend/services/test_tool_configuration_service.py

@@ -1,8 +1,10 @@
+import asyncio
 import inspect
+import sys
 import unittest
-from unittest.mock import Mock, patch, MagicMock, AsyncMock
 from typing import Any, List, Dict
-import sys
+from unittest.mock import AsyncMock, MagicMock, Mock, patch
+
 import pytest
 
 boto3_mock = MagicMock()
@@ -903,5 +905,171 @@ def __init__(self):
         assert mock_build_tool_info.call_count == 2
 
 
+class TestInitializeToolsOnStartup:
+    """Test cases for initialize_tools_on_startup function"""
+
+    @patch('backend.services.tool_configuration_service.get_all_tenant_ids')
+    @patch('backend.services.tool_configuration_service.update_tool_list')
+    @patch('backend.services.tool_configuration_service.query_all_tools')
+    @patch('backend.services.tool_configuration_service.logger')
+    async def test_initialize_tools_on_startup_no_tenants(self, mock_logger, mock_query_tools, mock_update_tool_list, mock_get_tenants):
+        """Test initialize_tools_on_startup when no tenants are found"""
+        # Mock get_all_tenant_ids to return empty list
+        mock_get_tenants.return_value = []
+        
+        # Import and call the function
+        from backend.services.tool_configuration_service import initialize_tools_on_startup
+        await initialize_tools_on_startup()
+        
+        # Verify warning was logged
+        mock_logger.warning.assert_called_with("No tenants found in database, skipping tool initialization")
+        mock_update_tool_list.assert_not_called()
+
+    @patch('backend.services.tool_configuration_service.get_all_tenant_ids')
+    @patch('backend.services.tool_configuration_service.update_tool_list')
+    @patch('backend.services.tool_configuration_service.query_all_tools')
+    @patch('backend.services.tool_configuration_service.logger')
+    async def test_initialize_tools_on_startup_success(self, mock_logger, mock_query_tools, mock_update_tool_list, mock_get_tenants):
+        """Test successful tool initialization for all tenants"""
+        # Mock tenant IDs
+        tenant_ids = ["tenant_1", "tenant_2", "default_tenant"]
+        mock_get_tenants.return_value = tenant_ids
+        
+        # Mock update_tool_list to succeed
+        mock_update_tool_list.return_value = None
+        
+        # Mock query_all_tools to return mock tools
+        mock_tools = [
+            {"tool_id": "tool_1", "name": "Test Tool 1"},
+            {"tool_id": "tool_2", "name": "Test Tool 2"}
+        ]
+        mock_query_tools.return_value = mock_tools
+        
+        # Import and call the function
+        from backend.services.tool_configuration_service import initialize_tools_on_startup
+        await initialize_tools_on_startup()
+        
+        # Verify update_tool_list was called for each tenant
+        assert mock_update_tool_list.call_count == len(tenant_ids)
+        
+        # Verify success logging
+        mock_logger.info.assert_any_call("Tool initialization completed!")
+        mock_logger.info.assert_any_call("Total tools available across all tenants: 6")  # 2 tools * 3 tenants
+        mock_logger.info.assert_any_call("Successfully processed: 3/3 tenants")
+
+    @patch('backend.services.tool_configuration_service.get_all_tenant_ids')
+    @patch('backend.services.tool_configuration_service.update_tool_list')
+    @patch('backend.services.tool_configuration_service.logger')
+    async def test_initialize_tools_on_startup_timeout(self, mock_logger, mock_update_tool_list, mock_get_tenants):
+        """Test tool initialization timeout scenario"""
+        tenant_ids = ["tenant_1", "tenant_2"]
+        mock_get_tenants.return_value = tenant_ids
+        
+        # Mock update_tool_list to timeout
+        mock_update_tool_list.side_effect = asyncio.TimeoutError()
+        
+        # Import and call the function
+        from backend.services.tool_configuration_service import initialize_tools_on_startup
+        await initialize_tools_on_startup()
+        
+        # Verify timeout error was logged for each tenant
+        assert mock_logger.error.call_count == len(tenant_ids)
+        for call in mock_logger.error.call_args_list:
+            assert "timed out" in str(call)
+        
+        # Verify failed tenants were logged
+        mock_logger.warning.assert_called_once()
+        warning_call = mock_logger.warning.call_args[0][0]
+        assert "Failed tenants:" in warning_call
+        assert "tenant_1 (timeout)" in warning_call
+        assert "tenant_2 (timeout)" in warning_call
+
+    @patch('backend.services.tool_configuration_service.get_all_tenant_ids')
+    @patch('backend.services.tool_configuration_service.update_tool_list')
+    @patch('backend.services.tool_configuration_service.logger')
+    async def test_initialize_tools_on_startup_exception(self, mock_logger, mock_update_tool_list, mock_get_tenants):
+        """Test tool initialization with exception during processing"""
+        tenant_ids = ["tenant_1", "tenant_2"]
+        mock_get_tenants.return_value = tenant_ids
+        
+        # Mock update_tool_list to raise exception
+        mock_update_tool_list.side_effect = Exception("Database connection failed")
+        
+        # Import and call the function
+        from backend.services.tool_configuration_service import initialize_tools_on_startup
+        await initialize_tools_on_startup()
+        
+        # Verify exception error was logged for each tenant
+        assert mock_logger.error.call_count == len(tenant_ids)
+        for call in mock_logger.error.call_args_list:
+            assert "Tool initialization failed" in str(call)
+            assert "Database connection failed" in str(call)
+        
+        # Verify failed tenants were logged
+        mock_logger.warning.assert_called_once()
+        warning_call = mock_logger.warning.call_args[0][0]
+        assert "Failed tenants:" in warning_call
+        assert "tenant_1 (error: Database connection failed)" in warning_call
+        assert "tenant_2 (error: Database connection failed)" in warning_call
+
+    @patch('backend.services.tool_configuration_service.get_all_tenant_ids')
+    @patch('backend.services.tool_configuration_service.logger')
+    async def test_initialize_tools_on_startup_critical_exception(self, mock_logger, mock_get_tenants):
+        """Test tool initialization when get_all_tenant_ids raises exception"""
+        # Mock get_all_tenant_ids to raise exception
+        mock_get_tenants.side_effect = Exception("Database connection failed")
+        
+        # Import and call the function
+        from backend.services.tool_configuration_service import initialize_tools_on_startup
+        
+        # Should raise the exception
+        with pytest.raises(Exception, match="Database connection failed"):
+            await initialize_tools_on_startup()
+        
+        # Verify critical error was logged
+        mock_logger.error.assert_called_with("❌ Tool initialization failed: Database connection failed")
+
+    @patch('backend.services.tool_configuration_service.get_all_tenant_ids')
+    @patch('backend.services.tool_configuration_service.update_tool_list')
+    @patch('backend.services.tool_configuration_service.query_all_tools')
+    @patch('backend.services.tool_configuration_service.logger')
+    async def test_initialize_tools_on_startup_mixed_results(self, mock_logger, mock_query_tools, mock_update_tool_list, mock_get_tenants):
+        """Test tool initialization with mixed success and failure results"""
+        tenant_ids = ["tenant_1", "tenant_2", "tenant_3"]
+        mock_get_tenants.return_value = tenant_ids
+        
+        # Mock update_tool_list with mixed results
+        def side_effect(*args, **kwargs):
+            tenant_id = kwargs.get('tenant_id')
+            if tenant_id == "tenant_1":
+                return None  # Success
+            elif tenant_id == "tenant_2":
+                raise asyncio.TimeoutError()  # Timeout
+            else:  # tenant_3
+                raise Exception("Connection error")  # Exception
+        
+        mock_update_tool_list.side_effect = side_effect
+        
+        # Mock query_all_tools for successful tenant
+        mock_tools = [{"tool_id": "tool_1", "name": "Test Tool"}]
+        mock_query_tools.return_value = mock_tools
+        
+        # Import and call the function
+        from backend.services.tool_configuration_service import initialize_tools_on_startup
+        await initialize_tools_on_startup()
+        
+        # Verify mixed results logging
+        mock_logger.info.assert_any_call("Tool initialization completed!")
+        mock_logger.info.assert_any_call("Total tools available across all tenants: 1")
+        mock_logger.info.assert_any_call("Successfully processed: 1/3 tenants")
+        
+        # Verify failed tenants were logged
+        mock_logger.warning.assert_called_once()
+        warning_call = mock_logger.warning.call_args[0][0]
+        assert "Failed tenants:" in warning_call
+        assert "tenant_2 (timeout)" in warning_call
+        assert "tenant_3 (error: Connection error)" in warning_call
+
+
 if __name__ == '__main__':
     unittest.main()