Skip to content

armgit / dify

Public Imported from GitHub
0

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

refactor(api): isolate trigger provider and subscription queries (#44514)

非法操作db3ffcc92b96
diff --git a/api/.importlinter b/api/.importlinter
index fa65cae4b57..6becbed4160 100644
--- a/api/.importlinter
+++ b/api/.importlinter
@@ -1434,6 +1434,8 @@ type = forbidden
source_modules =
services.trigger.oauth_client_service
services.trigger.oauth_service
+ services.trigger.provider_query
+ services.trigger.subscription_query_service
forbidden_modules =
controllers
extensions
diff --git a/api/controllers/console/workspace/trigger_providers.py b/api/controllers/console/workspace/trigger_providers.py
index dd2dbaa5d9e..9bd463966d7 100644
--- a/api/controllers/console/workspace/trigger_providers.py
+++ b/api/controllers/console/workspace/trigger_providers.py
@@ -41,7 +41,6 @@ from core.trigger.entities.api_entities import (
TriggerProviderSubscriptionApiEntity,
)
from core.trigger.entities.entities import RequestLog, SubscriptionBuilderUpdater
-from core.trigger.trigger_manager import TriggerManager
from enums.account import TenantAccountRole
from extensions.ext_application_services import application_services
from extensions.ext_database import db
@@ -163,79 +162,77 @@ register_response_schema_models(
@console_ns.route("/workspaces/current/trigger-provider/<path:provider>/icon")
class TriggerProviderIconApi(Resource):
- # response-contract:ignore binary trigger provider icon
- @console_ns.response(200, "Trigger provider icon")
- @setup_required
- @login_required
- @account_initialization_required
- @with_current_tenant_id
- def get(self, tenant_id: str, provider: str):
- return TriggerManager.get_trigger_plugin_icon(tenant_id=tenant_id, provider_id=provider)
+ # response-contract:ignore legacy JSON string containing the icon URL
+ @console_ns.response(HTTPStatus.OK, "Trigger provider icon")
+ @console_account_admission()
+ def get(self, context: RequestContext, provider: str) -> str:
+ return application_services().workspaces.trigger_providers.get_icon(
+ tenant_id=context.active_workspace_id, provider_id=TriggerProviderID(provider)
+ )
@console_ns.route("/workspaces/current/triggers")
class TriggerProviderListApi(Resource):
@console_ns.response(
- 200,
+ HTTPStatus.OK,
"Trigger providers retrieved successfully",
console_ns.models[TriggerProviderListResponse.__name__],
)
- @setup_required
- @login_required
- @account_initialization_required
- @with_current_tenant_id
- def get(self, tenant_id: str):
+ @console_account_admission()
+ def get(self, context: RequestContext) -> list[dict[str, Any]]:
"""List all trigger providers for the current tenant"""
- return dump_response(TriggerProviderListResponse, TriggerProviderService.list_trigger_providers(tenant_id))
+ return TriggerProviderListResponse(
+ application_services().workspaces.trigger_providers.list(tenant_id=context.active_workspace_id),
+ ).model_dump(mode="json")
@console_ns.route("/workspaces/current/trigger-provider/<path:provider>/info")
class TriggerProviderInfoApi(Resource):
@console_ns.response(
- 200,
+ HTTPStatus.OK,
"Trigger provider retrieved successfully",
console_ns.models[TriggerProviderApiEntity.__name__],
)
- @setup_required
- @login_required
- @account_initialization_required
- @with_current_tenant_id
- def get(self, tenant_id: str, provider: str):
+ @console_account_admission()
+ def get(self, context: RequestContext, provider: str) -> dict[str, Any]:
"""Get info for a trigger provider"""
- provider_entity = TriggerProviderService.get_trigger_provider(tenant_id, TriggerProviderID(provider))
- return provider_entity.model_dump(mode="json")
+ return dump_response(
+ TriggerProviderApiEntity,
+ application_services().workspaces.trigger_providers.get(
+ tenant_id=context.active_workspace_id, provider_id=TriggerProviderID(provider)
+ ),
+ )
@console_ns.route("/workspaces/current/trigger-provider/<path:provider>/subscriptions/list")
class TriggerSubscriptionListApi(Resource):
@console_ns.response(
- 200,
+ HTTPStatus.OK,
"Trigger subscriptions retrieved successfully",
console_ns.models[TriggerProviderSubscriptionListResponse.__name__],
)
- @console_ns.response(404, "Trigger provider not found", console_ns.models[TriggerProviderErrorResponse.__name__])
- @setup_required
- @login_required
- @edit_permission_required
- @rbac_permission_required(RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace()))
+ @console_ns.response(
+ HTTPStatus.NOT_FOUND, "Trigger provider not found", console_ns.models[TriggerProviderErrorResponse.__name__]
+ )
+ @console_account_admission(
+ require_initialized=False,
+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}),
+ rbac_checks=[RBACCheck(RBACPermission.PLUGIN_PREFERENCES, Workspace())],
+ )
@account_initialization_required
- @with_current_user
- @with_current_tenant_id
- def get(self, tenant_id: str, user: Account, provider: str):
+ def get(self, context: RequestContext, provider: str) -> list[dict[str, Any]] | tuple[dict[str, Any], HTTPStatus]:
"""List all trigger subscriptions for the current tenant's provider"""
try:
- return dump_response(
- TriggerProviderSubscriptionListResponse,
- TriggerProviderService.list_trigger_provider_subscriptions(
- tenant_id=tenant_id,
+ return TriggerProviderSubscriptionListResponse(
+ application_services().workspaces.trigger_subscriptions.list(
+ tenant_id=context.active_workspace_id,
+ account_id=context.account_id,
provider_id=TriggerProviderID(provider),
- user=user,
- credential_query=application_services().credential_queries,
),
- )
+ ).model_dump(mode="json")
except ValueError as e:
- return TriggerProviderErrorResponse(error=str(e)).model_dump(mode="json"), 404
+ return TriggerProviderErrorResponse(error=str(e)).model_dump(mode="json"), HTTPStatus.NOT_FOUND
except Exception as e:
logger.exception("Error listing trigger providers", exc_info=e)
raise
diff --git a/api/extensions/application_services/workspace.py b/api/extensions/application_services/workspace.py
index 96895b623c4..2bacdf8db6e 100644
--- a/api/extensions/application_services/workspace.py
+++ b/api/extensions/application_services/workspace.py
@@ -13,6 +13,7 @@ from repositories.trigger.oauth_client_repository import TriggerOAuthClientRepos
from repositories.workspace.resource_cleanup_repository import WorkspaceResourceCleanupRepository
from repositories.workspace.workspace_repository import WorkspaceRepository
from services.account.adapters import RedisInvitationTokenStore
+from services.credentials.query import CredentialQuery
from services.file_service import FileService
from services.trigger.oauth_client_service import TriggerOAuthClientService
from services.trigger.oauth_gateway import (
@@ -21,6 +22,9 @@ from services.trigger.oauth_gateway import (
TriggerOAuthBuilderGateway,
)
from services.trigger.oauth_service import TriggerOAuthService
+from services.trigger.provider_gateway import PluginTriggerProviderQuery
+from services.trigger.provider_query import TriggerProviderQuery
+from services.trigger.subscription_query_service import TriggerSubscriptionQueryService
from services.workspace.gateways import (
DeploymentWorkspaceCreationPolicy,
DeploymentWorkspaceFeatureGateway,
@@ -56,6 +60,8 @@ class WorkspaceServices:
invitations: WorkspaceInvitationService
identity: WorkspaceIdentityGateway
resource_cleanup: WorkspaceResourceCleanupService
+ trigger_providers: TriggerProviderQuery
+ trigger_subscriptions: TriggerSubscriptionQueryService
trigger_oauth_clients: TriggerOAuthClientService
trigger_oauth: TriggerOAuthService
@@ -93,11 +99,13 @@ def build_workspace_services(
provisioning: WorkspaceProvisioningService,
registration: InvitedAccountRegistration,
invitation_tokens: RedisInvitationTokenStore,
+ credentials: CredentialQuery,
) -> WorkspaceServices:
- trigger_providers = PluginTriggerOAuthGateway(oauth=OAuthHandler())
+ trigger_providers = PluginTriggerProviderQuery()
+ trigger_oauth_provider = PluginTriggerOAuthGateway(oauth=OAuthHandler())
trigger_oauth_clients = TriggerOAuthClientService(
clients=TriggerOAuthClientRepository(session_factory=database_client),
- providers=trigger_providers,
+ providers=trigger_oauth_provider,
)
return WorkspaceServices(
queries=WorkspaceQueryService(workspaces=workspaces, plans=DeploymentWorkspacePlanGateway()),
@@ -131,10 +139,12 @@ def build_workspace_services(
datasets=SQLAlchemyDatasetRepository(session_factory=database_client),
agent_resources=WorkspaceResourceCleanupRepository(session_factory=database_client),
),
+ trigger_providers=trigger_providers,
+ trigger_subscriptions=TriggerSubscriptionQueryService(credentials=credentials, schemas=trigger_providers),
trigger_oauth_clients=trigger_oauth_clients,
trigger_oauth=TriggerOAuthService(
clients=trigger_oauth_clients,
- providers=trigger_providers,
+ providers=trigger_oauth_provider,
contexts=OAuthProxyContextGateway(),
builders=TriggerOAuthBuilderGateway(),
),
diff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.py
index 8bedb8fc91c..bc117963922 100644
--- a/api/extensions/ext_application_services.py
+++ b/api/extensions/ext_application_services.py
@@ -575,6 +575,7 @@ def build_application_services(
invitation_tokens=invitation_tokens,
activation_accounts=activation_accounts,
)
+ credential_queries = CredentialQueryRepository(session_factory=database_client)
workspace_services = build_workspace_services(
database_client=database_client,
workspaces=workspace_repository,
@@ -585,6 +586,7 @@ def build_application_services(
provisioning=workspace_provisioning,
registration=account_services.lifecycle,
invitation_tokens=invitation_tokens,
+ credentials=credential_queries,
)
conversations = ConversationRepository(session_factory=database_client)
conversation_names = ConversationNameService(
@@ -639,7 +641,7 @@ def build_application_services(
conversation_queries=conversation_queries,
accounts=account_services,
apps=apps,
- credential_queries=CredentialQueryRepository(session_factory=database_client),
+ credential_queries=credential_queries,
agent_apps=build_agent_app_services(database_client=database_client),
advanced_prompt_templates=AdvancedPromptTemplateService(),
app_definitions=app_definitions,
diff --git a/api/services/trigger/provider_gateway.py b/api/services/trigger/provider_gateway.py
new file mode 100644
index 00000000000..cd4b7833f4e
--- /dev/null
+++ b/api/services/trigger/provider_gateway.py
@@ -0,0 +1,34 @@
+"""Adapt plugin trigger declarations to the workspace provider query contract."""
+
+from core.plugin.entities.plugin_daemon import CredentialType
+from core.trigger.entities.api_entities import TriggerProviderApiEntity
+from core.trigger.trigger_manager import TriggerManager
+from models.provider_ids import TriggerProviderID
+from services.trigger.subscription_query_service import TriggerSubscriptionSchemas
+
+
+class PluginTriggerProviderQuery:
+ def list(self, *, tenant_id: str) -> list[TriggerProviderApiEntity]:
+ return [provider.to_api_entity() for provider in TriggerManager.list_all_trigger_providers(tenant_id)]
+
+ def get(self, *, tenant_id: str, provider_id: TriggerProviderID) -> TriggerProviderApiEntity:
+ return TriggerManager.get_trigger_provider(tenant_id, provider_id).to_api_entity()
+
+ def get_icon(self, *, tenant_id: str, provider_id: TriggerProviderID) -> str:
+ return TriggerManager.get_trigger_plugin_icon(tenant_id=tenant_id, provider_id=str(provider_id))
+
+ def get_subscription_schemas(
+ self,
+ *,
+ tenant_id: str,
+ provider_id: TriggerProviderID,
+ credential_types: frozenset[CredentialType],
+ ) -> TriggerSubscriptionSchemas:
+ provider = TriggerManager.get_trigger_provider(tenant_id, provider_id)
+ return TriggerSubscriptionSchemas(
+ credentials={
+ credential_type: provider.get_credential_schema_config(credential_type)
+ for credential_type in credential_types
+ },
+ properties=provider.get_properties_schema(),
+ )
diff --git a/api/services/trigger/provider_query.py b/api/services/trigger/provider_query.py
new file mode 100644
index 00000000000..5f9bd37a4e8
--- /dev/null
+++ b/api/services/trigger/provider_query.py
@@ -0,0 +1,16 @@
+"""Read contract for the trigger providers installed in a workspace."""
+
+from typing import Protocol
+
+from core.trigger.entities.api_entities import TriggerProviderApiEntity
+from models.provider_ids import TriggerProviderID
+
+
+class TriggerProviderQuery(Protocol):
+ def list(self, *, tenant_id: str) -> list[TriggerProviderApiEntity]: ...
+
+ def get(self, *, tenant_id: str, provider_id: TriggerProviderID) -> TriggerProviderApiEntity: ...
+
+ def get_icon(self, *, tenant_id: str, provider_id: TriggerProviderID) -> str:
+ """Return the icon URL, not the icon bytes."""
+ ...
diff --git a/api/services/trigger/subscription_query_service.py b/api/services/trigger/subscription_query_service.py
new file mode 100644
index 00000000000..0cadd156fe6
--- /dev/null
+++ b/api/services/trigger/subscription_query_service.py
@@ -0,0 +1,96 @@
+"""Read visible trigger subscriptions and mask their credentials outside the query transaction."""
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Protocol
+
+from core.entities.provider_entities import BasicProviderConfig
+from core.helper.provider_encryption import create_provider_encrypter
+from core.plugin.entities.plugin_daemon import CredentialType
+from core.trigger.entities.api_entities import TriggerProviderSubscriptionApiEntity
+from core.trigger.utils.encryption import TriggerProviderCredentialsCache, TriggerProviderPropertiesCache
+from core.trigger.utils.endpoint import generate_plugin_trigger_endpoint_url
+from models.provider_ids import TriggerProviderID
+from services.credentials.query import CredentialQuery
+
+
+@dataclass(frozen=True, slots=True)
+class TriggerSubscriptionSchemas:
+ credentials: Mapping[CredentialType, list[BasicProviderConfig]]
+ properties: list[BasicProviderConfig]
+
+
+class TriggerSubscriptionSchemaQuery(Protocol):
+ def get_subscription_schemas(
+ self,
+ *,
+ tenant_id: str,
+ provider_id: TriggerProviderID,
+ credential_types: frozenset[CredentialType],
+ ) -> TriggerSubscriptionSchemas: ...
+
+
+class TriggerSubscriptionQueryService:
+ """Compose visible records with plugin schemas after the read session closes.
+
+ Credential decryption and caching remain with the shared encryption helpers.
+ """
+
+ def __init__(self, *, credentials: CredentialQuery, schemas: TriggerSubscriptionSchemaQuery) -> None:
+ self._credentials = credentials
+ self._schemas = schemas
+
+ def list(
+ self, *, tenant_id: str, account_id: str, provider_id: TriggerProviderID
+ ) -> list[TriggerProviderSubscriptionApiEntity]:
+ rows = self._credentials.list_trigger_subscriptions(
+ workspace_id=tenant_id,
+ provider=str(provider_id),
+ actor_id=account_id,
+ )
+ if not rows:
+ return []
+
+ schemas = self._schemas.get_subscription_schemas(
+ tenant_id=tenant_id,
+ provider_id=provider_id,
+ credential_types=frozenset(row.credential_type for row in rows),
+ )
+ subscriptions: list[TriggerProviderSubscriptionApiEntity] = []
+ for row in rows:
+ credential_encrypter, _ = create_provider_encrypter(
+ tenant_id=tenant_id,
+ config=schemas.credentials[row.credential_type],
+ cache=TriggerProviderCredentialsCache(
+ tenant_id=tenant_id,
+ provider_id=str(provider_id),
+ credential_id=row.id,
+ ),
+ )
+ properties_encrypter, _ = create_provider_encrypter(
+ tenant_id=tenant_id,
+ config=schemas.properties,
+ cache=TriggerProviderPropertiesCache(
+ tenant_id=tenant_id,
+ provider_id=str(provider_id),
+ subscription_id=row.id,
+ ),
+ )
+ subscriptions.append(
+ TriggerProviderSubscriptionApiEntity(
+ id=row.id,
+ name=row.name,
+ provider=row.provider,
+ credential_type=row.credential_type,
+ credentials=dict(
+ credential_encrypter.mask_credentials(credential_encrypter.decrypt(row.credentials))
+ ),
+ endpoint=generate_plugin_trigger_endpoint_url(row.endpoint_id),
+ parameters=dict(row.parameters),
+ properties=dict(
+ properties_encrypter.mask_credentials(properties_encrypter.decrypt(row.properties))
+ ),
+ workflows_in_use=row.workflows_in_use,
+ )
+ )
+ return subscriptions
diff --git a/api/services/trigger/trigger_provider_service.py b/api/services/trigger/trigger_provider_service.py
index 3741ffd37de..97180dd5e03 100644
--- a/api/services/trigger/trigger_provider_service.py
+++ b/api/services/trigger/trigger_provider_service.py
@@ -2,13 +2,7 @@ import logging
import time as _time
import uuid
from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, TypedDict
-
-from services.credentials.query import CredentialQuery
-from services.plugin.dispatch_identity import PluginOAuthClientConfig
-
-if TYPE_CHECKING:
- from models.account import Account
+from typing import Any, TypedDict
from sqlalchemy import func, select
from sqlalchemy.orm import Session, sessionmaker
@@ -21,10 +15,6 @@ from core.plugin.entities.plugin_daemon import CredentialType
from core.plugin.impl.oauth import OAuthHandler
from core.plugin.plugin_service import PluginService
from core.tools.utils.system_encryption import decrypt_system_params
-from core.trigger.entities.api_entities import (
- TriggerProviderApiEntity,
- TriggerProviderSubscriptionApiEntity,
-)
from core.trigger.entities.entities import Subscription as TriggerSubscriptionEntity
from core.trigger.provider import PluginTriggerProviderController
from core.trigger.trigger_manager import TriggerManager
@@ -42,6 +32,7 @@ from models.trigger import (
TriggerOAuthTenantClient,
TriggerSubscription,
)
+from services.plugin.dispatch_identity import PluginOAuthClientConfig
logger = logging.getLogger(__name__)
@@ -58,67 +49,6 @@ class TriggerProviderService:
##########################
__MAX_TRIGGER_PROVIDER_COUNT__ = 10
- @classmethod
- def get_trigger_provider(cls, tenant_id: str, provider: TriggerProviderID) -> TriggerProviderApiEntity:
- """Get info for a trigger provider"""
- return TriggerManager.get_trigger_provider(tenant_id, provider).to_api_entity()
-
- @classmethod
- def list_trigger_providers(cls, tenant_id: str) -> list[TriggerProviderApiEntity]:
- """List all trigger providers for the current tenant"""
- return [provider.to_api_entity() for provider in TriggerManager.list_all_trigger_providers(tenant_id)]
-
- @classmethod
- def list_trigger_provider_subscriptions(
- cls,
- tenant_id: str,
- provider_id: TriggerProviderID,
- user: "Account | None" = None,
- *,
- credential_query: CredentialQuery,
- ) -> list[TriggerProviderSubscriptionApiEntity]:
- """List all trigger subscriptions for the current tenant, filtered by visibility."""
- subscriptions = [
- TriggerProviderSubscriptionApiEntity(
- id=row.id,
- name=row.name,
- provider=row.provider,
- credential_type=row.credential_type,
- credentials=dict(row.credentials),
- endpoint=generate_plugin_trigger_endpoint_url(row.endpoint_id),
- parameters=dict(row.parameters),
- properties=dict(row.properties),
- workflows_in_use=row.workflows_in_use,
- )
- for row in credential_query.list_trigger_subscriptions(
- workspace_id=tenant_id, provider=str(provider_id), actor_id=user.id if user else None
- )
- ]
- if not subscriptions:
- return []
-
- provider_controller = TriggerManager.get_trigger_provider(tenant_id, provider_id)
- for subscription in subscriptions:
- credential_encrypter, _ = create_trigger_provider_encrypter_for_subscription(
- tenant_id=tenant_id,
- controller=provider_controller,
- subscription=subscription,
- )
- subscription.credentials = dict(
- credential_encrypter.mask_credentials(dict(credential_encrypter.decrypt(subscription.credentials)))
- )
- properties_encrypter, _ = create_trigger_provider_encrypter_for_properties(
- tenant_id=tenant_id,
- controller=provider_controller,
- subscription=subscription,
- )
- subscription.properties = dict(
- properties_encrypter.mask_credentials(dict(properties_encrypter.decrypt(subscription.properties)))
- )
- subscription.parameters = dict(subscription.parameters)
-
- return subscriptions
-
@classmethod
def add_trigger_subscription(
cls,
diff --git a/api/tests/e2e_tests/containers/services/test_trigger_subscription_query.py b/api/tests/e2e_tests/containers/services/test_trigger_subscription_query.py
new file mode 100644
index 00000000000..b417a89905f
--- /dev/null
+++ b/api/tests/e2e_tests/containers/services/test_trigger_subscription_query.py
@@ -0,0 +1,178 @@
+"""Subscription HTTP reads use real plugin HTTP, RSA, SQL and Redis credential caches."""
+
+import json
+from collections.abc import Iterator
+from contextvars import Context
+from http import HTTPStatus
+from pathlib import Path
+from uuid import uuid4
+
+import pytest
+from flask import Flask
+from sqlalchemy import Engine, create_engine, select
+from sqlalchemy.orm import Session, sessionmaker
+
+from core.entities.provider_entities import ProviderConfig, ProviderConfigType
+from core.helper.encrypter import encrypt_token
+from core.plugin.entities.plugin_daemon import CredentialType
+from core.trigger.utils.encryption import TriggerProviderCredentialsCache, TriggerProviderPropertiesCache
+from core.trigger.utils.endpoint import generate_plugin_trigger_endpoint_url
+from extensions.ext_redis import redis_client
+from models.base import TypeBase
+from models.credential_permission import CredentialPermission
+from models.credential_permission import CredentialType as PermissionCredentialType
+from models.enums import PermissionEnum
+from models.trigger import TriggerSubscription, WorkflowPluginTrigger
+from tests.unit_tests.controllers.console.workspace import test_trigger_oauth_client, test_trigger_provider_query
+from tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _PROVIDER, _Harness
+from tests.unit_tests.controllers.console.workspace.test_trigger_provider_query import _Daemon, _provider
+from tests.unit_tests.controllers.console.workspace.test_trigger_subscription_query import _LIST, _add_subscription
+
+harness = test_trigger_oauth_client.harness
+daemon = test_trigger_provider_query.daemon
+
+
+def sqlite_engine(flask_app_with_containers: Flask, tmp_path: Path) -> Iterator[Engine]:
+ # Reuse the real HTTP/admission harness with an isolated SQL database. Redis
+ # is the container-backed production cache, initialized by the Flask fixture.
+ assert redis_client is flask_app_with_containers.extensions["redis"]
+ engine = create_engine(f"sqlite:///{tmp_path / 'subscriptions.sqlite3'}")
+ TypeBase.metadata.create_all(engine)
+ try:
+ yield engine
+ finally:
+ engine.dispose()
+
+
+def sqlite_session_factory(sqlite_engine: Engine) -> sessionmaker[Session]:
+ return sessionmaker(bind=sqlite_engine, expire_on_commit=False)
+
+
+def _provider_with_secrets() -> dict[str, object]:
+ provider = _provider()
+ declaration = provider["declaration"]
+ assert isinstance(declaration, dict)
+ credential_schema = [
+ ProviderConfig(name="token", type=ProviderConfigType.SECRET_INPUT).model_dump(mode="json"),
+ ProviderConfig(name="username", type=ProviderConfigType.TEXT_INPUT).model_dump(mode="json"),
+ ]
+ declaration["subscription_constructor"] = {
+ "credentials_schema": credential_schema,
+ "oauth_schema": {"credentials_schema": credential_schema},
+ }
+ declaration["subscription_schema"] = [
+ ProviderConfig(name="secret", type=ProviderConfigType.SECRET_INPUT).model_dump(mode="json"),
+ ProviderConfig(name="repository", type=ProviderConfigType.TEXT_INPUT).model_dump(mode="json"),
+ ]
+ return provider
+
+
+ "credential_type", [CredentialType.API_KEY, CredentialType.OAUTH2, CredentialType.UNAUTHORIZED]
+)
+def test_subscription_http_masks_real_secrets_and_preserves_visibility_and_workflow_counts(
+ harness: _Harness, daemon: _Daemon, credential_type: CredentialType
+) -> None:
+ daemon.response = _provider_with_secrets()
+ with harness.app.app_context():
+ ciphertext = encrypt_token(harness.tenant_id, "credential-secret")
+ property_ciphertext = encrypt_token(harness.tenant_id, "property-secret")
+ credentials = {} if credential_type == CredentialType.UNAUTHORIZED else {"token": ciphertext, "username": "octocat"}
+ visible = [
+ _add_subscription(
+ harness,
+ name="personal",
+ credential_type=credential_type,
+ credentials=credentials,
+ properties={"secret": property_ciphertext, "repository": "dify"},
+ visibility=PermissionEnum.ONLY_ME,
+ ),
+ _add_subscription(harness, name="team", user_id=str(uuid4())),
+ _add_subscription(harness, name="shared", user_id=str(uuid4()), visibility=PermissionEnum.PARTIAL_TEAM),
+ ]
+ _add_subscription(harness, name="private", user_id=str(uuid4()), visibility=PermissionEnum.ONLY_ME)
+ revoked = _add_subscription(harness, name="revoked", user_id=str(uuid4()), visibility=PermissionEnum.PARTIAL_TEAM)
+ _add_subscription(harness, name="foreign-tenant", tenant_id=str(uuid4()))
+ _add_subscription(harness, name="foreign-provider", provider_id="langgenius/github/other")
+ app_id = str(uuid4())
+ with harness.session_factory.begin() as session:
+ session.add_all(
+ [
+ CredentialPermission(
+ credential_id=row.id,
+ credential_type=PermissionCredentialType.TRIGGER_SUBSCRIPTION,
+ account_id=harness.account_id,
+ tenant_id=harness.tenant_id,
+ has_permission=allowed,
+ )
+ for row, allowed in [(visible[2], True), (revoked, False)]
+ ]
+ + [
+ WorkflowPluginTrigger(
+ app_id=app_id,
+ node_id=f"node-{index}",
+ tenant_id=harness.tenant_id,
+ provider_id=_PROVIDER,
+ event_name="push",
+ subscription_id=visible[0].id,
+ )
+ for index in range(2)
+ ]
+ + [
+ WorkflowPluginTrigger(
+ app_id=str(uuid4()),
+ node_id="foreign-node",
+ tenant_id=str(uuid4()),
+ provider_id=_PROVIDER,
+ event_name="push",
+ subscription_id=visible[0].id,
+ )
+ ]
+ )
+
+ response = Context().run(harness.call, "GET", url=_LIST)
+
+ assert response.status_code == HTTPStatus.OK
+ assert response.content_type == "application/json"
+ rows = {row["id"]: row for row in response.get_json()}
+ assert rows.keys() == {row.id for row in visible}
+ target = visible[0]
+ assert rows[target.id] == {
+ "id": target.id,
+ "name": "personal",
+ "provider": _PROVIDER,
+ "credential_type": credential_type.value,
+ "credentials": {}
+ if credential_type == CredentialType.UNAUTHORIZED
+ else {"token": "cr*************et", "username": "octocat"},
+ "endpoint": generate_plugin_trigger_endpoint_url(target.endpoint_id),
+ "parameters": {"event": "push"},
+ "properties": {"secret": "pr***********et", "repository": "dify"},
+ "workflows_in_use": 1,
+ }
+ assert all(rows[row.id]["workflows_in_use"] == 0 for row in visible[1:])
+ assert len(daemon.requests) == 1
+ assert not daemon.requests[0].open_transactions
+ with harness.session_factory() as session:
+ saved = session.scalar(select(TriggerSubscription).where(TriggerSubscription.id == target.id))
+ assert saved is not None
+ assert saved.credentials == credentials
+ assert saved.properties == {"secret": property_ciphertext, "repository": "dify"}
+
+ # The normal cache must contain decrypted values while the HTTP response
+ # remains masked, including on a second request served from that cache.
+ key = TriggerProviderPropertiesCache(harness.tenant_id, _PROVIDER, target.id).cache_key
+ cached = redis_client.get(key)
+ assert cached is not None
+ assert json.loads(cached) == {"secret": "property-secret", "repository": "dify"}
+ credential_key = TriggerProviderCredentialsCache(harness.tenant_id, _PROVIDER, target.id).cache_key
+ cached_credentials = redis_client.get(credential_key)
+ assert cached_credentials is not None
+ assert json.loads(cached_credentials) == (
+ {} if credential_type == CredentialType.UNAUTHORIZED else {"token": "credential-secret", "username": "octocat"}
+ )
+ repeated = Context().run(harness.call, "GET", url=_LIST)
+ assert repeated.status_code == HTTPStatus.OK
+ assert repeated.get_json() == response.get_json()
diff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_client.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_oauth_client.py
index b86b2bb925d..e703487338f 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
@@ -20,6 +20,10 @@ from controllers.console.workspace.trigger_providers import (
TriggerOAuthAuthorizeApi,
TriggerOAuthCallbackApi,
TriggerOAuthClientManageApi,
+ TriggerProviderIconApi,
+ TriggerProviderInfoApi,
+ TriggerProviderListApi,
+ TriggerSubscriptionListApi,
)
from controllers.console.wraps import _is_setup_completed
from core.entities.provider_entities import ProviderConfig, ProviderConfigType
@@ -215,6 +219,12 @@ def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]
login_manager.init_app(app)
blueprint = Blueprint("console", __name__, url_prefix="/console/api")
api = ExternalApi(blueprint)
+ api.add_resource(TriggerProviderListApi, "/workspaces/current/triggers")
+ api.add_resource(TriggerProviderInfoApi, "/workspaces/current/trigger-provider/<path:provider>/info")
+ api.add_resource(TriggerProviderIconApi, "/workspaces/current/trigger-provider/<path:provider>/icon")
+ api.add_resource(
+ TriggerSubscriptionListApi, "/workspaces/current/trigger-provider/<path:provider>/subscriptions/list"
+ )
api.add_resource(
TriggerOAuthClientManageApi, "/workspaces/current/trigger-provider/<path:provider>/oauth/client"
)
diff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_provider_query.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_provider_query.py
new file mode 100644
index 00000000000..b064a510f4d
--- /dev/null
+++ b/api/tests/unit_tests/controllers/console/workspace/test_trigger_provider_query.py
@@ -0,0 +1,230 @@
+"""Provider queries exercise real admission, gateway and plugin-daemon HTTP transport."""
+
+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
+from urllib.parse import parse_qs, urlsplit
+
+import pytest
+from sqlalchemy import delete
+from yarl import URL
+
+from configs import dify_config
+from core.plugin.impl import base as plugin_transport
+from models import TenantAccountJoin
+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
+
+harness = test_trigger_oauth_client.harness
+
+_LIST = "/console/api/workspaces/current/triggers"
+_INFO = f"/console/api/workspaces/current/trigger-provider/{_PROVIDER}/info"
+_ICON = f"/console/api/workspaces/current/trigger-provider/{_PROVIDER}/icon"
+_IDENTIFIER = "langgenius/github:1.0.0@package-hash"
+
+
+def _provider() -> dict[str, object]:
+ return {
+ "provider": "github",
+ "plugin_id": "langgenius/github",
+ "plugin_unique_identifier": _IDENTIFIER,
+ "declaration": {
+ "identity": {
+ "author": "Dify",
+ "name": "github",
+ "label": {"en_US": "GitHub"},
+ "description": {"en_US": "GitHub trigger"},
+ "icon": "icon.svg",
+ "tags": ["code"],
+ },
+ "events": [
+ {
+ "identity": {"author": "Dify", "name": "push", "label": {"en_US": "Push"}},
+ "description": {"en_US": "Repository push"},
+ "output_schema": {"type": "object"},
+ }
+ ],
+ },
+ }
+
+
+@dataclass(frozen=True)
+class _DaemonRequest:
+ path: str
+ headers: dict[str, str]
+ open_transactions: bool
+
+
+@dataclass
+class _Daemon:
+ response: dict[str, object] | list[dict[str, object]] = field(default_factory=_provider)
+ 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:
+ daemon.requests.append(
+ _DaemonRequest(
+ path=self.path,
+ headers=dict(self.headers.items()),
+ open_transactions=any(session.in_transaction() for session in harness.metadata.sessions),
+ )
+ )
+ response = json.dumps({"code": 0, "message": "", "data": daemon.response}).encode()
+ self.send_response(daemon.status)
+ self.send_header("Content-Type", "application/json")
+ self.send_header("Content-Length", str(len(response)))
+ self.end_headers()
+ self.wfile.write(response)
+
+ @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)
+
+
+def _localized(text: str) -> dict[str, str]:
+ return dict.fromkeys(("en_US", "zh_Hans", "pt_BR", "ja_JP"), text)
+
+
+def _expected_provider(tenant_id: str) -> dict[str, object]:
+ return {
+ "author": "Dify",
+ "name": _PROVIDER,
+ "label": _localized("GitHub"),
+ "description": _localized("GitHub trigger"),
+ "icon": f"https://console.example.test/console/api/workspaces/current/plugin/icon?tenant_id={tenant_id}&filename=icon.svg",
+ "icon_dark": None,
+ "tags": ["code"],
+ "plugin_id": "langgenius/github",
+ "plugin_unique_identifier": _IDENTIFIER,
+ "supported_creation_methods": ["MANUAL"],
+ "subscription_constructor": None,
+ "subscription_schema": [],
+ "events": [
+ {
+ "name": "push",
+ "identity": {
+ "author": "Dify",
+ "name": "push",
+ "label": _localized("Push"),
+ "provider": _PROVIDER,
+ },
+ "description": _localized("Repository push"),
+ "parameters": [],
+ "output_schema": {"type": "object"},
+ }
+ ],
+ }
+
+
[email protected]("url", [_LIST, _INFO, _ICON], ids=["list", "info", "icon"])
+def test_queries_keep_response_shapes_and_use_active_workspace_after_admission(
+ harness: _Harness, daemon: _Daemon, url: str
+) -> None:
+ harness.set_role(TenantAccountRole.NORMAL)
+ if url == _LIST:
+ daemon.response = [_provider()]
+
+ # A fresh context uses the real per-request provider cache without leaking it
+ # to another test. Query-string workspace IDs must not override admission.
+ response = Context().run(harness.call, "GET", url=f"{url}?tenant_id=other-workspace")
+
+ assert response.status_code == HTTPStatus.OK
+ assert response.content_type == "application/json"
+ expected = _expected_provider(harness.tenant_id)
+ if url == _LIST:
+ assert response.get_json() == [expected]
+ elif url == _INFO:
+ assert response.get_json() == expected
+ else:
+ assert response.get_json() == expected["icon"]
+ assert "Location" not in response.headers
+ assert len(daemon.requests) == 1
+ sent = daemon.requests[0]
+ upstream = urlsplit(sent.path)
+ assert upstream.path == f"/plugin/{harness.tenant_id}/management/{'triggers' if url == _LIST else 'trigger'}"
+ assert parse_qs(upstream.query) == (
+ {"page": ["1"], "page_size": ["256"]}
+ if url == _LIST
+ else {"provider": ["github"], "plugin_id": ["langgenius/github"]}
+ )
+ assert sent.headers["X-Api-Key"] == dify_config.PLUGIN_DAEMON_KEY
+ assert harness.metadata.sessions
+ assert not sent.open_transactions
+
+
+def test_empty_provider_list_is_an_empty_json_array(harness: _Harness, daemon: _Daemon) -> None:
+ daemon.response = []
+
+ response = Context().run(harness.call, "GET", url=_LIST)
+
+ assert response.status_code == HTTPStatus.OK
+ assert response.get_json() == []
+ assert len(daemon.requests) == 1
+
+
[email protected]("url", [_LIST, _INFO, _ICON], ids=["list", "info", "icon"])
+def test_queries_require_login_before_plugin_lookup(harness: _Harness, daemon: _Daemon, url: str) -> None:
+ response = Context().run(harness.client.get, url)
+
+ 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]("url", [_LIST, _INFO, _ICON], ids=["list", "info", "icon"])
+def test_queries_reject_account_without_workspace_membership(harness: _Harness, daemon: _Daemon, url: str) -> None:
+ with harness.session_factory.begin() as session:
+ session.execute(delete(TenantAccountJoin).where(TenantAccountJoin.account_id == harness.account_id))
+
+ response = Context().run(harness.call, "GET", url=url)
+
+ assert response.status_code == HTTPStatus.UNAUTHORIZED
+ assert response.get_json()["code"] == "unauthorized"
+ assert daemon.requests == []
+
+
[email protected]("url", [_INFO, _ICON], ids=["info", "icon"])
+def test_invalid_provider_is_rejected_before_plugin_lookup(harness: _Harness, daemon: _Daemon, url: str) -> None:
+ response = Context().run(harness.call, "GET", url=url.replace(_PROVIDER, "not/a/valid/provider"))
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ assert response.get_json()["code"] == "invalid_param"
+ assert daemon.requests == []
+
+
[email protected]("url", [_LIST, _INFO, _ICON], ids=["list", "info", "icon"])
+def test_daemon_failure_is_not_returned_as_success(harness: _Harness, daemon: _Daemon, url: str) -> None:
+ daemon.status = HTTPStatus.SERVICE_UNAVAILABLE
+
+ response = Context().run(harness.call, "GET", url=url)
+
+ 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
diff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_providers.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_providers.py
index 32bf8fb747e..a253ee0ec14 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
@@ -4,8 +4,7 @@ from collections.abc import Iterator
from datetime import datetime
from importlib import import_module
from inspect import unwrap
-from types import SimpleNamespace
-from unittest.mock import ANY, MagicMock, create_autospec, patch
+from unittest.mock import ANY, MagicMock, patch
import pytest
from flask import Flask
@@ -15,9 +14,6 @@ from werkzeug.exceptions import BadRequest
from controllers.common.errors import NotFoundError
from controllers.console.workspace.trigger_providers import (
- TriggerProviderIconApi,
- TriggerProviderInfoApi,
- TriggerProviderListApi,
TriggerSubscriptionBuilderBuildApi,
TriggerSubscriptionBuilderCreateApi,
TriggerSubscriptionBuilderCreatePayload,
@@ -28,17 +24,15 @@ from controllers.console.workspace.trigger_providers import (
TriggerSubscriptionBuilderVerifyApi,
TriggerSubscriptionBuilderVerifyPayload,
TriggerSubscriptionDeleteApi,
- TriggerSubscriptionListApi,
TriggerSubscriptionUpdateApi,
TriggerSubscriptionVerifyApi,
TriggerSubscriptionVerifyPayload,
)
from core.plugin.entities.plugin_daemon import CredentialType
-from core.trigger.entities.api_entities import SubscriptionBuilderApiEntity, TriggerProviderApiEntity
+from core.trigger.entities.api_entities import SubscriptionBuilderApiEntity
from core.trigger.entities.entities import RequestLog
from models.account import Account
from models.engine import db
-from services.credentials.query import CredentialQuery
"""Unit tests for controllers.console.workspace.trigger_providers endpoints."""
@@ -49,24 +43,6 @@ def mock_user() -> Account:
return user
-def trigger_provider() -> TriggerProviderApiEntity:
- return TriggerProviderApiEntity(
- author="Dify",
- name="github",
- label={"en_US": "GitHub"},
- description={"en_US": "GitHub trigger provider"},
- icon="icon.svg",
- icon_dark=None,
- tags=["code"],
- plugin_id="plugin",
- plugin_unique_identifier="plugin:github",
- supported_creation_methods=[],
- subscription_constructor=None,
- subscription_schema=[],
- events=[],
- )
-
-
def subscription_builder() -> SubscriptionBuilderApiEntity:
return SubscriptionBuilderApiEntity(
id="b1",
@@ -91,86 +67,6 @@ def request_log() -> RequestLog:
class TestTriggerProviderApisCases:
- @staticmethod
- @pytest.fixture
- def credential_query() -> Iterator[MagicMock]:
- query = create_autospec(CredentialQuery, instance=True, spec_set=True)
- with patch(
- "controllers.console.workspace.trigger_providers.application_services",
- return_value=SimpleNamespace(credential_queries=query),
- ):
- yield query
-
- class TestTriggerProviderApis:
- def test_icon_success(self, app: Flask) -> None:
- api = TriggerProviderIconApi()
- method = unwrap(api.get)
-
- with (
- app.test_request_context("/"),
- patch(
- "controllers.console.workspace.trigger_providers.TriggerManager.get_trigger_plugin_icon",
- return_value="icon",
- ),
- ):
- assert method(api, "t1", "github") == "icon"
-
- def test_list_providers(self, app: Flask) -> None:
- api = TriggerProviderListApi()
- method = unwrap(api.get)
-
- with (
- app.test_request_context("/"),
- patch(
- "controllers.console.workspace.trigger_providers.TriggerProviderService.list_trigger_providers",
- return_value=[],
- ),
- ):
- assert method(api, "t1") == []
-
- def test_provider_info(self, app: Flask) -> None:
- api = TriggerProviderInfoApi()
- method = unwrap(api.get)
-
- with (
- app.test_request_context("/"),
- patch(
- "controllers.console.workspace.trigger_providers.TriggerProviderService.get_trigger_provider",
- return_value=trigger_provider(),
- ),
- ):
- assert method(api, "t1", "github")["name"] == "github"
-
- class TestTriggerSubscriptionListApi:
- def test_list_success(self, app: Flask, credential_query: MagicMock) -> None:
- api = TriggerSubscriptionListApi()
- method = unwrap(api.get)
-
- with (
- app.test_request_context("/"),
- patch(
- "controllers.console.workspace.trigger_providers.TriggerProviderService.list_trigger_provider_subscriptions",
- return_value=[],
- ) as list_subscriptions,
- ):
- assert method(api, "t1", mock_user(), "github") == []
- assert list_subscriptions.call_args.kwargs["credential_query"] is credential_query
-
- def test_list_invalid_provider(self, app: Flask, credential_query: MagicMock) -> None:
- api = TriggerSubscriptionListApi()
- method = unwrap(api.get)
-
- with (
- app.test_request_context("/"),
- patch(
- "controllers.console.workspace.trigger_providers.TriggerProviderService.list_trigger_provider_subscriptions",
- side_effect=ValueError("bad"),
- ) as list_subscriptions,
- ):
- result, status = method(api, "t1", mock_user(), "bad")
- assert status == 404
- assert list_subscriptions.call_args.kwargs["credential_query"] is credential_query
-
class TestTriggerSubscriptionBuilderApis:
def test_create_builder(self, app: Flask) -> None:
api = TriggerSubscriptionBuilderCreateApi()
diff --git a/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_query.py b/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_query.py
new file mode 100644
index 00000000000..a10b40547ed
--- /dev/null
+++ b/api/tests/unit_tests/controllers/console/workspace/test_trigger_subscription_query.py
@@ -0,0 +1,200 @@
+"""Subscription reads exercise real admission, SQL visibility and daemon transport."""
+
+import json
+from contextvars import Context
+from http import HTTPStatus
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from threading import Thread
+from typing import override
+from uuid import uuid4
+
+import pytest
+from sqlalchemy import delete
+
+from core.plugin.entities.plugin_daemon import CredentialType
+from models import TenantAccountJoin
+from models.account import Account, AccountStatus, TenantAccountRole
+from models.enums import PermissionEnum
+from models.trigger import TriggerSubscription
+from services.enterprise.base import EnterpriseRequest
+from tests.helpers.unit.config_override import config_overrides_context
+from tests.unit_tests.controllers.console.workspace import test_trigger_oauth_client, test_trigger_provider_query
+from tests.unit_tests.controllers.console.workspace.test_trigger_oauth_client import _PROVIDER, _Harness
+from tests.unit_tests.controllers.console.workspace.test_trigger_provider_query import _Daemon
+
+harness = test_trigger_oauth_client.harness
+daemon = test_trigger_provider_query.daemon
+
+_LIST = f"/console/api/workspaces/current/trigger-provider/{_PROVIDER}/subscriptions/list"
+
+
+def _add_subscription(
+ harness: _Harness,
+ *,
+ name: str = "subscription",
+ tenant_id: str | None = None,
+ user_id: str | None = None,
+ provider_id: str = _PROVIDER,
+ visibility: PermissionEnum = PermissionEnum.ALL_TEAM,
+ credential_type: CredentialType = CredentialType.API_KEY,
+ credentials: dict[str, str] | None = None,
+ properties: dict[str, object] | None = None,
+) -> TriggerSubscription:
+ subscription = TriggerSubscription(
+ name=name,
+ tenant_id=tenant_id or harness.tenant_id,
+ user_id=user_id or harness.account_id,
+ provider_id=provider_id,
+ endpoint_id=str(uuid4()),
+ parameters={"event": "push"},
+ properties=properties or {},
+ credentials=credentials or {},
+ credential_type=credential_type,
+ visibility=visibility,
+ )
+ with harness.session_factory.begin() as session:
+ session.add(subscription)
+ return subscription
+
+
[email protected]("role", [TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR])
+def test_empty_subscriptions_return_array_without_plugin_lookup(
+ harness: _Harness, daemon: _Daemon, role: TenantAccountRole
+) -> None:
+ harness.set_role(role)
+
+ response = Context().run(harness.call, "GET", url=_LIST)
+
+ assert response.status_code == HTTPStatus.OK
+ assert response.content_type == "application/json"
+ assert response.get_json() == []
+ assert daemon.requests == []
+
+
+def test_owner_cannot_see_other_members_private_or_foreign_subscriptions(harness: _Harness, daemon: _Daemon) -> None:
+ _add_subscription(harness, name="private", user_id=str(uuid4()), visibility=PermissionEnum.ONLY_ME)
+ _add_subscription(harness, name="unshared", user_id=str(uuid4()), visibility=PermissionEnum.PARTIAL_TEAM)
+ _add_subscription(harness, name="foreign-workspace", tenant_id=str(uuid4()))
+ _add_subscription(harness, name="foreign-provider", provider_id="langgenius/github/other")
+
+ response = Context().run(harness.call, "GET", url=f"{_LIST}?tenant_id=other-workspace")
+
+ assert response.status_code == HTTPStatus.OK
+ assert response.get_json() == []
+ assert daemon.requests == []
+
+
[email protected]("role", [TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR])
+def test_subscriptions_require_editor_role_before_querying_plugin(
+ harness: _Harness, daemon: _Daemon, role: TenantAccountRole
+) -> None:
+ harness.set_role(role)
+ _add_subscription(harness)
+
+ response = Context().run(harness.call, "GET", url=_LIST)
+
+ assert response.status_code == HTTPStatus.FORBIDDEN
+ assert response.get_json()["code"] == "forbidden"
+ assert daemon.requests == []
+
+
+def test_uninitialized_member_without_editor_role_is_forbidden(harness: _Harness, daemon: _Daemon) -> 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
+
+ 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
+
+ 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 daemon.requests == []
+
+
+def test_subscriptions_require_login(harness: _Harness, daemon: _Daemon) -> None:
+ response = harness.client.get(_LIST)
+
+ assert response.status_code == HTTPStatus.UNAUTHORIZED
+ assert response.get_json()["code"] == "unauthorized"
+ assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'
+ assert daemon.requests == []
+
+
+def test_subscriptions_require_workspace_membership(harness: _Harness, daemon: _Daemon) -> None:
+ with harness.session_factory.begin() as session:
+ session.execute(delete(TenantAccountJoin).where(TenantAccountJoin.account_id == harness.account_id))
+
+ response = Context().run(harness.call, "GET", url=_LIST)
+
+ assert response.status_code == HTTPStatus.UNAUTHORIZED
+ assert response.get_json()["code"] == "unauthorized"
+ assert daemon.requests == []
+
+
+def test_invalid_provider_preserves_not_found_response(harness: _Harness, daemon: _Daemon) -> None:
+ response = harness.call("GET", url=_LIST.replace(_PROVIDER, "not/a/valid/provider"))
+
+ assert response.status_code == HTTPStatus.NOT_FOUND
+ assert response.get_json() == {"error": "Invalid plugin id not/a/valid/provider"}
+ assert daemon.requests == []
+
+
+def test_plugin_failure_propagates_after_query_transaction_closes(harness: _Harness, daemon: _Daemon) -> None:
+ _add_subscription(harness)
+ daemon.status = HTTPStatus.SERVICE_UNAVAILABLE
+
+ response = Context().run(harness.call, "GET", url=_LIST)
+
+ 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
diff --git a/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py b/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py
index 53dc3759603..279deaa9dd4 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
@@ -18,6 +18,7 @@ from controllers.inner_api.wraps import InnerApiUnauthorizedError
from core.plugin.impl.oauth import OAuthHandler
from extensions.application_services.workspace import WorkspaceServices
from libs.external_api import register_external_error_handlers
+from repositories.credentials.query_repository import CredentialQueryRepository
from repositories.trigger.oauth_client_repository import TriggerOAuthClientRepository
from services.account_errors import AccountNotFoundError
from services.errors.workspace import (
@@ -33,6 +34,8 @@ from services.trigger.oauth_gateway import (
TriggerOAuthBuilderGateway,
)
from services.trigger.oauth_service import TriggerOAuthService
+from services.trigger.provider_gateway import PluginTriggerProviderQuery
+from services.trigger.subscription_query_service import TriggerSubscriptionQueryService
from services.workspace.contracts import CreatedWorkspace, WorkspaceMembership
from services.workspace.provisioning_service import WorkspaceProvisioningService
from services.workspace.service import WorkspaceQueryService, WorkspaceService
@@ -117,6 +120,11 @@ class TestWorkspaceCases:
invitations=Mock(),
identity=Mock(),
resource_cleanup=Mock(),
+ trigger_providers=PluginTriggerProviderQuery(),
+ trigger_subscriptions=TriggerSubscriptionQueryService(
+ credentials=CredentialQueryRepository(session_factory=sqlite_session_factory),
+ schemas=PluginTriggerProviderQuery(),
+ ),
trigger_oauth_clients=oauth_clients,
trigger_oauth=TriggerOAuthService(
clients=oauth_clients,
diff --git a/api/tests/unit_tests/extensions/test_ext_application_services.py b/api/tests/unit_tests/extensions/test_ext_application_services.py
index 51c60a08f96..749de53bb7f 100644
--- a/api/tests/unit_tests/extensions/test_ext_application_services.py
+++ b/api/tests/unit_tests/extensions/test_ext_application_services.py
@@ -1118,6 +1118,8 @@ def test_build_application_services_wires_credential_query(
records = services.credential_queries.list_models(workspace_id=tenant_id, provider="openai", actor_id=actor_id)
assert [(record.id, record.name) for record in records] == [(credential_id, "Team")]
+ assert services.workspaces.trigger_subscriptions._credentials is services.credential_queries
+ assert services.workspaces.trigger_subscriptions._schemas is services.workspaces.trigger_providers
def test_build_application_services_uses_supplied_redis_for_both_workflow_stop_signals(
diff --git a/api/tests/unit_tests/services/trigger/test_trigger_provider_service.py b/api/tests/unit_tests/services/trigger/test_trigger_provider_service.py
index 5366ace04b4..7c5b88637e6 100644
--- a/api/tests/unit_tests/services/trigger/test_trigger_provider_service.py
+++ b/api/tests/unit_tests/services/trigger/test_trigger_provider_service.py
@@ -32,7 +32,6 @@ from models.trigger import (
TriggerSubscription,
WorkflowPluginTrigger,
)
-from repositories.credentials.query_repository import CredentialQueryRepository
from services.plugin.dispatch_identity import PluginOAuthClientConfig
from services.trigger import trigger_provider_service as service_module
from services.trigger.trigger_provider_service import TriggerProviderService
@@ -164,90 +163,6 @@ def _patch_identity_encryption(mocker) -> Mock:
return cache
-def test_provider_manager_entities_are_forwarded(mocker, trigger_db: TriggerDatabase) -> None:
- provider = Mock()
- provider.to_api_entity.return_value = {"provider": "ok"}
- _patch_provider(mocker, provider)
- provider_b = Mock()
- provider_b.to_api_entity.return_value = {"provider": "other"}
- mocker.patch.object(
- service_module.TriggerManager, "list_all_trigger_providers", return_value=[provider, provider_b]
- )
-
- assert TriggerProviderService.get_trigger_provider(trigger_db.tenant_id, trigger_db.provider_id) == {
- "provider": "ok"
- }
- assert TriggerProviderService.list_trigger_providers(trigger_db.tenant_id) == [
- {"provider": "ok"},
- {"provider": "other"},
- ]
-
-
-def test_list_subscriptions_empty_state(trigger_db: TriggerDatabase) -> None:
- assert (
- TriggerProviderService.list_trigger_provider_subscriptions(
- trigger_db.tenant_id,
- trigger_db.provider_id,
- credential_query=CredentialQueryRepository(session_factory=trigger_db.session_maker),
- )
- == []
- )
-
-
-def test_list_subscriptions_masks_and_counts_distinct_apps(
- mocker, trigger_db: TriggerDatabase, provider_controller: Mock
-) -> None:
- target = trigger_db.add_subscription(subscription_id=str(uuid4()))
- trigger_db.add_subscription(tenant_id=trigger_db.other_tenant_id, name="foreign")
- with trigger_db.session_maker.begin() as session:
- session.add_all(
- [
- WorkflowPluginTrigger(
- app_id=str(uuid4()),
- node_id="node-1",
- tenant_id=trigger_db.tenant_id,
- provider_id=str(trigger_db.provider_id),
- event_name="push",
- subscription_id=target.id,
- ),
- WorkflowPluginTrigger(
- app_id=str(uuid4()),
- node_id="node-2",
- tenant_id=trigger_db.tenant_id,
- provider_id=str(trigger_db.provider_id),
- event_name="push",
- subscription_id=target.id,
- ),
- WorkflowPluginTrigger(
- app_id=str(uuid4()),
- node_id="foreign",
- tenant_id=trigger_db.other_tenant_id,
- provider_id=str(trigger_db.provider_id),
- event_name="push",
- subscription_id=target.id,
- ),
- ]
- )
- _patch_provider(mocker, provider_controller)
- masked = _encrypter(masked={"secret": "****"})
- mocker.patch.object(
- service_module, "create_trigger_provider_encrypter_for_subscription", return_value=(masked, Mock())
- )
- mocker.patch.object(
- service_module, "create_trigger_provider_encrypter_for_properties", return_value=(masked, Mock())
- )
-
- subscriptions = TriggerProviderService.list_trigger_provider_subscriptions(
- trigger_db.tenant_id,
- trigger_db.provider_id,
- credential_query=CredentialQueryRepository(session_factory=trigger_db.session_maker),
- )
-
- assert [item.id for item in subscriptions] == [target.id]
- assert subscriptions[0].credentials == {"secret": "****"}
- assert subscriptions[0].workflows_in_use == 2
-
-
@pytest.mark.parametrize("credential_type", [CredentialType.API_KEY, CredentialType.UNAUTHORIZED])
def test_add_subscription_commits_encrypted_state(
mocker,