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
test: use real account activation adapters (#43218)
Asuka Minato1dbf02727788
diff --git a/api/tests/unit_tests/services/test_account_activation_service.py b/api/tests/unit_tests/services/test_account_activation_service.pyindex bd3bd4d39d7..232a2928dfe 100644--- a/api/tests/unit_tests/services/test_account_activation_service.py+++ b/api/tests/unit_tests/services/test_account_activation_service.py@@ -1,47 +1,39 @@-from unittest.mock import Mock, call+from unittest.mock import MagicMock, callimport pytest--from services.account_activation_service import (- AccountActivationEligibility,- AccountActivationRepository,- AccountActivationService,- InvitationTokenStore,- WorkspaceInvitePolicy,- WorkspaceMemberAccessSync,- WorkspaceMembershipCache,+from pytest_mock import MockerFixture+from sqlalchemy import delete, select+from sqlalchemy.orm import Session, sessionmaker++from extensions.ext_redis import RedisClientWrapper+from models.account import Account, AccountStatus, TenantAccountJoin, TenantAccountRole+from repositories.account_activation_repository import SQLAlchemyAccountActivationRepository+from services.account.adapters import (+ BillingAccountActivationEligibility,+ BillingWorkspaceMembershipCache,+ DeploymentWorkspaceInvitePolicy,+ RBACWorkspaceMemberAccessSync,+ RedisInvitationTokenStore,)+from services.account_activation_service import AccountActivationServicefrom services.account_errors import AccountEmailDomainSuspendedError as EmailDomainSuspendedErrorfrom services.account_errors import FrozenAccountError, InvalidInvitationError, InvitationAccountMismatchErrorfrom services.entities.account_activation_entities import (AccountInvitation,AccountSetup,ActivationCommand,- ActivationPersistenceResult,InvitationLookup,InvitationToken,)+from tests.unit_tests.model_factories import make_account, make_tenantdef _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,+ *, account_status: str = "pending", role: str | None = None, requires_setup: bool | None = None) -> AccountInvitation:return AccountInvitation(account_id="account-1",@@ -54,143 +46,167 @@ def _invitation()-def _service() -> tuple[AccountActivationService, Mock, 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)- member_access_sync = Mock(spec=WorkspaceMemberAccessSync)- eligibility.get_freeze_type.return_value = None- service = AccountActivationService(- tokens=tokens,- accounts=accounts,- workspace_policy=policy,- eligibility=eligibility,- membership_cache=membership_cache,- member_access_sync=member_access_sync,+def service(+ sqlite_session_factory: sessionmaker[Session], redis_transport: tuple[RedisClientWrapper, MagicMock]+) -> AccountActivationService:+ redis, commands = redis_transport+ commands.return_value = b"account-1"+ with sqlite_session_factory.begin() as session:+ session.add(make_account(email="[email protected]", status=AccountStatus.PENDING))+ session.add(make_tenant(tenant_id="workspace-1", name="Workspace"))+ return AccountActivationService(+ tokens=RedisInvitationTokenStore(redis=redis),+ accounts=SQLAlchemyAccountActivationRepository(sqlite_session_factory),+ workspace_policy=DeploymentWorkspaceInvitePolicy(),+ eligibility=BillingAccountActivationEligibility(enabled=True),+ membership_cache=BillingWorkspaceMembershipCache(enabled=True),+ member_access_sync=RBACWorkspaceMemberAccessSync(enabled=True),)- return service, tokens, accounts, policy, eligibility, membership_cache, member_access_sync+++def boundaries(service: AccountActivationService, mocker: MockerFixture) -> dict[str, MagicMock]:+ return {+ "find": mocker.spy(service._tokens, "find"),+ "revoke": mocker.spy(service._tokens, "revoke"),+ "resolve": mocker.spy(service._accounts, "resolve"),+ "activate": mocker.spy(service._accounts, "activate"),+ "policy": mocker.patch("services.account.adapters.check_workspace_member_invite_permission"),+ "freeze": mocker.patch("services.account.adapters.BillingService.get_email_freeze_type", return_value=None),+ "cache": mocker.patch("services.account.adapters.BillingService.clean_billing_info_cache"),+ "sync": mocker.patch(+ "tasks.initialize_created_app_rbac_access_task.sync_joined_workspace_member_rbac_access_task.delay"+ ),+ }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+ def test_returns_invalid_without_touching_database_when_token_is_missing(+ self,+ service: AccountActivationService,+ boundaries: dict[str, MagicMock],+ redis_transport: tuple[RedisClientWrapper, MagicMock],+ ) -> None:+ redis_transport[1].return_value = Noneresult = service.check(_lookup())assert result.is_valid is Falseassert 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+ boundaries["resolve"].assert_not_called()+ boundaries["policy"].assert_not_called()++ def test_does_not_repeat_database_lookup_for_normalized_email(+ self,+ service: AccountActivationService,+ boundaries: dict[str, MagicMock],+ sqlite_session_factory: sessionmaker[Session],+ ) -> None:+ with sqlite_session_factory.begin() as session:+ session.execute(delete(Account))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",+ boundaries["resolve"].assert_called_once_with(+ 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]+ boundaries["policy"].assert_not_called()+ def test_falls_back_to_normalized_email_and_applies_workspace_policy(+ self,+ service: AccountActivationService,+ boundaries: dict[str, MagicMock],+ ) -> None:result = service.check(_lookup("[email protected]"))assert result.is_valid is Trueassert result.data is not Noneassert result.data.requires_setup is Trueassert result.data.account_status == "pending"- assert tokens.find.call_args_list == [+ assert boundaries["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")+ assert boundaries["resolve"].call_args_list == [+ call(InvitationToken(account_id="account-1", email=email, workspace_id="workspace-1"))+ for email in ("[email protected]", "[email protected]")+ ]+ boundaries["policy"].assert_called_once_with("workspace-1")class TestActivateInvitation:- def test_rejects_authenticated_account_mismatch_before_side_effects(self) -> None:- service, tokens, accounts, _, eligibility, _, member_access_sync = _service()- tokens.find.return_value = _token()- accounts.resolve.return_value = _invitation()-+ def test_rejects_authenticated_account_mismatch_before_side_effects(+ self,+ service: AccountActivationService,+ boundaries: dict[str, MagicMock],+ ) -> None:with pytest.raises(InvitationAccountMismatchError):service.activate(ActivationCommand(invitation=_lookup()),authenticated_account_id="different-account",)- eligibility.get_freeze_type.assert_not_called()- tokens.revoke.assert_not_called()- accounts.activate.assert_not_called()- member_access_sync.sync.assert_not_called()+ boundaries["freeze"].assert_not_called()+ boundaries["revoke"].assert_not_called()+ boundaries["activate"].assert_not_called()+ boundaries["sync"].assert_not_called()- def test_rejects_frozen_account_without_consuming_token(self) -> None:- service, tokens, accounts, _, eligibility, _, member_access_sync = _service()- tokens.find.return_value = _token()- accounts.resolve.return_value = _invitation()- eligibility.get_freeze_type.return_value = "freeze"-- with pytest.raises(FrozenAccountError):+ @pytest.mark.parametrize(+ ("freeze_type", "error"),+ [("freeze", FrozenAccountError), ("email_domain_suspended", EmailDomainSuspendedError)],+ )+ def test_rejects_ineligible_account_without_consuming_token(+ self,+ service: AccountActivationService,+ boundaries: dict[str, MagicMock],+ freeze_type: str,+ error: type[Exception],+ ) -> None:+ boundaries["freeze"].return_value = freeze_type++ with pytest.raises(error):service.activate(ActivationCommand(invitation=_lookup()), authenticated_account_id=None)- eligibility.get_freeze_type.assert_called_once_with("[email protected]")- tokens.revoke.assert_not_called()- accounts.activate.assert_not_called()- member_access_sync.sync.assert_not_called()-- def test_requires_all_setup_fields_before_consuming_token(self) -> None:- service, tokens, accounts, _, _, _, member_access_sync = _service()- tokens.find.return_value = _token()- accounts.resolve.return_value = _invitation()+ boundaries["freeze"].assert_called_once_with("[email protected]")+ boundaries["revoke"].assert_not_called()+ boundaries["activate"].assert_not_called()+ boundaries["sync"].assert_not_called()+ def test_requires_all_setup_fields_before_consuming_token(+ self,+ service: AccountActivationService,+ boundaries: dict[str, MagicMock],+ ) -> None: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()- member_access_sync.sync.assert_not_called()-- def test_rejects_suspended_email_domain_without_consuming_token(self) -> None:- service, tokens, accounts, _, eligibility, _, member_access_sync = _service()- tokens.find.return_value = _token()- accounts.resolve.return_value = _invitation()- eligibility.get_freeze_type.return_value = "email_domain_suspended"-- with pytest.raises(EmailDomainSuspendedError):- service.activate(ActivationCommand(invitation=_lookup()), authenticated_account_id=None)-- eligibility.get_freeze_type.assert_called_once_with("[email protected]")- tokens.revoke.assert_not_called()- accounts.activate.assert_not_called()- member_access_sync.sync.assert_not_called()-- def test_activates_anonymous_invitation_and_invalidates_new_membership_cache(self) -> None:- service, tokens, accounts, _, eligibility, membership_cache, member_access_sync = _service()- tokens.find.return_value = _token()- invitation = _invitation(role="owner")- accounts.resolve.return_value = invitation- accounts.activate.return_value = ActivationPersistenceResult(membership_created=True)+ boundaries["revoke"].assert_not_called()+ boundaries["activate"].assert_not_called()+ boundaries["sync"].assert_not_called()++ @pytest.mark.parametrize("role", [None, "owner"])+ def test_activates_anonymous_invitation_and_invalidates_new_membership_cache(+ self,+ service: AccountActivationService,+ boundaries: dict[str, MagicMock],+ sqlite_session_factory: sessionmaker[Session],+ redis_transport: tuple[RedisClientWrapper, MagicMock],+ role: str | None,+ ) -> None:+ lookup = _lookup("[email protected]")+ if role == "owner":+ lookup = InvitationLookup(workspace_id=None, email=None, token="token-1")+ redis_transport[1].return_value = (+ b'{"account_id":"account-1","email":"[email protected]","workspace_id":"workspace-1",'+ b'"role":"owner","requires_setup":true}'+ )command = ActivationCommand(- invitation=_lookup("[email protected]"),+ invitation=lookup,name="John Doe",interface_language="en-US",timezone="UTC",@@ -198,30 +214,48 @@ class TestActivateInvitation:service.activate(command, authenticated_account_id=None)- eligibility.get_freeze_type.assert_called_once_with("[email protected]")- tokens.revoke.assert_called_once_with(_lookup("[email protected]"))- accounts.activate.assert_called_once_with(- invitation,+ boundaries["freeze"].assert_called_once_with("[email protected]")+ boundaries["revoke"].assert_called_once_with(_lookup("[email protected]") if role is None else lookup)+ boundaries["activate"].assert_called_once_with(+ _invitation(role=role, requires_setup=True if role == "owner" else None),role="normal",setup=AccountSetup(name="John Doe", interface_language="en-US", timezone="UTC"),)- membership_cache.invalidate.assert_called_once_with("workspace-1")- member_access_sync.sync.assert_called_once_with("workspace-1", "account-1")-- def test_preserves_existing_membership_cache_and_ignores_setup_fields(self) -> None:- service, tokens, accounts, _, _, membership_cache, member_access_sync = _service()- tokens.find.return_value = _token()- invitation = _invitation(- account_status="active",- role="editor",- requires_setup=False,+ boundaries["cache"].assert_called_once_with("workspace-1")+ boundaries["sync"].assert_called_once_with("workspace-1", "account-1", operator_account_id=None)+ with sqlite_session_factory() as session:+ account = session.get(Account, "account-1")+ membership = session.scalar(select(TenantAccountJoin))+ assert account is not None+ assert membership is not None+ assert (account.name, account.interface_language, account.timezone) == ("John Doe", "en-US", "UTC")+ assert account.status == AccountStatus.ACTIVE+ assert account.initialized_at is not None+ assert membership.role == TenantAccountRole.NORMAL+ assert membership.current is True++ def test_preserves_existing_membership_cache_and_ignores_setup_fields(+ self,+ service: AccountActivationService,+ boundaries: dict[str, MagicMock],+ sqlite_session_factory: sessionmaker[Session],+ redis_transport: tuple[RedisClientWrapper, MagicMock],+ ) -> None:+ with sqlite_session_factory.begin() as session:+ account = session.get(Account, "account-1")+ assert account is not None+ account.status = AccountStatus.ACTIVE+ session.add(+ TenantAccountJoin(tenant_id="workspace-1", account_id="account-1", role=TenantAccountRole.EDITOR)+ )+ redis_transport[1].return_value = (+ b'{"account_id":"account-1","email":"[email protected]","workspace_id":"workspace-1",'+ b'"role":"editor","requires_setup":false}')- accounts.resolve.return_value = invitation- accounts.activate.return_value = ActivationPersistenceResult(membership_created=False)service.activate(ActivationCommand(- invitation=_lookup(),+ invitation=InvitationLookup(workspace_id=None, email=None, token="token-1"),name="Ignored",interface_language="zh-Hans",timezone="Asia/Shanghai",@@ -229,6 +263,16 @@ class TestActivateInvitation:authenticated_account_id="account-1",)- accounts.activate.assert_called_once_with(invitation, role="editor", setup=None)- membership_cache.invalidate.assert_not_called()- member_access_sync.sync.assert_called_once_with("workspace-1", "account-1")+ boundaries["activate"].assert_called_once_with(+ _invitation(account_status="active", role="editor", requires_setup=False), role="editor", setup=None+ )+ boundaries["cache"].assert_not_called()+ boundaries["sync"].assert_called_once_with("workspace-1", "account-1", operator_account_id=None)+ with sqlite_session_factory() as session:+ account = session.get(Account, "account-1")+ memberships = session.scalars(select(TenantAccountJoin)).all()+ assert account is not None+ assert account.name == "Test User"+ assert len(memberships) == 1+ assert memberships[0].role == TenantAccountRole.EDITOR+ assert memberships[0].current is True