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.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
refactor(api): inject trigger subscription builder lifecycle (#44532)
非法操作107bbf85ca65
diff --git a/api/.importlinter b/api/.importlinterindex 6becbed4160..90df3674e1f 100644--- a/api/.importlinter+++ b/api/.importlinter@@ -1444,3 +1444,16 @@ forbidden_modules =sqlalchemywerkzeugallow_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 = Truediff --git a/api/controllers/console/workspace/plugin.py b/api/controllers/console/workspace/plugin.pyindex 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 ToolProviderApiEntityfrom core.tools.entities.common_entities import I18nObjectfrom core.tools.entities.tool_entities import ToolProviderTypefrom core.tools.tool_manager import ToolManager+from extensions.ext_application_services import application_servicesfrom extensions.ext_database import dbfrom fields.base import ResponseModelfrom 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 ediff --git a/api/controllers/console/workspace/trigger_providers.py b/api/controllers/console/workspace/trigger_providers.pyindex 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 TriggerSubscriptionBuilderServicefrom services.trigger.trigger_subscription_operator_service import TriggerSubscriptionOperatorServicelogger = 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_requireddef 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.pyindex 26197d84112..b4acc2e8676 100644--- a/api/controllers/trigger/trigger.py+++ b/api/controllers/trigger/trigger.py@@ -1,12 +1,12 @@import loggingimport re-from flask import jsonify, request+from flask import Response, jsonify, requestfrom controllers.common.access_response import plugin_endpoint_not_found_responsefrom controllers.trigger import bp+from extensions.ext_application_services import application_servicesfrom services.trigger.trigger_service import TriggerService-from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderServicelogger = 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 UUIDif not UUID_MATCHER.match(endpoint_id):return plugin_endpoint_not_found_response()- handling_chain = [- TriggerService.process_endpoint,- TriggerSubscriptionBuilderService.process_builder_validation_endpoint,- ]- response = Nonetry:- 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.pyindex 2bacdf8db6e..f3d106d9f73 100644--- a/api/extensions/application_services/workspace.py+++ b/api/extensions/application_services/workspace.py@@ -5,11 +5,13 @@ from dataclasses import dataclassfrom sqlalchemy.orm import Session, sessionmakerfrom core.plugin.impl.oauth import OAuthHandler+from core.trigger.trigger_manager import TriggerManagerfrom extensions.ext_redis import RedisClientWrapperfrom repositories.account.repository import SQLAlchemyAccountRepositoryfrom repositories.app.console_repository import ConsoleAppRepositoryfrom repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepositoryfrom repositories.trigger.oauth_client_repository import TriggerOAuthClientRepository+from repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepositoryfrom repositories.workspace.resource_cleanup_repository import WorkspaceResourceCleanupRepositoryfrom repositories.workspace.workspace_repository import WorkspaceRepositoryfrom services.account.adapters import RedisInvitationTokenStore@@ -25,6 +27,8 @@ from services.trigger.oauth_service import TriggerOAuthServicefrom services.trigger.provider_gateway import PluginTriggerProviderQueryfrom services.trigger.provider_query import TriggerProviderQueryfrom services.trigger.subscription_query_service import TriggerSubscriptionQueryService+from services.trigger.trigger_provider_service import TriggerProviderService+from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderServicefrom services.workspace.gateways import (DeploymentWorkspaceCreationPolicy,DeploymentWorkspaceFeatureGateway,@@ -62,6 +66,7 @@ class WorkspaceServices:resource_cleanup: WorkspaceResourceCleanupServicetrigger_providers: TriggerProviderQuerytrigger_subscriptions: TriggerSubscriptionQueryService+ trigger_builders: TriggerSubscriptionBuilderServicetrigger_oauth_clients: TriggerOAuthClientServicetrigger_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.pynew file mode 100644index 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.pyindex 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 dbfrom models.provider_ids import TriggerProviderIDfrom models.tools import BuiltinToolProviderfrom services.trigger.trigger_provider_service import TriggerProviderService-from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService+from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderQueryclass 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 | Noneif 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.pyindex 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 = buildersdef 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.pyindex 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 loggingimport uuidfrom collections.abc import Mapping-from contextlib import contextmanager+from contextlib import AbstractContextManagerfrom datetime import datetime-from typing import Any+from typing import Any, Protocolfrom flask import Request, Response-from pydantic import TypeAdapterfrom core.plugin.entities.plugin_daemon import CredentialTypefrom 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 TriggerManagerfrom core.trigger.utils.encryption import masked_credentialsfrom core.trigger.utils.endpoint import generate_plugin_trigger_endpoint_url-from extensions.ext_redis import redis_clientfrom models.provider_ids import TriggerProviderID-from services.trigger.trigger_provider_service import TriggerProviderServicelogger = 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)- @classmethoddef 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)- @classmethoddef 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:# Updatesubscription_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}- @classmethoddef 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:# Updatesubscription_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+ @staticmethoddef 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_builderreturn None- @classmethoddef 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 Noneif (@@ -331,16 +349,15 @@ class TriggerSubscriptionBuilderService:raise ValueError(f"Subscription builder {subscription_builder_id} not found")return subscription_builder- @classmethoddef _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)- @classmethoddef 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 Nonetry:# 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- @classmethoddef 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.pynew file mode 100644index 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": {}}++[email protected]("runtime")+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.pyindex 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_servicesfrom extensions.ext_redis import redis_clientfrom models.provider_ids import TriggerProviderID+from repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepositoryfrom services.plugin.oauth_service import OAuthProxyServicefrom services.trigger.oauth_gateway import OAuthProxyContextGateway, TriggerOAuthBuilderGatewayfrom 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_contaiclass _CreatedBuilder:context: TriggerOAuthContextresponse: SubscriptionBuilderApiEntity+ gateway: TriggerOAuthBuilderGatewaydef _provider(tenant_id: str, provider_id: TriggerProviderID) -> PluginTriggerProviderController:@@ -137,9 +139,8 @@ def created_builder(flask_app_with_containers: Flask) -> Iterator[_CreatedBuildecontexts.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[_CreatedBuildeplugin_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 Nonereturn SubscriptionBuilder.model_validate_json(cached)@@ -176,7 +177,7 @@ def test_builder_gateway_creates_owned_oauth_builder(created_builder: _CreatedBuassert stored.credential_expires_at == -1assert 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 * 60def 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: _Cbefore = _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.pynew file mode 100644index 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 Nonediff --git a/api/tests/e2e_tests/containers/services/test_trigger_subscription_query.py b/api/tests/e2e_tests/containers/services/test_trigger_subscription_query.pyindex 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 imfrom tests.unit_tests.controllers.console.workspace.test_trigger_provider_query import _Daemon, _providerfrom tests.unit_tests.controllers.console.workspace.test_trigger_subscription_query import _LIST, _add_subscription+application_redis = test_trigger_oauth_client.application_redisharness = test_trigger_oauth_client.harnessdaemon = test_trigger_provider_query.daemondiff --git a/api/tests/unit_tests/controllers/common/test_access_response.py b/api/tests/unit_tests/controllers/common/test_access_response.pyindex 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, sessionmakerfrom werkzeug.exceptions import NotFound, Unauthorizedimport controllers.service_api.wraps as token_wraps-import controllers.trigger.trigger as plugin_triggerimport services.api_token_service as token_servicefrom 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.pyindex 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, patchimport pytestfrom flask import Flask+from sqlalchemy.orm import Session, sessionmakerfrom werkzeug.datastructures import FileStoragefrom werkzeug.exceptions import Forbidden@@ -72,6 +73,9 @@ from core.plugin.plugin_service import PluginServicefrom core.tools.entities.api_entities import ToolProviderApiEntityfrom core.tools.entities.common_entities import I18nObjectfrom 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 RedisClientWrapperfrom models.account import (Account,TenantAccountRole,@@ -85,6 +89,9 @@ from models.account import (from tests.helpers.unit.config_override import config_overrides_contextfrom tests.helpers.unit.controllers.error_body import raised_errorfrom 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_redisdef _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"] = servicesapi = 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_buildersclass 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.pyindex 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._providerwith (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.pyindex 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_clientfrom tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _PROVIDER, _Harness+application_redis = test_trigger_oauth_client.application_redisharness = 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.pyindex 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 TenantAccountRolefrom tests.unit_tests.controllers.console.workspace import test_trigger_oauth_clientfrom tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _PROVIDER, _Harness+application_redis = test_trigger_oauth_client.application_redisharness = 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.pyindex 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 annotationsfrom collections.abc import Iterator-from datetime import datetimefrom importlib import import_modulefrom inspect import unwrap-from unittest.mock import ANY, MagicMock, patch+from unittest.mock import MagicMock, patchimport pytestfrom flask import Flask@@ -14,14 +13,7 @@ from werkzeug.exceptions import BadRequestfrom controllers.common.errors import NotFoundErrorfrom 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 RequestLogfrom models.account import Accountfrom 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.pynew file mode 100644index 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.pyindex 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 jsonfrom contextvars import Contextfrom http import HTTPStatus-from http.server import BaseHTTPRequestHandler, HTTPServer-from threading import Thread-from typing import overridefrom uuid import uuid4import pytest@@ -16,12 +12,12 @@ from models import TenantAccountJoinfrom models.account import Account, AccountStatus, TenantAccountRolefrom models.enums import PermissionEnumfrom models.trigger import TriggerSubscription-from services.enterprise.base import EnterpriseRequestfrom tests.helpers.unit.config_override import config_overrides_contextfrom tests.unit_tests.controllers.console.workspace import test_trigger_oauth_client, test_trigger_provider_queryfrom tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _PROVIDER, _Harnessfrom tests.unit_tests.controllers.console.workspace.test_trigger_provider_query import _Daemon+application_redis = test_trigger_oauth_client.application_redisharness = test_trigger_oauth_client.harnessdaemon = 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 Noneaccount.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.pyindex 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 pytestfrom flask import Flaskfrom flask.typing import ResponseReturnValuefrom flask_restx import Api, Resource+from redis import Redisfrom sqlalchemy.orm import Session, sessionmakerfrom werkzeug.exceptions import UnprocessableEntityfrom controllers.inner_api.workspace import workspace as controllerfrom controllers.inner_api.wraps import InnerApiUnauthorizedErrorfrom core.plugin.impl.oauth import OAuthHandler+from core.trigger.trigger_manager import TriggerManagerfrom extensions.application_services.workspace import WorkspaceServices+from extensions.ext_redis import RedisClientWrapperfrom libs.external_api import register_external_error_handlersfrom repositories.credentials.query_repository import CredentialQueryRepositoryfrom repositories.trigger.oauth_client_repository import TriggerOAuthClientRepository+from repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepositoryfrom services.account_errors import AccountNotFoundErrorfrom services.errors.workspace import (InvalidWorkspaceMemberRoleError,@@ -36,6 +40,8 @@ from services.trigger.oauth_gateway import (from services.trigger.oauth_service import TriggerOAuthServicefrom services.trigger.provider_gateway import PluginTriggerProviderQueryfrom services.trigger.subscription_query_service import TriggerSubscriptionQueryService+from services.trigger.trigger_provider_service import TriggerProviderService+from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderServicefrom services.workspace.contracts import CreatedWorkspace, WorkspaceMembershipfrom services.workspace.provisioning_service import WorkspaceProvisioningServicefrom 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.pyindex 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.pyindex 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 TagApplicationServicefrom services.tool_file_download_service import ToolFileDownloadServicefrom services.tracing.adapters import CeleryTraceEmitterfrom services.tracing.runtime_bridge import RuntimeApplicationTracingHooks+from services.trigger.oauth_gateway import TriggerOAuthBuilderGatewayfrom services.upload_file_delivery_service import UploadFileDeliveryServicefrom 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_queriesassert 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_buildersdef 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.pyindex 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 annotationsimport jsonfrom collections.abc import Iterator+from threading import Lockfrom unittest.mock import MagicMock, patchfrom uuid import uuid4import pytestfrom flask import Flask+from redis import Redisfrom sqlalchemy.orm import Session+import contextsfrom core.plugin.entities.plugin_daemon import CredentialType-from core.trigger.provider import PluginTriggerProviderControllerfrom core.trigger.trigger_manager import TriggerManager+from extensions.ext_redis import RedisClientWrapperfrom models.engine import dbfrom models.provider_ids import TriggerProviderIDfrom models.tools import BuiltinToolProvider+from repositories.trigger.subscription_builder_repository import RedisTriggerSubscriptionBuilderRepositoryfrom services.plugin.plugin_parameter_service import PluginParameterService+from services.trigger.trigger_provider_service import TriggerProviderService+from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderServicefrom 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.pydeleted file mode 100644index 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"}