Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

refactor(api): inject trigger subscription builder lifecycle (#44532)

非法操作107bbf85ca65
diff --git a/api/.importlinter b/api/.importlinter
index 6becbed4160..90df3674e1f 100644
--- a/api/.importlinter
+++ b/api/.importlinter
@@ -1444,3 +1444,16 @@ forbidden_modules =
sqlalchemy
werkzeug
allow_indirect_imports = True
+
+[importlinter:contract:trigger-subscription-builder-persistence-boundary]
+name = Trigger subscription builder orchestration uses injected persistence
+type = forbidden
+source_modules =
+ services.trigger.trigger_subscription_builder_service
+forbidden_modules =
+ controllers
+ extensions
+ repositories
+ sqlalchemy
+ services.trigger.trigger_provider_service
+allow_indirect_imports = True
diff --git a/api/controllers/console/workspace/plugin.py b/api/controllers/console/workspace/plugin.py
index 5a189afa02f..a9e4f964d93 100644
--- a/api/controllers/console/workspace/plugin.py
+++ b/api/controllers/console/workspace/plugin.py
@@ -50,6 +50,7 @@ from core.tools.entities.api_entities import ToolProviderApiEntity
from core.tools.entities.common_entities import I18nObject
from core.tools.entities.tool_entities import ToolProviderType
from core.tools.tool_manager import ToolManager
+from extensions.ext_application_services import application_services
from extensions.ext_database import db
from fields.base import ResponseModel
from graphon.model_runtime.utils.encoders import jsonable_encoder
@@ -1176,6 +1177,7 @@ class PluginFetchDynamicSelectOptionsApi(Resource):
parameter=req_data.parameter,
credential_id=req_data.credential_id,
provider_type=req_data.provider_type,
+ builders=application_services().workspaces.trigger_builders,
)
except PluginDaemonClientSideError as e:
raise PluginOperationError(e.description) from e
diff --git a/api/controllers/console/workspace/trigger_providers.py b/api/controllers/console/workspace/trigger_providers.py
index 9bd463966d7..15db2094adf 100644
--- a/api/controllers/console/workspace/trigger_providers.py
+++ b/api/controllers/console/workspace/trigger_providers.py
@@ -60,7 +60,6 @@ from services.trigger.oauth_service import (
TriggerOAuthProviderError,
)
from services.trigger.trigger_provider_service import TriggerProviderService
-from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService
from services.trigger.trigger_subscription_operator_service import TriggerSubscriptionOperatorService
logger = logging.getLogger(__name__)
@@ -215,11 +214,9 @@ class TriggerSubscriptionListApi(Resource):
HTTPStatus.NOT_FOUND, "Trigger provider not found", console_ns.models[TriggerProviderErrorResponse.__name__]
)
@console_account_admission(
- require_initialized=False,
allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}),
rbac_checks=[RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace())],
)
- @account_initialization_required
def get(self, context: RequestContext, provider: str) -> list[dict[str, Any]] | tuple[dict[str, Any], HTTPStatus]:
"""List all trigger subscriptions for the current tenant's provider"""
@@ -244,28 +241,29 @@ class TriggerSubscriptionListApi(Resource):
class TriggerSubscriptionBuilderCreateApi(Resource):
@console_ns.expect(console_ns.models[TriggerSubscriptionBuilderCreatePayload.__name__])
@console_ns.response(
- 200,
+ HTTPStatus.OK,
"Trigger subscription builder created successfully",
console_ns.models[TriggerSubscriptionBuilderCreateResponse.__name__],
)
- @setup_required
- @login_required
- @edit_permission_required
- @rbac_permission_required(RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace()))
- @account_initialization_required
- @with_current_user
- @with_current_tenant_id
+ @console_account_admission(
+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}),
+ rbac_checks=[RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace())],
+ )
@model_validate(TriggerSubscriptionBuilderCreatePayload)
- def post(self, req_data: TriggerSubscriptionBuilderCreatePayload, tenant_id: str, user: Account, provider: str):
+ def post(
+ self, req_data: TriggerSubscriptionBuilderCreatePayload, context: RequestContext, provider: str
+ ) -> dict[str, Any]:
"""Add a new subscription instance for a trigger provider"""
try:
credential_type = CredentialType.of(req_data.credential_type)
- subscription_builder = TriggerSubscriptionBuilderService.create_trigger_subscription_builder(
- tenant_id=tenant_id,
- user_id=user.id,
- provider_id=TriggerProviderID(provider),
- credential_type=credential_type,
+ subscription_builder = (
+ application_services().workspaces.trigger_builders.create_trigger_subscription_builder(
+ tenant_id=context.active_workspace_id,
+ user_id=context.account_id,
+ provider_id=TriggerProviderID(provider),
+ credential_type=credential_type,
+ )
)
return TriggerSubscriptionBuilderCreateResponse(subscription_builder=subscription_builder).model_dump(
mode="json"
@@ -280,22 +278,19 @@ class TriggerSubscriptionBuilderCreateApi(Resource):
)
class TriggerSubscriptionBuilderGetApi(Resource):
@console_ns.response(
- 200,
+ HTTPStatus.OK,
"Trigger subscription builder retrieved successfully",
console_ns.models[SubscriptionBuilderApiEntity.__name__],
)
- @setup_required
- @login_required
- @edit_permission_required
- @rbac_permission_required(RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace()))
- @account_initialization_required
- @with_current_user
- @with_current_tenant_id
- def get(self, tenant_id: str, user: Account, provider: str, subscription_builder_id: str):
+ @console_account_admission(
+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}),
+ rbac_checks=[RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace())],
+ )
+ def get(self, context: RequestContext, provider: str, subscription_builder_id: str) -> dict[str, Any]:
"""Get a subscription instance for a trigger provider"""
- subscription_builder = TriggerSubscriptionBuilderService.get_subscription_builder_by_id(
- tenant_id=tenant_id,
- user_id=user.id,
+ subscription_builder = application_services().workspaces.trigger_builders.get_subscription_builder_by_id(
+ tenant_id=context.active_workspace_id,
+ user_id=context.account_id,
provider_id=TriggerProviderID(provider),
subscription_builder_id=subscription_builder_id,
)
@@ -308,33 +303,29 @@ class TriggerSubscriptionBuilderGetApi(Resource):
class TriggerSubscriptionBuilderVerifyApi(Resource):
@console_ns.expect(console_ns.models[TriggerSubscriptionBuilderVerifyPayload.__name__])
@console_ns.response(
- 200,
+ HTTPStatus.OK,
"Trigger subscription builder verified successfully",
console_ns.models[TriggerVerificationResponse.__name__],
)
- @setup_required
- @login_required
- @edit_permission_required
- @rbac_permission_required(RBACCheck(RBACPermission.CREDENTIAL_MANAGE, Workspace()))
- @account_initialization_required
- @with_current_user
- @with_current_tenant_id
+ @console_account_admission(
+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}),
+ rbac_checks=[RBACCheck(RBACPermission.CREDENTIAL_MANAGE, Workspace())],
+ )
@model_validate(TriggerSubscriptionBuilderVerifyPayload)
def post(
self,
req_data: TriggerSubscriptionBuilderVerifyPayload,
- tenant_id: str,
- user: Account,
+ context: RequestContext,
provider: str,
subscription_builder_id: str,
- ):
+ ) -> dict[str, Any]:
"""Verify and update a subscription instance for a trigger provider"""
try:
# Use atomic update_and_verify to prevent race conditions
- result = TriggerSubscriptionBuilderService.update_and_verify_builder(
- tenant_id=tenant_id,
- user_id=user.id,
+ result = application_services().workspaces.trigger_builders.update_and_verify_builder(
+ tenant_id=context.active_workspace_id,
+ user_id=context.account_id,
provider_id=TriggerProviderID(provider),
subscription_builder_id=subscription_builder_id,
subscription_builder_updater=SubscriptionBuilderUpdater(
@@ -353,41 +344,41 @@ class TriggerSubscriptionBuilderVerifyApi(Resource):
class TriggerSubscriptionBuilderUpdateApi(Resource):
@console_ns.expect(console_ns.models[TriggerSubscriptionBuilderUpdatePayload.__name__])
@console_ns.response(
- 200,
+ HTTPStatus.OK,
"Trigger subscription builder updated successfully",
console_ns.models[SubscriptionBuilderApiEntity.__name__],
)
- @setup_required
- @login_required
- @edit_permission_required
- @rbac_permission_required(RBACCheck(RBACPermission.CREDENTIAL_MANAGE, Workspace()))
- @account_initialization_required
- @with_current_user
- @with_current_tenant_id
+ @console_account_admission(
+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}),
+ rbac_checks=[RBACCheck(RBACPermission.CREDENTIAL_MANAGE, Workspace())],
+ )
@model_validate(TriggerSubscriptionBuilderUpdatePayload)
def post(
self,
req_data: TriggerSubscriptionBuilderUpdatePayload,
- tenant_id: str,
- user: Account,
+ context: RequestContext,
provider: str,
subscription_builder_id: str,
- ):
+ ) -> dict[str, Any]:
"""Update a subscription instance for a trigger provider"""
try:
- return TriggerSubscriptionBuilderService.update_trigger_subscription_builder(
- tenant_id=tenant_id,
- user_id=user.id,
- provider_id=TriggerProviderID(provider),
- subscription_builder_id=subscription_builder_id,
- subscription_builder_updater=SubscriptionBuilderUpdater(
- name=req_data.name,
- parameters=req_data.parameters,
- properties=req_data.properties,
- credentials=req_data.credentials,
- ),
- ).model_dump(mode="json")
+ return (
+ application_services()
+ .workspaces.trigger_builders.update_trigger_subscription_builder(
+ tenant_id=context.active_workspace_id,
+ user_id=context.account_id,
+ provider_id=TriggerProviderID(provider),
+ subscription_builder_id=subscription_builder_id,
+ subscription_builder_updater=SubscriptionBuilderUpdater(
+ name=req_data.name,
+ parameters=req_data.parameters,
+ properties=req_data.properties,
+ credentials=req_data.credentials,
+ ),
+ )
+ .model_dump(mode="json")
+ )
except Exception as e:
logger.exception("Error updating provider credential", exc_info=e)
raise
@@ -398,24 +389,21 @@ class TriggerSubscriptionBuilderUpdateApi(Resource):
)
class TriggerSubscriptionBuilderLogsApi(Resource):
@console_ns.response(
- 200,
+ HTTPStatus.OK,
"Trigger subscription builder logs retrieved successfully",
console_ns.models[TriggerSubscriptionBuilderLogsResponse.__name__],
)
- @setup_required
- @login_required
- @edit_permission_required
- @rbac_permission_required(RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace()))
- @account_initialization_required
- @with_current_user
- @with_current_tenant_id
- def get(self, tenant_id: str, user: Account, provider: str, subscription_builder_id: str):
+ @console_account_admission(
+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}),
+ rbac_checks=[RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace())],
+ )
+ def get(self, context: RequestContext, provider: str, subscription_builder_id: str) -> dict[str, Any]:
"""Get the request logs for a subscription instance for a trigger provider"""
try:
- logs = TriggerSubscriptionBuilderService.list_logs(
- tenant_id=tenant_id,
- user_id=user.id,
+ logs = application_services().workspaces.trigger_builders.list_logs(
+ tenant_id=context.active_workspace_id,
+ user_id=context.account_id,
provider_id=TriggerProviderID(provider),
subscription_builder_id=subscription_builder_id,
)
@@ -431,30 +419,28 @@ class TriggerSubscriptionBuilderLogsApi(Resource):
class TriggerSubscriptionBuilderBuildApi(Resource):
@console_ns.expect(console_ns.models[TriggerSubscriptionBuilderUpdatePayload.__name__])
@console_ns.response(
- 200, "Trigger subscription builder built successfully", console_ns.models[SimpleResultResponse.__name__]
+ HTTPStatus.OK,
+ "Trigger subscription builder built successfully",
+ console_ns.models[SimpleResultResponse.__name__],
+ )
+ @console_account_admission(
+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}),
+ rbac_checks=[RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace())],
)
- @setup_required
- @login_required
- @edit_permission_required
- @rbac_permission_required(RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace()))
- @account_initialization_required
- @with_current_user
- @with_current_tenant_id
@model_validate(TriggerSubscriptionBuilderUpdatePayload)
def post(
self,
req_data: TriggerSubscriptionBuilderUpdatePayload,
- tenant_id: str,
- user: Account,
+ context: RequestContext,
provider: str,
subscription_builder_id: str,
- ):
+ ) -> dict[str, Any]:
"""Build a subscription instance for a trigger provider"""
try:
# Use atomic update_and_build to prevent race conditions
- TriggerSubscriptionBuilderService.update_and_build_builder(
- tenant_id=tenant_id,
- user_id=user.id,
+ application_services().workspaces.trigger_builders.update_and_build_builder(
+ tenant_id=context.active_workspace_id,
+ user_id=context.account_id,
provider_id=TriggerProviderID(provider),
subscription_builder_id=subscription_builder_id,
subscription_builder_updater=SubscriptionBuilderUpdater(
diff --git a/api/controllers/trigger/trigger.py b/api/controllers/trigger/trigger.py
index 26197d84112..b4acc2e8676 100644
--- a/api/controllers/trigger/trigger.py
+++ b/api/controllers/trigger/trigger.py
@@ -1,12 +1,12 @@
import logging
import re
-from flask import jsonify, request
+from flask import Response, jsonify, request
from controllers.common.access_response import plugin_endpoint_not_found_response
from controllers.trigger import bp
+from extensions.ext_application_services import application_services
from services.trigger.trigger_service import TriggerService
-from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService
logger = logging.getLogger(__name__)
@@ -15,23 +15,19 @@ UUID_MATCHER = re.compile(UUID_PATTERN)
@bp.route("/plugin/<string:endpoint_id>", methods=["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"])
-def trigger_endpoint(endpoint_id: str):
+def trigger_endpoint(endpoint_id: str) -> Response | tuple[Response, int]:
"""
Handle endpoint trigger calls.
"""
# endpoint_id must be UUID
if not UUID_MATCHER.match(endpoint_id):
return plugin_endpoint_not_found_response()
- handling_chain = [
- TriggerService.process_endpoint,
- TriggerSubscriptionBuilderService.process_builder_validation_endpoint,
- ]
- response = None
try:
- for handler in handling_chain:
- response = handler(endpoint_id, request)
- if response:
- break
+ response = TriggerService.process_endpoint(endpoint_id, request)
+ if not response:
+ response = application_services().workspaces.trigger_builders.process_builder_validation_endpoint(
+ endpoint_id, request
+ )
if not response:
logger.info("Endpoint not found for %s", endpoint_id)
return plugin_endpoint_not_found_response()
diff --git a/api/extensions/application_services/workspace.py b/api/extensions/application_services/workspace.py
index 2bacdf8db6e..f3d106d9f73 100644
--- a/api/extensions/application_services/workspace.py
+++ b/api/extensions/application_services/workspace.py
@@ -5,11 +5,13 @@ from dataclasses import dataclass
from sqlalchemy.orm import Session, sessionmaker
from core.plugin.impl.oauth import OAuthHandler
+from core.trigger.trigger_manager import TriggerManager
from extensions.ext_redis import RedisClientWrapper
from repositories.account.repository import SQLAlchemyAccountRepository
from repositories.app.console_repository import ConsoleAppRepository
from repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepository
from repositories.trigger.oauth_client_repository import TriggerOAuthClientRepository
+from repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepository
from repositories.workspace.resource_cleanup_repository import WorkspaceResourceCleanupRepository
from repositories.workspace.workspace_repository import WorkspaceRepository
from services.account.adapters import RedisInvitationTokenStore
@@ -25,6 +27,8 @@ from services.trigger.oauth_service import TriggerOAuthService
from services.trigger.provider_gateway import PluginTriggerProviderQuery
from services.trigger.provider_query import TriggerProviderQuery
from services.trigger.subscription_query_service import TriggerSubscriptionQueryService
+from services.trigger.trigger_provider_service import TriggerProviderService
+from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService
from services.workspace.gateways import (
DeploymentWorkspaceCreationPolicy,
DeploymentWorkspaceFeatureGateway,
@@ -62,6 +66,7 @@ class WorkspaceServices:
resource_cleanup: WorkspaceResourceCleanupService
trigger_providers: TriggerProviderQuery
trigger_subscriptions: TriggerSubscriptionQueryService
+ trigger_builders: TriggerSubscriptionBuilderService
trigger_oauth_clients: TriggerOAuthClientService
trigger_oauth: TriggerOAuthService
@@ -102,6 +107,13 @@ def build_workspace_services(
credentials: CredentialQuery,
) -> WorkspaceServices:
trigger_providers = PluginTriggerProviderQuery()
+ trigger_builders = TriggerSubscriptionBuilderService(
+ builders=RedisTriggerSubscriptionBuilderRepository(redis=redis),
+ get_provider=TriggerManager.get_trigger_provider,
+ subscribe=TriggerManager.subscribe_trigger,
+ # Keep the shared subscription writer until subscription management migrates.
+ create_subscription=TriggerProviderService.add_trigger_subscription,
+ )
trigger_oauth_provider = PluginTriggerOAuthGateway(oauth=OAuthHandler())
trigger_oauth_clients = TriggerOAuthClientService(
clients=TriggerOAuthClientRepository(session_factory=database_client),
@@ -141,11 +153,12 @@ def build_workspace_services(
),
trigger_providers=trigger_providers,
trigger_subscriptions=TriggerSubscriptionQueryService(credentials=credentials, schemas=trigger_providers),
+ trigger_builders=trigger_builders,
trigger_oauth_clients=trigger_oauth_clients,
trigger_oauth=TriggerOAuthService(
clients=trigger_oauth_clients,
providers=trigger_oauth_provider,
contexts=OAuthProxyContextGateway(),
- builders=TriggerOAuthBuilderGateway(),
+ builders=TriggerOAuthBuilderGateway(builders=trigger_builders),
),
)
diff --git a/api/repositories/trigger/subscription_builder_repository.py b/api/repositories/trigger/subscription_builder_repository.py
new file mode 100644
index 00000000000..c1a6a65429b
--- /dev/null
+++ b/api/repositories/trigger/subscription_builder_repository.py
@@ -0,0 +1,64 @@
+"""Redis persistence for temporary trigger subscription builders and validation logs."""
+
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import override
+
+from pydantic import TypeAdapter
+
+from core.trigger.entities.entities import RequestLog, SubscriptionBuilder
+from extensions.ext_redis import RedisClientWrapper
+from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderStore
+
+_request_logs_adapter = TypeAdapter(list[RequestLog])
+_BUILDER_TTL_SECONDS = 30 * 60
+_LOG_TTL_SECONDS = 30 * 60
+_LOCK_TTL_SECONDS = 30
+_LOG_COUNT = 10
+
+
+class RedisTriggerSubscriptionBuilderRepository(TriggerSubscriptionBuilderStore):
+ def __init__(self, *, redis: RedisClientWrapper) -> None:
+ self._redis = redis
+
+ @staticmethod
+ def encode_cache_key(subscription_id: str) -> str:
+ return f"trigger:subscription:builder:{subscription_id}"
+
+ @staticmethod
+ def encode_lock_key(subscription_id: str) -> str:
+ return f"trigger:subscription:builder:lock:{subscription_id}"
+
+ @override
+ def get(self, *, subscription_id: str) -> SubscriptionBuilder | None:
+ value = self._redis.get(self.encode_cache_key(subscription_id))
+ return SubscriptionBuilder.model_validate_json(value) if value else None
+
+ @override
+ def save(self, *, builder: SubscriptionBuilder) -> None:
+ self._redis.setex(self.encode_cache_key(builder.id), _BUILDER_TTL_SECONDS, builder.model_dump_json())
+
+ @override
+ def delete(self, *, subscription_id: str) -> None:
+ self._redis.delete(self.encode_cache_key(subscription_id))
+
+ @override
+ @contextmanager
+ def lock(self, *, subscription_id: str) -> Generator[None]:
+ with self._redis.lock(self.encode_lock_key(subscription_id), timeout=_LOCK_TTL_SECONDS):
+ yield
+
+ @override
+ def list_logs(self, *, endpoint_id: str) -> list[RequestLog]:
+ value = self._redis.get(f"trigger:subscription:builder:logs:{endpoint_id}")
+ return _request_logs_adapter.validate_json(value) if value else []
+
+ @override
+ def append_log(self, *, log: RequestLog) -> None:
+ logs = self.list_logs(endpoint_id=log.endpoint)
+ logs.append(log)
+ self._redis.setex(
+ f"trigger:subscription:builder:logs:{log.endpoint}",
+ _LOG_TTL_SECONDS,
+ _request_logs_adapter.dump_json(logs[-_LOG_COUNT:]),
+ )
diff --git a/api/services/plugin/plugin_parameter_service.py b/api/services/plugin/plugin_parameter_service.py
index d34c65ff714..b43f5bfea3d 100644
--- a/api/services/plugin/plugin_parameter_service.py
+++ b/api/services/plugin/plugin_parameter_service.py
@@ -16,7 +16,7 @@ from extensions.ext_database import db
from models.provider_ids import TriggerProviderID
from models.tools import BuiltinToolProvider
from services.trigger.trigger_provider_service import TriggerProviderService
-from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService
+from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderQuery
class PluginParameterService:
@@ -30,6 +30,8 @@ class PluginParameterService:
parameter: str,
credential_id: str | None,
provider_type: Literal["tool", "trigger"],
+ *,
+ builders: TriggerSubscriptionBuilderQuery,
) -> Sequence[PluginParameterOption]:
"""
Get dynamic select options for a plugin parameter.
@@ -90,7 +92,7 @@ class PluginParameterService:
case "trigger":
subscription: TriggerProviderSubscriptionApiEntity | SubscriptionBuilder | None
if credential_id:
- subscription = TriggerSubscriptionBuilderService.get_subscription_builder(
+ subscription = builders.get_subscription_builder(
tenant_id=tenant_id,
user_id=user_id,
provider_id=TriggerProviderID(provider_name),
diff --git a/api/services/trigger/oauth_gateway.py b/api/services/trigger/oauth_gateway.py
index 62e9a90c90f..becd53b84d0 100644
--- a/api/services/trigger/oauth_gateway.py
+++ b/api/services/trigger/oauth_gateway.py
@@ -126,14 +126,13 @@ class OAuthProxyContextGateway:
class TriggerOAuthBuilderGateway:
- """Keep builder locking, ownership and masking with its existing owner.
+ """Adapt OAuth credentials to the shared subscription builder lifecycle."""
- TODO: Inject the shared builder application service when the remaining
- subscription builder endpoints are migrated.
- """
+ def __init__(self, *, builders: TriggerSubscriptionBuilderService) -> None:
+ self._builders = builders
def create(self, *, tenant_id: str, user_id: str, provider_id: TriggerProviderID) -> SubscriptionBuilderApiEntity:
- return TriggerSubscriptionBuilderService.create_trigger_subscription_builder(
+ return self._builders.create_trigger_subscription_builder(
tenant_id=tenant_id,
user_id=user_id,
provider_id=provider_id,
@@ -148,7 +147,7 @@ class TriggerOAuthBuilderGateway:
credentials: Mapping[str, object],
expires_at: int,
) -> None:
- TriggerSubscriptionBuilderService.update_trigger_subscription_builder(
+ self._builders.update_trigger_subscription_builder(
tenant_id=context.tenant_id,
user_id=context.user_id,
provider_id=provider_id,
diff --git a/api/services/trigger/trigger_subscription_builder_service.py b/api/services/trigger/trigger_subscription_builder_service.py
index d8c58776af2..21246765146 100644
--- a/api/services/trigger/trigger_subscription_builder_service.py
+++ b/api/services/trigger/trigger_subscription_builder_service.py
@@ -1,12 +1,11 @@
import logging
import uuid
from collections.abc import Mapping
-from contextlib import contextmanager
+from contextlib import AbstractContextManager
from datetime import datetime
-from typing import Any
+from typing import Any, Protocol
from flask import Request, Response
-from pydantic import TypeAdapter
from core.plugin.entities.plugin_daemon import CredentialType
from core.plugin.entities.request import TriggerDispatchResponse
@@ -20,62 +19,97 @@ from core.trigger.entities.entities import (
SubscriptionConstructor,
)
from core.trigger.provider import PluginTriggerProviderController
-from core.trigger.trigger_manager import TriggerManager
from core.trigger.utils.encryption import masked_credentials
from core.trigger.utils.endpoint import generate_plugin_trigger_endpoint_url
-from extensions.ext_redis import redis_client
from models.provider_ids import TriggerProviderID
-from services.trigger.trigger_provider_service import TriggerProviderService
logger = logging.getLogger(__name__)
-_request_logs_adapter: TypeAdapter[list[RequestLog]] = TypeAdapter(list[RequestLog])
+class TriggerSubscriptionBuilderStore(Protocol):
+ """Persist temporary builders and validation logs without owning their policies."""
-class TriggerSubscriptionBuilderService:
- """Service for managing trigger providers and credentials"""
+ def get(self, *, subscription_id: str) -> SubscriptionBuilder | None: ...
- ##########################
- # Trigger provider
- ##########################
- __MAX_TRIGGER_PROVIDER_COUNT__ = 10
+ def save(self, *, builder: SubscriptionBuilder) -> None: ...
- ##########################
- # Builder endpoint
- ##########################
- __BUILDER_CACHE_EXPIRE_SECONDS__ = 30 * 60
+ def delete(self, *, subscription_id: str) -> None: ...
- __VALIDATION_REQUEST_CACHE_COUNT__ = 10
- __VALIDATION_REQUEST_CACHE_EXPIRE_SECONDS__ = 30 * 60
+ def lock(self, *, subscription_id: str) -> AbstractContextManager[None]: ...
- ##########################
- # Distributed lock
- ##########################
- __LOCK_EXPIRE_SECONDS__ = 30
+ def list_logs(self, *, endpoint_id: str) -> list[RequestLog]: ...
- @classmethod
- def encode_cache_key(cls, subscription_id: str) -> str:
- return f"trigger:subscription:builder:{subscription_id}"
+ def append_log(self, *, log: RequestLog) -> None: ...
- @classmethod
- def encode_lock_key(cls, subscription_id: str) -> str:
- return f"trigger:subscription:builder:lock:{subscription_id}"
- @classmethod
- @contextmanager
- def acquire_builder_lock(cls, subscription_id: str):
- """
- Acquire a distributed lock for a subscription builder.
+class TriggerSubscriptionBuilderQuery(Protocol):
+ def get_subscription_builder(
+ self,
+ *,
+ tenant_id: str,
+ user_id: str,
+ provider_id: TriggerProviderID,
+ subscription_builder_id: str,
+ ) -> SubscriptionBuilder | None:
+ """Return the owned builder, or None if its temporary capability expired."""
+ ...
+
+
+class TriggerSubscriptionProviderLookup(Protocol):
+ def __call__(self, *, tenant_id: str, provider_id: TriggerProviderID) -> PluginTriggerProviderController: ...
+
+
+class TriggerSubscriber(Protocol):
+ def __call__(
+ self,
+ *,
+ tenant_id: str,
+ user_id: str,
+ provider_id: TriggerProviderID,
+ endpoint: str,
+ parameters: Mapping[str, Any],
+ credentials: Mapping[str, str],
+ credential_type: CredentialType,
+ ) -> Subscription: ...
+
+
+class TriggerSubscriptionWriter(Protocol):
+ def __call__(
+ self,
+ *,
+ tenant_id: str,
+ user_id: str,
+ name: str,
+ provider_id: TriggerProviderID,
+ endpoint_id: str,
+ credential_type: CredentialType,
+ parameters: Mapping[str, Any],
+ properties: Mapping[str, Any],
+ credentials: Mapping[str, str],
+ subscription_id: str,
+ credential_expires_at: int,
+ expires_at: int,
+ ) -> Mapping[str, Any]: ...
- :param subscription_id: The subscription builder ID
- """
- lock_key = cls.encode_lock_key(subscription_id)
- with redis_client.lock(lock_key, timeout=cls.__LOCK_EXPIRE_SECONDS__):
- yield
- @classmethod
+class TriggerSubscriptionBuilderService:
+ """Manage temporary subscription ownership, updates and provider verification."""
+
+ def __init__(
+ self,
+ *,
+ builders: TriggerSubscriptionBuilderStore,
+ get_provider: TriggerSubscriptionProviderLookup,
+ subscribe: TriggerSubscriber,
+ create_subscription: TriggerSubscriptionWriter,
+ ) -> None:
+ self._builders = builders
+ self._get_provider = get_provider
+ self._subscribe = subscribe
+ self._create_subscription = create_subscription
+
def create_trigger_subscription_builder(
- cls,
+ self,
tenant_id: str,
user_id: str,
provider_id: TriggerProviderID,
@@ -84,7 +118,7 @@ class TriggerSubscriptionBuilderService:
"""
Add a new trigger subscription validation.
"""
- provider_controller = TriggerManager.get_trigger_provider(tenant_id, provider_id)
+ provider_controller = self._get_provider(tenant_id=tenant_id, provider_id=provider_id)
if not provider_controller:
raise ValueError(f"Provider {provider_id} not found")
@@ -104,13 +138,11 @@ class TriggerSubscriptionBuilderService:
credential_expires_at=-1,
expires_at=-1,
)
- cache_key = cls.encode_cache_key(subscription_id)
- redis_client.setex(cache_key, cls.__BUILDER_CACHE_EXPIRE_SECONDS__, subscription_builder.model_dump_json())
- return cls.builder_to_api_entity(controller=provider_controller, entity=subscription_builder)
+ self._builders.save(builder=subscription_builder)
+ return self.builder_to_api_entity(controller=provider_controller, entity=subscription_builder)
- @classmethod
def update_trigger_subscription_builder(
- cls,
+ self,
tenant_id: str,
user_id: str,
provider_id: TriggerProviderID,
@@ -121,14 +153,13 @@ class TriggerSubscriptionBuilderService:
Update a trigger subscription validation.
"""
subscription_id = subscription_builder_id
- provider_controller = TriggerManager.get_trigger_provider(tenant_id, provider_id)
+ provider_controller = self._get_provider(tenant_id=tenant_id, provider_id=provider_id)
if not provider_controller:
raise ValueError(f"Provider {provider_id} not found")
# Acquire lock to prevent concurrent updates
- with cls.acquire_builder_lock(subscription_id):
- cache_key = cls.encode_cache_key(subscription_id)
- subscription_builder_cache = cls._require_owned_subscription_builder(
+ with self._builders.lock(subscription_id=subscription_id):
+ subscription_builder_cache = self._require_owned_subscription_builder(
tenant_id=tenant_id,
user_id=user_id,
provider_id=provider_id,
@@ -137,33 +168,29 @@ class TriggerSubscriptionBuilderService:
subscription_builder_updater.update(subscription_builder_cache)
- redis_client.setex(
- cache_key, cls.__BUILDER_CACHE_EXPIRE_SECONDS__, subscription_builder_cache.model_dump_json()
- )
- return cls.builder_to_api_entity(controller=provider_controller, entity=subscription_builder_cache)
+ self._builders.save(builder=subscription_builder_cache)
+ return self.builder_to_api_entity(controller=provider_controller, entity=subscription_builder_cache)
- @classmethod
def update_and_verify_builder(
- cls,
+ self,
tenant_id: str,
user_id: str,
provider_id: TriggerProviderID,
subscription_builder_id: str,
subscription_builder_updater: SubscriptionBuilderUpdater,
- ) -> Mapping[str, Any]:
+ ) -> Mapping[str, bool]:
"""
Atomically update and verify a subscription builder.
This ensures the verification is done on the exact data that was just updated.
"""
subscription_id = subscription_builder_id
- provider_controller = TriggerManager.get_trigger_provider(tenant_id, provider_id)
+ provider_controller = self._get_provider(tenant_id=tenant_id, provider_id=provider_id)
if not provider_controller:
raise ValueError(f"Provider {provider_id} not found")
# Acquire lock for the entire update + verify operation
- with cls.acquire_builder_lock(subscription_id):
- cache_key = cls.encode_cache_key(subscription_id)
- subscription_builder_cache = cls._require_owned_subscription_builder(
+ with self._builders.lock(subscription_id=subscription_id):
+ subscription_builder_cache = self._require_owned_subscription_builder(
tenant_id=tenant_id,
user_id=user_id,
provider_id=provider_id,
@@ -172,9 +199,7 @@ class TriggerSubscriptionBuilderService:
# Update
subscription_builder_updater.update(subscription_builder_cache)
- redis_client.setex(
- cache_key, cls.__BUILDER_CACHE_EXPIRE_SECONDS__, subscription_builder_cache.model_dump_json()
- )
+ self._builders.save(builder=subscription_builder_cache)
# Verify (using the just-updated data)
if subscription_builder_cache.credential_type == CredentialType.OAUTH2:
@@ -190,9 +215,8 @@ class TriggerSubscriptionBuilderService:
return {"verified": True}
- @classmethod
def update_and_build_builder(
- cls,
+ self,
tenant_id: str,
user_id: str,
provider_id: TriggerProviderID,
@@ -204,14 +228,13 @@ class TriggerSubscriptionBuilderService:
This ensures the build uses the exact data that was just updated.
"""
subscription_id = subscription_builder_id
- provider_controller = TriggerManager.get_trigger_provider(tenant_id, provider_id)
+ provider_controller = self._get_provider(tenant_id=tenant_id, provider_id=provider_id)
if not provider_controller:
raise ValueError(f"Provider {provider_id} not found")
# Acquire lock for the entire update + build operation
- with cls.acquire_builder_lock(subscription_id):
- cache_key = cls.encode_cache_key(subscription_id)
- subscription_builder = cls._require_owned_subscription_builder(
+ with self._builders.lock(subscription_id=subscription_id):
+ subscription_builder = self._require_owned_subscription_builder(
tenant_id=tenant_id,
user_id=user_id,
provider_id=provider_id,
@@ -220,7 +243,7 @@ class TriggerSubscriptionBuilderService:
# Update
subscription_builder_updater.update(subscription_builder)
- redis_client.setex(cache_key, cls.__BUILDER_CACHE_EXPIRE_SECONDS__, subscription_builder.model_dump_json())
+ self._builders.save(builder=subscription_builder)
if not subscription_builder.name:
raise ValueError("Subscription builder name is required")
@@ -229,7 +252,7 @@ class TriggerSubscriptionBuilderService:
credential_type = CredentialType.of(subscription_builder.credential_type or CredentialType.UNAUTHORIZED)
if credential_type == CredentialType.UNAUTHORIZED:
# manually create
- TriggerProviderService.add_trigger_subscription(
+ self._create_subscription(
subscription_id=subscription_builder.id,
tenant_id=tenant_id,
user_id=user_id,
@@ -245,7 +268,7 @@ class TriggerSubscriptionBuilderService:
)
else:
# automatically create
- subscription: Subscription = TriggerManager.subscribe_trigger(
+ subscription: Subscription = self._subscribe(
tenant_id=tenant_id,
user_id=user_id,
provider_id=provider_id,
@@ -255,7 +278,7 @@ class TriggerSubscriptionBuilderService:
credential_type=credential_type,
)
- TriggerProviderService.add_trigger_subscription(
+ self._create_subscription(
subscription_id=subscription_builder.id,
tenant_id=tenant_id,
user_id=user_id,
@@ -275,11 +298,11 @@ class TriggerSubscriptionBuilderService:
)
# Delete the builder after successful subscription creation
- redis_client.delete(cache_key)
+ self._builders.delete(subscription_id=subscription_id)
- @classmethod
+ @staticmethod
def builder_to_api_entity(
- cls, controller: PluginTriggerProviderController, entity: SubscriptionBuilder
+ controller: PluginTriggerProviderController, entity: SubscriptionBuilder
) -> SubscriptionBuilderApiEntity:
credential_type = CredentialType.of(entity.credential_type or CredentialType.UNAUTHORIZED.value)
return SubscriptionBuilderApiEntity(
@@ -298,28 +321,23 @@ class TriggerSubscriptionBuilderService:
else {},
)
- @classmethod
- def _get_subscription_builder_by_endpoint_id(cls, endpoint_id: str) -> SubscriptionBuilder | None:
+ def _get_subscription_builder_by_endpoint_id(self, endpoint_id: str) -> SubscriptionBuilder | None:
"""Resolve the public validation capability without authenticated owner context."""
- cache_key = cls.encode_cache_key(endpoint_id)
- subscription_cache = redis_client.get(cache_key)
- if subscription_cache:
- subscription_builder = SubscriptionBuilder.model_validate_json(subscription_cache)
- if subscription_builder.endpoint_id == endpoint_id:
- return subscription_builder
+ subscription_builder = self._builders.get(subscription_id=endpoint_id)
+ if subscription_builder is not None and subscription_builder.endpoint_id == endpoint_id:
+ return subscription_builder
return None
- @classmethod
def get_subscription_builder(
- cls,
+ self,
tenant_id: str,
user_id: str,
provider_id: TriggerProviderID,
subscription_builder_id: str,
) -> SubscriptionBuilder | None:
"""Return an owned temporary builder, or None when no temporary builder exists."""
- subscription_builder = cls._get_subscription_builder_by_endpoint_id(subscription_builder_id)
+ subscription_builder = self._get_subscription_builder_by_endpoint_id(subscription_builder_id)
if subscription_builder is None:
return None
if (
@@ -331,16 +349,15 @@ class TriggerSubscriptionBuilderService:
raise ValueError(f"Subscription builder {subscription_builder_id} not found")
return subscription_builder
- @classmethod
def _require_owned_subscription_builder(
- cls,
+ self,
tenant_id: str,
user_id: str,
provider_id: TriggerProviderID,
subscription_builder_id: str,
) -> SubscriptionBuilder:
"""Return an owned temporary builder or reject an absent capability."""
- subscription_builder = cls.get_subscription_builder(
+ subscription_builder = self.get_subscription_builder(
tenant_id=tenant_id,
user_id=user_id,
provider_id=provider_id,
@@ -350,9 +367,8 @@ class TriggerSubscriptionBuilderService:
raise ValueError(f"Subscription builder {subscription_builder_id} not found")
return subscription_builder
- @classmethod
- def append_log(cls, endpoint_id: str, request: Request, response: Response) -> None:
- """Append validation request log to Redis."""
+ def append_log(self, endpoint_id: str, request: Request, response: Response) -> None:
+ """Record the validation request and its response."""
log = RequestLog(
id=str(uuid.uuid4()),
endpoint=endpoint_id,
@@ -370,42 +386,26 @@ class TriggerSubscriptionBuilderService:
created_at=datetime.now(),
)
- key = f"trigger:subscription:builder:logs:{endpoint_id}"
- logs = _request_logs_adapter.validate_json(redis_client.get(key) or b"[]")
- logs.append(log)
-
- # Keep last N logs
- logs = logs[-cls.__VALIDATION_REQUEST_CACHE_COUNT__ :]
- redis_client.setex(
- key,
- cls.__VALIDATION_REQUEST_CACHE_EXPIRE_SECONDS__,
- _request_logs_adapter.dump_json(logs),
- )
+ self._builders.append_log(log=log)
- @classmethod
def list_logs(
- cls,
+ self,
tenant_id: str,
user_id: str,
provider_id: TriggerProviderID,
subscription_builder_id: str,
) -> list[RequestLog]:
"""List request logs for validation endpoint."""
- subscription_builder = cls._require_owned_subscription_builder(
+ subscription_builder = self._require_owned_subscription_builder(
tenant_id=tenant_id,
user_id=user_id,
provider_id=provider_id,
subscription_builder_id=subscription_builder_id,
)
- key = f"trigger:subscription:builder:logs:{subscription_builder.endpoint_id}"
- logs_json = redis_client.get(key)
- if not logs_json:
- return []
- return _request_logs_adapter.validate_json(logs_json)
+ return self._builders.list_logs(endpoint_id=subscription_builder.endpoint_id)
- @classmethod
- def process_builder_validation_endpoint(cls, endpoint_id: str, request: Request) -> Response | None:
+ def process_builder_validation_endpoint(self, endpoint_id: str, request: Request) -> Response | None:
"""
Process a temporary endpoint request.
@@ -414,13 +414,13 @@ class TriggerSubscriptionBuilderService:
:return: The Flask response object
"""
# check if validation endpoint exists
- subscription_builder: SubscriptionBuilder | None = cls._get_subscription_builder_by_endpoint_id(endpoint_id)
+ subscription_builder: SubscriptionBuilder | None = self._get_subscription_builder_by_endpoint_id(endpoint_id)
if not subscription_builder:
return None
try:
# response to validation endpoint
- controller: PluginTriggerProviderController = TriggerManager.get_trigger_provider(
+ controller: PluginTriggerProviderController = self._get_provider(
tenant_id=subscription_builder.tenant_id,
provider_id=TriggerProviderID(subscription_builder.provider_id),
)
@@ -432,7 +432,7 @@ class TriggerSubscriptionBuilderService:
)
response: Response = dispatch_response.response
# append the request log
- cls.append_log(
+ self.append_log(
endpoint_id=endpoint_id,
request=request,
response=response,
@@ -441,25 +441,24 @@ class TriggerSubscriptionBuilderService:
except Exception:
logger.exception("Error during validation endpoint dispatch for endpoint_id=%s", endpoint_id)
error_response = Response(status=500, response="An internal error has occurred.")
- cls.append_log(endpoint_id=endpoint_id, request=request, response=error_response)
+ self.append_log(endpoint_id=endpoint_id, request=request, response=error_response)
return error_response
- @classmethod
def get_subscription_builder_by_id(
- cls,
+ self,
tenant_id: str,
user_id: str,
provider_id: TriggerProviderID,
subscription_builder_id: str,
) -> SubscriptionBuilderApiEntity:
"""Get a trigger subscription builder API entity."""
- subscription_builder = cls._require_owned_subscription_builder(
+ subscription_builder = self._require_owned_subscription_builder(
tenant_id=tenant_id,
user_id=user_id,
provider_id=provider_id,
subscription_builder_id=subscription_builder_id,
)
- return cls.builder_to_api_entity(
- controller=TriggerManager.get_trigger_provider(tenant_id, provider_id),
+ return self.builder_to_api_entity(
+ controller=self._get_provider(tenant_id=tenant_id, provider_id=provider_id),
entity=subscription_builder,
)
diff --git a/api/tests/e2e_tests/containers/services/test_trigger_builder_callers.py b/api/tests/e2e_tests/containers/services/test_trigger_builder_callers.py
new file mode 100644
index 00000000000..9f0b8c6fd4c
--- /dev/null
+++ b/api/tests/e2e_tests/containers/services/test_trigger_builder_callers.py
@@ -0,0 +1,336 @@
+"""Builder compatibility callers use real Redis, SQL, Flask and plugin HTTP transport."""
+
+import logging
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+from http import HTTPStatus
+from threading import Lock
+from uuid import uuid4
+
+import pytest
+from flask import Flask
+
+import contexts
+from controllers.trigger.trigger import trigger_endpoint
+from core.plugin.entities.plugin_daemon import CredentialType
+from core.trigger.entities.entities import SubscriptionBuilderUpdater
+from extensions.ext_application_services import application_services
+from extensions.ext_redis import RedisClientWrapper, redis_client
+from models.provider_ids import TriggerProviderID
+from models.trigger import TriggerSubscription
+from repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepository
+from services.plugin.plugin_parameter_service import PluginParameterService
+from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService
+from tests.e2e_tests.containers.services import test_trigger_subscription_query
+from tests.unit_tests.controllers.console.workspace import test_trigger_subscription_builder
+from tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _PROVIDER, _Harness
+from tests.unit_tests.controllers.console.workspace.test_trigger_subscription_builder import _Daemon
+
+sqlite_engine = test_trigger_subscription_query.sqlite_engine
+sqlite_session_factory = test_trigger_subscription_query.sqlite_session_factory
+harness = test_trigger_subscription_builder.harness
+daemon = test_trigger_subscription_builder.daemon
+_PROVIDER_ID = TriggerProviderID(_PROVIDER)
+
+
+def application_redis(flask_app_with_containers: Flask) -> RedisClientWrapper:
+ assert redis_client is flask_app_with_containers.extensions["redis"]
+ return redis_client
+
+
+@dataclass
+class _Runtime:
+ builders: TriggerSubscriptionBuilderService
+ ids: set[str] = field(default_factory=set)
+
+ def key(self, builder_id: str) -> str:
+ self.ids.add(builder_id)
+ return RedisTriggerSubscriptionBuilderRepository.encode_cache_key(builder_id)
+
+ def create(self, harness: _Harness) -> str:
+ builder = self.builders.create_trigger_subscription_builder(
+ tenant_id=harness.tenant_id,
+ user_id=harness.account_id,
+ provider_id=_PROVIDER_ID,
+ credential_type=CredentialType.API_KEY,
+ )
+ self.ids.add(builder.id)
+ return builder.id
+
+
+def runtime(harness: _Harness) -> Iterator[_Runtime]:
+ harness.app.add_url_rule(
+ "/triggers/plugin/<string:endpoint_id>", view_func=trigger_endpoint, methods=["GET", "POST"]
+ )
+ previous_providers = contexts.plugin_trigger_providers.get({})
+ previous_lock = contexts.plugin_trigger_providers_lock.get(Lock())
+ contexts.plugin_trigger_providers.set({})
+ contexts.plugin_trigger_providers_lock.set(Lock())
+ with harness.app.app_context():
+ runtime = _Runtime(application_services().workspaces.trigger_builders)
+ try:
+ yield runtime
+ finally:
+ for builder_id in runtime.ids:
+ redis_client.delete(
+ RedisTriggerSubscriptionBuilderRepository.encode_cache_key(builder_id),
+ RedisTriggerSubscriptionBuilderRepository.encode_lock_key(builder_id),
+ f"trigger:subscription:builder:logs:{builder_id}",
+ )
+ contexts.plugin_trigger_providers.set(previous_providers)
+ contexts.plugin_trigger_providers_lock.set(previous_lock)
+
+
+def _persist_subscription(
+ harness: _Harness, *, subscription_id: str, tenant_id: str, provider_id: str, credentials: dict[str, str]
+) -> None:
+ with harness.session_factory.begin() as session:
+ subscription = TriggerSubscription(
+ name=f"subscription-{subscription_id}",
+ tenant_id=tenant_id,
+ user_id=harness.account_id,
+ provider_id=provider_id,
+ endpoint_id=subscription_id,
+ parameters={},
+ properties={},
+ credentials=credentials,
+ credential_type=CredentialType.API_KEY,
+ )
+ subscription.id = subscription_id
+ session.add(subscription)
+
+
+def _options_response(daemon: _Daemon) -> None:
+ daemon.response_data = {"options": [{"value": "main", "label": {"en_US": "Main branch"}}]}
+
+
+def test_dynamic_select_uses_owned_builder_credentials_and_package(
+ harness: _Harness, runtime: _Runtime, daemon: _Daemon
+) -> None:
+ builder_id = runtime.create(harness)
+ runtime.builders.update_trigger_subscription_builder(
+ tenant_id=harness.tenant_id,
+ user_id=harness.account_id,
+ provider_id=_PROVIDER_ID,
+ subscription_builder_id=builder_id,
+ subscription_builder_updater=SubscriptionBuilderUpdater(credentials={"token": "draft-token"}),
+ )
+ _options_response(daemon)
+ daemon.requests.clear()
+
+ options = PluginParameterService.get_dynamic_select_options(
+ tenant_id=harness.tenant_id,
+ user_id=harness.account_id,
+ plugin_id=_PROVIDER_ID.plugin_id,
+ provider=_PROVIDER_ID.provider_name,
+ action="push",
+ parameter="branch",
+ credential_id=builder_id,
+ provider_type="trigger",
+ builders=runtime.builders,
+ )
+
+ assert [(option.value, option.label.en_US) for option in options] == [("main", "Main branch")]
+ assert len(daemon.requests) == 1
+ sent = daemon.requests[0]
+ assert sent.path == f"/plugin/{harness.tenant_id}/dispatch/dynamic_select/fetch_parameter_options"
+ assert sent.headers["X-Plugin-ID"] == _PROVIDER_ID.plugin_id
+ assert sent.headers["X-Plugin-Unique-Identifier"] == daemon.provider["plugin_unique_identifier"]
+ assert sent.payload == {
+ "user_id": harness.account_id,
+ "data": {
+ "provider": _PROVIDER_ID.provider_name,
+ "credentials": {"token": "draft-token"},
+ "credential_type": CredentialType.API_KEY,
+ "provider_action": "push",
+ "parameter": "branch",
+ },
+ }
+
+
[email protected]("mismatch", ["tenant", "user", "provider"])
+def test_dynamic_select_rejects_builder_owner_mismatch_before_persisted_fallback(
+ harness: _Harness, runtime: _Runtime, daemon: _Daemon, mismatch: str
+) -> None:
+ builder_id = runtime.create(harness)
+ tenant_id = str(uuid4()) if mismatch == "tenant" else harness.tenant_id
+ user_id = str(uuid4()) if mismatch == "user" else harness.account_id
+ provider_id = TriggerProviderID("langgenius/github/other") if mismatch == "provider" else _PROVIDER_ID
+ # A fallback with this ID would succeed, so a rejection proves that an owned
+ # builder mismatch is not treated as an expired temporary capability.
+ _persist_subscription(
+ harness,
+ subscription_id=builder_id,
+ tenant_id=tenant_id,
+ provider_id=str(provider_id),
+ credentials={"token": "persisted-token"},
+ )
+ daemon.requests.clear()
+
+ with pytest.raises(ValueError, match="not found"):
+ PluginParameterService.get_dynamic_select_options(
+ tenant_id=tenant_id,
+ user_id=user_id,
+ plugin_id=provider_id.plugin_id,
+ provider=provider_id.provider_name,
+ action="push",
+ parameter="branch",
+ credential_id=builder_id,
+ provider_type="trigger",
+ builders=runtime.builders,
+ )
+
+ assert daemon.requests == []
+
+
+def test_dynamic_select_uses_persisted_subscription_after_builder_expires(
+ harness: _Harness, runtime: _Runtime, daemon: _Daemon
+) -> None:
+ subscription_id = str(uuid4())
+ _persist_subscription(
+ harness,
+ subscription_id=subscription_id,
+ tenant_id=harness.tenant_id,
+ provider_id=_PROVIDER,
+ credentials={"token": "persisted-token"},
+ )
+ _options_response(daemon)
+
+ options = PluginParameterService.get_dynamic_select_options(
+ tenant_id=harness.tenant_id,
+ user_id=harness.account_id,
+ plugin_id=_PROVIDER_ID.plugin_id,
+ provider=_PROVIDER_ID.provider_name,
+ action="push",
+ parameter="branch",
+ credential_id=subscription_id,
+ provider_type="trigger",
+ builders=runtime.builders,
+ )
+
+ assert [option.value for option in options] == ["main"]
+ sent = [request for request in daemon.requests if request.method == "POST"]
+ assert len(sent) == 1
+ assert sent[0].payload["data"] == {
+ "provider": _PROVIDER_ID.provider_name,
+ "credentials": {"token": "persisted-token"},
+ "credential_type": CredentialType.API_KEY,
+ "provider_action": "push",
+ "parameter": "branch",
+ }
+
+
+def test_dynamic_select_rejects_missing_builder_and_subscription(
+ harness: _Harness, runtime: _Runtime, daemon: _Daemon
+) -> None:
+ with pytest.raises(ValueError, match="not found"):
+ PluginParameterService.get_dynamic_select_options(
+ tenant_id=harness.tenant_id,
+ user_id=harness.account_id,
+ plugin_id=_PROVIDER_ID.plugin_id,
+ provider=_PROVIDER_ID.provider_name,
+ action="push",
+ parameter="branch",
+ credential_id=str(uuid4()),
+ provider_type="trigger",
+ builders=runtime.builders,
+ )
+
+ assert daemon.requests == []
+
+
+def _dispatch_response(daemon: _Daemon) -> None:
+ raw_response = b"HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 8\r\n\r\naccepted"
+ daemon.response_data = {"user_id": "plugin-user", "events": [], "response": raw_response.hex(), "payload": {}}
+
+
+def test_public_callback_missing_capability_keeps_its_json_contract(harness: _Harness, daemon: _Daemon) -> None:
+ response = harness.client.post(f"/triggers/plugin/{uuid4()}", json={})
+
+ assert response.status_code == HTTPStatus.NOT_FOUND
+ assert response.data == b'{"error":"Endpoint not found"}'
+ assert response.mimetype == "application/json"
+ assert response.headers["Cache-Control"] == "no-store"
+ assert daemon.requests == []
+
+
+def test_public_callback_uses_builder_without_account_admission_and_records_log(
+ harness: _Harness, runtime: _Runtime, daemon: _Daemon
+) -> None:
+ builder_id = runtime.create(harness)
+ _dispatch_response(daemon)
+ daemon.requests.clear()
+
+ response = harness.client.post(f"/triggers/plugin/{builder_id}", data="validation-request")
+
+ assert response.status_code == HTTPStatus.OK
+ assert response.data == b"accepted"
+ assert response.mimetype == "text/plain"
+ assert len(daemon.requests) == 1
+ assert daemon.requests[0].path == f"/plugin/{harness.tenant_id}/dispatch/trigger/dispatch_event"
+ logs = runtime.builders.list_logs(
+ tenant_id=harness.tenant_id,
+ user_id=harness.account_id,
+ provider_id=_PROVIDER_ID,
+ subscription_builder_id=builder_id,
+ )
+ assert len(logs) == 1
+ assert logs[0].endpoint == builder_id
+ assert logs[0].request["data"] == "validation-request"
+ assert logs[0].response["data"] == "accepted"
+ assert logs[0].response["status_code"] == HTTPStatus.OK
+
+
+def test_public_callback_handles_persisted_subscription_before_builder_fallback(
+ harness: _Harness, runtime: _Runtime, daemon: _Daemon
+) -> None:
+ subscription_id = str(uuid4())
+ _persist_subscription(
+ harness,
+ subscription_id=subscription_id,
+ tenant_id=harness.tenant_id,
+ provider_id=_PROVIDER,
+ credentials={},
+ )
+ # Accessing this invalid Redis value would fail if the builder fallback ran.
+ redis_client.hset(runtime.key(subscription_id), "invalid", "not-a-string")
+ _dispatch_response(daemon)
+
+ response = harness.client.post(f"/triggers/plugin/{subscription_id}", json={})
+
+ assert response.status_code == HTTPStatus.OK
+ assert response.data == b"accepted"
+ assert redis_client.hgetall(runtime.key(subscription_id)) == {b"invalid": b"not-a-string"}
+
+
+def test_public_callback_invalid_builder_data_is_a_bad_request(
+ harness: _Harness, runtime: _Runtime, daemon: _Daemon
+) -> None:
+ builder_id = str(uuid4())
+ redis_client.set(runtime.key(builder_id), "invalid-json")
+
+ response = harness.client.post(f"/triggers/plugin/{builder_id}", json={})
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ assert response.get_json()["error"] == "Endpoint processing failed"
+ assert "Invalid JSON" in response.get_json()["message"]
+ assert daemon.requests == []
+
+
+def test_public_callback_unexpected_redis_error_is_logged_without_exposing_details(
+ harness: _Harness, runtime: _Runtime, daemon: _Daemon, caplog: pytest.LogCaptureFixture
+) -> None:
+ builder_id = str(uuid4())
+ redis_client.hset(runtime.key(builder_id), "invalid", "not-a-string")
+
+ with caplog.at_level(logging.ERROR, logger="controllers.trigger.trigger"):
+ response = harness.client.post(f"/triggers/plugin/{builder_id}", json={})
+
+ assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
+ assert response.get_json() == {"error": "Internal server error"}
+ assert builder_id in caplog.text
+ assert "WRONGTYPE" in caplog.text
+ assert daemon.requests == []
diff --git a/api/tests/e2e_tests/containers/services/test_trigger_oauth_gateway.py b/api/tests/e2e_tests/containers/services/test_trigger_oauth_gateway.py
index 93e4022e4bd..939046f0260 100644
--- a/api/tests/e2e_tests/containers/services/test_trigger_oauth_gateway.py
+++ b/api/tests/e2e_tests/containers/services/test_trigger_oauth_gateway.py
@@ -24,12 +24,13 @@ from core.trigger.entities.entities import (
TriggerProviderIdentity,
)
from core.trigger.provider import PluginTriggerProviderController
+from extensions.ext_application_services import application_services
from extensions.ext_redis import redis_client
from models.provider_ids import TriggerProviderID
+from repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepository
from services.plugin.oauth_service import OAuthProxyService
from services.trigger.oauth_gateway import OAuthProxyContextGateway, TriggerOAuthBuilderGateway
from services.trigger.oauth_service import TriggerOAuthContext, TriggerOAuthContextError
-from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService
_PROVIDER_ID = TriggerProviderID("langgenius/github/github")
_PLUGIN_IDENTIFIER = "langgenius/github:0.1.0@package-hash"
@@ -97,6 +98,7 @@ def test_existing_context_is_consumed_once_by_new_callback(flask_app_with_contai
class _CreatedBuilder:
context: TriggerOAuthContext
response: SubscriptionBuilderApiEntity
+ gateway: TriggerOAuthBuilderGateway
def _provider(tenant_id: str, provider_id: TriggerProviderID) -> PluginTriggerProviderController:
@@ -137,9 +139,8 @@ def created_builder(flask_app_with_containers: Flask) -> Iterator[_CreatedBuilde
contexts.plugin_trigger_providers_lock.set(Lock())
try:
with flask_app_with_containers.app_context():
- response = TriggerOAuthBuilderGateway().create(
- tenant_id=tenant_id, user_id=user_id, provider_id=_PROVIDER_ID
- )
+ gateway = TriggerOAuthBuilderGateway(builders=application_services().workspaces.trigger_builders)
+ response = gateway.create(tenant_id=tenant_id, user_id=user_id, provider_id=_PROVIDER_ID)
context = TriggerOAuthContext(
tenant_id=tenant_id,
user_id=user_id,
@@ -149,16 +150,16 @@ def created_builder(flask_app_with_containers: Flask) -> Iterator[_CreatedBuilde
plugin_unique_identifier=_PLUGIN_IDENTIFIER,
)
try:
- yield _CreatedBuilder(context=context, response=response)
+ yield _CreatedBuilder(context=context, response=response, gateway=gateway)
finally:
- redis_client.delete(TriggerSubscriptionBuilderService.encode_cache_key(response.id))
+ redis_client.delete(RedisTriggerSubscriptionBuilderRepository.encode_cache_key(response.id))
finally:
contexts.plugin_trigger_providers.set(previous_providers)
contexts.plugin_trigger_providers_lock.set(previous_lock)
def _read_builder(builder_id: str) -> SubscriptionBuilder:
- cached = redis_client.get(TriggerSubscriptionBuilderService.encode_cache_key(builder_id))
+ cached = redis_client.get(RedisTriggerSubscriptionBuilderRepository.encode_cache_key(builder_id))
assert cached is not None
return SubscriptionBuilder.model_validate_json(cached)
@@ -176,7 +177,7 @@ def test_builder_gateway_creates_owned_oauth_builder(created_builder: _CreatedBu
assert stored.credential_expires_at == -1
assert stored.parameters == response.parameters == {"event": "push"}
assert stored.properties == response.properties == {"repository": "dify"}
- assert 0 < redis_client.ttl(TriggerSubscriptionBuilderService.encode_cache_key(response.id)) <= 30 * 60
+ assert 0 < redis_client.ttl(RedisTriggerSubscriptionBuilderRepository.encode_cache_key(response.id)) <= 30 * 60
def test_builder_gateway_updates_credentials_and_expiry_only(created_builder: _CreatedBuilder) -> None:
@@ -184,7 +185,7 @@ def test_builder_gateway_updates_credentials_and_expiry_only(created_builder: _C
before = _read_builder(context.subscription_builder_id)
credentials = {"access_token": "provider-access-token", "refresh_token": "provider-refresh-token"}
- TriggerOAuthBuilderGateway().set_credentials(
+ created_builder.gateway.set_credentials(
context=context,
provider_id=_PROVIDER_ID,
credentials=credentials,
@@ -213,7 +214,7 @@ def test_builder_gateway_rejects_mismatched_owner_without_updating(
context = replace(context, subscription_builder_id=str(uuid4()))
with pytest.raises(ValueError, match="not found"):
- TriggerOAuthBuilderGateway().set_credentials(
+ created_builder.gateway.set_credentials(
context=context,
provider_id=provider_id,
credentials={"access_token": "must-not-be-stored"},
diff --git a/api/tests/e2e_tests/containers/services/test_trigger_subscription_builder.py b/api/tests/e2e_tests/containers/services/test_trigger_subscription_builder.py
new file mode 100644
index 00000000000..b97fd9cb182
--- /dev/null
+++ b/api/tests/e2e_tests/containers/services/test_trigger_subscription_builder.py
@@ -0,0 +1,278 @@
+"""Real Redis-backed builder HTTP lifecycle, plugin dispatch and subscription persistence."""
+
+from contextvars import Context
+from http import HTTPStatus
+from uuid import uuid4
+
+import pytest
+from flask import Flask, Response, request
+from sqlalchemy import select
+
+from core.plugin.entities.plugin_daemon import CredentialType
+from core.trigger.entities.entities import SubscriptionBuilder
+from core.trigger.utils.endpoint import generate_plugin_trigger_endpoint_url
+from extensions.ext_application_services import application_services
+from extensions.ext_redis import RedisClientWrapper, redis_client
+from models.trigger import TriggerSubscription
+from repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepository
+from tests.e2e_tests.containers.services import test_trigger_subscription_query
+from tests.e2e_tests.containers.services.test_trigger_subscription_query import _provider_with_secrets
+from tests.unit_tests.controllers.console.workspace import test_trigger_oauth_client, test_trigger_subscription_builder
+from tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _PROVIDER, _Harness
+from tests.unit_tests.controllers.console.workspace.test_trigger_subscription_builder import _BASE, _Daemon
+
+sqlite_engine = test_trigger_subscription_query.sqlite_engine
+sqlite_session_factory = test_trigger_subscription_query.sqlite_session_factory
+harness = test_trigger_oauth_client.harness
+daemon = test_trigger_subscription_builder.daemon
+
+
+def application_redis(flask_app_with_containers: Flask) -> RedisClientWrapper:
+ assert flask_app_with_containers.extensions["redis"] is redis_client
+ return redis_client
+
+
+def _key(builder_id: str) -> str:
+ return RedisTriggerSubscriptionBuilderRepository.encode_cache_key(builder_id)
+
+
+def _stored(builder_id: str) -> SubscriptionBuilder:
+ value = redis_client.get(_key(builder_id))
+ assert value is not None
+ return SubscriptionBuilder.model_validate_json(value)
+
+
+def _create(harness: _Harness, daemon: _Daemon, credential_type: CredentialType) -> SubscriptionBuilder:
+ provider = _provider_with_secrets()
+ declaration = provider["declaration"]
+ assert isinstance(declaration, dict)
+ constructor = declaration["subscription_constructor"]
+ assert isinstance(constructor, dict)
+ constructor["parameters"] = [{"name": "event", "type": "string", "label": {"en_US": "Event"}, "default": "push"}]
+ declaration["subscription_schema"] = [{"name": "repository", "type": "text-input", "default": "dify"}]
+ daemon.provider = provider
+ response = Context().run(
+ harness.call, "POST", url=f"{_BASE}/create", payload={"credential_type": credential_type.value}
+ )
+ assert response.status_code == HTTPStatus.OK
+ body = response.get_json()["subscription_builder"]
+ builder = _stored(body["id"])
+ assert body == {
+ "id": builder.id,
+ "name": "",
+ "provider": _PROVIDER,
+ "endpoint": generate_plugin_trigger_endpoint_url(builder.id),
+ "parameters": {"event": "push"},
+ "properties": {"repository": "dify"},
+ "credentials": {},
+ "credential_type": credential_type.value,
+ }
+ assert (builder.tenant_id, builder.user_id, builder.provider_id) == (
+ harness.tenant_id,
+ harness.account_id,
+ _PROVIDER,
+ )
+ assert builder.id == builder.endpoint_id
+ assert builder.credential_expires_at == builder.expires_at == -1
+ assert 0 < redis_client.ttl(_key(builder.id)) <= 1800
+ assert all(not sent.open_transactions for sent in daemon.requests)
+ return builder
+
+
[email protected]("credential_type", list(CredentialType))
+def test_create_and_get_preserve_defaults_and_credential_type(
+ harness: _Harness, daemon: _Daemon, credential_type: CredentialType
+) -> None:
+ builder = _create(harness, daemon, credential_type)
+
+ response = Context().run(harness.call, "GET", url=f"{_BASE}/{builder.id}")
+
+ assert response.status_code == HTTPStatus.OK
+ assert response.get_json()["parameters"] == {"event": "push"}
+ assert response.get_json()["properties"] == {"repository": "dify"}
+ assert response.get_json()["credential_type"] == credential_type.value
+
+
+def test_update_masks_response_and_preserves_credentials_when_not_supplied(harness: _Harness, daemon: _Daemon) -> None:
+ builder = _create(harness, daemon, CredentialType.API_KEY)
+ first = Context().run(
+ harness.call,
+ "POST",
+ url=f"{_BASE}/update/{builder.id}",
+ payload={"name": "Updated", "credentials": {"token": "first-secret"}, "parameters": {"event": "pull"}},
+ )
+ assert first.status_code == HTTPStatus.OK
+ assert first.get_json()["credentials"] == {"token": "fi********et"}
+ assert _stored(builder.id).credentials == {"token": "first-secret"}
+
+ second = Context().run(
+ harness.call, "POST", url=f"{_BASE}/update/{builder.id}", payload={"properties": {"repository": "other"}}
+ )
+ assert second.status_code == HTTPStatus.OK
+ assert second.get_json()["name"] == "Updated"
+ assert second.get_json()["parameters"] == {"event": "pull"}
+ assert second.get_json()["properties"] == {"repository": "other"}
+ assert second.get_json()["credentials"] == first.get_json()["credentials"]
+ assert _stored(builder.id).credentials == {"token": "first-secret"}
+ assert 0 < redis_client.ttl(_key(builder.id)) <= 1800
+
+
+ ("field", "operation"),
+ [
+ ("id", "get"),
+ ("tenant_id", "get"),
+ ("user_id", "get"),
+ ("provider_id", "get"),
+ ("endpoint_id", "get"),
+ ("user_id", "update"),
+ ("tenant_id", "verify-and-update"),
+ ("provider_id", "logs"),
+ ("user_id", "build"),
+ ],
+)
+def test_all_owned_builder_routes_reject_foreign_capabilities_without_changing_them(
+ harness: _Harness, daemon: _Daemon, field: str, operation: str
+) -> None:
+ builder = _create(harness, daemon, CredentialType.UNAUTHORIZED)
+ foreign = builder.model_copy(update={field: "langgenius/github/other" if field == "provider_id" else str(uuid4())})
+ redis_client.setex(_key(builder.id), 1800, foreign.model_dump_json())
+ path = builder.id if operation == "get" else f"{operation}/{builder.id}"
+ method = "GET" if operation in {"get", "logs"} else "POST"
+
+ response = Context().run(harness.call, method, url=f"{_BASE}/{path}", payload={"name": "Must not persist"})
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ assert response.get_json()["code"] == "invalid_param"
+ assert "not found" in response.get_json()["message"]
+ assert _stored(builder.id) == foreign
+ assert not any(sent.method == "POST" for sent in daemon.requests)
+
+
[email protected]("operation", ["get", "update", "verify-and-update", "logs", "build"])
+def test_missing_builder_does_not_recreate_a_draft(harness: _Harness, daemon: _Daemon, operation: str) -> None:
+ builder = _create(harness, daemon, CredentialType.UNAUTHORIZED)
+ redis_client.delete(_key(builder.id))
+ path = builder.id if operation == "get" else f"{operation}/{builder.id}"
+ method = "GET" if operation in {"get", "logs"} else "POST"
+
+ response = Context().run(harness.call, method, url=f"{_BASE}/{path}", payload={"name": "Must not persist"})
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ assert "not found" in response.get_json()["message"]
+ assert redis_client.get(_key(builder.id)) is None
+
+
+def test_logs_are_owned_and_keep_only_last_ten_requests(harness: _Harness, daemon: _Daemon) -> None:
+ builder = _create(harness, daemon, CredentialType.UNAUTHORIZED)
+ with harness.app.app_context():
+ service = application_services().workspaces.trigger_builders
+ for index in range(12):
+ with harness.app.test_request_context(f"/triggers/plugin/{builder.id}", method="POST", data=str(index)):
+ service.append_log(builder.id, request, Response(f"response-{index}", status=202))
+
+ response = Context().run(harness.call, "GET", url=f"{_BASE}/logs/{builder.id}")
+
+ assert response.status_code == HTTPStatus.OK
+ logs = response.get_json()["logs"]
+ assert [log["request"]["data"] for log in logs] == [str(index) for index in range(2, 12)]
+ assert [log["response"]["data"] for log in logs] == [f"response-{index}" for index in range(2, 12)]
+ assert all(log["endpoint"] == builder.id and log["response"]["status_code"] == 202 for log in logs)
+ assert 0 < redis_client.ttl(f"trigger:subscription:builder:logs:{builder.id}") <= 1800
+
+
[email protected]("credentials", [{}, {"token": "oauth-secret"}], ids=["empty", "authorized"])
+def test_oauth_verification_depends_on_saved_credentials_without_plugin_invocation(
+ harness: _Harness, daemon: _Daemon, credentials: dict[str, str]
+) -> None:
+ builder = _create(harness, daemon, CredentialType.OAUTH2)
+
+ response = Context().run(
+ harness.call, "POST", url=f"{_BASE}/verify-and-update/{builder.id}", payload={"credentials": credentials}
+ )
+
+ assert response.status_code == HTTPStatus.OK
+ assert response.get_json() == {"verified": bool(credentials)}
+ assert _stored(builder.id).credentials == credentials
+ assert not any(sent.method == "POST" for sent in daemon.requests)
+
+
+def test_api_key_verification_dispatches_new_credentials_to_the_owned_provider(
+ harness: _Harness, daemon: _Daemon
+) -> None:
+ builder = _create(harness, daemon, CredentialType.API_KEY)
+
+ response = Context().run(
+ harness.call,
+ "POST",
+ url=f"{_BASE}/verify-and-update/{builder.id}",
+ payload={"credentials": {"token": "new-secret"}},
+ )
+
+ assert response.status_code == HTTPStatus.OK
+ assert response.get_json() == {"verified": True}
+ sent = [sent for sent in daemon.requests if sent.method == "POST"]
+ assert len(sent) == 1
+ assert sent[0].path == f"/plugin/{harness.tenant_id}/dispatch/trigger/validate_credentials"
+ assert sent[0].payload == {
+ "user_id": harness.account_id,
+ "data": {"provider": "github", "credentials": {"token": "new-secret"}},
+ }
+ assert sent[0].headers["X-Plugin-ID"] == "langgenius/github"
+ assert not sent[0].open_transactions
+ assert _stored(builder.id).credentials == {"token": "new-secret"}
+
+
[email protected]("credential_type", [CredentialType.UNAUTHORIZED, CredentialType.OAUTH2])
+def test_successful_build_persists_owned_subscription_then_removes_builder(
+ harness: _Harness, daemon: _Daemon, credential_type: CredentialType
+) -> None:
+ builder = _create(harness, daemon, credential_type)
+ daemon.response_data = {
+ "subscription": {
+ "endpoint": generate_plugin_trigger_endpoint_url(builder.id),
+ "parameters": {"event": "push"},
+ "properties": {"repository": "provider-value"},
+ "expires_at": 1787560681,
+ }
+ }
+
+ response = Context().run(harness.call, "POST", url=f"{_BASE}/build/{builder.id}", payload={"name": "Published"})
+
+ assert response.status_code == HTTPStatus.OK
+ assert response.get_json() == {"result": "success"}
+ assert redis_client.get(_key(builder.id)) is None
+ with harness.session_factory() as session:
+ subscription = session.scalar(select(TriggerSubscription).where(TriggerSubscription.id == builder.id))
+ assert subscription is not None
+ assert subscription.tenant_id == harness.tenant_id
+ assert subscription.user_id == harness.account_id
+ assert subscription.provider_id == _PROVIDER
+ assert subscription.endpoint_id == builder.id
+ assert subscription.name == "Published"
+ assert subscription.credential_type == credential_type
+ assert subscription.parameters == {"event": "push"}
+ assert subscription.properties == {
+ "repository": "dify" if credential_type == CredentialType.UNAUTHORIZED else "provider-value"
+ }
+ assert subscription.expires_at == (-1 if credential_type == CredentialType.UNAUTHORIZED else 1787560681)
+ assert len([sent for sent in daemon.requests if sent.method == "POST"]) == (
+ 0 if credential_type == CredentialType.UNAUTHORIZED else 1
+ )
+
+
+def test_failed_plugin_build_preserves_the_updated_draft(harness: _Harness, daemon: _Daemon) -> None:
+ builder = _create(harness, daemon, CredentialType.OAUTH2)
+ daemon.response_code = 1
+ daemon.response_message = "subscription rejected"
+ daemon.response_data = None
+
+ response = Context().run(harness.call, "POST", url=f"{_BASE}/build/{builder.id}", payload={"name": "Retry me"})
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ assert response.get_json()["code"] == "invalid_param"
+ assert response.get_json()["message"] == "plugin daemon: subscription rejected, code: 1"
+ assert _stored(builder.id).name == "Retry me"
+ with harness.session_factory() as session:
+ assert session.scalar(select(TriggerSubscription).where(TriggerSubscription.id == builder.id)) is None
diff --git a/api/tests/e2e_tests/containers/services/test_trigger_subscription_query.py b/api/tests/e2e_tests/containers/services/test_trigger_subscription_query.py
index b417a89905f..dabeb6a70f0 100644
--- a/api/tests/e2e_tests/containers/services/test_trigger_subscription_query.py
+++ b/api/tests/e2e_tests/containers/services/test_trigger_subscription_query.py
@@ -28,6 +28,7 @@ from tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client im
from tests.unit_tests.controllers.console.workspace.test_trigger_provider_query import _Daemon, _provider
from tests.unit_tests.controllers.console.workspace.test_trigger_subscription_query import _LIST, _add_subscription
+application_redis = test_trigger_oauth_client.application_redis
harness = test_trigger_oauth_client.harness
daemon = test_trigger_provider_query.daemon
diff --git a/api/tests/unit_tests/controllers/common/test_access_response.py b/api/tests/unit_tests/controllers/common/test_access_response.py
index 807c991aeb6..573e7d7e2bb 100644
--- a/api/tests/unit_tests/controllers/common/test_access_response.py
+++ b/api/tests/unit_tests/controllers/common/test_access_response.py
@@ -19,7 +19,6 @@ from sqlalchemy.orm import Session, object_session, sessionmaker
from werkzeug.exceptions import NotFound, Unauthorized
import controllers.service_api.wraps as token_wraps
-import controllers.trigger.trigger as plugin_trigger
import services.api_token_service as token_service
from controllers.common.access_response import (
MCP_ERROR_BODY_LIMIT,
@@ -577,28 +576,6 @@ def test_webhook_missing_identity_uses_native_html_without_disclosing_id(
execute.assert_not_called()
[email protected]("endpoint", ["123e4567-e89b-42d3-a456-426614174000", "invalid-id"])
-def test_plugin_callback_retains_its_json_error_contract(
- http_app: Flask, monkeypatch: pytest.MonkeyPatch, mocker: MockerFixture, endpoint: str
-) -> None:
- monkeypatch.setattr(plugin_trigger, "request", request)
- monkeypatch.setattr(plugin_trigger, "jsonify", jsonify)
- mocker.patch.object(plugin_trigger.TriggerService, "process_endpoint", return_value=None)
- mocker.patch.object(
- plugin_trigger.TriggerSubscriptionBuilderService,
- "process_builder_validation_endpoint",
- return_value=None,
- )
- http_app.add_url_rule(
- "/triggers/plugin/<string:endpoint_id>", view_func=plugin_trigger.trigger_endpoint, methods=["POST"]
- )
- response = http_app.test_client().post(f"/triggers/plugin/{endpoint}", json={})
- assert response.status_code == 404
- assert response.data == b'{"error":"Endpoint not found"}'
- assert response.mimetype == "application/json"
- assert response.headers["Cache-Control"] == "no-store"
-
-
@pytest.mark.parametrize("status", [401, 403, 429])
def test_openapi_local_hook_preserves_native_details_and_oauth_challenge(http_app: Flask, status: int) -> None:
payload = {
diff --git a/api/tests/unit_tests/controllers/console/workspace/test_plugin.py b/api/tests/unit_tests/controllers/console/workspace/test_plugin.py
index 364b640d93f..be3519629a1 100644
--- a/api/tests/unit_tests/controllers/console/workspace/test_plugin.py
+++ b/api/tests/unit_tests/controllers/console/workspace/test_plugin.py
@@ -6,6 +6,7 @@ from unittest.mock import MagicMock, patch
import pytest
from flask import Flask
+from sqlalchemy.orm import Session, sessionmaker
from werkzeug.datastructures import FileStorage
from werkzeug.exceptions import Forbidden
@@ -72,6 +73,9 @@ from core.plugin.plugin_service import PluginService
from core.tools.entities.api_entities import ToolProviderApiEntity
from core.tools.entities.common_entities import I18nObject
from core.tools.entities.tool_entities import ToolProviderType
+from enums import DeploymentEdition
+from extensions.ext_application_services import build_application_services
+from extensions.ext_redis import RedisClientWrapper
from models.account import (
Account,
TenantAccountRole,
@@ -85,6 +89,9 @@ from models.account import (
from tests.helpers.unit.config_override import config_overrides_context
from tests.helpers.unit.controllers.error_body import raised_error
from tests.helpers.unit.model_factories import make_account
+from tests.unit_tests.controllers.console.workspace import test_trigger_oauth_client
+
+application_redis = test_trigger_oauth_client.application_redis
def _plugin_category_list_item(category: str = "tool") -> dict[str, Any]:
@@ -760,7 +767,20 @@ class TestPluginFetchPermissionApi:
class TestPluginFetchDynamicSelectOptionsApi:
- def test_fetch_dynamic_options(self, app: Flask, user):
+ def test_fetch_dynamic_options(
+ self,
+ user: Account,
+ sqlite_session_factory: sessionmaker[Session],
+ application_redis: RedisClientWrapper,
+ ) -> None:
+ app = Flask(__name__)
+ services = build_application_services(
+ database_client=sqlite_session_factory,
+ deployment_edition=DeploymentEdition.COMMUNITY,
+ initialization_password="",
+ redis=application_redis,
+ )
+ app.extensions["application_services"] = services
api = PluginFetchDynamicSelectOptionsApi()
method = unwrap(api.get)
@@ -769,7 +789,7 @@ class TestPluginFetchDynamicSelectOptionsApi:
patch(
"controllers.console.workspace.plugin.PluginParameterService.get_dynamic_select_options",
return_value=[_dynamic_option()],
- ),
+ ) as get_options,
):
result = method(
api,
@@ -781,6 +801,7 @@ class TestPluginFetchDynamicSelectOptionsApi:
)
assert result == {"options": [_expected_dynamic_option_dump()]}
+ assert get_options.call_args.kwargs["builders"] is services.workspaces.trigger_builders
class TestPluginReadmeApi:
diff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_client.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_client.py
index e703487338f..fe404104d6f 100644
--- a/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_client.py
+++ b/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_client.py
@@ -23,6 +23,12 @@ from controllers.console.workspace.trigger_providers import (
TriggerProviderIconApi,
TriggerProviderInfoApi,
TriggerProviderListApi,
+ TriggerSubscriptionBuilderBuildApi,
+ TriggerSubscriptionBuilderCreateApi,
+ TriggerSubscriptionBuilderGetApi,
+ TriggerSubscriptionBuilderLogsApi,
+ TriggerSubscriptionBuilderUpdateApi,
+ TriggerSubscriptionBuilderVerifyApi,
TriggerSubscriptionListApi,
)
from controllers.console.wraps import _is_setup_completed
@@ -137,12 +143,23 @@ class _Harness:
@pytest.fixture
-def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]) -> Iterator[_Harness]:
+def application_redis() -> Iterator[RedisClientWrapper]:
+ with Redis() as client:
+ redis = RedisClientWrapper()
+ redis.initialize(client)
+ yield redis
+
+
+def harness(
+ sqlite_engine: Engine,
+ sqlite_session_factory: sessionmaker[Session],
+ application_redis: RedisClientWrapper,
+) -> Iterator[_Harness]:
previous_storage = storage.__dict__.copy()
previous_key_provider = key_provider_manager._provider
with (
TemporaryDirectory(prefix="trigger-oauth-keys-") as storage_path,
- Redis() as redis_client,
config_overrides_context(
DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY,
RBAC_ENABLED=False,
@@ -198,13 +215,11 @@ def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]
tenant_id=tenant_id,
)
metadata = _PluginMetadata(provider, sessions)
- redis = RedisClientWrapper()
- redis.initialize(redis_client)
services = build_application_services(
database_client=sqlite_session_factory,
deployment_edition=DeploymentEdition.COMMUNITY,
initialization_password="",
- redis=redis,
+ redis=application_redis,
)
oauth_clients = TriggerOAuthClientService(
clients=TriggerOAuthClientRepository(session_factory=sqlite_session_factory),
@@ -233,6 +248,15 @@ def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]
"/workspaces/current/trigger-provider/<path:provider>/subscriptions/oauth/authorize",
)
api.add_resource(TriggerOAuthCallbackApi, "/oauth/plugin/<path:provider>/trigger/callback")
+ builder_path = "/workspaces/current/trigger-provider/<path:provider>/subscriptions/builder"
+ api.add_resource(TriggerSubscriptionBuilderCreateApi, f"{builder_path}/create")
+ api.add_resource(TriggerSubscriptionBuilderGetApi, f"{builder_path}/<path:subscription_builder_id>")
+ api.add_resource(TriggerSubscriptionBuilderUpdateApi, f"{builder_path}/update/<path:subscription_builder_id>")
+ api.add_resource(
+ TriggerSubscriptionBuilderVerifyApi, f"{builder_path}/verify-and-update/<path:subscription_builder_id>"
+ )
+ api.add_resource(TriggerSubscriptionBuilderLogsApi, f"{builder_path}/logs/<path:subscription_builder_id>")
+ api.add_resource(TriggerSubscriptionBuilderBuildApi, f"{builder_path}/build/<path:subscription_builder_id>")
app.register_blueprint(blueprint)
with app.app_context():
diff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_flow.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_flow.py
index 45373d9d13e..d41a91978af 100644
--- a/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_flow.py
+++ b/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_flow.py
@@ -27,6 +27,7 @@ from services.trigger.oauth_service import (
from tests.unit_tests.controllers.console.workspace import test_trigger_oauth_client
from tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _PROVIDER, _Harness
+application_redis = test_trigger_oauth_client.application_redis
harness = test_trigger_oauth_client.harness
_AUTHORIZE = f"/console/api/workspaces/current/trigger-provider/{_PROVIDER}/subscriptions/oauth/authorize"
diff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_provider_query.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_provider_query.py
index b064a510f4d..18324069fdd 100644
--- a/api/tests/unit_tests/controllers/console/workspace/test_trigger_provider_query.py
+++ b/api/tests/unit_tests/controllers/console/workspace/test_trigger_provider_query.py
@@ -21,6 +21,7 @@ from models.account import TenantAccountRole
from tests.unit_tests.controllers.console.workspace import test_trigger_oauth_client
from tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _PROVIDER, _Harness
+application_redis = test_trigger_oauth_client.application_redis
harness = test_trigger_oauth_client.harness
_LIST = "/console/api/workspaces/current/triggers"
diff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_providers.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_providers.py
index a253ee0ec14..7e6a35afeed 100644
--- a/api/tests/unit_tests/controllers/console/workspace/test_trigger_providers.py
+++ b/api/tests/unit_tests/controllers/console/workspace/test_trigger_providers.py
@@ -1,10 +1,9 @@
from __future__ import annotations
from collections.abc import Iterator
-from datetime import datetime
from importlib import import_module
from inspect import unwrap
-from unittest.mock import ANY, MagicMock, patch
+from unittest.mock import MagicMock, patch
import pytest
from flask import Flask
@@ -14,14 +13,7 @@ from werkzeug.exceptions import BadRequest
from controllers.common.errors import NotFoundError
from controllers.console.workspace.trigger_providers import (
- TriggerSubscriptionBuilderBuildApi,
- TriggerSubscriptionBuilderCreateApi,
- TriggerSubscriptionBuilderCreatePayload,
- TriggerSubscriptionBuilderGetApi,
- TriggerSubscriptionBuilderLogsApi,
- TriggerSubscriptionBuilderUpdateApi,
TriggerSubscriptionBuilderUpdatePayload,
- TriggerSubscriptionBuilderVerifyApi,
TriggerSubscriptionBuilderVerifyPayload,
TriggerSubscriptionDeleteApi,
TriggerSubscriptionUpdateApi,
@@ -29,8 +21,6 @@ from controllers.console.workspace.trigger_providers import (
TriggerSubscriptionVerifyPayload,
)
from core.plugin.entities.plugin_daemon import CredentialType
-from core.trigger.entities.api_entities import SubscriptionBuilderApiEntity
-from core.trigger.entities.entities import RequestLog
from models.account import Account
from models.engine import db
@@ -43,181 +33,7 @@ def mock_user() -> Account:
return user
-def subscription_builder() -> SubscriptionBuilderApiEntity:
- return SubscriptionBuilderApiEntity(
- id="b1",
- name="Builder",
- provider="github",
- endpoint="b1",
- parameters={"repo": "dify"},
- properties={"branch": "main"},
- credentials={"token": "secret"},
- credential_type=CredentialType.UNAUTHORIZED,
- )
-
-
-def request_log() -> RequestLog:
- return RequestLog(
- id="log1",
- endpoint="/hooks/b1",
- request={"headers": {}, "body": {"event": "push"}},
- response={"status": 200, "body": {"ok": True}},
- created_at=datetime(2024, 1, 1),
- )
-
-
class TestTriggerProviderApisCases:
- class TestTriggerSubscriptionBuilderApis:
- def test_create_builder(self, app: Flask) -> None:
- api = TriggerSubscriptionBuilderCreateApi()
- method = unwrap(api.post)
-
- with (
- app.test_request_context("/", json={"credential_type": "UNAUTHORIZED"}),
- patch(
- "controllers.console.workspace.trigger_providers.TriggerSubscriptionBuilderService.create_trigger_subscription_builder",
- return_value=subscription_builder(),
- ),
- ):
- result = method(
- api,
- TriggerSubscriptionBuilderCreatePayload(credential_type="UNAUTHORIZED"),
- "t1",
- mock_user(),
- "github",
- )
- assert result["subscription_builder"]["id"] == "b1"
-
- def test_get_builder(self, app: Flask) -> None:
- api = TriggerSubscriptionBuilderGetApi()
- method = unwrap(api.get)
-
- with (
- app.test_request_context("/"),
- patch(
- "controllers.console.workspace.trigger_providers.TriggerSubscriptionBuilderService.get_subscription_builder_by_id",
- return_value=subscription_builder(),
- ) as mock_get_builder,
- ):
- assert method(api, "t1", mock_user(), "github", "b1")["id"] == "b1"
- mock_get_builder.assert_called_once_with(
- tenant_id="t1",
- user_id="u1",
- provider_id=ANY,
- subscription_builder_id="b1",
- )
-
- def test_verify_builder(self, app: Flask) -> None:
- api = TriggerSubscriptionBuilderVerifyApi()
- method = unwrap(api.post)
-
- with (
- app.test_request_context("/", json={"credentials": {"a": 1}}),
- patch(
- "controllers.console.workspace.trigger_providers.TriggerSubscriptionBuilderService.update_and_verify_builder",
- return_value={"verified": True},
- ),
- ):
- assert method(
- api,
- TriggerSubscriptionBuilderVerifyPayload(credentials={"a": 1}),
- "t1",
- mock_user(),
- "github",
- "b1",
- ) == {"verified": True}
-
- def test_verify_builder_error(self, app: Flask) -> None:
- api = TriggerSubscriptionBuilderVerifyApi()
- method = unwrap(api.post)
-
- with (
- app.test_request_context("/", json={"credentials": {}}),
- patch(
- "controllers.console.workspace.trigger_providers.TriggerSubscriptionBuilderService.update_and_verify_builder",
- side_effect=Exception("err"),
- ),
- ):
- with pytest.raises(ValueError, match="err"):
- method(
- api,
- TriggerSubscriptionBuilderVerifyPayload(credentials={}),
- "t1",
- mock_user(),
- "github",
- "b1",
- )
-
- def test_update_builder(self, app: Flask) -> None:
- api = TriggerSubscriptionBuilderUpdateApi()
- method = unwrap(api.post)
-
- with (
- app.test_request_context("/", json={"name": "n"}),
- patch(
- "controllers.console.workspace.trigger_providers.TriggerSubscriptionBuilderService.update_trigger_subscription_builder",
- return_value=subscription_builder(),
- ) as mock_update_builder,
- ):
- assert (
- method(
- api,
- TriggerSubscriptionBuilderUpdatePayload(name="n"),
- "t1",
- mock_user(),
- "github",
- "b1",
- )["id"]
- == "b1"
- )
- mock_update_builder.assert_called_once_with(
- tenant_id="t1",
- user_id="u1",
- provider_id=ANY,
- subscription_builder_id="b1",
- subscription_builder_updater=ANY,
- )
-
- def test_logs(self, app: Flask) -> None:
- api = TriggerSubscriptionBuilderLogsApi()
- method = unwrap(api.get)
-
- with (
- app.test_request_context("/"),
- patch(
- "controllers.console.workspace.trigger_providers.TriggerSubscriptionBuilderService.list_logs",
- return_value=[request_log()],
- ) as mock_list_logs,
- ):
- result = method(api, "t1", mock_user(), "github", "b1")
- assert result["logs"][0]["id"] == "log1"
- mock_list_logs.assert_called_once_with(
- tenant_id="t1",
- user_id="u1",
- provider_id=ANY,
- subscription_builder_id="b1",
- )
-
- def test_build(self, app: Flask) -> None:
- api = TriggerSubscriptionBuilderBuildApi()
- method = unwrap(api.post)
-
- with (
- app.test_request_context("/", json={"name": "x"}),
- patch(
- "controllers.console.workspace.trigger_providers.TriggerSubscriptionBuilderService.update_and_build_builder",
- return_value=None,
- ),
- ):
- assert method(
- api,
- TriggerSubscriptionBuilderUpdatePayload(name="x"),
- "t1",
- mock_user(),
- "github",
- "b1",
- ) == {"result": "success"}
-
class TestTriggerSubscriptionCrud:
def test_update_rename_only(self, app: Flask) -> None:
api = TriggerSubscriptionUpdateApi()
diff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_builder.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_builder.py
new file mode 100644
index 00000000000..27cdd9371e7
--- /dev/null
+++ b/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_builder.py
@@ -0,0 +1,204 @@
+"""Builder admission and transport failures run through the real Console HTTP entrypoints."""
+
+import json
+from collections.abc import Iterator
+from contextvars import Context
+from dataclasses import dataclass, field
+from http import HTTPStatus
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from threading import Thread
+from typing import override
+
+import pytest
+from yarl import URL
+
+from core.plugin.entities.plugin_daemon import CredentialType
+from core.plugin.impl import base as plugin_transport
+from core.plugin.impl.trigger import PluginTriggerClient
+from models.account import TenantAccountRole
+from tests.unit_tests.controllers.console.workspace import test_trigger_oauth_client
+from tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _PROVIDER, _Harness
+from tests.unit_tests.controllers.console.workspace.test_trigger_provider_query import _provider
+
+application_redis = test_trigger_oauth_client.application_redis
+harness = test_trigger_oauth_client.harness
+
+_BASE = f"/console/api/workspaces/current/trigger-provider/{_PROVIDER}/subscriptions/builder"
+_ROUTES = [
+ pytest.param("POST", "create", {"credential_type": "api-key"}, id="create"),
+ pytest.param("GET", "builder-id", None, id="get"),
+ pytest.param("POST", "update/builder-id", {"name": "Updated"}, id="update"),
+ pytest.param("POST", "verify-and-update/builder-id", {"credentials": {}}, id="verify"),
+ pytest.param("GET", "logs/builder-id", None, id="logs"),
+ pytest.param("POST", "build/builder-id", {"name": "Built"}, id="build"),
+]
+
+
+@dataclass(frozen=True)
+class _DaemonRequest:
+ method: str
+ path: str
+ headers: dict[str, str]
+ payload: dict[str, object]
+ open_transactions: bool
+
+
+@dataclass
+class _Daemon:
+ provider: dict[str, object] = field(default_factory=_provider)
+ response_data: dict[str, object] | None = field(default_factory=lambda: {"result": True})
+ response_code: int = 0
+ response_message: str = ""
+ status: HTTPStatus = HTTPStatus.OK
+ post_status: HTTPStatus = HTTPStatus.OK
+ requests: list[_DaemonRequest] = field(default_factory=list)
+
+
+def daemon(harness: _Harness) -> Iterator[_Daemon]:
+ daemon = _Daemon()
+
+ class Handler(BaseHTTPRequestHandler):
+ def do_GET(self) -> None:
+ self.respond({}, daemon.provider, daemon.status, streamed=False)
+
+ def do_POST(self) -> None:
+ payload = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
+ self.respond(payload, daemon.response_data, daemon.post_status, streamed=True)
+
+ def respond(
+ self, payload: dict[str, object], data: dict[str, object] | None, status: HTTPStatus, *, streamed: bool
+ ) -> None:
+ daemon.requests.append(
+ _DaemonRequest(
+ self.command,
+ self.path,
+ dict(self.headers.items()),
+ payload,
+ any(session.in_transaction() for session in harness.metadata.sessions),
+ )
+ )
+ body = json.dumps(
+ {
+ "code": daemon.response_code if streamed else 0,
+ "message": daemon.response_message if streamed else "",
+ "data": data,
+ }
+ )
+ encoded = f"data: {body}\n\n".encode() if streamed else body.encode()
+ self.send_response(status)
+ self.send_header("Content-Type", "text/event-stream" if streamed else "application/json")
+ self.send_header("Content-Length", str(len(encoded)))
+ self.end_headers()
+ self.wfile.write(encoded)
+
+ @override
+ def log_message(self, format: str, *args: object) -> None:
+ pass
+
+ server = HTTPServer(("127.0.0.1", 0), Handler)
+ thread = Thread(target=server.serve_forever, kwargs={"poll_interval": 0.01}, daemon=True)
+ previous_url = plugin_transport.plugin_daemon_inner_api_baseurl
+ plugin_transport.plugin_daemon_inner_api_baseurl = URL(f"http://127.0.0.1:{server.server_port}")
+ thread.start()
+ try:
+ yield daemon
+ finally:
+ plugin_transport.plugin_daemon_inner_api_baseurl = previous_url
+ server.shutdown()
+ server.server_close()
+ thread.join(timeout=5)
+
+
[email protected](("method", "path", "payload"), _ROUTES)
+def test_builder_routes_require_login(
+ harness: _Harness, daemon: _Daemon, method: str, path: str, payload: dict[str, object] | None
+) -> None:
+ response = harness.client.open(f"{_BASE}/{path}", method=method, json=payload)
+
+ assert response.status_code == HTTPStatus.UNAUTHORIZED
+ assert response.get_json()["code"] == "unauthorized"
+ assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'
+ assert daemon.requests == []
+
+
[email protected](("method", "path", "payload"), _ROUTES)
[email protected]("role", [TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR])
+def test_builder_routes_require_editor_role_before_external_io(
+ harness: _Harness,
+ daemon: _Daemon,
+ method: str,
+ path: str,
+ payload: dict[str, object] | None,
+ role: TenantAccountRole,
+) -> None:
+ harness.set_role(role)
+
+ response = Context().run(harness.call, method, url=f"{_BASE}/{path}", payload=payload)
+
+ assert response.status_code == HTTPStatus.FORBIDDEN
+ assert response.get_json()["code"] == "forbidden"
+ assert daemon.requests == []
+
+
[email protected](("method", "path", "payload"), _ROUTES)
+def test_builder_routes_reject_invalid_provider_before_external_io(
+ harness: _Harness, daemon: _Daemon, method: str, path: str, payload: dict[str, object] | None
+) -> None:
+ url = f"{_BASE}/{path}".replace(_PROVIDER, "not/a/valid/provider")
+
+ response = Context().run(harness.call, method, url=url, payload=payload)
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ assert response.get_json()["code"] == "invalid_param"
+ assert daemon.requests == []
+
+
+ ("path", "payload"),
+ [
+ pytest.param("create", {"credential_type": []}, id="create"),
+ pytest.param("update/builder-id", {"parameters": []}, id="update"),
+ pytest.param("verify-and-update/builder-id", {"credentials": []}, id="verify"),
+ pytest.param("build/builder-id", {"name": []}, id="build"),
+ ],
+)
+def test_builder_routes_validate_payload_before_external_io(
+ harness: _Harness, daemon: _Daemon, path: str, payload: dict[str, object]
+) -> None:
+ response = Context().run(harness.call, "POST", url=f"{_BASE}/{path}", payload=payload)
+
+ assert response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY
+ assert daemon.requests == []
+
+
+def test_create_provider_failure_occurs_after_admission_transaction_closes(harness: _Harness, daemon: _Daemon) -> None:
+ daemon.status = HTTPStatus.SERVICE_UNAVAILABLE
+
+ response = Context().run(harness.call, "POST", url=f"{_BASE}/create", payload={"credential_type": "api-key"})
+
+ assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
+ assert response.get_json()["status"] == HTTPStatus.INTERNAL_SERVER_ERROR
+ assert len(daemon.requests) == 1
+ assert not daemon.requests[0].open_transactions
+
+
+def test_subscribe_transport_preserves_explicit_plugin_rejection(harness: _Harness, daemon: _Daemon) -> None:
+ daemon.response_code = 1
+ daemon.response_message = "subscription rejected"
+ daemon.response_data = None
+ client = PluginTriggerClient(plugin_unique_identifier="langgenius/github:1.0.0@package-hash")
+
+ with pytest.raises(ValueError, match="^plugin daemon: subscription rejected, code: 1$"):
+ client.subscribe(
+ tenant_id=harness.tenant_id,
+ user_id=harness.account_id,
+ provider=_PROVIDER,
+ credentials={},
+ credential_type=CredentialType.OAUTH2,
+ endpoint="https://example.test/triggers/plugin/builder",
+ parameters={},
+ )
+
+ assert len(daemon.requests) == 1
+ assert daemon.requests[0].path.endswith("/dispatch/trigger/subscribe")
diff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_query.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_query.py
index a10b40547ed..f1424f30b5c 100644
--- a/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_query.py
+++ b/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_query.py
@@ -1,11 +1,7 @@
"""Subscription reads exercise real admission, SQL visibility and daemon transport."""
-import json
from contextvars import Context
from http import HTTPStatus
-from http.server import BaseHTTPRequestHandler, HTTPServer
-from threading import Thread
-from typing import override
from uuid import uuid4
import pytest
@@ -16,12 +12,12 @@ from models import TenantAccountJoin
from models.account import Account, AccountStatus, TenantAccountRole
from models.enums import PermissionEnum
from models.trigger import TriggerSubscription
-from services.enterprise.base import EnterpriseRequest
from tests.helpers.unit.config_override import config_overrides_context
from tests.unit_tests.controllers.console.workspace import test_trigger_oauth_client, test_trigger_provider_query
from tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _PROVIDER, _Harness
from tests.unit_tests.controllers.console.workspace.test_trigger_provider_query import _Daemon
+application_redis = test_trigger_oauth_client.application_redis
harness = test_trigger_oauth_client.harness
daemon = test_trigger_provider_query.daemon
@@ -98,65 +94,22 @@ def test_subscriptions_require_editor_role_before_querying_plugin(
assert daemon.requests == []
-def test_uninitialized_member_without_editor_role_is_forbidden(harness: _Harness, daemon: _Daemon) -> None:
- harness.set_role(TenantAccountRole.NORMAL)
[email protected]("rbac_enabled", [False, True], ids=["roles", "rbac"])
[email protected]("role", [TenantAccountRole.NORMAL, TenantAccountRole.OWNER])
+def test_uninitialized_account_is_rejected_before_permission_checks(
+ harness: _Harness, daemon: _Daemon, rbac_enabled: bool, role: TenantAccountRole
+) -> None:
+ harness.set_role(role)
with harness.session_factory.begin() as session:
account = session.get(Account, harness.account_id)
assert account is not None
account.status = AccountStatus.UNINITIALIZED
- response = Context().run(harness.call, "GET", url=_LIST)
-
- assert response.status_code == HTTPStatus.FORBIDDEN
- assert response.get_json()["code"] == "forbidden"
- assert daemon.requests == []
-
-
[email protected]("allowed", [False, True], ids=["permission-denied", "permission-granted"])
-def test_rbac_precedes_account_initialization(harness: _Harness, daemon: _Daemon, allowed: bool) -> None:
- harness.set_role(TenantAccountRole.NORMAL)
- with harness.session_factory.begin() as session:
- account = session.get(Account, harness.account_id)
- assert account is not None
- account.status = AccountStatus.UNINITIALIZED
+ with config_overrides_context(RBAC_ENABLED=rbac_enabled):
+ response = Context().run(harness.call, "GET", url=_LIST)
- requests: list[dict[str, object]] = []
-
- class Handler(BaseHTTPRequestHandler):
- def do_POST(self) -> None:
- assert self.path == "/rbac/check-access"
- requests.append(json.loads(self.rfile.read(int(self.headers["Content-Length"]))))
- body = json.dumps({"allowed": allowed}).encode()
- self.send_response(HTTPStatus.OK)
- self.send_header("Content-Type", "application/json")
- self.send_header("Content-Length", str(len(body)))
- self.end_headers()
- self.wfile.write(body)
-
- @override
- def log_message(self, format: str, *args: object) -> None:
- pass
-
- server = HTTPServer(("127.0.0.1", 0), Handler)
- thread = Thread(target=server.serve_forever, kwargs={"poll_interval": 0.01}, daemon=True)
- previous_url = EnterpriseRequest.rbac_base_url
- EnterpriseRequest.rbac_base_url = f"http://127.0.0.1:{server.server_port}"
- thread.start()
- try:
- with config_overrides_context(RBAC_ENABLED=True):
- response = Context().run(harness.call, "GET", url=_LIST)
- finally:
- EnterpriseRequest.rbac_base_url = previous_url
- server.shutdown()
- server.server_close()
- thread.join(timeout=5)
-
- assert response.status_code == (HTTPStatus.BAD_REQUEST if allowed else HTTPStatus.FORBIDDEN)
- assert response.get_json()["code"] == ("account_not_initialized" if allowed else "forbidden")
- assert len(requests) == 1
- assert requests[0]["account_id"] == harness.account_id
- assert requests[0]["tenant_id"] == harness.tenant_id
- assert requests[0]["scene"] == "plugin_preferences"
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ assert response.get_json()["code"] == "account_not_initialized"
assert daemon.requests == []
diff --git a/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py b/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py
index 279deaa9dd4..667add8f4d9 100644
--- a/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py
+++ b/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py
@@ -10,16 +10,20 @@ import pytest
from flask import Flask
from flask.typing import ResponseReturnValue
from flask_restx import Api, Resource
+from redis import Redis
from sqlalchemy.orm import Session, sessionmaker
from werkzeug.exceptions import UnprocessableEntity
from controllers.inner_api.workspace import workspace as controller
from controllers.inner_api.wraps import InnerApiUnauthorizedError
from core.plugin.impl.oauth import OAuthHandler
+from core.trigger.trigger_manager import TriggerManager
from extensions.application_services.workspace import WorkspaceServices
+from extensions.ext_redis import RedisClientWrapper
from libs.external_api import register_external_error_handlers
from repositories.credentials.query_repository import CredentialQueryRepository
from repositories.trigger.oauth_client_repository import TriggerOAuthClientRepository
+from repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepository
from services.account_errors import AccountNotFoundError
from services.errors.workspace import (
InvalidWorkspaceMemberRoleError,
@@ -36,6 +40,8 @@ from services.trigger.oauth_gateway import (
from services.trigger.oauth_service import TriggerOAuthService
from services.trigger.provider_gateway import PluginTriggerProviderQuery
from services.trigger.subscription_query_service import TriggerSubscriptionQueryService
+from services.trigger.trigger_provider_service import TriggerProviderService
+from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService
from services.workspace.contracts import CreatedWorkspace, WorkspaceMembership
from services.workspace.provisioning_service import WorkspaceProvisioningService
from services.workspace.service import WorkspaceQueryService, WorkspaceService
@@ -110,6 +116,14 @@ class TestWorkspaceCases:
oauth_clients = TriggerOAuthClientService(
clients=TriggerOAuthClientRepository(session_factory=sqlite_session_factory), providers=oauth_provider
)
+ redis = RedisClientWrapper()
+ redis.initialize(Redis())
+ builders = TriggerSubscriptionBuilderService(
+ builders=RedisTriggerSubscriptionBuilderRepository(redis=redis),
+ get_provider=TriggerManager.get_trigger_provider,
+ subscribe=TriggerManager.subscribe_trigger,
+ create_subscription=TriggerProviderService.add_trigger_subscription,
+ )
services = WorkspaceServices(
queries=create_autospec(WorkspaceQueryService, instance=True),
management=create_autospec(WorkspaceService, instance=True),
@@ -125,12 +139,13 @@ class TestWorkspaceCases:
credentials=CredentialQueryRepository(session_factory=sqlite_session_factory),
schemas=PluginTriggerProviderQuery(),
),
+ trigger_builders=builders,
trigger_oauth_clients=oauth_clients,
trigger_oauth=TriggerOAuthService(
clients=oauth_clients,
providers=oauth_provider,
contexts=OAuthProxyContextGateway(),
- builders=TriggerOAuthBuilderGateway(),
+ builders=TriggerOAuthBuilderGateway(builders=builders),
),
)
monkeypatch.setattr(controller, "application_services", lambda: Services(services))
diff --git a/api/tests/unit_tests/controllers/trigger/test_trigger.py b/api/tests/unit_tests/controllers/trigger/test_trigger.py
index d42f4249465..39fe950fa2b 100644
--- a/api/tests/unit_tests/controllers/trigger/test_trigger.py
+++ b/api/tests/unit_tests/controllers/trigger/test_trigger.py
@@ -1,81 +1,21 @@
-import logging
-from unittest.mock import patch
+"""Invalid trigger capabilities fail through the real Flask route before dependencies are accessed."""
-import pytest
-
-import controllers.trigger.trigger as module
-
-
[email protected](autouse=True)
-def mock_request():
- module.request = object()
-
-
[email protected](autouse=True)
-def mock_jsonify():
- module.jsonify = lambda payload: payload
-
-
-VALID_UUID = "123e4567-e89b-42d3-a456-426614174000"
-INVALID_UUID = "not-a-uuid"
-
-
-class TestTriggerEndpoint:
- def test_invalid_uuid(self):
- response = module.trigger_endpoint(INVALID_UUID)
- assert response.status_code == 404
- assert response.data == b'{"error":"Endpoint not found"}'
+from http import HTTPStatus
- @patch.object(module.TriggerService, "process_endpoint")
- @patch.object(module.TriggerSubscriptionBuilderService, "process_builder_validation_endpoint")
- def test_first_handler_returns_response(self, mock_builder, mock_trigger):
- mock_trigger.return_value = ("ok", 200)
- mock_builder.return_value = None
-
- response = module.trigger_endpoint(VALID_UUID)
-
- assert response == ("ok", 200)
- mock_builder.assert_not_called()
-
- @patch.object(module.TriggerService, "process_endpoint")
- @patch.object(module.TriggerSubscriptionBuilderService, "process_builder_validation_endpoint")
- def test_second_handler_returns_response(self, mock_builder, mock_trigger):
- mock_trigger.return_value = None
- mock_builder.return_value = ("ok", 200)
-
- response = module.trigger_endpoint(VALID_UUID)
-
- assert response == ("ok", 200)
-
- @patch.object(module.TriggerService, "process_endpoint")
- @patch.object(module.TriggerSubscriptionBuilderService, "process_builder_validation_endpoint")
- def test_no_handler_returns_response(self, mock_builder, mock_trigger):
- mock_trigger.return_value = None
- mock_builder.return_value = None
-
- response = module.trigger_endpoint(VALID_UUID)
- assert response.status_code == 404
- assert response.data == b'{"error":"Endpoint not found"}'
-
- @patch.object(module.TriggerService, "process_endpoint", side_effect=ValueError("bad input"))
- def test_value_error(self, mock_trigger):
- response, status = module.trigger_endpoint(VALID_UUID)
+import pytest
+from flask import Flask
- assert status == 400
- assert response["error"] == "Endpoint processing failed"
- assert response["message"] == "bad input"
+from controllers.trigger.trigger import trigger_endpoint
- @patch.object(module.TriggerService, "process_endpoint", side_effect=Exception("boom"))
- def test_unexpected_exception(self, mock_trigger):
- response, status = module.trigger_endpoint(VALID_UUID)
- assert status == 500
- assert response["error"] == "Internal server error"
[email protected]("endpoint_id", ["not-a-uuid", "123e4567-e89b-12d3-a456-426614174000"])
+def test_invalid_endpoint_preserves_json_error_contract(endpoint_id: str) -> None:
+ app = Flask(__name__)
+ app.add_url_rule("/triggers/plugin/<string:endpoint_id>", view_func=trigger_endpoint, methods=["POST"])
- @patch.object(module.TriggerService, "process_endpoint", side_effect=Exception("boom"))
- def test_unexpected_exception_logs_endpoint_id(self, mock_trigger, caplog):
- with caplog.at_level(logging.ERROR, logger=module.logger.name):
- module.trigger_endpoint(VALID_UUID)
+ response = app.test_client().post(f"/triggers/plugin/{endpoint_id}", json={})
- assert VALID_UUID in caplog.text
- assert "{endpoint_id}" not in caplog.text
+ assert response.status_code == HTTPStatus.NOT_FOUND
+ assert response.data == b'{"error":"Endpoint not found"}'
+ assert response.mimetype == "application/json"
+ assert response.headers["Cache-Control"] == "no-store"
diff --git a/api/tests/unit_tests/extensions/test_ext_application_services.py b/api/tests/unit_tests/extensions/test_ext_application_services.py
index 749de53bb7f..fb202ddbc73 100644
--- a/api/tests/unit_tests/extensions/test_ext_application_services.py
+++ b/api/tests/unit_tests/extensions/test_ext_application_services.py
@@ -158,6 +158,7 @@ from services.tag_application_service import TagApplicationService
from services.tool_file_download_service import ToolFileDownloadService
from services.tracing.adapters import CeleryTraceEmitter
from services.tracing.runtime_bridge import RuntimeApplicationTracingHooks
+from services.trigger.oauth_gateway import TriggerOAuthBuilderGateway
from services.upload_file_delivery_service import UploadFileDeliveryService
from services.web_authentication_adapters import (
AccountWebAuthenticationSecurityGateway,
@@ -1120,6 +1121,9 @@ def test_build_application_services_wires_credential_query(
assert [(record.id, record.name) for record in records] == [(credential_id, "Team")]
assert services.workspaces.trigger_subscriptions._credentials is services.credential_queries
assert services.workspaces.trigger_subscriptions._schemas is services.workspaces.trigger_providers
+ gateway = services.workspaces.trigger_oauth._builders
+ assert isinstance(gateway, TriggerOAuthBuilderGateway)
+ assert gateway._builders is services.workspaces.trigger_builders
def test_build_application_services_uses_supplied_redis_for_both_workflow_stop_signals(
diff --git a/api/tests/unit_tests/services/plugin/test_plugin_parameter_service.py b/api/tests/unit_tests/services/plugin/test_plugin_parameter_service.py
index 356edb60010..475f2bb9ea3 100644
--- a/api/tests/unit_tests/services/plugin/test_plugin_parameter_service.py
+++ b/api/tests/unit_tests/services/plugin/test_plugin_parameter_service.py
@@ -8,32 +8,58 @@ from __future__ import annotations
import json
from collections.abc import Iterator
+from threading import Lock
from unittest.mock import MagicMock, patch
from uuid import uuid4
import pytest
from flask import Flask
+from redis import Redis
from sqlalchemy.orm import Session
+import contexts
from core.plugin.entities.plugin_daemon import CredentialType
-from core.trigger.provider import PluginTriggerProviderController
from core.trigger.trigger_manager import TriggerManager
+from extensions.ext_redis import RedisClientWrapper
from models.engine import db
from models.provider_ids import TriggerProviderID
from models.tools import BuiltinToolProvider
+from repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepository
from services.plugin.plugin_parameter_service import PluginParameterService
+from services.trigger.trigger_provider_service import TriggerProviderService
+from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService
from tests.unit_tests.core.trigger.conftest import make_controller
@pytest.fixture(autouse=True)
-def trigger_declaration(monkeypatch: pytest.MonkeyPatch) -> None:
- def resolve(tenant_id: str, provider_id: TriggerProviderID) -> PluginTriggerProviderController:
- controller = make_controller(tenant_id=tenant_id, provider_id=str(provider_id))
- controller.plugin_id = provider_id.plugin_id
- controller.plugin_unique_identifier = f"{provider_id.plugin_id}:1.0.0@{'a' * 32}"
- return controller
+def trigger_declaration() -> Iterator[None]:
+ provider_id = TriggerProviderID("org/plugin/github")
+ controller = make_controller(tenant_id="t1", provider_id=str(provider_id))
+ controller.plugin_id = provider_id.plugin_id
+ controller.plugin_unique_identifier = f"{provider_id.plugin_id}:1.0.0@{'a' * 32}"
+ previous_providers = contexts.plugin_trigger_providers.get({})
+ previous_lock = contexts.plugin_trigger_providers_lock.get(Lock())
+ contexts.plugin_trigger_providers.set({str(provider_id): controller})
+ contexts.plugin_trigger_providers_lock.set(Lock())
+ try:
+ yield
+ finally:
+ contexts.plugin_trigger_providers.set(previous_providers)
+ contexts.plugin_trigger_providers_lock.set(previous_lock)
- monkeypatch.setattr(TriggerManager, "get_trigger_provider", resolve)
+
+def builders() -> Iterator[TriggerSubscriptionBuilderService]:
+ # Tool-provider paths receive the real dependency but must not query builder Redis.
+ with Redis(socket_connect_timeout=0.1) as client:
+ redis = RedisClientWrapper()
+ redis.initialize(client)
+ yield TriggerSubscriptionBuilderService(
+ builders=RedisTriggerSubscriptionBuilderRepository(redis=redis),
+ get_provider=TriggerManager.get_trigger_provider,
+ subscribe=TriggerManager.subscribe_trigger,
+ create_subscription=TriggerProviderService.add_trigger_subscription,
+ )
@pytest.fixture
@@ -52,7 +78,9 @@ def plugin_parameter_db() -> Iterator[Session]:
class TestGetDynamicSelectOptionsTool:
@patch("services.plugin.plugin_parameter_service.DynamicSelectClient")
@patch("services.plugin.plugin_parameter_service.ToolManager")
- def test_no_credentials_needed(self, mock_tool_mgr, mock_client_cls):
+ def test_no_credentials_needed(
+ self, mock_tool_mgr: MagicMock, mock_client_cls: MagicMock, builders: TriggerSubscriptionBuilderService
+ ) -> None:
provider_ctrl = MagicMock()
provider_ctrl.entity.identity.name = "google"
provider_ctrl.plugin_unique_identifier = "org/plugin:1.0.0@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
@@ -69,6 +97,7 @@ class TestGetDynamicSelectOptionsTool:
parameter="engine",
credential_id=None,
provider_type="tool",
+ builders=builders,
)
assert result == ["opt1"]
@@ -82,8 +111,9 @@ class TestGetDynamicSelectOptionsTool:
self,
mock_tool_mgr: MagicMock,
mock_encrypter_fn: MagicMock,
- mock_client_cls,
+ mock_client_cls: MagicMock,
plugin_parameter_db: Session,
+ builders: TriggerSubscriptionBuilderService,
) -> None:
tenant_id = str(uuid4())
provider_ctrl = MagicMock()
@@ -116,6 +146,7 @@ class TestGetDynamicSelectOptionsTool:
parameter="engine",
credential_id=db_record.id,
provider_type="tool",
+ builders=builders,
)
assert result == ["opt1"]
@@ -127,6 +158,7 @@ class TestGetDynamicSelectOptionsTool:
mock_tool_mgr: MagicMock,
mock_encrypter_fn: MagicMock,
plugin_parameter_db: Session,
+ builders: TriggerSubscriptionBuilderService,
) -> None:
provider_ctrl = MagicMock()
provider_ctrl.entity.identity.name = "google"
@@ -145,79 +177,7 @@ class TestGetDynamicSelectOptionsTool:
parameter="engine",
credential_id=None,
provider_type="tool",
- )
-
-
-class TestGetDynamicSelectOptionsTrigger:
- @patch("services.plugin.plugin_parameter_service.DynamicSelectClient")
- @patch("services.plugin.plugin_parameter_service.TriggerSubscriptionBuilderService")
- def test_uses_subscription_builder_when_credential_id(self, mock_builder_svc, mock_client_cls):
- sub = MagicMock()
- sub.credentials = {"token": "abc"}
- sub.credential_type = "api_key"
- mock_builder_svc.get_subscription_builder.return_value = sub
- mock_client_cls.return_value.fetch_dynamic_select_options.return_value.options = ["opt"]
-
- result = PluginParameterService.get_dynamic_select_options(
- tenant_id="t1",
- user_id="u1",
- plugin_id="org/plugin",
- provider="github",
- action="on_push",
- parameter="branch",
- credential_id="builder-1",
- provider_type="trigger",
- )
-
- assert result == ["opt"]
- builder_call = mock_builder_svc.get_subscription_builder.call_args.kwargs
- assert builder_call["tenant_id"] == "t1"
- assert builder_call["user_id"] == "u1"
- assert str(builder_call["provider_id"]) == "org/plugin/github"
- assert builder_call["subscription_builder_id"] == "builder-1"
-
- @patch("services.plugin.plugin_parameter_service.DynamicSelectClient")
- @patch("services.plugin.plugin_parameter_service.TriggerProviderService")
- @patch("services.plugin.plugin_parameter_service.TriggerSubscriptionBuilderService")
- def test_falls_back_to_trigger_service(self, mock_builder_svc, mock_provider_svc, mock_client_cls):
- mock_builder_svc.get_subscription_builder.return_value = None
- trigger_sub = MagicMock()
- api_entity = MagicMock()
- api_entity.credentials = {"token": "abc"}
- api_entity.credential_type = "api_key"
- trigger_sub.to_api_entity.return_value = api_entity
- mock_provider_svc.get_subscription_by_id.return_value = trigger_sub
- mock_client_cls.return_value.fetch_dynamic_select_options.return_value.options = ["opt"]
-
- result = PluginParameterService.get_dynamic_select_options(
- tenant_id="t1",
- user_id="u1",
- plugin_id="org/plugin",
- provider="github",
- action="on_push",
- parameter="branch",
- credential_id="sub-1",
- provider_type="trigger",
- )
-
- assert result == ["opt"]
-
- @patch("services.plugin.plugin_parameter_service.TriggerProviderService")
- @patch("services.plugin.plugin_parameter_service.TriggerSubscriptionBuilderService")
- def test_raises_when_no_subscription_found(self, mock_builder_svc, mock_provider_svc):
- mock_builder_svc.get_subscription_builder.return_value = None
- mock_provider_svc.get_subscription_by_id.return_value = None
-
- with pytest.raises(ValueError, match="not found"):
- PluginParameterService.get_dynamic_select_options(
- tenant_id="t1",
- user_id="u1",
- plugin_id="org/plugin",
- provider="github",
- action="on_push",
- parameter="branch",
- credential_id="nonexistent",
- provider_type="trigger",
+ builders=builders,
)
diff --git a/api/tests/unit_tests/services/trigger/test_trigger_subscription_builder_service.py b/api/tests/unit_tests/services/trigger/test_trigger_subscription_builder_service.py
deleted file mode 100644
index 1eb28c3dcd2..00000000000
--- a/api/tests/unit_tests/services/trigger/test_trigger_subscription_builder_service.py
+++ /dev/null
@@ -1,298 +0,0 @@
-from collections.abc import Callable
-from contextlib import nullcontext
-from unittest.mock import Mock, patch
-
-import pytest
-
-from core.plugin.entities.plugin_daemon import CredentialType
-from core.trigger.entities.entities import Subscription, SubscriptionBuilder, SubscriptionBuilderUpdater
-from core.trigger.trigger_manager import TriggerManager
-from models.provider_ids import TriggerProviderID
-from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService
-
-PROVIDER_ID = TriggerProviderID("org/plugin/provider")
-
-
-def subscription_builder() -> SubscriptionBuilder:
- return SubscriptionBuilder(
- id="builder-1",
- name="Builder",
- tenant_id="tenant-1",
- user_id="user-1",
- provider_id=str(PROVIDER_ID),
- endpoint_id="builder-1",
- parameters={},
- properties={},
- credentials={},
- credential_type=CredentialType.UNAUTHORIZED,
- credential_expires_at=-1,
- expires_at=-1,
- )
-
-
- ("field", "value"),
- [
- ("id", "other-builder"),
- ("tenant_id", "other-tenant"),
- ("user_id", "other-user"),
- ("provider_id", "org/plugin/other"),
- ],
-)
-def test_get_subscription_builder_rejects_non_owner(field: str, value: str) -> None:
- builder = subscription_builder().model_copy(update={field: value})
- with patch.object(
- TriggerSubscriptionBuilderService,
- "_get_subscription_builder_by_endpoint_id",
- return_value=builder,
- ):
- with pytest.raises(ValueError, match="not found"):
- TriggerSubscriptionBuilderService.get_subscription_builder(
- tenant_id="tenant-1",
- user_id="user-1",
- provider_id=PROVIDER_ID,
- subscription_builder_id="builder-1",
- )
-
-
-def test_get_subscription_builder_accepts_owner() -> None:
- builder = subscription_builder()
- with patch.object(
- TriggerSubscriptionBuilderService,
- "_get_subscription_builder_by_endpoint_id",
- return_value=builder,
- ):
- assert (
- TriggerSubscriptionBuilderService.get_subscription_builder(
- tenant_id="tenant-1",
- user_id="user-1",
- provider_id=PROVIDER_ID,
- subscription_builder_id="builder-1",
- )
- is builder
- )
-
-
-def test_get_subscription_builder_returns_none_when_temporary_builder_is_absent() -> None:
- with patch.object(
- TriggerSubscriptionBuilderService,
- "_get_subscription_builder_by_endpoint_id",
- return_value=None,
- ):
- assert (
- TriggerSubscriptionBuilderService.get_subscription_builder(
- tenant_id="tenant-1",
- user_id="user-1",
- provider_id=PROVIDER_ID,
- subscription_builder_id="builder-1",
- )
- is None
- )
-
-
-def test_get_subscription_builder_rejects_mismatched_endpoint() -> None:
- builder = subscription_builder().model_copy(update={"endpoint_id": "other-builder"})
- with patch(
- "services.trigger.trigger_subscription_builder_service.redis_client.get",
- return_value=builder.model_dump_json(),
- ):
- assert TriggerSubscriptionBuilderService._get_subscription_builder_by_endpoint_id("builder-1") is None
-
-
-def test_get_subscription_builder_accepts_matching_endpoint() -> None:
- builder = subscription_builder()
- with patch(
- "services.trigger.trigger_subscription_builder_service.redis_client.get",
- return_value=builder.model_dump_json(),
- ):
- assert TriggerSubscriptionBuilderService._get_subscription_builder_by_endpoint_id("builder-1") == builder
-
-
- ("operation", "needs_updater"),
- [
- (TriggerSubscriptionBuilderService.update_trigger_subscription_builder, True),
- (TriggerSubscriptionBuilderService.update_and_verify_builder, True),
- (TriggerSubscriptionBuilderService.update_and_build_builder, True),
- (TriggerSubscriptionBuilderService.list_logs, False),
- (TriggerSubscriptionBuilderService.get_subscription_builder_by_id, False),
- ],
-)
-def test_owner_scoped_operations_reject_missing_builder_before_side_effects(
- operation: Callable[..., object], needs_updater: bool
-) -> None:
- kwargs: dict[str, object] = {
- "tenant_id": "tenant-1",
- "user_id": "user-1",
- "provider_id": PROVIDER_ID,
- "subscription_builder_id": "builder-1",
- }
- if needs_updater:
- kwargs["subscription_builder_updater"] = SubscriptionBuilderUpdater(name="Updated")
-
- with (
- patch.object(TriggerManager, "get_trigger_provider", return_value=Mock()),
- patch.object(TriggerSubscriptionBuilderService, "acquire_builder_lock", return_value=nullcontext()),
- patch.object(
- TriggerSubscriptionBuilderService,
- "get_subscription_builder",
- return_value=None,
- ) as get_subscription_builder,
- patch("services.trigger.trigger_subscription_builder_service.redis_client.setex") as setex,
- patch("services.trigger.trigger_subscription_builder_service.redis_client.delete") as delete,
- ):
- with pytest.raises(ValueError, match="not found"):
- operation(**kwargs)
-
- get_subscription_builder.assert_called_once_with(
- tenant_id="tenant-1",
- user_id="user-1",
- provider_id=PROVIDER_ID,
- subscription_builder_id="builder-1",
- )
- setex.assert_not_called()
- delete.assert_not_called()
-
-
-def test_update_and_build_uses_the_owned_builder_without_refetching() -> None:
- builder = subscription_builder()
- cache_key = TriggerSubscriptionBuilderService.encode_cache_key(builder.id)
-
- with (
- patch.object(TriggerManager, "get_trigger_provider", return_value=Mock()),
- patch.object(TriggerSubscriptionBuilderService, "acquire_builder_lock", return_value=nullcontext()),
- patch.object(
- TriggerSubscriptionBuilderService,
- "get_subscription_builder",
- return_value=builder,
- ) as get_subscription_builder,
- patch("services.trigger.trigger_subscription_builder_service.redis_client.setex") as setex,
- patch(
- "services.trigger.trigger_subscription_builder_service.TriggerProviderService.add_trigger_subscription"
- ) as add_subscription,
- patch("services.trigger.trigger_subscription_builder_service.redis_client.delete") as delete,
- ):
- TriggerSubscriptionBuilderService.update_and_build_builder(
- tenant_id="tenant-1",
- user_id="user-1",
- provider_id=PROVIDER_ID,
- subscription_builder_id=builder.id,
- subscription_builder_updater=SubscriptionBuilderUpdater(name="Updated"),
- )
-
- get_subscription_builder.assert_called_once_with(
- tenant_id="tenant-1",
- user_id="user-1",
- provider_id=PROVIDER_ID,
- subscription_builder_id=builder.id,
- )
- setex.assert_called_once_with(cache_key, 30 * 60, builder.model_dump_json())
- add_subscription.assert_called_once()
- subscription_call = add_subscription.call_args.kwargs
- assert subscription_call["subscription_id"] == builder.id
- assert subscription_call["tenant_id"] == "tenant-1"
- assert subscription_call["user_id"] == "user-1"
- assert subscription_call["provider_id"] == PROVIDER_ID
- assert subscription_call["endpoint_id"] == builder.endpoint_id
- assert subscription_call["name"] == "Updated"
- delete.assert_called_once_with(cache_key)
-
-
-def test_list_logs_uses_the_owned_builder_endpoint() -> None:
- builder = subscription_builder()
- logs_key = f"trigger:subscription:builder:logs:{builder.endpoint_id}"
-
- with (
- patch.object(TriggerSubscriptionBuilderService, "get_subscription_builder", return_value=builder),
- patch("services.trigger.trigger_subscription_builder_service.redis_client.get", return_value=None) as redis_get,
- ):
- assert (
- TriggerSubscriptionBuilderService.list_logs(
- tenant_id="tenant-1",
- user_id="user-1",
- provider_id=PROVIDER_ID,
- subscription_builder_id=builder.id,
- )
- == []
- )
-
- redis_get.assert_called_once_with(logs_key)
-
-
-def test_process_validation_endpoint_uses_the_public_capability() -> None:
- builder = subscription_builder()
- request = Mock()
- response = Mock()
- controller = Mock()
- controller.dispatch.return_value = Mock(response=response)
-
- with (
- patch.object(
- TriggerSubscriptionBuilderService,
- "_get_subscription_builder_by_endpoint_id",
- return_value=builder,
- ) as get_by_endpoint,
- patch.object(TriggerSubscriptionBuilderService, "get_subscription_builder") as get_owned,
- patch.object(TriggerManager, "get_trigger_provider", return_value=controller) as get_provider,
- patch.object(TriggerSubscriptionBuilderService, "append_log") as append_log,
- ):
- assert (
- TriggerSubscriptionBuilderService.process_builder_validation_endpoint(builder.endpoint_id, request)
- is response
- )
-
- get_by_endpoint.assert_called_once_with(builder.endpoint_id)
- get_owned.assert_not_called()
- get_provider.assert_called_once()
- provider_call = get_provider.call_args.kwargs
- assert provider_call["tenant_id"] == builder.tenant_id
- assert str(provider_call["provider_id"]) == str(PROVIDER_ID)
- controller.dispatch.assert_called_once()
- append_log.assert_called_once()
-
-
-def test_update_and_build_persists_provider_subscription_expires_at() -> None:
- """Authorized create must store the plugin lease, not the builder's -1 placeholder."""
- builder = subscription_builder().model_copy(
- update={
- "credential_type": CredentialType.OAUTH2,
- "credentials": {"token": "x"},
- "credential_expires_at": 1_787_560_741,
- }
- )
- assert builder.expires_at == -1
- real_lease = 1_787_560_681
- provider_subscription = Subscription(
- expires_at=real_lease,
- endpoint="https://dify.example.com/triggers/plugin/builder-1",
- parameters={"label_ids": ["INBOX"]},
- properties={"topic_name": "projects/p/topics/t"},
- )
-
- with (
- patch.object(TriggerManager, "get_trigger_provider", return_value=Mock()),
- patch.object(TriggerSubscriptionBuilderService, "acquire_builder_lock", return_value=nullcontext()),
- patch.object(TriggerSubscriptionBuilderService, "get_subscription_builder", return_value=builder),
- patch.object(TriggerManager, "subscribe_trigger", return_value=provider_subscription) as subscribe_trigger,
- patch(
- "services.trigger.trigger_subscription_builder_service.TriggerProviderService.add_trigger_subscription"
- ) as add_subscription,
- patch("services.trigger.trigger_subscription_builder_service.redis_client.setex"),
- patch("services.trigger.trigger_subscription_builder_service.redis_client.delete"),
- ):
- TriggerSubscriptionBuilderService.update_and_build_builder(
- tenant_id="tenant-1",
- user_id="user-1",
- provider_id=PROVIDER_ID,
- subscription_builder_id=builder.id,
- subscription_builder_updater=SubscriptionBuilderUpdater(),
- )
-
- subscribe_trigger.assert_called_once()
- add_subscription.assert_called_once()
- persisted = add_subscription.call_args.kwargs
- assert persisted["expires_at"] == real_lease
- assert persisted["expires_at"] != -1
- assert persisted["properties"] == {"topic_name": "projects/p/topics/t"}
- assert persisted["credential_expires_at"] == 1_787_560_741
- assert persisted["credentials"] == {"token": "x"}