From 46160d3303a50a2e4e25ce59ab67cedb18191e1f Mon Sep 17 00:00:00 2001 From: David Castro Date: Fri, 30 Oct 2026 21:11:13 -0500 Subject: [PATCH 1/2] test(tools): use real ApiToolProvider and unbound_session in TestApiProviderToController --- .../tools/test_tools_transform_service.py | 89 ++++++++++++------- 1 file changed, 59 insertions(+), 30 deletions(-) diff --git a/api/tests/unit_tests/services/tools/test_tools_transform_service.py b/api/tests/unit_tests/services/tools/test_tools_transform_service.py index e1501f1ec7f5f7..2a9125a6c757ed 100644 --- a/api/tests/unit_tests/services/tools/test_tools_transform_service.py +++ b/api/tests/unit_tests/services/tools/test_tools_transform_service.py @@ -1,20 +1,23 @@ -from unittest.mock import ANY, MagicMock, Mock, patch +import json +from unittest.mock import Mock, patch import pytest from pytest_mock import MockerFixture +from sqlalchemy.orm import Session from core.mcp.types import Tool as MCPTool from core.tools.entities.api_entities import ToolApiEntity, ToolProviderApiEntity from core.tools.entities.common_entities import I18nObject from core.tools.entities.tool_entities import ( ApiProviderAuthType, + ApiProviderSchemaType, ToolParameter, ToolProviderEntity, ToolProviderIdentity, ToolProviderType, ) from models.account import Account -from models.tools import MCPToolProvider +from models.tools import ApiToolProvider, MCPToolProvider from services.tools.tools_transform_service import ToolTransformService from tests.tool_fixtures import make_runtime_tool @@ -486,6 +489,20 @@ def _parameter( ) +def _api_provider(auth_type: str) -> ApiToolProvider: + return ApiToolProvider( + name="Test API Provider", + icon='{"background": "#000", "content": "A"}', + schema="{}", + schema_type_str=ApiProviderSchemaType.OPENAPI, + user_id="00000000-0000-0000-0000-000000000001", + tenant_id="00000000-0000-0000-0000-000000000002", + description="Test API tool provider", + tools_str="[]", + credentials_str=json.dumps({"auth_type": auth_type}), + ) + + class TestToolsTransformServiceCases: class TestToolTransformService: """Test cases for ToolTransformService.convert_tool_entity_to_api_entity method""" @@ -930,42 +947,54 @@ def test_missing_description_defaults_empty(self): assert ToolTransformService.convert_mcp_schema_to_parameter(schema)[0].llm_description == "" class TestApiProviderToController: - def test_api_key_header_auth(self): - db_provider = MagicMock() - db_provider.credentials = {"auth_type": "api_key_header"} - with patch(f"{MODULE}.db.session"), patch(f"{MODULE}.ApiToolProviderController") as ctrl_cls: - ctrl_cls.from_db.return_value = MagicMock() - ToolTransformService.api_provider_to_controller(db_provider) + def test_api_key_header_auth(self, unbound_session: Session) -> None: + db_provider = _api_provider("api_key_header") + with ( + patch(f"{MODULE}.db.session", return_value=unbound_session), + patch(f"{MODULE}.ApiToolProviderController") as ctrl_cls, + ): + ctrl_cls.from_db.return_value = Mock() + result = ToolTransformService.api_provider_to_controller(db_provider) + assert result is ctrl_cls.from_db.return_value ctrl_cls.from_db.assert_called_once_with( - db_provider=db_provider, auth_type=ApiProviderAuthType.API_KEY_HEADER, session=ANY + db_provider=db_provider, auth_type=ApiProviderAuthType.API_KEY_HEADER, session=unbound_session ) - def test_api_key_query_auth(self): - db_provider = MagicMock() - db_provider.credentials = {"auth_type": "api_key_query"} - with patch(f"{MODULE}.db.session"), patch(f"{MODULE}.ApiToolProviderController") as ctrl_cls: - ctrl_cls.from_db.return_value = MagicMock() - ToolTransformService.api_provider_to_controller(db_provider) + def test_api_key_query_auth(self, unbound_session: Session) -> None: + db_provider = _api_provider("api_key_query") + with ( + patch(f"{MODULE}.db.session", return_value=unbound_session), + patch(f"{MODULE}.ApiToolProviderController") as ctrl_cls, + ): + ctrl_cls.from_db.return_value = Mock() + result = ToolTransformService.api_provider_to_controller(db_provider) + assert result is ctrl_cls.from_db.return_value ctrl_cls.from_db.assert_called_once_with( - db_provider=db_provider, auth_type=ApiProviderAuthType.API_KEY_QUERY, session=ANY + db_provider=db_provider, auth_type=ApiProviderAuthType.API_KEY_QUERY, session=unbound_session ) - def test_legacy_api_key_maps_to_header(self): - db_provider = MagicMock() - db_provider.credentials = {"auth_type": "api_key"} - with patch(f"{MODULE}.db.session"), patch(f"{MODULE}.ApiToolProviderController") as ctrl_cls: - ctrl_cls.from_db.return_value = MagicMock() - ToolTransformService.api_provider_to_controller(db_provider) + def test_legacy_api_key_maps_to_header(self, unbound_session: Session) -> None: + db_provider = _api_provider("api_key") + with ( + patch(f"{MODULE}.db.session", return_value=unbound_session), + patch(f"{MODULE}.ApiToolProviderController") as ctrl_cls, + ): + ctrl_cls.from_db.return_value = Mock() + result = ToolTransformService.api_provider_to_controller(db_provider) + assert result is ctrl_cls.from_db.return_value ctrl_cls.from_db.assert_called_once_with( - db_provider=db_provider, auth_type=ApiProviderAuthType.API_KEY_HEADER, session=ANY + db_provider=db_provider, auth_type=ApiProviderAuthType.API_KEY_HEADER, session=unbound_session ) - def test_unknown_auth_defaults_to_none(self): - db_provider = MagicMock() - db_provider.credentials = {"auth_type": "something_else"} - with patch(f"{MODULE}.db.session"), patch(f"{MODULE}.ApiToolProviderController") as ctrl_cls: - ctrl_cls.from_db.return_value = MagicMock() - ToolTransformService.api_provider_to_controller(db_provider) + def test_unknown_auth_defaults_to_none(self, unbound_session: Session) -> None: + db_provider = _api_provider("something_else") + with ( + patch(f"{MODULE}.db.session", return_value=unbound_session), + patch(f"{MODULE}.ApiToolProviderController") as ctrl_cls, + ): + ctrl_cls.from_db.return_value = Mock() + result = ToolTransformService.api_provider_to_controller(db_provider) + assert result is ctrl_cls.from_db.return_value ctrl_cls.from_db.assert_called_once_with( - db_provider=db_provider, auth_type=ApiProviderAuthType.NONE, session=ANY + db_provider=db_provider, auth_type=ApiProviderAuthType.NONE, session=unbound_session ) From d3d7986c0c9232ccdfd7e9a7a0fbdb8256b1fc71 Mon Sep 17 00:00:00 2001 From: David Castro Date: Fri, 30 Oct 2026 21:28:39 -0500 Subject: [PATCH 2/2] test(tools): exercise real ApiToolProviderController.from_db with sqlite_session --- .../tools/test_tools_transform_service.py | 99 +++++++++---------- 1 file changed, 47 insertions(+), 52 deletions(-) diff --git a/api/tests/unit_tests/services/tools/test_tools_transform_service.py b/api/tests/unit_tests/services/tools/test_tools_transform_service.py index 2a9125a6c757ed..c165d12490dcd6 100644 --- a/api/tests/unit_tests/services/tools/test_tools_transform_service.py +++ b/api/tests/unit_tests/services/tools/test_tools_transform_service.py @@ -9,7 +9,6 @@ from core.tools.entities.api_entities import ToolApiEntity, ToolProviderApiEntity from core.tools.entities.common_entities import I18nObject from core.tools.entities.tool_entities import ( - ApiProviderAuthType, ApiProviderSchemaType, ToolParameter, ToolProviderEntity, @@ -489,18 +488,24 @@ def _parameter( ) -def _api_provider(auth_type: str) -> ApiToolProvider: - return ApiToolProvider( +def _api_provider(session: Session, auth_type: str) -> ApiToolProvider: + user = Account(name="Test User", email="user@example.com") + session.add(user) + session.flush() + provider = ApiToolProvider( name="Test API Provider", icon='{"background": "#000", "content": "A"}', schema="{}", schema_type_str=ApiProviderSchemaType.OPENAPI, - user_id="00000000-0000-0000-0000-000000000001", + user_id=user.id, tenant_id="00000000-0000-0000-0000-000000000002", description="Test API tool provider", tools_str="[]", credentials_str=json.dumps({"auth_type": auth_type}), ) + session.add(provider) + session.commit() + return provider class TestToolsTransformServiceCases: @@ -947,54 +952,44 @@ def test_missing_description_defaults_empty(self): assert ToolTransformService.convert_mcp_schema_to_parameter(schema)[0].llm_description == "" class TestApiProviderToController: - def test_api_key_header_auth(self, unbound_session: Session) -> None: - db_provider = _api_provider("api_key_header") - with ( - patch(f"{MODULE}.db.session", return_value=unbound_session), - patch(f"{MODULE}.ApiToolProviderController") as ctrl_cls, - ): - ctrl_cls.from_db.return_value = Mock() - result = ToolTransformService.api_provider_to_controller(db_provider) - assert result is ctrl_cls.from_db.return_value - ctrl_cls.from_db.assert_called_once_with( - db_provider=db_provider, auth_type=ApiProviderAuthType.API_KEY_HEADER, session=unbound_session - ) + def test_api_key_header_auth(self, sqlite_session: Session) -> None: + db_provider = _api_provider(sqlite_session, "api_key_header") + with patch(f"{MODULE}.db.session", return_value=sqlite_session): + controller = ToolTransformService.api_provider_to_controller(db_provider) + assert controller.entity.identity.author == "Test User" + assert [c.name for c in controller.entity.credentials_schema] == [ + "auth_type", + "api_key_header", + "api_key_value", + "api_key_header_prefix", + ] - def test_api_key_query_auth(self, unbound_session: Session) -> None: - db_provider = _api_provider("api_key_query") - with ( - patch(f"{MODULE}.db.session", return_value=unbound_session), - patch(f"{MODULE}.ApiToolProviderController") as ctrl_cls, - ): - ctrl_cls.from_db.return_value = Mock() - result = ToolTransformService.api_provider_to_controller(db_provider) - assert result is ctrl_cls.from_db.return_value - ctrl_cls.from_db.assert_called_once_with( - db_provider=db_provider, auth_type=ApiProviderAuthType.API_KEY_QUERY, session=unbound_session - ) + def test_api_key_query_auth(self, sqlite_session: Session) -> None: + db_provider = _api_provider(sqlite_session, "api_key_query") + with patch(f"{MODULE}.db.session", return_value=sqlite_session): + controller = ToolTransformService.api_provider_to_controller(db_provider) + assert controller.entity.identity.author == "Test User" + assert [c.name for c in controller.entity.credentials_schema] == [ + "auth_type", + "api_key_query_param", + "api_key_value", + ] - def test_legacy_api_key_maps_to_header(self, unbound_session: Session) -> None: - db_provider = _api_provider("api_key") - with ( - patch(f"{MODULE}.db.session", return_value=unbound_session), - patch(f"{MODULE}.ApiToolProviderController") as ctrl_cls, - ): - ctrl_cls.from_db.return_value = Mock() - result = ToolTransformService.api_provider_to_controller(db_provider) - assert result is ctrl_cls.from_db.return_value - ctrl_cls.from_db.assert_called_once_with( - db_provider=db_provider, auth_type=ApiProviderAuthType.API_KEY_HEADER, session=unbound_session - ) + def test_legacy_api_key_maps_to_header(self, sqlite_session: Session) -> None: + db_provider = _api_provider(sqlite_session, "api_key") + with patch(f"{MODULE}.db.session", return_value=sqlite_session): + controller = ToolTransformService.api_provider_to_controller(db_provider) + assert controller.entity.identity.author == "Test User" + assert [c.name for c in controller.entity.credentials_schema] == [ + "auth_type", + "api_key_header", + "api_key_value", + "api_key_header_prefix", + ] - def test_unknown_auth_defaults_to_none(self, unbound_session: Session) -> None: - db_provider = _api_provider("something_else") - with ( - patch(f"{MODULE}.db.session", return_value=unbound_session), - patch(f"{MODULE}.ApiToolProviderController") as ctrl_cls, - ): - ctrl_cls.from_db.return_value = Mock() - result = ToolTransformService.api_provider_to_controller(db_provider) - assert result is ctrl_cls.from_db.return_value - ctrl_cls.from_db.assert_called_once_with( - db_provider=db_provider, auth_type=ApiProviderAuthType.NONE, session=unbound_session - ) + def test_unknown_auth_defaults_to_none(self, sqlite_session: Session) -> None: + db_provider = _api_provider(sqlite_session, "something_else") + with patch(f"{MODULE}.db.session", return_value=sqlite_session): + controller = ToolTransformService.api_provider_to_controller(db_provider) + assert controller.entity.identity.author == "Test User" + assert [c.name for c in controller.entity.credentials_schema] == ["auth_type"]