🧪 add test case

Author: ljy65535

test/backend/app/test_tool_config_app.py

@@ -401,6 +401,85 @@ def test_scan_tool_auth_failure(self, mock_get_user_id):
         assert "Failed to update tool" in data["detail"]
 
 
+class TestLoadLastToolConfigAPI:
+    """Test endpoint for loading last tool configuration"""
+
+    @patch('apps.tool_config_app.get_current_user_id')
+    @patch('apps.tool_config_app.load_last_tool_config_impl')
+    def test_load_last_tool_config_success(self, mock_load_config, mock_get_user_id):
+        """Test successful loading of last tool configuration"""
+        mock_get_user_id.return_value = ("user123", "tenant456")
+        mock_load_config.return_value = {"param1": "value1", "param2": "value2"}
+
+        response = client.get("/tool/load_config/123")
+
+        assert response.status_code == HTTPStatus.OK
+        data = response.json()
+        assert data["status"] == "success"
+        assert data["message"] == {"param1": "value1", "param2": "value2"}
+
+        mock_get_user_id.assert_called_once_with(None)
+        mock_load_config.assert_called_once_with(123, "tenant456", "user123")
+
+    @patch('apps.tool_config_app.get_current_user_id')
+    @patch('apps.tool_config_app.load_last_tool_config_impl')
+    def test_load_last_tool_config_not_found(self, mock_load_config, mock_get_user_id):
+        """Test loading tool config when not found"""
+        mock_get_user_id.return_value = ("user123", "tenant456")
+        mock_load_config.side_effect = ValueError("Tool configuration not found for tool ID: 123")
+
+        response = client.get("/tool/load_config/123")
+
+        assert response.status_code == HTTPStatus.NOT_FOUND
+        data = response.json()
+        assert "Tool configuration not found" in data["detail"]
+
+        mock_get_user_id.assert_called_once_with(None)
+        mock_load_config.assert_called_once_with(123, "tenant456", "user123")
+
+    @patch('apps.tool_config_app.get_current_user_id')
+    @patch('apps.tool_config_app.load_last_tool_config_impl')
+    def test_load_last_tool_config_service_error(self, mock_load_config, mock_get_user_id):
+        """Test service error when loading tool config"""
+        mock_get_user_id.return_value = ("user123", "tenant456")
+        mock_load_config.side_effect = Exception("Database error")
+
+        response = client.get("/tool/load_config/123")
+
+        assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
+        data = response.json()
+        assert "Failed to load tool config" in data["detail"]
+
+        mock_get_user_id.assert_called_once_with(None)
+        mock_load_config.assert_called_once_with(123, "tenant456", "user123")
+
+    @patch('apps.tool_config_app.get_current_user_id')
+    def test_load_last_tool_config_auth_error(self, mock_get_user_id):
+        """Test authentication error when loading tool config"""
+        mock_get_user_id.side_effect = Exception("Auth error")
+
+        response = client.get("/tool/load_config/123")
+
+        assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
+        data = response.json()
+        assert "Failed to load tool config" in data["detail"]
+
+    @patch('apps.tool_config_app.get_current_user_id')
+    @patch('apps.tool_config_app.load_last_tool_config_impl')
+    def test_load_last_tool_config_with_authorization_header(self, mock_load_config, mock_get_user_id):
+        """Test loading tool config with authorization header"""
+        mock_get_user_id.return_value = ("user123", "tenant456")
+        mock_load_config.return_value = {"param1": "value1"}
+
+        response = client.get(
+            "/tool/load_config/123",
+            headers={"Authorization": "Bearer test_token"}
+        )
+
+        assert response.status_code == HTTPStatus.OK
+        mock_get_user_id.assert_called_with("Bearer test_token")
+
+
 class TestDataValidation:
     """Data validation tests"""
 

test/backend/database/test_tool_db.py

@@ -78,7 +78,8 @@
     add_tool_field,
     search_tools_for_sub_agent,
     check_tool_is_available,
