Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
refactor(api): extract account activation application service (#40421)
Byron.wangba61ab4f9f8f
diff --git a/api/.importlinter b/api/.importlinterindex f2e4177c863..1cbafd9b8ec 100644--- a/api/.importlinter+++ b/api/.importlinter@@ -167,3 +167,19 @@ forbidden_modules =repositoriessqlalchemywerkzeug++[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+ werkzeugdiff --git a/api/controllers/console/auth/activate.py b/api/controllers/console/auth/activate.pyindex 07c9d30d997..3921414369e 100644--- a/api/controllers/console/auth/activate.py+++ b/api/controllers/console/auth/activate.py@@ -1,25 +1,22 @@from flask import requestfrom flask_restx import Resourcefrom pydantic import BaseModel, Field, field_validator-from sqlalchemy import select-from configs import dify_configfrom constants.languages import supported_languagefrom controllers.common.schema import query_params_from_model, register_schema_modelsfrom controllers.console import console_ns-from controllers.console.auth.error import InvitationAccountMismatchError+from controllers.console.auth.error import InvitationAccountMismatchError as InvitationAccountMismatchHTTPErrorfrom 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, timezonefrom libs.login import current_account_with_tenantfrom 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, InvitationLookupclass 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 alreadycarries a console session, that session must belong to the account encoded in theinvitation 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.pyindex 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_makerfrom core.schemas.schema_manager import SchemaManagerfrom enums import DeploymentEditionfrom extensions.ext_redis import RedisClientWrapper, redis_client+from repositories.account_activation_repository import SQLAlchemyAccountActivationRepositoryfrom repositories.app_definition_query_repository import AppDefinitionQueryRepositoryfrom repositories.data_source_api_key_auth_repository import SQLAlchemyDataSourceApiKeyAuthBindingRepositoryfrom repositories.explore_banner_query_repository import ExploreBannerQueryRepositoryfrom repositories.installation_state_repository import InstallationStateRepositoryfrom repositories.workspace_member_query_repository import WorkspaceMemberQueryRepositoryfrom repositories.workspace_query_repository import WorkspaceQueryRepository+from services.account_activation_adapters import (+ BillingAccountActivationEligibility,+ BillingWorkspaceMembershipCache,+ DeploymentWorkspaceInvitePolicy,+ RegisterServiceInvitationTokenStore,+)+from services.account_activation_service import AccountActivationServicefrom services.app_definition_query_service import AppDefinitionQueryServicefrom 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: AccountActivationServiceapp_definitions: AppDefinitionQueryServicedata_source_api_key_auth: DataSourceApiKeyAuthServiceexplore_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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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: booldiff --git a/api/tests/unit_tests/controllers/console/auth/test_account_activation.py b/api/tests/unit_tests/controllers/console/auth/test_account_activation.pyindex 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 unwrapfrom types import SimpleNamespace-from unittest.mock import ANY, Mock, patch+from unittest.mock import Mock, patchimport pytestfrom flask import Flask-from sqlalchemy import func, select-from sqlalchemy.orm import Session, scoped_session-from controllers.console.auth import activate as activate_modulefrom controllers.console.auth.activate import ActivateApi, ActivateCheckApi-from controllers.console.auth.error import InvitationAccountMismatchError+from controllers.console.auth.error import InvitationAccountMismatchError as InvitationAccountMismatchHTTPErrorfrom 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"] = Truereturn 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",+ email="[email protected]",+ 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",+ email="[email protected]",+ 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",- "[email protected]",+ 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 Noneassert 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",+ email="[email protected]",+ 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_errorwith (- 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.pyindex 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 DeploymentEditionfrom extensions import ext_application_servicesfrom extensions.ext_redis import RedisClientWrapperfrom 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 DataSourceApiKeyAuthServicefrom 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.pynew file mode 100644index 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",+ email="[email protected]",+ 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",+ email="[email protected]",+ 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 Truediff --git a/api/tests/unit_tests/services/test_account_activation_adapters.py b/api/tests/unit_tests/services/test_account_activation_adapters.pynew file mode 100644index 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",+ email="[email protected]",+ 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.pynew file mode 100644index 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",+ email="[email protected]",+ 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",+ email="[email protected]",+ 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()