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): extract account activation application service (#40421)

Byron.wangba61ab4f9f8f
diff --git a/api/.importlinter b/api/.importlinter
index f2e4177c863..1cbafd9b8ec 100644
--- a/api/.importlinter
+++ b/api/.importlinter
@@ -167,3 +167,19 @@ forbidden_modules =
repositories
sqlalchemy
werkzeug
+
+[importlinter:contract:account-activation-service-boundary]
+name = Account activation application service is framework and persistence neutral
+type = forbidden
+source_modules =
+ services.account_activation_service
+ services.entities.account_activation_entities
+forbidden_modules =
+ configs
+ controllers
+ extensions
+ flask
+ models
+ repositories
+ sqlalchemy
+ werkzeug
diff --git a/api/controllers/console/auth/activate.py b/api/controllers/console/auth/activate.py
index 07c9d30d997..3921414369e 100644
--- a/api/controllers/console/auth/activate.py
+++ b/api/controllers/console/auth/activate.py
@@ -1,25 +1,22 @@
from flask import request
from flask_restx import Resource
from pydantic import BaseModel, Field, field_validator
-from sqlalchemy import select
-from configs import dify_config
from constants.languages import supported_language
from controllers.common.schema import query_params_from_model, register_schema_models
from controllers.console import console_ns
-from controllers.console.auth.error import InvitationAccountMismatchError
+from controllers.console.auth.error import InvitationAccountMismatchError as InvitationAccountMismatchHTTPError
from controllers.console.error import AccountInFreezeError, AlreadyActivateError
-from controllers.console.wraps import model_validate
-from enums import DeploymentEdition
-from extensions.ext_database import db
-from libs.datetime_utils import naive_utc_now
-from libs.helper import EmailStr, timezone
+from extensions.ext_application_services import application_services
+from libs.helper import EmailStr, dump_response, timezone
from libs.login import current_account_with_tenant
from libs.token import extract_access_token
-from models import AccountStatus
-from models.account import TenantAccountJoin, TenantAccountRole
-from services.account_service import RegisterService, TenantService
-from services.billing_service import BillingService
+from services.account_activation_service import (
+ FrozenAccountError,
+ InvalidInvitationError,
+ InvitationAccountMismatchError,
+)
+from services.entities.account_activation_entities import ActivationCommand, InvitationLookup
class ActivateCheckQuery(BaseModel):
@@ -88,45 +85,19 @@ class ActivateCheckApi(Resource):
"Success",
console_ns.models[ActivationCheckResponse.__name__],
)
- @model_validate(ActivateCheckQuery)
- def get(self, req_data: ActivateCheckQuery):
-
- workspaceId = req_data.workspace_id
- token = req_data.token
-
- invitation = RegisterService.get_invitation_with_case_fallback(
- workspaceId, req_data.email, token, session=db.session()
+ def get(self):
+ args = ActivateCheckQuery.model_validate(request.args.to_dict(flat=True))
+ result = application_services().account_activation.check(
+ InvitationLookup(
+ workspace_id=args.workspace_id,
+ email=args.email,
+ token=args.token,
+ ),
+ )
+ return ActivationCheckResponse.model_validate(result, from_attributes=True).model_dump(
+ mode="json",
+ exclude_none=True,
)
- if invitation:
- data = invitation.get("data", {})
- tenant = invitation.get("tenant", None)
-
- # Check workspace permission
- if tenant:
- from libs.workspace_permission import check_workspace_member_invite_permission
-
- check_workspace_member_invite_permission(tenant.id)
-
- workspace_name = tenant.name if tenant else None
- workspace_id = tenant.id if tenant else None
- invitee_email = data.get("email") if data else None
- account = invitation.get("account")
- account_status = account.status if account else None
- requires_setup = data.get("requires_setup")
- if requires_setup is None:
- requires_setup = account_status == AccountStatus.PENDING
- return {
- "is_valid": invitation is not None,
- "data": {
- "workspace_name": workspace_name,
- "workspace_id": workspace_id,
- "email": invitee_email,
- "account_status": account_status,
- "requires_setup": requires_setup,
- },
- }
- else:
- return {"is_valid": False}
@console_ns.route("/activate")
@@ -140,72 +111,37 @@ class ActivateApi(Resource):
console_ns.models[ActivationResponse.__name__],
)
@console_ns.response(400, "Already activated or invalid token")
- @model_validate(ActivatePayload)
- def post(self, req_data: ActivatePayload):
+ def post(self):
"""Accept an invitation without letting an existing session act for another account.
Token-only activation remains available for legacy clients. When the request already
carries a console session, that session must belong to the account encoded in the
invitation before the token is consumed or tenant membership is changed.
"""
+ args = ActivatePayload.model_validate(console_ns.payload or {})
+ authenticated_account_id: str | None = None
+ if extract_access_token(request) is not None:
+ authenticated_account_id = current_account_with_tenant().account.id
- normalized_request_email = req_data.email.lower() if req_data.email else None
- invitation = RegisterService.get_invitation_with_case_fallback(
- req_data.workspace_id, req_data.email, req_data.token, session=db.session()
- )
- if invitation is None:
- raise AlreadyActivateError()
-
- account = invitation["account"]
- if extract_access_token(request):
- current_account, _ = current_account_with_tenant()
- if current_account.id != account.id:
- raise InvitationAccountMismatchError()
-
- if dify_config.DEPLOYMENT_EDITION == DeploymentEdition.CLOUD and BillingService.is_email_in_freeze(
- account.email
- ):
- raise AccountInFreezeError()
-
- tenant = invitation["tenant"]
- raw_role = invitation["data"].get("role")
try:
- role = TenantAccountRole(raw_role) if raw_role else TenantAccountRole.NORMAL
- except ValueError:
- role = TenantAccountRole.NORMAL
- if not TenantAccountRole.is_non_owner_role(role):
- role = TenantAccountRole.NORMAL
-
- membership_id = db.session.scalar(
- select(TenantAccountJoin.id).where(
- TenantAccountJoin.tenant_id == tenant.id,
- TenantAccountJoin.account_id == account.id,
+ application_services().account_activation.activate(
+ ActivationCommand(
+ invitation=InvitationLookup(
+ workspace_id=args.workspace_id,
+ email=args.email,
+ token=args.token,
+ ),
+ name=args.name,
+ interface_language=args.interface_language,
+ timezone=args.timezone,
+ ),
+ authenticated_account_id=authenticated_account_id,
)
- )
-
- requires_setup = invitation["data"].get("requires_setup")
- if requires_setup is None:
- requires_setup = account.status == AccountStatus.PENDING
-
- setup_fields: tuple[str, str, str] | None = None
- if requires_setup:
- if not req_data.name or not req_data.interface_language or not req_data.timezone:
- raise AlreadyActivateError()
- setup_fields = (req_data.name, req_data.interface_language, req_data.timezone)
-
- RegisterService.revoke_token(req_data.workspace_id, normalized_request_email, req_data.token)
-
- if membership_id is None:
- TenantService.create_tenant_member(tenant, account, db.session(), role=role)
-
- if setup_fields:
- account.name = setup_fields[0]
- account.interface_language = setup_fields[1]
- account.timezone = setup_fields[2]
- account.interface_theme = "light"
- account.status = AccountStatus.ACTIVE
- account.initialized_at = naive_utc_now()
-
- TenantService.switch_tenant(account, tenant.id, session=db.session())
-
- return {"result": "success"}
+ except InvalidInvitationError:
+ raise AlreadyActivateError() from None
+ except InvitationAccountMismatchError:
+ raise InvitationAccountMismatchHTTPError() from None
+ except FrozenAccountError:
+ raise AccountInFreezeError() from None
+
+ return dump_response(ActivationResponse, {"result": "success"})
diff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.py
index 43f5989dfce..9d9b37c88c0 100644
--- a/api/extensions/ext_application_services.py
+++ b/api/extensions/ext_application_services.py
@@ -12,12 +12,20 @@ from core.db.session_factory import get_session_maker
from core.schemas.schema_manager import SchemaManager
from enums import DeploymentEdition
from extensions.ext_redis import RedisClientWrapper, redis_client
+from repositories.account_activation_repository import SQLAlchemyAccountActivationRepository
from repositories.app_definition_query_repository import AppDefinitionQueryRepository
from repositories.data_source_api_key_auth_repository import SQLAlchemyDataSourceApiKeyAuthBindingRepository
from repositories.explore_banner_query_repository import ExploreBannerQueryRepository
from repositories.installation_state_repository import InstallationStateRepository
from repositories.workspace_member_query_repository import WorkspaceMemberQueryRepository
from repositories.workspace_query_repository import WorkspaceQueryRepository
+from services.account_activation_adapters import (
+ BillingAccountActivationEligibility,
+ BillingWorkspaceMembershipCache,
+ DeploymentWorkspaceInvitePolicy,
+ RegisterServiceInvitationTokenStore,
+)
+from services.account_activation_service import AccountActivationService
from services.app_definition_query_service import AppDefinitionQueryService
from services.auth.data_source_api_key_auth_gateways import (
ProviderApiKeyAuthCredentialValidator,
@@ -42,6 +50,7 @@ _EXTENSION_KEY = "application_services"
@dataclass(frozen=True, slots=True)
class ApplicationServices:
+ account_activation: AccountActivationService
app_definitions: AppDefinitionQueryService
data_source_api_key_auth: DataSourceApiKeyAuthService
explore_banner_queries: ExploreBannerQueryService
@@ -63,6 +72,17 @@ def build_application_services(
installation_state = InstallationStateRepository(client=database_client)
data_source_api_key_auth_bindings = SQLAlchemyDataSourceApiKeyAuthBindingRepository(session_factory=database_client)
return ApplicationServices(
+ account_activation=AccountActivationService(
+ tokens=RegisterServiceInvitationTokenStore(),
+ accounts=SQLAlchemyAccountActivationRepository(database_client),
+ workspace_policy=DeploymentWorkspaceInvitePolicy(),
+ eligibility=BillingAccountActivationEligibility(
+ enabled=deployment_edition == DeploymentEdition.CLOUD,
+ ),
+ membership_cache=BillingWorkspaceMembershipCache(
+ enabled=deployment_edition == DeploymentEdition.CLOUD,
+ ),
+ ),
app_definitions=AppDefinitionQueryService(
definitions=AppDefinitionQueryRepository(session_factory=database_client),
builtin_icon_url_prefix=(
diff --git a/api/repositories/account_activation_repository.py b/api/repositories/account_activation_repository.py
new file mode 100644
index 00000000000..b8b30689335
--- /dev/null
+++ b/api/repositories/account_activation_repository.py
@@ -0,0 +1,114 @@
+"""SQLAlchemy repository for account invitation activation."""
+
+from typing import override
+
+from sqlalchemy import select, update
+from sqlalchemy.orm import Session, sessionmaker
+
+from libs.datetime_utils import naive_utc_now
+from models.account import Account, AccountStatus, Tenant, TenantAccountJoin, TenantAccountRole, TenantStatus
+from services.account_activation_service import AccountActivationRepository
+from services.entities.account_activation_entities import (
+ AccountInvitation,
+ AccountSetup,
+ ActivationPersistenceResult,
+ InvitationToken,
+)
+
+
+class SQLAlchemyAccountActivationRepository(AccountActivationRepository):
+ def __init__(self, session_factory: sessionmaker[Session]) -> None:
+ self._session_factory = session_factory
+
+ @override
+ def resolve(self, invitation: InvitationToken) -> AccountInvitation | None:
+ with self._session_factory() as session:
+ tenant = session.scalar(
+ select(Tenant).where(
+ Tenant.id == invitation.workspace_id,
+ Tenant.status == TenantStatus.NORMAL,
+ )
+ )
+ if tenant is None:
+ return None
+
+ account = session.scalar(
+ select(Account).where(
+ Account.id == invitation.account_id,
+ Account.email == invitation.email,
+ )
+ )
+ if account is None:
+ return None
+
+ return AccountInvitation(
+ account_id=account.id,
+ account_email=account.email,
+ account_status=account.status.value,
+ workspace_id=tenant.id,
+ workspace_name=tenant.name,
+ role=invitation.role,
+ requires_setup=invitation.requires_setup,
+ )
+
+ @override
+ def activate(
+ self,
+ invitation: AccountInvitation,
+ *,
+ role: str,
+ setup: AccountSetup | None,
+ ) -> ActivationPersistenceResult | None:
+ with self._session_factory.begin() as session:
+ tenant_id = session.scalar(
+ select(Tenant.id).where(
+ Tenant.id == invitation.workspace_id,
+ Tenant.status == TenantStatus.NORMAL,
+ )
+ )
+ account = session.scalar(
+ select(Account)
+ .where(
+ Account.id == invitation.account_id,
+ Account.email == invitation.account_email,
+ )
+ .with_for_update()
+ )
+ if tenant_id is None or account is None:
+ return None
+
+ membership = session.scalar(
+ select(TenantAccountJoin).where(
+ TenantAccountJoin.tenant_id == tenant_id,
+ TenantAccountJoin.account_id == account.id,
+ )
+ )
+ membership_created = membership is None
+ if membership is None:
+ membership = TenantAccountJoin(
+ tenant_id=tenant_id,
+ account_id=account.id,
+ role=TenantAccountRole(role),
+ )
+ session.add(membership)
+
+ if setup is not None:
+ account.name = setup.name
+ account.interface_language = setup.interface_language
+ account.timezone = setup.timezone
+ account.interface_theme = "light"
+ account.status = AccountStatus.ACTIVE
+ account.initialized_at = naive_utc_now()
+
+ session.execute(
+ update(TenantAccountJoin)
+ .where(
+ TenantAccountJoin.account_id == account.id,
+ TenantAccountJoin.tenant_id != tenant_id,
+ )
+ .values(current=False)
+ )
+ membership.current = True
+ membership.last_opened_at = naive_utc_now()
+
+ return ActivationPersistenceResult(membership_created=membership_created)
diff --git a/api/services/account_activation_adapters.py b/api/services/account_activation_adapters.py
new file mode 100644
index 00000000000..ca22e7983b8
--- /dev/null
+++ b/api/services/account_activation_adapters.py
@@ -0,0 +1,68 @@
+"""Infrastructure gateways for account invitation activation."""
+
+from typing import override
+
+from libs.workspace_permission import check_workspace_member_invite_permission
+from services.account_activation_service import (
+ AccountActivationEligibility,
+ InvitationTokenStore,
+ WorkspaceInvitePolicy,
+ WorkspaceMembershipCache,
+)
+from services.account_service import RegisterService
+from services.billing_service import BillingService
+from services.entities.account_activation_entities import InvitationLookup, InvitationToken
+
+
+class RegisterServiceInvitationTokenStore(InvitationTokenStore):
+ """Compatibility adapter around the existing Redis invitation token owner."""
+
+ @override
+ def find(self, invitation: InvitationLookup) -> InvitationToken | None:
+ data = RegisterService.get_invitation_by_token(
+ invitation.token,
+ invitation.workspace_id,
+ invitation.email,
+ )
+ if data is None:
+ return None
+ return InvitationToken(
+ account_id=data["account_id"],
+ email=data["email"],
+ workspace_id=data["workspace_id"],
+ role=data.get("role"),
+ requires_setup=data.get("requires_setup"),
+ )
+
+ @override
+ def revoke(self, invitation: InvitationLookup) -> None:
+ RegisterService.revoke_token(
+ invitation.workspace_id,
+ invitation.email,
+ invitation.token,
+ )
+
+
+class DeploymentWorkspaceInvitePolicy(WorkspaceInvitePolicy):
+ @override
+ def ensure_allowed(self, workspace_id: str) -> None:
+ check_workspace_member_invite_permission(workspace_id)
+
+
+class BillingAccountActivationEligibility(AccountActivationEligibility):
+ def __init__(self, *, enabled: bool) -> None:
+ self._enabled = enabled
+
+ @override
+ def is_frozen(self, email: str) -> bool:
+ return self._enabled and BillingService.is_email_in_freeze(email)
+
+
+class BillingWorkspaceMembershipCache(WorkspaceMembershipCache):
+ def __init__(self, *, enabled: bool) -> None:
+ self._enabled = enabled
+
+ @override
+ def invalidate(self, workspace_id: str) -> None:
+ if self._enabled:
+ BillingService.clean_billing_info_cache(workspace_id)
diff --git a/api/services/account_activation_service.py b/api/services/account_activation_service.py
new file mode 100644
index 00000000000..1aaafab538d
--- /dev/null
+++ b/api/services/account_activation_service.py
@@ -0,0 +1,161 @@
+"""Application service for checking and accepting account invitations."""
+
+from typing import Protocol
+
+from services.entities.account_activation_entities import (
+ AccountInvitation,
+ AccountSetup,
+ ActivationCheckData,
+ ActivationCheckResult,
+ ActivationCommand,
+ ActivationPersistenceResult,
+ InvitationLookup,
+ InvitationToken,
+)
+
+_DEFAULT_ROLE = "normal"
+_NON_OWNER_ROLES = frozenset({"admin", "editor", "normal", "dataset_operator"})
+_PENDING_ACCOUNT_STATUS = "pending"
+
+
+class InvitationTokenStore(Protocol):
+ def find(self, invitation: InvitationLookup) -> InvitationToken | None: ...
+
+ def revoke(self, invitation: InvitationLookup) -> None: ...
+
+
+class AccountActivationRepository(Protocol):
+ def resolve(self, invitation: InvitationToken) -> AccountInvitation | None: ...
+
+ def activate(
+ self,
+ invitation: AccountInvitation,
+ *,
+ role: str,
+ setup: AccountSetup | None,
+ ) -> ActivationPersistenceResult | None: ...
+
+
+class WorkspaceInvitePolicy(Protocol):
+ def ensure_allowed(self, workspace_id: str) -> None: ...
+
+
+class AccountActivationEligibility(Protocol):
+ def is_frozen(self, email: str) -> bool: ...
+
+
+class WorkspaceMembershipCache(Protocol):
+ def invalidate(self, workspace_id: str) -> None: ...
+
+
+class InvalidInvitationError(Exception):
+ """The invitation is invalid, stale, or missing required activation data."""
+
+
+class InvitationAccountMismatchError(Exception):
+ """An authenticated account attempted to consume another account's invitation."""
+
+
+class FrozenAccountError(Exception):
+ """The invited account is temporarily ineligible for activation."""
+
+
+class AccountActivationService:
+ def __init__(
+ self,
+ *,
+ tokens: InvitationTokenStore,
+ accounts: AccountActivationRepository,
+ workspace_policy: WorkspaceInvitePolicy,
+ eligibility: AccountActivationEligibility,
+ membership_cache: WorkspaceMembershipCache,
+ ) -> None:
+ self._tokens = tokens
+ self._accounts = accounts
+ self._workspace_policy = workspace_policy
+ self._eligibility = eligibility
+ self._membership_cache = membership_cache
+
+ def check(self, invitation: InvitationLookup) -> ActivationCheckResult:
+ resolved = self._resolve(invitation)
+ if resolved is None:
+ return ActivationCheckResult(is_valid=False)
+
+ self._workspace_policy.ensure_allowed(resolved.workspace_id)
+ return ActivationCheckResult(
+ is_valid=True,
+ data=ActivationCheckData(
+ workspace_name=resolved.workspace_name,
+ workspace_id=resolved.workspace_id,
+ email=resolved.account_email,
+ account_status=resolved.account_status,
+ requires_setup=self._requires_setup(resolved),
+ ),
+ )
+
+ def activate(self, command: ActivationCommand, *, authenticated_account_id: str | None) -> None:
+ invitation = self._resolve(command.invitation)
+ if invitation is None:
+ raise InvalidInvitationError
+
+ if authenticated_account_id is not None and authenticated_account_id != invitation.account_id:
+ raise InvitationAccountMismatchError
+
+ if self._eligibility.is_frozen(invitation.account_email):
+ raise FrozenAccountError
+
+ setup = self._resolve_setup(invitation, command)
+ raw_role = invitation.role
+ role = raw_role if raw_role is not None and raw_role in _NON_OWNER_ROLES else _DEFAULT_ROLE
+
+ normalized_email = command.invitation.email.lower() if command.invitation.email else None
+ self._tokens.revoke(
+ InvitationLookup(
+ workspace_id=command.invitation.workspace_id,
+ email=normalized_email,
+ token=command.invitation.token,
+ )
+ )
+ result = self._accounts.activate(invitation, role=role, setup=setup)
+ if result is None:
+ raise InvalidInvitationError
+ if result.membership_created:
+ self._membership_cache.invalidate(invitation.workspace_id)
+
+ def _resolve(self, invitation: InvitationLookup) -> AccountInvitation | None:
+ token = self._tokens.find(invitation)
+ resolved = self._accounts.resolve(token) if token is not None else None
+ if resolved is not None:
+ return resolved
+
+ if invitation.email is None or invitation.email == invitation.email.lower():
+ return None
+
+ token = self._tokens.find(
+ InvitationLookup(
+ workspace_id=invitation.workspace_id,
+ email=invitation.email.lower(),
+ token=invitation.token,
+ )
+ )
+ if token is None:
+ return None
+ return self._accounts.resolve(token)
+
+ @staticmethod
+ def _requires_setup(invitation: AccountInvitation) -> bool:
+ if invitation.requires_setup is not None:
+ return invitation.requires_setup
+ return invitation.account_status == _PENDING_ACCOUNT_STATUS
+
+ @classmethod
+ def _resolve_setup(cls, invitation: AccountInvitation, command: ActivationCommand) -> AccountSetup | None:
+ if not cls._requires_setup(invitation):
+ return None
+ if not command.name or not command.interface_language or not command.timezone:
+ raise InvalidInvitationError
+ return AccountSetup(
+ name=command.name,
+ interface_language=command.interface_language,
+ timezone=command.timezone,
+ )
diff --git a/api/services/entities/account_activation_entities.py b/api/services/entities/account_activation_entities.py
new file mode 100644
index 00000000000..95e5d9a094c
--- /dev/null
+++ b/api/services/entities/account_activation_entities.py
@@ -0,0 +1,65 @@
+"""Framework-neutral data contracts for account invitation activation."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class InvitationLookup:
+ workspace_id: str | None
+ email: str | None
+ token: str
+
+
+@dataclass(frozen=True, slots=True)
+class InvitationToken:
+ account_id: str
+ email: str
+ workspace_id: str
+ role: str | None = None
+ requires_setup: bool | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class AccountInvitation:
+ account_id: str
+ account_email: str
+ account_status: str
+ workspace_id: str
+ workspace_name: str | None
+ role: str | None
+ requires_setup: bool | None
+
+
+@dataclass(frozen=True, slots=True)
+class AccountSetup:
+ name: str
+ interface_language: str
+ timezone: str
+
+
+@dataclass(frozen=True, slots=True)
+class ActivationCommand:
+ invitation: InvitationLookup
+ name: str | None = None
+ interface_language: str | None = None
+ timezone: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class ActivationCheckData:
+ workspace_name: str | None
+ workspace_id: str
+ email: str
+ account_status: str
+ requires_setup: bool
+
+
+@dataclass(frozen=True, slots=True)
+class ActivationCheckResult:
+ is_valid: bool
+ data: ActivationCheckData | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class ActivationPersistenceResult:
+ membership_created: bool
diff --git a/api/tests/unit_tests/controllers/console/auth/test_account_activation.py b/api/tests/unit_tests/controllers/console/auth/test_account_activation.py
index e9afc527bcd..bd5bd18e089 100644
--- a/api/tests/unit_tests/controllers/console/auth/test_account_activation.py
+++ b/api/tests/unit_tests/controllers/console/auth/test_account_activation.py
@@ -1,451 +1,195 @@
-"""SQLite-backed tests for account invitation and activation flows."""
-
-from __future__ import annotations
+"""Transport-boundary tests for account invitation activation."""
+from inspect import unwrap
from types import SimpleNamespace
-from unittest.mock import ANY, Mock, patch
+from unittest.mock import Mock, patch
import pytest
from flask import Flask
-from sqlalchemy import func, select
-from sqlalchemy.orm import Session, scoped_session
-from controllers.console.auth import activate as activate_module
from controllers.console.auth.activate import ActivateApi, ActivateCheckApi
-from controllers.console.auth.error import InvitationAccountMismatchError
+from controllers.console.auth.error import InvitationAccountMismatchError as InvitationAccountMismatchHTTPError
from controllers.console.error import AccountInFreezeError, AlreadyActivateError
-from enums import DeploymentEdition
-from models.account import Account, AccountStatus, Tenant, TenantAccountJoin, TenantAccountRole
+from services.account_activation_service import (
+ AccountActivationService,
+ FrozenAccountError,
+ InvalidInvitationError,
+ InvitationAccountMismatchError,
+)
+from services.entities.account_activation_entities import (
+ ActivationCheckData,
+ ActivationCheckResult,
+ ActivationCommand,
+ InvitationLookup,
+)
@pytest.fixture
-def app(sqlite_session: Session, monkeypatch: pytest.MonkeyPatch) -> Flask:
- session_proxy = scoped_session(lambda: sqlite_session)
- monkeypatch.setattr(activate_module, "db", SimpleNamespace(session=session_proxy))
+def app() -> Flask:
app = Flask(__name__)
app.config["TESTING"] = True
return app
@pytest.fixture
-def invitation(sqlite_session: Session) -> dict[str, object]:
- account = Account(name="Invited user", email="[email protected]", status=AccountStatus.PENDING)
- account.id = "account-123"
- tenant = Tenant(name="Test Workspace")
- tenant.id = "workspace-123"
- sqlite_session.add_all([account, tenant])
- sqlite_session.commit()
- return {
- "data": {"email": account.email},
- "tenant": tenant,
- "account": account,
- }
-
-
-def switch_tenant(monkeypatch: pytest.MonkeyPatch) -> Mock:
- switch = Mock()
- monkeypatch.setattr(activate_module.TenantService, "switch_tenant", switch)
- return switch
-
-
-def _post(app: Flask, payload: dict[str, object]) -> dict[str, str]:
- with app.test_request_context("/activate", method="POST", json=payload):
- return ActivateApi().post()
+def activation_service() -> Mock:
+ return Mock(spec=AccountActivationService)
-def _setup_payload(**overrides: object) -> dict[str, object]:
- payload: dict[str, object] = {
- "workspace_id": "workspace-123",
- "email": "[email protected]",
- "token": "valid_token",
- "name": "John Doe",
- "interface_language": "en-US",
- "timezone": "UTC",
- }
- payload.update(overrides)
- return payload
+def _services(service: Mock) -> SimpleNamespace:
+ return SimpleNamespace(account_activation=service)
class TestActivateCheckApi:
- def test_check_valid_invitation_token(self, app: Flask, invitation: dict[str, object]) -> None:
- with (
- patch.object(
- activate_module.RegisterService,
- "get_invitation_with_case_fallback",
- return_value=invitation,
+ def test_serializes_valid_invitation(
+ self,
+ app: Flask,
+ activation_service: Mock,
+ ) -> None:
+ activation_service.check.return_value = ActivationCheckResult(
+ is_valid=True,
+ data=ActivationCheckData(
+ workspace_name="Test Workspace",
+ workspace_id="workspace-123",
+ account_status="pending",
+ requires_setup=True,
),
+ )
+ with (
app.test_request_context(
- "/activate/check?workspace_id=workspace-123&[email protected]&token=valid_token"
+ "/activate/check?workspace_id=workspace-123&[email protected]&token=valid-token"
),
- ):
- response = ActivateCheckApi().get()
-
- assert response["is_valid"] is True
- assert response["data"]["workspace_name"] == "Test Workspace"
- assert response["data"]["workspace_id"] == "workspace-123"
- assert response["data"]["email"] == "[email protected]"
-
- def test_check_includes_persisted_account_status(self, app: Flask, invitation: dict[str, object]) -> None:
- account = invitation["account"]
- assert isinstance(account, Account)
- account.status = AccountStatus.ACTIVE
-
- with (
- patch.object(
- activate_module.RegisterService,
- "get_invitation_with_case_fallback",
- return_value=invitation,
+ patch(
+ "controllers.console.auth.activate.application_services",
+ return_value=_services(activation_service),
),
- app.test_request_context("/activate/[email protected]&token=valid_token"),
):
- response = ActivateCheckApi().get()
+ response = unwrap(ActivateCheckApi.get)(ActivateCheckApi())
+
+ assert response == {
+ "is_valid": True,
+ "data": {
+ "workspace_name": "Test Workspace",
+ "workspace_id": "workspace-123",
+ "email": "[email protected]",
+ "account_status": "pending",
+ "requires_setup": True,
+ },
+ }
+ activation_service.check.assert_called_once_with(
+ InvitationLookup(
+ workspace_id="workspace-123",
+ token="valid-token",
+ ),
+ )
- assert response["data"]["account_status"] == AccountStatus.ACTIVE
- assert response["data"]["requires_setup"] is False
+ def test_omits_data_for_invalid_invitation(self, app: Flask, activation_service: Mock) -> None:
+ activation_service.check.return_value = ActivationCheckResult(is_valid=False)
- def test_check_invalid_invitation_token(self, app: Flask) -> None:
with (
- patch.object(
- activate_module.RegisterService,
- "get_invitation_with_case_fallback",
- return_value=None,
- ),
- app.test_request_context("/activate/[email protected]&token=invalid_token"),
- ):
- assert ActivateCheckApi().get() == {"is_valid": False}
-
- @pytest.mark.parametrize(
- ("query", "workspace_id", "email"),
- [
- ("[email protected]&token=valid_token", None, "[email protected]"),
- ("workspace_id=workspace-123&token=valid_token", "workspace-123", None),
- (
- "workspace_id=workspace-123&[email protected]&token=valid_token",
- "workspace-123",
+ app.test_request_context("/activate/check?token=invalid-token"),
+ patch(
+ "controllers.console.auth.activate.application_services",
+ return_value=_services(activation_service),
),
- ],
- )
- def test_check_forwards_optional_lookup_fields(
- self,
- app: Flask,
- invitation: dict[str, object],
- query: str,
- workspace_id: str | None,
- email: str | None,
- ) -> None:
- with (
- patch.object(
- activate_module.RegisterService,
- "get_invitation_with_case_fallback",
- return_value=invitation,
- ) as lookup,
- app.test_request_context(f"/activate/check?{query}"),
):
- assert ActivateCheckApi().get()["is_valid"] is True
+ response = unwrap(ActivateCheckApi.get)(ActivateCheckApi())
- lookup.assert_called_once_with(workspace_id, email, "valid_token", session=ANY)
- assert isinstance(lookup.call_args.kwargs["session"], Session)
+ assert response == {"is_valid": False}
class TestActivateApi:
- def test_activation_rejects_invitation_for_different_authenticated_account(
+ def test_passes_parsed_command_to_application_service(
self,
- sqlite_session: Session,
app: Flask,
- invitation: dict[str, object],
- switch_tenant: Mock,
+ activation_service: Mock,
) -> None:
- """A logged-in account cannot consume another account's invitation token."""
- invited_account = invitation["account"]
- assert isinstance(invited_account, Account)
- invited_account.status = AccountStatus.ACTIVE
- data = invitation["data"]
- assert isinstance(data, dict)
- data["requires_setup"] = False
- sqlite_session.commit()
- current_account = Mock(id="current-account-id")
-
+ payload = {
+ "workspace_id": "workspace-123",
+ "email": "[email protected]",
+ "token": "valid-token",
+ "name": "John Doe",
+ "interface_language": "en-US",
+ "timezone": "UTC",
+ }
with (
- patch.object(
- activate_module.RegisterService,
- "get_invitation_with_case_fallback",
- return_value=invitation,
+ app.test_request_context("/activate", method="POST", json=payload),
+ patch(
+ "controllers.console.auth.activate.application_services",
+ return_value=_services(activation_service),
),
- patch.object(
- activate_module,
- "current_account_with_tenant",
- return_value=(current_account, "current-workspace-id"),
+ patch("controllers.console.auth.activate.extract_access_token", return_value="access-token"),
+ patch(
+ "controllers.console.auth.activate.current_account_with_tenant",
+ return_value=SimpleNamespace(account=SimpleNamespace(id="account-123")),
),
- patch.object(activate_module, "extract_access_token", return_value="access-token") as extract_access_token,
- patch.object(activate_module.RegisterService, "revoke_token") as revoke_token,
- patch.object(activate_module.TenantService, "create_tenant_member") as create_tenant_member,
- pytest.raises(InvitationAccountMismatchError),
):
- _post(app, {"token": "valid_token"})
+ response = unwrap(ActivateApi.post)(ActivateApi())
- extract_access_token.assert_called_once()
- revoke_token.assert_not_called()
- create_tenant_member.assert_not_called()
- switch_tenant.assert_not_called()
- assert sqlite_session.scalar(select(func.count(TenantAccountJoin.id))) == 0
-
- def test_successful_account_activation_persists_membership(
- self,
- sqlite_session: Session,
- app: Flask,
- invitation: dict[str, object],
- ) -> None:
- invited_account = invitation["account"]
- invited_tenant = invitation["tenant"]
- assert isinstance(invited_account, Account)
- assert isinstance(invited_tenant, Tenant)
- account_id = invited_account.id
- tenant_id = invited_tenant.id
-
- with (
- patch.object(
- activate_module.RegisterService,
- "get_invitation_with_case_fallback",
- return_value=invitation,
- ),
- patch.object(activate_module.RegisterService, "revoke_token") as revoke_token,
- ):
- response = _post(app, _setup_payload())
-
- sqlite_session.expire_all()
- account = sqlite_session.get(Account, account_id)
- assert account is not None
- membership = sqlite_session.scalar(
- select(TenantAccountJoin).where(
- TenantAccountJoin.account_id == account_id,
- TenantAccountJoin.tenant_id == tenant_id,
- )
- )
- assert membership is not None
- assert membership.role == TenantAccountRole.NORMAL
- assert membership.current is True
- assert membership.last_opened_at is not None
assert response == {"result": "success"}
- assert account.name == "John Doe"
- assert account.interface_language == "en-US"
- assert account.timezone == "UTC"
- assert account.interface_theme == "light"
- assert account.status == AccountStatus.ACTIVE
- assert account.initialized_at is not None
- revoke_token.assert_called_once_with("workspace-123", "[email protected]", "valid_token")
-
- def test_missing_setup_fields_does_not_consume_invitation_or_create_membership(
- self,
- sqlite_session: Session,
- app: Flask,
- invitation: dict[str, object],
- switch_tenant: Mock,
- ) -> None:
- data = invitation["data"]
- assert isinstance(data, dict)
- data["requires_setup"] = True
-
- with (
- patch.object(
- activate_module.RegisterService,
- "get_invitation_with_case_fallback",
- return_value=invitation,
+ activation_service.activate.assert_called_once_with(
+ ActivationCommand(
+ invitation=InvitationLookup(
+ workspace_id="workspace-123",
+ token="valid-token",
+ ),
+ name="John Doe",
+ interface_language="en-US",
+ timezone="UTC",
),
- patch.object(activate_module.RegisterService, "revoke_token") as revoke_token,
- pytest.raises(AlreadyActivateError),
- ):
- _post(app, _setup_payload(name=None, interface_language=None, timezone=None))
-
- assert sqlite_session.scalar(select(func.count(TenantAccountJoin.id))) == 0
- revoke_token.assert_not_called()
- switch_tenant.assert_not_called()
-
- def test_activation_with_invalid_token(self, app: Flask, switch_tenant: Mock) -> None:
- with (
- patch.object(
- activate_module.RegisterService,
- "get_invitation_with_case_fallback",
- return_value=None,
- ),
- pytest.raises(AlreadyActivateError),
- ):
- _post(app, _setup_payload(token="invalid_token"))
- switch_tenant.assert_not_called()
+ authenticated_account_id="account-123",
+ )
- def test_billing_freeze_leaves_persisted_account_pending(
+ def test_passes_no_authenticated_account_for_token_only_activation(
self,
- sqlite_session: Session,
app: Flask,
- invitation: dict[str, object],
- switch_tenant: Mock,
- monkeypatch: pytest.MonkeyPatch,
+ activation_service: Mock,
) -> None:
- account = invitation["account"]
- assert isinstance(account, Account)
- account.email = "[email protected]"
- sqlite_session.commit()
- monkeypatch.setattr(activate_module.dify_config, "DEPLOYMENT_EDITION", DeploymentEdition.CLOUD)
-
with (
- patch.object(
- activate_module.RegisterService,
- "get_invitation_with_case_fallback",
- return_value=invitation,
+ app.test_request_context("/activate", method="POST", json={"token": "valid-token"}),
+ patch(
+ "controllers.console.auth.activate.application_services",
+ return_value=_services(activation_service),
),
- patch.object(activate_module.RegisterService, "revoke_token") as revoke_token,
- patch.object(activate_module.BillingService, "is_email_in_freeze", return_value=True) as is_frozen,
- pytest.raises(AccountInFreezeError),
+ patch("controllers.console.auth.activate.extract_access_token", return_value=None),
+ patch("controllers.console.auth.activate.current_account_with_tenant") as resolve_account,
):
- _post(app, _setup_payload())
+ response = unwrap(ActivateApi.post)(ActivateApi())
- sqlite_session.refresh(account)
- assert account.status == AccountStatus.PENDING
- assert sqlite_session.scalar(select(func.count(TenantAccountJoin.id))) == 0
- is_frozen.assert_called_once_with("[email protected]")
- revoke_token.assert_not_called()
- switch_tenant.assert_not_called()
+ assert response == {"result": "success"}
+ activation_service.activate.assert_called_once_with(
+ ActivationCommand(invitation=InvitationLookup(workspace_id=None, email=None, token="valid-token")),
+ authenticated_account_id=None,
+ )
+ resolve_account.assert_not_called()
@pytest.mark.parametrize(
- ("language", "timezone"),
+ ("service_error", "http_error"),
[
- ("en-US", "UTC"),
- ("zh-Hans", "Asia/Shanghai"),
- ("ja-JP", "Asia/Tokyo"),
- ("es-ES", "Europe/Madrid"),
+ (InvalidInvitationError(), AlreadyActivateError),
+ (InvitationAccountMismatchError(), InvitationAccountMismatchHTTPError),
+ (FrozenAccountError(), AccountInFreezeError),
],
)
- def test_activation_with_different_locales(
- self,
- app: Flask,
- invitation: dict[str, object],
- switch_tenant: Mock,
- language: str,
- timezone: str,
- ) -> None:
- with (
- patch.object(
- activate_module.RegisterService,
- "get_invitation_with_case_fallback",
- return_value=invitation,
- ),
- patch.object(activate_module.RegisterService, "revoke_token"),
- ):
- assert _post(app, _setup_payload(interface_language=language, timezone=timezone)) == {"result": "success"}
-
- account = invitation["account"]
- assert isinstance(account, Account)
- assert account.interface_language == language
- assert account.timezone == timezone
-
- def test_activation_without_workspace_id_revokes_normalized_email(
- self,
- app: Flask,
- invitation: dict[str, object],
- switch_tenant: Mock,
- ) -> None:
- with (
- patch.object(
- activate_module.RegisterService,
- "get_invitation_with_case_fallback",
- return_value=invitation,
- ) as lookup,
- patch.object(activate_module.RegisterService, "revoke_token") as revoke_token,
- ):
- response = _post(
- app,
- _setup_payload(workspace_id=None, email="[email protected]"),
- )
-
- assert response == {"result": "success"}
- lookup.assert_called_once_with(None, "[email protected]", "valid_token", session=ANY)
- revoke_token.assert_called_once_with(None, "[email protected]", "valid_token")
-
- def test_existing_active_account_gets_tenant_scoped_admin_membership(
- self,
- sqlite_session: Session,
- app: Flask,
- invitation: dict[str, object],
- switch_tenant: Mock,
- ) -> None:
- session = sqlite_session
- account = invitation["account"]
- tenant = invitation["tenant"]
- data = invitation["data"]
- assert isinstance(account, Account)
- assert isinstance(tenant, Tenant)
- assert isinstance(data, dict)
- account.status = AccountStatus.ACTIVE
- data.update({"role": "admin", "requires_setup": False})
- other_tenant = Tenant(name="Other Workspace")
- other_tenant.id = "workspace-456"
- session.add(other_tenant)
- session.flush()
- session.add(
- TenantAccountJoin(
- tenant_id=other_tenant.id,
- account_id=account.id,
- role=TenantAccountRole.NORMAL,
- )
- )
- session.commit()
-
- with (
- patch.object(
- activate_module.RegisterService,
- "get_invitation_with_case_fallback",
- return_value=invitation,
- ),
- patch.object(activate_module.RegisterService, "revoke_token"),
- ):
- assert _post(
- app,
- {"workspace_id": tenant.id, "email": account.email, "token": "valid_token"},
- ) == {"result": "success"}
-
- memberships = session.scalars(select(TenantAccountJoin).where(TenantAccountJoin.account_id == account.id)).all()
- assert {(row.tenant_id, row.role) for row in memberships} == {
- (other_tenant.id, TenantAccountRole.NORMAL),
- (tenant.id, TenantAccountRole.ADMIN),
- }
-
- def test_existing_membership_is_not_duplicated(
+ def test_translates_application_errors(
self,
- sqlite_session: Session,
app: Flask,
- invitation: dict[str, object],
- switch_tenant: Mock,
+ activation_service: Mock,
+ service_error: Exception,
+ http_error: type[Exception],
) -> None:
- session = sqlite_session
- account = invitation["account"]
- tenant = invitation["tenant"]
- assert isinstance(account, Account)
- assert isinstance(tenant, Tenant)
- account.status = AccountStatus.ACTIVE
- session.add(
- TenantAccountJoin(
- tenant_id=tenant.id,
- account_id=account.id,
- role=TenantAccountRole.EDITOR,
- )
- )
- session.commit()
+ activation_service.activate.side_effect = service_error
with (
- patch.object(
- activate_module.RegisterService,
- "get_invitation_with_case_fallback",
- return_value=invitation,
+ app.test_request_context("/activate", method="POST", json={"token": "invalid-token"}),
+ patch(
+ "controllers.console.auth.activate.application_services",
+ return_value=_services(activation_service),
),
- patch.object(activate_module.RegisterService, "revoke_token"),
+ patch("controllers.console.auth.activate.extract_access_token", return_value=None),
+ pytest.raises(http_error),
):
- assert _post(
- app,
- {"workspace_id": tenant.id, "email": account.email, "token": "valid_token"},
- ) == {"result": "success"}
-
- assert session.scalar(select(func.count(TenantAccountJoin.id))) == 1
- membership = session.scalar(select(TenantAccountJoin))
- assert membership is not None
- assert membership.role == TenantAccountRole.EDITOR
+ unwrap(ActivateApi.post)(ActivateApi())
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 d3cc79c9760..5701827304c 100644
--- a/api/tests/unit_tests/extensions/test_ext_application_services.py
+++ b/api/tests/unit_tests/extensions/test_ext_application_services.py
@@ -10,6 +10,13 @@ from enums import DeploymentEdition
from extensions import ext_application_services
from extensions.ext_redis import RedisClientWrapper
from models.model import DifySetup
+from repositories.account_activation_repository import SQLAlchemyAccountActivationRepository
+from services.account_activation_adapters import (
+ BillingAccountActivationEligibility,
+ BillingWorkspaceMembershipCache,
+ DeploymentWorkspaceInvitePolicy,
+ RegisterServiceInvitationTokenStore,
+)
from services.auth.data_source_api_key_auth_service import DataSourceApiKeyAuthService
from services.init_validation_service import InvalidInitializationPasswordError
@@ -137,6 +144,37 @@ def test_build_application_services_does_not_construct_schema_manager(
schema_manager.assert_not_called()
+ ("deployment_edition", "billing_enabled"),
+ [
+ pytest.param(DeploymentEdition.CLOUD, True, id="cloud"),
+ pytest.param(DeploymentEdition.COMMUNITY, False, id="community"),
+ pytest.param(DeploymentEdition.ENTERPRISE, False, id="enterprise"),
+ ],
+)
+def test_build_application_services_wires_account_activation(
+ sqlite_session_factory: sessionmaker[Session],
+ deployment_edition: DeploymentEdition,
+ billing_enabled: bool,
+) -> None:
+ services = ext_application_services.build_application_services(
+ database_client=sqlite_session_factory,
+ deployment_edition=deployment_edition,
+ initialization_password="",
+ redis=MagicMock(spec=RedisClientWrapper),
+ )
+
+ activation = services.account_activation
+ assert isinstance(activation._tokens, RegisterServiceInvitationTokenStore)
+ assert isinstance(activation._accounts, SQLAlchemyAccountActivationRepository)
+ assert activation._accounts._session_factory is sqlite_session_factory
+ assert isinstance(activation._workspace_policy, DeploymentWorkspaceInvitePolicy)
+ assert isinstance(activation._eligibility, BillingAccountActivationEligibility)
+ assert activation._eligibility._enabled is billing_enabled
+ assert isinstance(activation._membership_cache, BillingWorkspaceMembershipCache)
+ assert activation._membership_cache._enabled is billing_enabled
+
+
def test_build_application_services_wires_data_source_api_key_auth(
sqlite_session_factory: sessionmaker[Session],
) -> None:
diff --git a/api/tests/unit_tests/repositories/test_account_activation_repository.py b/api/tests/unit_tests/repositories/test_account_activation_repository.py
new file mode 100644
index 00000000000..8c24093661c
--- /dev/null
+++ b/api/tests/unit_tests/repositories/test_account_activation_repository.py
@@ -0,0 +1,178 @@
+from typing import cast
+
+from sqlalchemy import event, select
+from sqlalchemy.dialects import postgresql
+from sqlalchemy.orm import ORMExecuteState, Session, sessionmaker
+from sqlalchemy.sql.elements import ClauseElement
+
+from models.account import Account, AccountStatus, Tenant, TenantAccountJoin, TenantAccountRole
+from repositories.account_activation_repository import SQLAlchemyAccountActivationRepository
+from services.entities.account_activation_entities import AccountInvitation, AccountSetup, InvitationToken
+
+
+def _persist_invitation_state(session: Session) -> tuple[Account, Tenant]:
+ account = Account(name="Invited", email="[email protected]", status=AccountStatus.PENDING)
+ account.id = "account-1"
+ tenant = Tenant(name="Workspace")
+ tenant.id = "workspace-1"
+ session.add_all([account, tenant])
+ session.commit()
+ return account, tenant
+
+
+def _invitation() -> AccountInvitation:
+ return AccountInvitation(
+ account_id="account-1",
+ account_email="[email protected]",
+ account_status="pending",
+ workspace_id="workspace-1",
+ workspace_name="Workspace",
+ role="admin",
+ requires_setup=True,
+ )
+
+
+class TestResolveInvitation:
+ def test_returns_framework_neutral_record(
+ self,
+ sqlite_session: Session,
+ sqlite_session_factory: sessionmaker[Session],
+ ) -> None:
+ _persist_invitation_state(sqlite_session)
+ repository = SQLAlchemyAccountActivationRepository(sqlite_session_factory)
+
+ result = repository.resolve(
+ InvitationToken(
+ account_id="account-1",
+ workspace_id="workspace-1",
+ role="admin",
+ requires_setup=True,
+ )
+ )
+
+ assert result == _invitation()
+
+ def test_rejects_token_for_different_account(
+ self,
+ sqlite_session: Session,
+ sqlite_session_factory: sessionmaker[Session],
+ ) -> None:
+ _persist_invitation_state(sqlite_session)
+ repository = SQLAlchemyAccountActivationRepository(sqlite_session_factory)
+
+ result = repository.resolve(
+ InvitationToken(
+ account_id="different-account",
+ workspace_id="workspace-1",
+ )
+ )
+
+ assert result is None
+
+
+class TestPersistActivation:
+ def test_locks_account_while_switching_current_workspace(
+ self,
+ sqlite_session: Session,
+ sqlite_session_factory: sessionmaker[Session],
+ ) -> None:
+ _persist_invitation_state(sqlite_session)
+ repository = SQLAlchemyAccountActivationRepository(sqlite_session_factory)
+ statements: list[ClauseElement] = []
+
+ def capture_statement(execute_state: ORMExecuteState) -> None:
+ statements.append(cast(ClauseElement, execute_state.statement))
+
+ event.listen(sqlite_session_factory.class_, "do_orm_execute", capture_statement)
+ try:
+ result = repository.activate(_invitation(), role="admin", setup=None)
+ finally:
+ event.remove(sqlite_session_factory.class_, "do_orm_execute", capture_statement)
+
+ assert result is not None
+ account_selects = [
+ str(statement.compile(dialect=postgresql.dialect()))
+ for statement in statements
+ if "FROM accounts" in str(statement.compile(dialect=postgresql.dialect()))
+ ]
+ assert len(account_selects) == 1
+ assert "FOR UPDATE" in account_selects[0]
+
+ def test_creates_membership_initializes_account_and_switches_workspace(
+ self,
+ sqlite_session: Session,
+ sqlite_session_factory: sessionmaker[Session],
+ ) -> None:
+ account, _ = _persist_invitation_state(sqlite_session)
+ other_tenant = Tenant(name="Other Workspace")
+ other_tenant.id = "workspace-2"
+ sqlite_session.add(other_tenant)
+ sqlite_session.flush()
+ sqlite_session.add(
+ TenantAccountJoin(
+ tenant_id=other_tenant.id,
+ account_id=account.id,
+ role=TenantAccountRole.NORMAL,
+ current=True,
+ )
+ )
+ sqlite_session.commit()
+ repository = SQLAlchemyAccountActivationRepository(sqlite_session_factory)
+
+ result = repository.activate(
+ _invitation(),
+ role="admin",
+ setup=AccountSetup(name="John Doe", interface_language="en-US", timezone="UTC"),
+ )
+
+ assert result is not None
+ assert result.membership_created is True
+ sqlite_session.expire_all()
+ persisted_account = sqlite_session.get(Account, "account-1")
+ assert persisted_account is not None
+ assert persisted_account.name == "John Doe"
+ assert persisted_account.interface_language == "en-US"
+ assert persisted_account.timezone == "UTC"
+ assert persisted_account.interface_theme == "light"
+ assert persisted_account.status == AccountStatus.ACTIVE
+ assert persisted_account.initialized_at is not None
+
+ memberships = sqlite_session.scalars(
+ select(TenantAccountJoin)
+ .where(TenantAccountJoin.account_id == "account-1")
+ .order_by(TenantAccountJoin.tenant_id)
+ ).all()
+ assert [(membership.tenant_id, membership.role, membership.current) for membership in memberships] == [
+ ("workspace-1", TenantAccountRole.ADMIN, True),
+ ("workspace-2", TenantAccountRole.NORMAL, False),
+ ]
+ assert memberships[0].last_opened_at is not None
+
+ def test_keeps_existing_membership_role(
+ self,
+ sqlite_session: Session,
+ sqlite_session_factory: sessionmaker[Session],
+ ) -> None:
+ account, tenant = _persist_invitation_state(sqlite_session)
+ sqlite_session.add(
+ TenantAccountJoin(
+ tenant_id=tenant.id,
+ account_id=account.id,
+ role=TenantAccountRole.EDITOR,
+ )
+ )
+ account.status = AccountStatus.ACTIVE
+ sqlite_session.commit()
+ repository = SQLAlchemyAccountActivationRepository(sqlite_session_factory)
+
+ result = repository.activate(_invitation(), role="admin", setup=None)
+
+ assert result is not None
+ assert result.membership_created is False
+ sqlite_session.expire_all()
+ membership = sqlite_session.scalar(select(TenantAccountJoin))
+ assert membership is not None
+ assert membership.role == TenantAccountRole.EDITOR
+ assert membership.current is True
diff --git a/api/tests/unit_tests/services/test_account_activation_adapters.py b/api/tests/unit_tests/services/test_account_activation_adapters.py
new file mode 100644
index 00000000000..931001197c7
--- /dev/null
+++ b/api/tests/unit_tests/services/test_account_activation_adapters.py
@@ -0,0 +1,63 @@
+from unittest.mock import patch
+
+from services.account_activation_adapters import (
+ BillingAccountActivationEligibility,
+ BillingWorkspaceMembershipCache,
+ DeploymentWorkspaceInvitePolicy,
+ RegisterServiceInvitationTokenStore,
+)
+from services.entities.account_activation_entities import InvitationLookup, InvitationToken
+
+
+def test_invitation_token_store_converts_legacy_service_data() -> None:
+ lookup = InvitationLookup(workspace_id="workspace-1", email="[email protected]", token="token-1")
+ with patch(
+ "services.account_activation_adapters.RegisterService.get_invitation_by_token",
+ return_value={
+ "account_id": "account-1",
+ "email": "[email protected]",
+ "workspace_id": "workspace-1",
+ "role": "editor",
+ "requires_setup": False,
+ },
+ ) as find:
+ result = RegisterServiceInvitationTokenStore().find(lookup)
+
+ assert result == InvitationToken(
+ account_id="account-1",
+ workspace_id="workspace-1",
+ role="editor",
+ requires_setup=False,
+ )
+ find.assert_called_once_with("token-1", "workspace-1", "[email protected]")
+
+
+def test_invitation_token_store_revokes_with_legacy_key_inputs() -> None:
+ lookup = InvitationLookup(workspace_id="workspace-1", email="[email protected]", token="token-1")
+ with patch("services.account_activation_adapters.RegisterService.revoke_token") as revoke:
+ RegisterServiceInvitationTokenStore().revoke(lookup)
+
+ revoke.assert_called_once_with("workspace-1", "[email protected]", "token-1")
+
+
+def test_billing_eligibility_skips_gateway_when_disabled() -> None:
+ with patch("services.account_activation_adapters.BillingService.is_email_in_freeze") as is_frozen:
+ result = BillingAccountActivationEligibility(enabled=False).is_frozen("[email protected]")
+
+ assert result is False
+ is_frozen.assert_not_called()
+
+
+def test_membership_cache_skips_gateway_when_disabled() -> None:
+ with patch("services.account_activation_adapters.BillingService.clean_billing_info_cache") as invalidate:
+ BillingWorkspaceMembershipCache(enabled=False).invalidate("workspace-1")
+
+ invalidate.assert_not_called()
+
+
+def test_workspace_policy_delegates_to_existing_policy_owner() -> None:
+ with patch("services.account_activation_adapters.check_workspace_member_invite_permission") as ensure_allowed:
+ DeploymentWorkspaceInvitePolicy().ensure_allowed("workspace-1")
+
+ ensure_allowed.assert_called_once_with("workspace-1")
diff --git a/api/tests/unit_tests/services/test_account_activation_service.py b/api/tests/unit_tests/services/test_account_activation_service.py
new file mode 100644
index 00000000000..e56214b3eb5
--- /dev/null
+++ b/api/tests/unit_tests/services/test_account_activation_service.py
@@ -0,0 +1,213 @@
+from unittest.mock import Mock, call
+
+import pytest
+
+from services.account_activation_service import (
+ AccountActivationEligibility,
+ AccountActivationRepository,
+ AccountActivationService,
+ FrozenAccountError,
+ InvalidInvitationError,
+ InvitationAccountMismatchError,
+ InvitationTokenStore,
+ WorkspaceInvitePolicy,
+ WorkspaceMembershipCache,
+)
+from services.entities.account_activation_entities import (
+ AccountInvitation,
+ AccountSetup,
+ ActivationCommand,
+ ActivationPersistenceResult,
+ InvitationLookup,
+ InvitationToken,
+)
+
+
+def _lookup(email: str | None = "[email protected]") -> InvitationLookup:
+ return InvitationLookup(workspace_id="workspace-1", email=email, token="token-1")
+
+
+def _token() -> InvitationToken:
+ return InvitationToken(
+ account_id="account-1",
+ workspace_id="workspace-1",
+ role="admin",
+ requires_setup=True,
+ )
+
+
+def _invitation(
+ *,
+ account_status: str = "pending",
+ role: str | None = "admin",
+ requires_setup: bool | None = True,
+) -> AccountInvitation:
+ return AccountInvitation(
+ account_id="account-1",
+ account_email="[email protected]",
+ account_status=account_status,
+ workspace_id="workspace-1",
+ workspace_name="Workspace",
+ role=role,
+ requires_setup=requires_setup,
+ )
+
+
+def _service() -> tuple[AccountActivationService, Mock, Mock, Mock, Mock, Mock]:
+ tokens = Mock(spec=InvitationTokenStore)
+ accounts = Mock(spec=AccountActivationRepository)
+ policy = Mock(spec=WorkspaceInvitePolicy)
+ eligibility = Mock(spec=AccountActivationEligibility)
+ membership_cache = Mock(spec=WorkspaceMembershipCache)
+ eligibility.is_frozen.return_value = False
+ service = AccountActivationService(
+ tokens=tokens,
+ accounts=accounts,
+ workspace_policy=policy,
+ eligibility=eligibility,
+ membership_cache=membership_cache,
+ )
+ return service, tokens, accounts, policy, eligibility, membership_cache
+
+
+class TestCheckInvitation:
+ def test_returns_invalid_without_touching_database_when_token_is_missing(self) -> None:
+ service, tokens, accounts, policy, _, _ = _service()
+ tokens.find.return_value = None
+
+ result = service.check(_lookup())
+
+ assert result.is_valid is False
+ assert result.data is None
+ accounts.resolve.assert_not_called()
+ policy.ensure_allowed.assert_not_called()
+
+ def test_does_not_repeat_database_lookup_for_normalized_email(self) -> None:
+ service, tokens, accounts, policy, _, _ = _service()
+ token = _token()
+ tokens.find.return_value = token
+ accounts.resolve.return_value = None
+
+ result = service.check(_lookup())
+
+ assert result.is_valid is False
+ accounts.resolve.assert_called_once_with(token)
+ policy.ensure_allowed.assert_not_called()
+
+ def test_falls_back_to_normalized_email_and_applies_workspace_policy(self) -> None:
+ service, tokens, accounts, policy, _, _ = _service()
+ upper_case_token = InvitationToken(
+ account_id="account-1",
+ workspace_id="workspace-1",
+ )
+ normalized_token = _token()
+ invitation = _invitation(requires_setup=None)
+ tokens.find.side_effect = [upper_case_token, normalized_token]
+ accounts.resolve.side_effect = [None, invitation]
+
+ result = service.check(_lookup("[email protected]"))
+
+ assert result.is_valid is True
+ assert result.data is not None
+ assert result.data.requires_setup is True
+ assert result.data.account_status == "pending"
+ assert tokens.find.call_args_list == [
+ call(_lookup("[email protected]")),
+ call(_lookup("[email protected]")),
+ ]
+ assert accounts.resolve.call_args_list == [call(upper_case_token), call(normalized_token)]
+ policy.ensure_allowed.assert_called_once_with("workspace-1")
+
+
+class TestActivateInvitation:
+ def test_rejects_authenticated_account_mismatch_before_side_effects(self) -> None:
+ service, tokens, accounts, _, eligibility, _ = _service()
+ tokens.find.return_value = _token()
+ accounts.resolve.return_value = _invitation()
+
+ with pytest.raises(InvitationAccountMismatchError):
+ service.activate(
+ ActivationCommand(invitation=_lookup()),
+ authenticated_account_id="different-account",
+ )
+
+ eligibility.is_frozen.assert_not_called()
+ tokens.revoke.assert_not_called()
+ accounts.activate.assert_not_called()
+
+ def test_rejects_frozen_account_without_consuming_token(self) -> None:
+ service, tokens, accounts, _, eligibility, _ = _service()
+ tokens.find.return_value = _token()
+ accounts.resolve.return_value = _invitation()
+ eligibility.is_frozen.return_value = True
+
+ with pytest.raises(FrozenAccountError):
+ service.activate(ActivationCommand(invitation=_lookup()), authenticated_account_id=None)
+
+ eligibility.is_frozen.assert_called_once_with("[email protected]")
+ tokens.revoke.assert_not_called()
+ accounts.activate.assert_not_called()
+
+ def test_requires_all_setup_fields_before_consuming_token(self) -> None:
+ service, tokens, accounts, _, _, _ = _service()
+ tokens.find.return_value = _token()
+ accounts.resolve.return_value = _invitation()
+
+ with pytest.raises(InvalidInvitationError):
+ service.activate(
+ ActivationCommand(invitation=_lookup(), name="Name"),
+ authenticated_account_id=None,
+ )
+
+ tokens.revoke.assert_not_called()
+ accounts.activate.assert_not_called()
+
+ def test_activates_anonymous_invitation_and_invalidates_new_membership_cache(self) -> None:
+ service, tokens, accounts, _, eligibility, membership_cache = _service()
+ tokens.find.return_value = _token()
+ invitation = _invitation(role="owner")
+ accounts.resolve.return_value = invitation
+ accounts.activate.return_value = ActivationPersistenceResult(membership_created=True)
+ command = ActivationCommand(
+ invitation=_lookup("[email protected]"),
+ name="John Doe",
+ interface_language="en-US",
+ timezone="UTC",
+ )
+
+ service.activate(command, authenticated_account_id=None)
+
+ eligibility.is_frozen.assert_called_once_with("[email protected]")
+ tokens.revoke.assert_called_once_with(_lookup("[email protected]"))
+ accounts.activate.assert_called_once_with(
+ invitation,
+ role="normal",
+ setup=AccountSetup(name="John Doe", interface_language="en-US", timezone="UTC"),
+ )
+ membership_cache.invalidate.assert_called_once_with("workspace-1")
+
+ def test_preserves_existing_membership_cache_and_ignores_setup_fields(self) -> None:
+ service, tokens, accounts, _, _, membership_cache = _service()
+ tokens.find.return_value = _token()
+ invitation = _invitation(
+ account_status="active",
+ role="editor",
+ requires_setup=False,
+ )
+ accounts.resolve.return_value = invitation
+ accounts.activate.return_value = ActivationPersistenceResult(membership_created=False)
+
+ service.activate(
+ ActivationCommand(
+ invitation=_lookup(),
+ name="Ignored",
+ interface_language="zh-Hans",
+ timezone="Asia/Shanghai",
+ ),
+ authenticated_account_id="account-1",
+ )
+
+ accounts.activate.assert_called_once_with(invitation, role="editor", setup=None)
+ membership_cache.invalidate.assert_not_called()