-    delete_tools_by_agent_id
+    delete_tools_by_agent_id,
+    search_last_tool_instance_by_tool_id
 )
 
 class MockToolInstance:
@@ -518,4 +519,129 @@ def test_delete_tools_by_agent_id_success(monkeypatch, mock_session):
     # Function returns no value, only verify successful execution
     delete_tools_by_agent_id(1, "tenant1", "user1")
 
-    mock_update.assert_called_once() 
+    mock_update.assert_called_once()
+
+
+def test_search_last_tool_instance_by_tool_id_found(monkeypatch, mock_session):
+    """Test successfully finding last tool instance by tool ID"""
+    session, query = mock_session
+    mock_tool_instance = MockToolInstance()
+    mock_tool_instance.params = {"param1": "value1", "param2": "value2"}
+    mock_tool_instance.update_time = "2023-01-01 12:00:00"
+    
+    mock_first = MagicMock()
+    mock_first.return_value = mock_tool_instance
+    mock_order_by = MagicMock()
+    mock_order_by.first = mock_first
+    mock_filter = MagicMock()
+    mock_filter.order_by.return_value = mock_order_by
+    query.filter.return_value = mock_filter
+    
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.tool_db.get_db_session", lambda: mock_ctx)
+    monkeypatch.setattr("backend.database.tool_db.as_dict", lambda obj: obj.__dict__)
+    
+    result = search_last_tool_instance_by_tool_id(1, "tenant1", "user1")
+    
+    assert result["tool_instance_id"] == 1
+    assert result["tool_id"] == 1
+    assert result["params"] == {"param1": "value1", "param2": "value2"}
+
+def test_search_last_tool_instance_by_tool_id_not_found(monkeypatch, mock_session):
+    """Test searching for non-existent last tool instance"""
+    session, query = mock_session
+    mock_first = MagicMock()
+    mock_first.return_value = None
+    mock_order_by = MagicMock()
+    mock_order_by.first = mock_first
+    mock_filter = MagicMock()
+    mock_filter.order_by.return_value = mock_order_by
+    query.filter.return_value = mock_filter
+    
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.tool_db.get_db_session", lambda: mock_ctx)
+    
+    result = search_last_tool_instance_by_tool_id(999, "tenant1", "user1")
+    
+    assert result is None
+
+def test_search_last_tool_instance_by_tool_id_with_deleted_flag(monkeypatch, mock_session):
+    """Test searching for tool instance with deleted flag filter"""
+    session, query = mock_session
+    mock_tool_instance = MockToolInstance()
+    mock_tool_instance.delete_flag = "N"
+    
+    mock_first = MagicMock()
+    mock_first.return_value = mock_tool_instance
+    mock_order_by = MagicMock()
+    mock_order_by.first = mock_first
+    mock_filter = MagicMock()
+    mock_filter.order_by.return_value = mock_order_by
+    query.filter.return_value = mock_filter
+    
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.tool_db.get_db_session", lambda: mock_ctx)
+    monkeypatch.setattr("backend.database.tool_db.as_dict", lambda obj: obj.__dict__)
+    
+    result = search_last_tool_instance_by_tool_id(1, "tenant1", "user1")
+    
+    assert result["delete_flag"] == "N"
+    # Verify that the filter was called with correct parameters
+    assert query.filter.call_count == 1
+
+def test_search_last_tool_instance_by_tool_id_ordering(monkeypatch, mock_session):
+    """Test that results are ordered by update_time desc"""
+    session, query = mock_session
+    mock_tool_instance = MockToolInstance()
+    
+    mock_first = MagicMock()
+    mock_first.return_value = mock_tool_instance
+    mock_order_by = MagicMock()
+    mock_order_by.first = mock_first
+    mock_filter = MagicMock()
+    mock_filter.order_by.return_value = mock_order_by
+    query.filter.return_value = mock_filter
+    
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.tool_db.get_db_session", lambda: mock_ctx)
+    monkeypatch.setattr("backend.database.tool_db.as_dict", lambda obj: obj.__dict__)
+    
+    result = search_last_tool_instance_by_tool_id(1, "tenant1", "user1")
+    
+    # Verify that order_by was called (indicating proper ordering)
+    mock_filter.order_by.assert_called_once()
+    assert result is not None
+
+def test_search_last_tool_instance_by_tool_id_different_tenants(monkeypatch, mock_session):
+    """Test searching with different tenant and user IDs"""
+    session, query = mock_session
+    mock_tool_instance = MockToolInstance()
+    mock_tool_instance.tenant_id = "tenant2"
+    mock_tool_instance.user_id = "user2"
+    
+    mock_first = MagicMock()
+    mock_first.return_value = mock_tool_instance
+    mock_order_by = MagicMock()
+    mock_order_by.first = mock_first
+    mock_filter = MagicMock()
+    mock_filter.order_by.return_value = mock_order_by
+    query.filter.return_value = mock_filter
+    
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+    mock_ctx.__exit__.return_value = None
+    monkeypatch.setattr("backend.database.tool_db.get_db_session", lambda: mock_ctx)
+    monkeypatch.setattr("backend.database.tool_db.as_dict", lambda obj: obj.__dict__)
+    
+    result = search_last_tool_instance_by_tool_id(1, "tenant2", "user2")
+    
+    assert result["tenant_id"] == "tenant2"
+    assert result["user_id"] == "user2" 

test/backend/services/test_tool_configuration_service.py

@@ -17,7 +17,8 @@
         get_local_tools_classes,
         search_tool_info_impl,
         update_tool_info_impl,
-        list_all_tools
+        list_all_tools,
+        load_last_tool_config_impl
     )
 from consts.model import ToolInfo, ToolSourceEnum, ToolInstanceInfoRequest
 from consts.exceptions import MCPConnectionError
@@ -1071,5 +1072,51 @@ def side_effect(*args, **kwargs):
         assert "tenant_3 (error: Connection error)" in warning_call
 
 
+class TestLoadLastToolConfigImpl:
+    """Test load_last_tool_config_impl function"""
+
+    @patch('backend.services.tool_configuration_service.search_last_tool_instance_by_tool_id')
+    def test_load_last_tool_config_impl_success(self, mock_search_tool_instance):
+        """Test successfully loading last tool configuration"""
+        mock_tool_instance = {
+            "tool_instance_id": 1,
+            "tool_id": 123,
+            "params": {"param1": "value1", "param2": "value2"},
+            "enabled": True
+        }
+        mock_search_tool_instance.return_value = mock_tool_instance
+
+        result = load_last_tool_config_impl(123, "tenant1", "user1")
+
+        assert result == {"param1": "value1", "param2": "value2"}
+        mock_search_tool_instance.assert_called_once_with(123, "tenant1", "user1")
+
+    @patch('backend.services.tool_configuration_service.search_last_tool_instance_by_tool_id')
+    def test_load_last_tool_config_impl_not_found(self, mock_search_tool_instance):
+        """Test loading tool config when tool instance not found"""
+        mock_search_tool_instance.return_value = None
+
+        with pytest.raises(ValueError, match="Tool configuration not found for tool ID: 123"):
+            load_last_tool_config_impl(123, "tenant1", "user1")
+
+        mock_search_tool_instance.assert_called_once_with(123, "tenant1", "user1")
+
+    @patch('backend.services.tool_configuration_service.search_last_tool_instance_by_tool_id')
+    def test_load_last_tool_config_impl_empty_params(self, mock_search_tool_instance):
+        """Test loading tool config with empty params"""
+        mock_tool_instance = {
+            "tool_instance_id": 1,
+            "tool_id": 123,
+            "params": {},
+            "enabled": True
+        }
+        mock_search_tool_instance.return_value = mock_tool_instance
+
+        result = load_last_tool_config_impl(123, "tenant1", "user1")
+
+        assert result == {}
+        mock_search_tool_instance.assert_called_once_with(123, "tenant1", "user1")
+
+
 if __name__ == '__main__':
     unittest.main()