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
from collections.abc import Callable, Mapping, Sequence
from contextlib import nullcontext
from dataclasses import dataclass, field
from datetime import datetime
from unittest.mock import Mock, create_autospec
import pytest
from sqlalchemy import event, select
from sqlalchemy.orm import Session, sessionmaker
from enums import DeploymentEdition
from enums.account import TenantAccountRole as _workspace_member_query_service_TenantAccountRole
from extensions.ext_redis import RedisClientWrapper
from machinery.context import RequestContext
from models.account import Account, AccountStatus, Tenant, TenantAccountJoin, TenantAccountRole
from models.account import TenantAccountRole as _member_service_TenantAccountRole
from models.dataset import Dataset
from models.human_input_v2 import HumanInputContactIdentity
from models.model import App, AppMode
from services.account.adapters import RedisInvitationTokenStore
from services.account_errors import AccountNotFoundError
from services.enterprise.rbac_service import RBACService
from services.entities.account_entities import AccountSnapshot
from services.entities.feature_entities import FeatureModel, LicenseLimitationModel, LicenseModel
from services.errors.base import NoPermissionError
from services.errors.workspace import (
AccountAlreadyInTenantError,
CannotOperateSelfError,
InvalidOwnerTransferCodeError,
InvalidOwnerTransferEmailError,
InvalidOwnerTransferTokenError,
InvalidWorkspaceMemberRoleError,
MemberNotInTenantError,
RoleAlreadyAssignedError,
WorkspaceAlreadyHasOwnerError,
WorkspaceInvitationQuotaError,
WorkspaceNotFoundError,
)
from services.feature_service import FeatureService
from services.rbac.contracts import MemberRolesResponse, Paginated, RBACRole
from services.system_feature_service import SystemFeatureService
from services.workspace.contracts import (
OwnerTransferToken,
WorkspaceMemberRecord,
WorkspaceMemberRole,
WorkspaceMemberRoleSubject,
WorkspaceMemberSummary,
)
from services.workspace.gateways import (
DeploymentWorkspaceMemberAccessGateway,
WorkspaceInvitationGateway,
)
from services.workspace.member_service import (
OwnerTransferGateway,
WorkspaceInvitationService,
WorkspaceMemberQueryService,
WorkspaceMemberService,
WorkspaceOwnerTransferService,
)
from tests.helpers.unit.account_domain import AccountDomain
"""Membership and invitation behavior across the application/persistence boundary."""
@dataclass(frozen=True)
class RoleAssignment:
tenant_id: str
account_id: str | None
member_account_id: str
role_ids: list[str]
@dataclass
class RecordedRoleAssignments:
calls: list[RoleAssignment] = field(default_factory=list)
failure: Exception | None = None
on_apply: Callable[..., None] | None = None
def __call__(
self, *, tenant_id: str, account_id: str | None, member_account_id: str, role_ids: list[str]
) -> MemberRolesResponse:
self.calls.append(RoleAssignment(tenant_id, account_id, member_account_id, list(role_ids)))
if self.failure:
raise self.failure
if self.on_apply:
self.on_apply(
tenant_id=tenant_id, account_id=account_id, member_account_id=member_account_id, role_ids=role_ids
)
return MemberRolesResponse(account_id=member_account_id)
class TestMemberServiceCases:
@staticmethod
@pytest.mark.parametrize("existing_member", [True, False])
def test_join_rejects_a_second_owner_without_changing_membership(
account_domain: AccountDomain, members: tuple[str, str, str], existing_member: bool
) -> None:
workspace_id, owner_id, member_id = members
if existing_member:
account = account_domain.accounts.get_account_by_id(member_id)
assert account is not None
else:
account = account_domain.accounts.create_account("[email protected]", "New owner", "en-US")
with pytest.raises(WorkspaceAlreadyHasOwnerError, match="Tenant already has an owner"):
account_domain.members.join_member(
workspace_id=workspace_id,
account_id=account.id,
email=account.email,
role=_member_service_TenantAccountRole.OWNER,
operator_account_id=owner_id,
)
assert account_domain.members.get_role(workspace_id, owner_id) == _member_service_TenantAccountRole.OWNER
assert account_domain.members.get_role(workspace_id, account.id) == (
_member_service_TenantAccountRole.NORMAL if existing_member else None
)
account_domain.access.membership_changed.assert_not_called()
@staticmethod
@pytest.mark.parametrize(
("status", "other_workspace", "deleted"),
[("pending", False, True), ("pending", True, False), ("active", False, False)],
)
def test_removal_deletes_only_orphaned_pending_accounts(
account_domain: AccountDomain,
sqlite_session: Session,
members: tuple[str, str, str],
status: str,
other_workspace: bool,
deleted: bool,
) -> None:
workspace_id, owner_id, member_id = members
member = sqlite_session.get(Account, member_id)
assert member is not None
member.status = AccountStatus(status)
if other_workspace:
tenant = Tenant(name="Other")
sqlite_session.add_all(
[
tenant,
TenantAccountJoin(
account_id=member_id, tenant_id=tenant.id, role=_member_service_TenantAccountRole.NORMAL
),
]
)
sqlite_session.commit()
sqlite_session.expunge_all()
account_domain.members.remove(workspace_id, member_id, owner_id)
assert (sqlite_session.get(Account, member_id) is None) == deleted
assert account_domain.members.get_role(workspace_id, member_id) is None
account_domain.access.member_removed.assert_called_once()
assert account_domain.access.member_removed.call_args.args[1].account_deleted == deleted
@staticmethod
@pytest.mark.parametrize("action", ["add", "remove", "update"])
def test_self_operations_and_non_administrators_are_denied(
account_domain: AccountDomain, members: tuple[str, str, str], action: str
) -> None:
workspace_id, owner_id, member_id = members
with pytest.raises(CannotOperateSelfError):
account_domain.members.check_permission(workspace_id, owner_id, owner_id, action)
with pytest.raises(NoPermissionError):
account_domain.members.check_permission(workspace_id, member_id, owner_id, action)
@staticmethod
def test_owner_transfer_demotes_previous_owner(
account_domain: AccountDomain, members: tuple[str, str, str]
) -> None:
workspace_id, owner_id, member_id = members
account_domain.members.update_role(workspace_id, member_id, "owner", owner_id)
assert account_domain.members.get_role(workspace_id, owner_id) == _member_service_TenantAccountRole.NORMAL
assert account_domain.members.get_role(workspace_id, member_id) == _member_service_TenantAccountRole.OWNER
@staticmethod
@pytest.mark.parametrize("new_role", ["normal", "owner"])
def test_admin_cannot_change_owner_or_promote_owner(
account_domain: AccountDomain, members: tuple[str, str, str], sqlite_session: Session, new_role: str
) -> None:
workspace_id, owner_id, member_id = members
membership = sqlite_session.scalar(select(TenantAccountJoin).where(TenantAccountJoin.account_id == member_id))
assert membership is not None
membership.role = _member_service_TenantAccountRole.ADMIN
sqlite_session.commit()
with pytest.raises(NoPermissionError):
account_domain.members.update_role(workspace_id, owner_id, new_role, member_id)
@staticmethod
def test_unchanged_role_does_not_sync(account_domain: AccountDomain, members: tuple[str, str, str]) -> None:
workspace_id, owner_id, member_id = members
with pytest.raises(RoleAlreadyAssignedError):
account_domain.members.update_role(workspace_id, member_id, "normal", owner_id)
account_domain.access.change_role.assert_not_called()
@staticmethod
@pytest.mark.parametrize("role", ["invalid", "dataset_operator"])
def test_role_policy_prevents_persistence_and_rbac_changes(
account_domain: AccountDomain,
members: tuple[str, str, str],
config_overrides: Callable[..., None],
role: str,
) -> None:
config_overrides(DATASET_OPERATOR_ENABLED=False)
account_domain.access.ensure_role_enabled.side_effect = (
DeploymentWorkspaceMemberAccessGateway().ensure_role_enabled
)
workspace_id, owner_id, member_id = members
with pytest.raises(InvalidWorkspaceMemberRoleError):
account_domain.members.update_role(workspace_id, member_id, role, owner_id)
assert account_domain.members.get_role(workspace_id, member_id) == _member_service_TenantAccountRole.NORMAL
account_domain.access.change_role.assert_not_called()
@staticmethod
@pytest.mark.parametrize("operation", ["remove", "update_role"])
@pytest.mark.parametrize("account_exists", [True, False])
def test_member_operations_distinguish_missing_account_from_missing_membership(
account_domain: AccountDomain, members: tuple[str, str, str], operation: str, account_exists: bool
) -> None:
workspace_id, owner_id, _ = members
account_id = "00000000-0000-0000-0000-000000000000"
if account_exists:
account_id = account_domain.accounts.create_account("[email protected]", "Outsider", "en-US").id
error = MemberNotInTenantError if account_exists else AccountNotFoundError
if operation == "remove":
with pytest.raises(error):
account_domain.members.remove(workspace_id, account_id, owner_id)
else:
with pytest.raises(error):
account_domain.members.update_role(workspace_id, account_id, "editor", owner_id)
account_domain.access.member_removed.assert_not_called()
account_domain.access.change_role.assert_not_called()
@staticmethod
@pytest.mark.parametrize(
("permission", "owner", "allowed"), [(True, False, True), (False, False, False), (True, True, False)]
)
def test_rbac_member_removal_uses_permissions_and_owner_protection(
account_domain: AccountDomain, members: tuple[str, str, str], permission: bool, owner: bool, allowed: bool
) -> None:
workspace_id, owner_id, member_id = members
account_domain.access.rbac_enabled = True
account_domain.access.permission_keys.return_value = {"workspace.member.manage"} if permission else set()
account_domain.access.is_owner.return_value = owner
account_domain.access.owner_id.return_value = owner_id
if allowed:
account_domain.members.remove(workspace_id, member_id, owner_id)
assert account_domain.members.get_role(workspace_id, member_id) is None
else:
with pytest.raises(NoPermissionError):
account_domain.members.remove(workspace_id, member_id, owner_id)
@staticmethod
def test_new_invitation_normalizes_email_and_sets_current_workspace(
account_domain: AccountDomain, members: tuple[str, str, str]
) -> None:
workspace_id, owner_id, _ = members
result = account_domain.invitations.invite(
RequestContext("request", None, owner_id, workspace_id), "[email protected]", "en-US", "editor"
)
assert result.token == "invitation-token"
assert result.email == "[email protected]"
assert result.workspace_id == workspace_id
assert result.role == "editor"
invitee = account_domain.repository.find_by_email("[email protected]")
assert invitee is not None
assert result.account_id == invitee.id
assert invitee.status == "pending"
assert account_domain.members.get_role(workspace_id, invitee.id) == _member_service_TenantAccountRole.EDITOR
membership = account_domain.workspaces.find_membership(invitee.id, workspace_id)
assert membership is not None
assert membership.current
invitation = account_domain.delivery.create.call_args.args[0]
assert invitation.requires_setup is True
assert invitation.email == "[email protected]"
@staticmethod
def test_active_invitee_must_accept_before_joining(
account_domain: AccountDomain, members: tuple[str, str, str]
) -> None:
workspace_id, owner_id, _ = members
account = account_domain.accounts.create_account("[email protected]", "New", "en-US")
account_domain.invitations.invite(RequestContext("request", None, owner_id, workspace_id), account.email, None)
assert account_domain.members.get_role(workspace_id, account.id) is None
assert account_domain.delivery.create.call_args.args[0].requires_setup is False
@staticmethod
def test_pending_member_can_be_reinvited(
account_domain: AccountDomain, members: tuple[str, str, str], sqlite_session: Session
) -> None:
workspace_id, owner_id, member_id = members
account = sqlite_session.get(Account, member_id)
assert account is not None
account.status = AccountStatus.PENDING
sqlite_session.commit()
account_domain.invitations.invite(RequestContext("request", None, owner_id, workspace_id), account.email, None)
assert account_domain.delivery.create.call_args.args[0].requires_setup is True
@staticmethod
def test_active_member_is_reported_without_sending_invitation(
account_domain: AccountDomain, members: tuple[str, str, str]
) -> None:
workspace_id, owner_id, _ = members
with pytest.raises(AccountAlreadyInTenantError):
account_domain.invitations.invite(
RequestContext("request", None, owner_id, workspace_id), "[email protected]", None
)
account_domain.delivery.send.assert_not_called()
@staticmethod
def test_removal_transfers_maintainers_only_in_the_target_workspace(
account_domain: AccountDomain, members: tuple[str, str, str], sqlite_session: Session
) -> None:
workspace_id, owner_id, member_id = members
other = Tenant(name="Other workspace")
sqlite_session.add(other)
apps = [
App(
tenant_id=tenant_id,
name="App",
mode=AppMode.CHAT,
maintainer=member_id,
enable_site=True,
enable_api=True,
max_active_requests=0,
)
for tenant_id in (workspace_id, other.id)
]
datasets = [
Dataset(tenant_id=tenant_id, name="Dataset", created_by=member_id, maintainer=member_id)
for tenant_id in (workspace_id, other.id)
]
sqlite_session.add_all([*apps, *datasets])
sqlite_session.commit()
account_domain.members.remove(workspace_id, member_id, owner_id)
sqlite_session.expire_all()
assert [app.maintainer for app in apps] == [owner_id, member_id]
assert [dataset.maintainer for dataset in datasets] == [owner_id, member_id]
@staticmethod
def test_community_invitation_continues_after_a_historical_duplicate_email(
account_domain: AccountDomain, members: tuple[str, str, str], sqlite_session: Session
) -> None:
workspace_id, owner_id, _ = members
sqlite_session.add_all(
[
Account(name="First", email="[email protected]"),
Account(name="Second", email="[email protected]"),
]
)
sqlite_session.commit()
account_domain.delivery.acquire.return_value = nullcontext()
results = account_domain.invitations.invite_many(
RequestContext("request", None, owner_id, workspace_id),
emails=["[email protected]", "[email protected]"],
language=None,
role="normal",
)
assert [result.status for result in results] == ["failed", "success"]
account_domain.delivery.check_capacity.assert_not_called()
account_domain.delivery.send.assert_called_once()
assert account_domain.repository.find_by_email("[email protected]") is not None
@staticmethod
def test_bulk_invitation_counts_new_accounts_and_members_before_writing(
account_domain: AccountDomain,
members: tuple[str, str, str],
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
) -> None:
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.ENTERPRISE)
monkeypatch.setattr(FeatureService, "get_features", Mock(return_value=FeatureModel()))
monkeypatch.setattr(
SystemFeatureService,
"get_license",
Mock(return_value=LicenseModel(seats=LicenseLimitationModel(enabled=True, size=3, limit=3))),
)
redis = create_autospec(RedisClientWrapper, instance=True)
gateway = WorkspaceInvitationGateway(tokens=RedisInvitationTokenStore(redis=redis), redis=redis)
workspace_id, owner_id, _ = members
account_domain.accounts.create_account("[email protected]", "Outside", "en-US")
account_domain.delivery.acquire.return_value = nullcontext()
account_domain.delivery.check_capacity.side_effect = gateway.check_capacity
account_domain.delivery.requires_capacity_check = True
with pytest.raises(WorkspaceInvitationQuotaError) as error:
account_domain.invitations.invite_many(
RequestContext("request", None, owner_id, workspace_id),
emails=["[email protected]", "[email protected]", "[email protected]"],
language=None,
role="normal",
)
assert error.value.seats is True
account_domain.delivery.check_capacity.assert_called_once_with(
workspace_id, current_members=2, new_members=2, new_accounts=1
)
assert account_domain.repository.find_by_email("[email protected]") is None
account_domain.delivery.create.assert_not_called()
@staticmethod
def test_bulk_invitation_retains_partial_results_under_workspace_lock(
account_domain: AccountDomain, members: tuple[str, str, str]
) -> None:
workspace_id, owner_id, _ = members
account_domain.delivery.acquire.return_value = nullcontext()
account_domain.delivery.send.side_effect = [None, RuntimeError("Mail unavailable")]
results = account_domain.invitations.invite_many(
RequestContext("request", None, owner_id, workspace_id),
emails=["[email protected]", "[email protected]", "[email protected]"],
language=None,
role="normal",
)
assert [(result.email, result.status) for result in results] == [
("[email protected]", "success"),
("[email protected]", "already_member"),
("[email protected]", "failed"),
]
assert results[-1].message == "Mail unavailable"
account_domain.delivery.acquire.assert_called_once_with(workspace_id)
@staticmethod
@pytest.fixture
def owner_transfer(account_domain: AccountDomain) -> tuple[WorkspaceOwnerTransferService, Mock]:
challenges = create_autospec(OwnerTransferGateway, instance=True)
challenges.is_ip_limited.return_value = False
challenges.is_verification_limited.return_value = False
challenges.read_token.return_value = OwnerTransferToken("[email protected]", "123456")
challenges.issue_token.return_value = "promoted-token"
return WorkspaceOwnerTransferService(
accounts=account_domain.repository,
workspaces=account_domain.workspaces,
members=account_domain.members,
challenges=challenges,
), challenges
@staticmethod
@pytest.mark.parametrize(
("challenge", "code", "error"),
[
(None, "123456", InvalidOwnerTransferTokenError),
(OwnerTransferToken("[email protected]", "123456"), "123456", InvalidOwnerTransferEmailError),
(OwnerTransferToken("[email protected]", "123456"), "000000", InvalidOwnerTransferCodeError),
],
)
def test_owner_verification_failure_preserves_challenge(
owner_transfer: tuple[WorkspaceOwnerTransferService, Mock],
members: tuple[str, str, str],
challenge: OwnerTransferToken | None,
code: str,
error: type[Exception],
) -> None:
service, challenges = owner_transfer
workspace_id, owner_id, _ = members
challenges.read_token.return_value = challenge
with pytest.raises(error):
service.verify_code(RequestContext("request", None, owner_id, workspace_id), token="challenge", code=code)
challenges.revoke_token.assert_not_called()
challenges.issue_token.assert_not_called()
if error is InvalidOwnerTransferCodeError:
challenges.record_verification_failure.assert_called_once_with("[email protected]")
@staticmethod
def test_owner_verification_promotes_token_and_clears_failure_count(
owner_transfer: tuple[WorkspaceOwnerTransferService, Mock],
members: tuple[str, str, str],
) -> None:
service, challenges = owner_transfer
workspace_id, owner_id, _ = members
result = service.verify_code(
RequestContext("request", None, owner_id, workspace_id), token="challenge", code="123456"
)
assert result == ("[email protected]", "promoted-token")
challenges.revoke_token.assert_called_once_with("challenge")
challenges.reset_verification_failures.assert_called_once_with("[email protected]")
@staticmethod
def test_owner_transfer_commits_roles_before_notification(
owner_transfer: tuple[WorkspaceOwnerTransferService, Mock],
members: tuple[str, str, str],
account_domain: AccountDomain,
) -> None:
service, challenges = owner_transfer
workspace_id, owner_id, member_id = members
def notify(*, old_owner: AccountSnapshot, new_owner: AccountSnapshot, workspace_name: str) -> None:
assert (old_owner.id, new_owner.id, workspace_name) == (owner_id, member_id, "Workspace")
assert account_domain.members.get_role(workspace_id, owner_id) == _member_service_TenantAccountRole.NORMAL
assert account_domain.members.get_role(workspace_id, member_id) == _member_service_TenantAccountRole.OWNER
challenges.notify.side_effect = notify
service.transfer(
RequestContext("request", None, owner_id, workspace_id), member_id=member_id, token="challenge"
)
challenges.notify.assert_called_once()
@staticmethod
def test_owner_transfer_rejects_accounts_outside_workspace(
owner_transfer: tuple[WorkspaceOwnerTransferService, Mock],
members: tuple[str, str, str],
account_domain: AccountDomain,
) -> None:
service, challenges = owner_transfer
workspace_id, owner_id, _ = members
outside = account_domain.accounts.create_account("[email protected]", "Outside", "en-US")
with pytest.raises(MemberNotInTenantError):
service.transfer(
RequestContext("request", None, owner_id, workspace_id), member_id=outside.id, token="challenge"
)
assert account_domain.members.get_role(workspace_id, owner_id) == _member_service_TenantAccountRole.OWNER
challenges.notify.assert_not_called()
@staticmethod
@pytest.mark.parametrize("operation", ["send_code", "transfer"])
def test_owner_transfer_reports_missing_workspace(
owner_transfer: tuple[WorkspaceOwnerTransferService, Mock],
members: tuple[str, str, str],
account_domain: AccountDomain,
monkeypatch: pytest.MonkeyPatch,
operation: str,
) -> None:
service, challenges = owner_transfer
workspace_id, owner_id, member_id = members
monkeypatch.setattr(account_domain.workspaces, "get", lambda _workspace_id: None)
context = RequestContext("request", None, owner_id, workspace_id)
if operation == "send_code":
with pytest.raises(WorkspaceNotFoundError):
service.send_code(context, ip_address="127.0.0.1", language=None)
else:
with pytest.raises(WorkspaceNotFoundError):
service.transfer(context, member_id=member_id, token="challenge")
challenges.send_confirmation.assert_not_called()
challenges.notify.assert_not_called()
assert account_domain.members.get_role(workspace_id, owner_id) == _member_service_TenantAccountRole.OWNER
@staticmethod
def test_rbac_transfer_failure_leaves_local_owner_unchanged(
account_domain: AccountDomain,
members: tuple[str, str, str],
) -> None:
workspace_id, owner_id, member_id = members
account_domain.access.rbac_enabled = True
account_domain.access.is_owner.side_effect = lambda _workspace_id, _actor_id, member_id: member_id == owner_id
account_domain.access.transfer_owner.side_effect = RuntimeError("RBAC unavailable")
with pytest.raises(RuntimeError, match="RBAC unavailable"):
account_domain.members.update_role(workspace_id, member_id, "owner", owner_id)
assert account_domain.members.get_role(workspace_id, owner_id) == _member_service_TenantAccountRole.OWNER
assert account_domain.members.get_role(workspace_id, member_id) == _member_service_TenantAccountRole.NORMAL
@staticmethod
@pytest.fixture
def rbac_access(
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
members: tuple[str, str, str],
) -> tuple[DeploymentWorkspaceMemberAccessGateway, RecordedRoleAssignments]:
config_overrides(RBAC_ENABLED=True, DATASET_OPERATOR_ENABLED=True)
gateway = DeploymentWorkspaceMemberAccessGateway()
roles = [
RBACRole(
id=f"role-{tag}", name=tag, type="", category="global_system_default", role_tag=tag, is_builtin=True
)
for tag in [*(role.value for role in _member_service_TenantAccountRole), "no_access"]
]
_, owner_id, _ = members
roles_by_tag = {role.role_tag: role for role in roles}
def get_roles(tenant_id: str, account_id: str | None, member_account_id: str) -> MemberRolesResponse:
del tenant_id, account_id
tag = "owner" if member_account_id == owner_id else "normal"
return MemberRolesResponse(account_id=member_account_id, roles=[roles_by_tag[tag]])
monkeypatch.setattr(RBACService.Roles, "list", lambda *_args, **_kwargs: Paginated[RBACRole](data=roles))
monkeypatch.setattr(RBACService.MemberRoles, "get", get_roles)
monkeypatch.setattr(gateway, "permission_keys", lambda _workspace_id, _actor_id: {"workspace.role.manage"})
replace = RecordedRoleAssignments()
monkeypatch.setattr(RBACService.MemberRoles, "replace", replace)
return gateway, replace
@staticmethod
@pytest.mark.parametrize(
("status", "already_joined"),
[
(None, False),
(AccountStatus.PENDING, False),
(AccountStatus.PENDING, True),
(AccountStatus.ACTIVE, False),
(AccountStatus.ACTIVE, True),
],
ids=["new-account", "pending-account", "pending-member", "active-account", "active-member"],
)
def test_rbac_invitation_assigns_requested_role(
account_domain: AccountDomain,
members: tuple[str, str, str],
sqlite_session: Session,
rbac_access: tuple[DeploymentWorkspaceMemberAccessGateway, RecordedRoleAssignments],
monkeypatch: pytest.MonkeyPatch,
status: AccountStatus | None,
already_joined: bool,
) -> None:
from tasks.initialize_created_app_rbac_access_task import sync_joined_workspace_member_rbac_access_task
workspace_id, owner_id, _ = members
email = "[email protected]"
if status is not None:
account = Account(name="Invited", email=email, status=status)
sqlite_session.add(account)
if already_joined:
sqlite_session.add(
TenantAccountJoin(
tenant_id=workspace_id, account_id=account.id, role=_member_service_TenantAccountRole.NORMAL
)
)
sqlite_session.commit()
access, replace = rbac_access
monkeypatch.setattr(access, "permission_keys", lambda _workspace, _actor: {"workspace.member.manage"})
synced_members: list[tuple[str, str, str | None]] = []
def sync(tenant_id: str, member_account_id: str, operator_account_id: str | None = None) -> None:
synced_members.append((tenant_id, member_account_id, operator_account_id))
monkeypatch.setattr(sync_joined_workspace_member_rbac_access_task, "delay", sync)
member_service = WorkspaceMemberService(
workspaces=account_domain.workspaces, accounts=account_domain.repository, access=access
)
invitations = WorkspaceInvitationService(
accounts=account_domain.accounts,
workspaces=account_domain.workspaces,
members=member_service,
invitations=account_domain.delivery,
)
account_domain.delivery.acquire.return_value = nullcontext()
results = invitations.invite_many(
RequestContext("request", None, owner_id, workspace_id),
emails=[email],
language="en-US",
role="custom-role-id",
)
invited = account_domain.repository.find_by_email(email)
assert invited is not None
assert member_service.get_role(workspace_id, invited.id) == _member_service_TenantAccountRole.NORMAL
if status == AccountStatus.ACTIVE and already_joined:
assert replace.calls == []
else:
assignments = [item for item in replace.calls if item.tenant_id == workspace_id]
assert len(assignments) == 1
assert assignments[0].account_id == owner_id
assert assignments[0].member_account_id == invited.id
assert assignments[0].role_ids == ["custom-role-id"]
if status is None:
# Registration also provisions the invitee's own workspace.
assert len(replace.calls) == 2
personal_workspace = replace.calls[0]
assert personal_workspace.tenant_id != workspace_id
assert personal_workspace.member_account_id == invited.id
assert personal_workspace.role_ids == ["role-owner"]
else:
assert len(replace.calls) == 1
if status == AccountStatus.ACTIVE:
assert results[0].status == "already_member"
account_domain.delivery.create.assert_not_called()
account_domain.delivery.send.assert_not_called()
else:
assert results[0].status == "success"
assert invited.status == "pending"
invitation = account_domain.delivery.create.call_args.args[0]
assert invitation.account_id == invited.id
assert invitation.role == "custom-role-id"
assert invitation.requires_setup is True
account_domain.delivery.send.assert_called_once_with(
language="en-US",
email=email,
token="invitation-token",
inviter_name="Owner",
workspace_name="Workspace",
)
assert synced_members == (
[(workspace_id, invited.id, owner_id)] if status == AccountStatus.ACTIVE and not already_joined else []
)
@staticmethod
@pytest.mark.parametrize(
"operator_role",
[
_member_service_TenantAccountRole.NORMAL,
_member_service_TenantAccountRole.EDITOR,
_member_service_TenantAccountRole.ADMIN,
_member_service_TenantAccountRole.DATASET_OPERATOR,
],
)
@pytest.mark.parametrize(
"new_role",
[
_member_service_TenantAccountRole.NORMAL,
_member_service_TenantAccountRole.EDITOR,
_member_service_TenantAccountRole.ADMIN,
_member_service_TenantAccountRole.DATASET_OPERATOR,
],
)
def test_rbac_role_managers_cannot_demote_owner(
account_domain: AccountDomain,
members: tuple[str, str, str],
sqlite_session: Session,
rbac_access: tuple[DeploymentWorkspaceMemberAccessGateway, RecordedRoleAssignments],
operator_role: _member_service_TenantAccountRole,
new_role: _member_service_TenantAccountRole,
) -> None:
workspace_id, owner_id, operator_id = members
membership = sqlite_session.scalar(select(TenantAccountJoin).where(TenantAccountJoin.account_id == operator_id))
assert membership is not None
membership.role = operator_role
sqlite_session.commit()
gateway, replace = rbac_access
service = WorkspaceMemberService(
workspaces=account_domain.workspaces, accounts=account_domain.repository, access=gateway
)
with pytest.raises(NoPermissionError):
service.update_role(workspace_id, owner_id, new_role.value, operator_id)
assert replace.calls == []
assert service.get_role(workspace_id, owner_id) == _member_service_TenantAccountRole.OWNER
assert service.get_role(workspace_id, operator_id) == operator_role
@staticmethod
@pytest.mark.parametrize(
"operator_role",
[
_member_service_TenantAccountRole.NORMAL,
_member_service_TenantAccountRole.EDITOR,
_member_service_TenantAccountRole.ADMIN,
_member_service_TenantAccountRole.DATASET_OPERATOR,
],
)
def test_rbac_role_managers_cannot_transfer_ownership(
account_domain: AccountDomain,
members: tuple[str, str, str],
sqlite_session: Session,
operator_role: _member_service_TenantAccountRole,
) -> None:
workspace_id, owner_id, operator_id = members
membership = sqlite_session.scalar(select(TenantAccountJoin).where(TenantAccountJoin.account_id == operator_id))
assert membership is not None
membership.role = operator_role
target = Account(name="Target", email="[email protected]")
sqlite_session.add_all(
[
target,
TenantAccountJoin(
tenant_id=workspace_id, account_id=target.id, role=_member_service_TenantAccountRole.NORMAL
),
]
)
sqlite_session.commit()
account_domain.access.rbac_enabled = True
account_domain.access.permission_keys.return_value = {"workspace.role.manage"}
with pytest.raises(NoPermissionError):
account_domain.members.update_role(workspace_id, target.id, "owner", operator_id)
account_domain.access.transfer_owner.assert_not_called()
account_domain.access.change_role.assert_not_called()
assert account_domain.members.get_role(workspace_id, owner_id) == _member_service_TenantAccountRole.OWNER
assert account_domain.members.get_role(workspace_id, target.id) == _member_service_TenantAccountRole.NORMAL
@staticmethod
def test_rbac_normal_role_manager_can_update_another_non_owner(
account_domain: AccountDomain,
members: tuple[str, str, str],
sqlite_session: Session,
rbac_access: tuple[DeploymentWorkspaceMemberAccessGateway, RecordedRoleAssignments],
) -> None:
workspace_id, owner_id, operator_id = members
target = Account(name="Target", email="[email protected]")
sqlite_session.add_all(
[
target,
TenantAccountJoin(
tenant_id=workspace_id, account_id=target.id, role=_member_service_TenantAccountRole.NORMAL
),
]
)
sqlite_session.commit()
gateway, replace = rbac_access
service = WorkspaceMemberService(
workspaces=account_domain.workspaces, accounts=account_domain.repository, access=gateway
)
service.update_role(workspace_id, target.id, "editor", operator_id)
assert len(replace.calls) == 1
assert replace.calls[0].member_account_id == target.id
assert replace.calls[0].role_ids == ["role-editor"]
assert service.get_role(workspace_id, target.id) == _member_service_TenantAccountRole.EDITOR
assert service.get_role(workspace_id, owner_id) == _member_service_TenantAccountRole.OWNER
@staticmethod
@pytest.mark.parametrize(
"role",
[
_member_service_TenantAccountRole.ADMIN,
_member_service_TenantAccountRole.EDITOR,
_member_service_TenantAccountRole.NORMAL,
_member_service_TenantAccountRole.DATASET_OPERATOR,
],
)
@pytest.mark.parametrize("remote_fails", [False, True])
def test_rbac_role_update_assigns_requested_role_and_synchronizes_membership(
account_domain: AccountDomain,
members: tuple[str, str, str],
sqlite_session: Session,
rbac_access: tuple[DeploymentWorkspaceMemberAccessGateway, RecordedRoleAssignments],
role: _member_service_TenantAccountRole,
remote_fails: bool,
) -> None:
workspace_id, owner_id, member_id = members
previous = (
_member_service_TenantAccountRole.EDITOR
if role == _member_service_TenantAccountRole.NORMAL
else _member_service_TenantAccountRole.NORMAL
)
membership = sqlite_session.scalar(select(TenantAccountJoin).where(TenantAccountJoin.account_id == member_id))
assert membership is not None
membership.role = previous
sqlite_session.commit()
gateway, replace = rbac_access
service = WorkspaceMemberService(
workspaces=account_domain.workspaces, accounts=account_domain.repository, access=gateway
)
if remote_fails:
replace.failure = RuntimeError("RBAC unavailable")
with pytest.raises(RuntimeError, match="RBAC unavailable"):
service.update_role(workspace_id, member_id, role.value, owner_id)
else:
service.update_role(workspace_id, member_id, role.value, owner_id)
assert len(replace.calls) == 1
assert replace.calls[0].role_ids == [f"role-{role.value}"]
assert replace.calls[0].member_account_id == member_id
assert service.get_role(workspace_id, member_id) == (previous if remote_fails else role)
assert service.get_role(workspace_id, owner_id) == _member_service_TenantAccountRole.OWNER
@staticmethod
def test_rbac_owner_transfer_preserves_other_roles_and_updates_both_memberships(
account_domain: AccountDomain,
members: tuple[str, str, str],
rbac_access: tuple[DeploymentWorkspaceMemberAccessGateway, RecordedRoleAssignments],
monkeypatch: pytest.MonkeyPatch,
) -> None:
workspace_id, owner_id, member_id = members
gateway, replace = rbac_access
monkeypatch.setattr(gateway, "owner_id", lambda _workspace_id, _actor_id: owner_id)
current_roles = MemberRolesResponse(
account_id=owner_id,
roles=[
RBACRole(
id="role-owner",
name="Owner",
type="",
category="global_system_default",
role_tag="owner",
is_builtin=True,
),
RBACRole(id="custom", name="Custom", type=""),
],
)
def get_roles(tenant_id: str, account_id: str | None, member_account_id: str) -> MemberRolesResponse:
del tenant_id, account_id
return current_roles if member_account_id == owner_id else MemberRolesResponse(account_id=member_account_id)
monkeypatch.setattr(RBACService.MemberRoles, "get", get_roles)
service = WorkspaceMemberService(
workspaces=account_domain.workspaces, accounts=account_domain.repository, access=gateway
)
service.update_role(workspace_id, member_id, "owner", owner_id)
assert [(call.member_account_id, call.role_ids) for call in replace.calls] == [
(owner_id, ["custom"]),
(member_id, ["role-owner"]),
]
assert service.get_role(workspace_id, owner_id) == _member_service_TenantAccountRole.NORMAL
assert service.get_role(workspace_id, member_id) == _member_service_TenantAccountRole.OWNER
@staticmethod
@pytest.mark.parametrize("operation", ["demote_new_owner", "transfer_to_another_member"])
def test_rbac_owner_is_protected_after_local_transfer_commit_fails(
account_domain: AccountDomain,
members: tuple[str, str, str],
sqlite_session: Session,
sqlite_session_factory: sessionmaker[Session],
rbac_access: tuple[DeploymentWorkspaceMemberAccessGateway, RecordedRoleAssignments],
monkeypatch: pytest.MonkeyPatch,
operation: str,
) -> None:
workspace_id, old_owner_id, new_owner_id = members
third_member = Account(name="Third", email="[email protected]")
sqlite_session.add_all(
[
third_member,
TenantAccountJoin(
tenant_id=workspace_id, account_id=third_member.id, role=_member_service_TenantAccountRole.NORMAL
),
]
)
sqlite_session.commit()
gateway, replace = rbac_access
owner_role = RBACRole(
id="role-owner", name="Owner", type="", category="global_system_default", role_tag="owner", is_builtin=True
)
custom_role = RBACRole(id="custom-manager", name="Role manager", type="")
remote_roles = {old_owner_id: [owner_role, custom_role], new_owner_id: [], third_member.id: []}
roles_by_id = {role.id: role for role in [owner_role, custom_role]}
def get_roles(tenant_id: str, account_id: str | None, member_account_id: str) -> MemberRolesResponse:
del tenant_id, account_id
return MemberRolesResponse(account_id=member_account_id, roles=remote_roles[member_account_id])
def replace_roles(*, tenant_id: str, account_id: str, member_account_id: str, role_ids: list[str]) -> None:
del tenant_id, account_id
remote_roles[member_account_id] = [
roles_by_id.get(role_id, RBACRole(id=role_id, name=role_id, type="")) for role_id in role_ids
]
def fail_commit(session: Session) -> None:
session.flush()
raise RuntimeError("Membership commit failed")
monkeypatch.setattr(RBACService.MemberRoles, "get", get_roles)
monkeypatch.setattr(
gateway,
"owner_id",
lambda _workspace_id, _actor_id: next(
member_id for member_id, roles in remote_roles.items() if owner_role in roles
),
)
replace.on_apply = replace_roles
service = WorkspaceMemberService(
workspaces=account_domain.workspaces, accounts=account_domain.repository, access=gateway
)
event.listen(sqlite_session_factory, "before_commit", fail_commit)
try:
with pytest.raises(RuntimeError, match="Membership commit failed"):
service.update_role(workspace_id, new_owner_id, "owner", old_owner_id)
finally:
event.remove(sqlite_session_factory, "before_commit", fail_commit)
assert remote_roles[old_owner_id] == [custom_role]
assert remote_roles[new_owner_id] == [owner_role]
assert service.get_role(workspace_id, old_owner_id) == _member_service_TenantAccountRole.OWNER
assert service.get_role(workspace_id, new_owner_id) == _member_service_TenantAccountRole.NORMAL
replace.calls.clear()
target_id, role = (new_owner_id, "editor") if operation == "demote_new_owner" else (third_member.id, "owner")
with pytest.raises(NoPermissionError):
service.update_role(workspace_id, target_id, role, old_owner_id)
assert replace.calls == []
assert remote_roles[old_owner_id] == [custom_role]
assert remote_roles[new_owner_id] == [owner_role]
assert remote_roles[third_member.id] == []
assert service.get_role(workspace_id, old_owner_id) == _member_service_TenantAccountRole.OWNER
assert service.get_role(workspace_id, new_owner_id) == _member_service_TenantAccountRole.NORMAL
assert service.get_role(workspace_id, third_member.id) == _member_service_TenantAccountRole.NORMAL
@staticmethod
@pytest.mark.parametrize("new_role", ["editor", "owner"])
def test_rbac_owner_lookup_failure_prevents_role_changes(
account_domain: AccountDomain,
members: tuple[str, str, str],
rbac_access: tuple[DeploymentWorkspaceMemberAccessGateway, RecordedRoleAssignments],
monkeypatch: pytest.MonkeyPatch,
new_role: str,
) -> None:
workspace_id, owner_id, member_id = members
gateway, replace = rbac_access
def get_roles(tenant_id: str, account_id: str | None, member_account_id: str) -> MemberRolesResponse:
del tenant_id, account_id
if new_role == "editor" or member_account_id == owner_id:
raise RuntimeError("RBAC unavailable")
return MemberRolesResponse(account_id=member_account_id)
monkeypatch.setattr(RBACService.MemberRoles, "get", get_roles)
service = WorkspaceMemberService(
workspaces=account_domain.workspaces, accounts=account_domain.repository, access=gateway
)
with pytest.raises(RuntimeError, match="RBAC unavailable"):
service.update_role(workspace_id, member_id, new_role, owner_id)
assert replace.calls == []
assert service.get_role(workspace_id, owner_id) == _member_service_TenantAccountRole.OWNER
assert service.get_role(workspace_id, member_id) == _member_service_TenantAccountRole.NORMAL
def make_context() -> RequestContext:
return RequestContext(
request_id="request-1",
trace_id="trace-1",
account_id="actor-1",
active_workspace_id="workspace-1",
)
def make_member(
member_id: str,
*,
status: str = "active",
legacy_role: str = "normal",
) -> WorkspaceMemberRecord:
created_at = datetime(2026, 1, 1)
return WorkspaceMemberRecord(
id=member_id,
name=f"Member {member_id}",
email=f"{member_id}@example.com",
avatar=None,
last_login_at=None,
last_active_at=created_at,
created_at=created_at,
status=status,
legacy_role=legacy_role,
)
class RecordingMemberQuery:
def __init__(self, records: Sequence[WorkspaceMemberRecord]) -> None:
self.records = tuple(records)
self.workspace_ids: list[str] = []
self.requested_roles: list[_workspace_member_query_service_TenantAccountRole | None] = []
def list_for_workspace(
self, workspace_id: str, *, role: _workspace_member_query_service_TenantAccountRole | None = None
) -> Sequence[WorkspaceMemberRecord]:
self.workspace_ids.append(workspace_id)
self.requested_roles.append(role)
return self.records
class RecordingRoleResolver:
def __init__(self, roles: Mapping[str, Sequence[WorkspaceMemberRole]]) -> None:
self.roles = roles
self.calls: list[tuple[str, str, tuple[WorkspaceMemberRoleSubject, ...]]] = []
self.languages: list[str | None] = []
def resolve_many(
self,
workspace_id: str,
actor_account_id: str,
subjects: Sequence[WorkspaceMemberRoleSubject],
*,
language: str | None = None,
) -> Mapping[str, Sequence[WorkspaceMemberRole]]:
self.calls.append((workspace_id, actor_account_id, tuple(subjects)))
self.languages.append(language)
return self.roles
class FailingRoleResolver:
def resolve_many(
self,
workspace_id: str,
actor_account_id: str,
subjects: Sequence[WorkspaceMemberRoleSubject],
*,
language: str | None = None,
) -> Mapping[str, Sequence[WorkspaceMemberRole]]:
del workspace_id, actor_account_id, subjects, language
raise RoleResolutionError
class RoleResolutionError(Exception):
pass
class TestWorkspaceMemberQueryServiceCases:
@staticmethod
@pytest.mark.parametrize("language", [None, "ja"])
def test_list_current_projects_members_and_merges_roles_by_account_id(language: str | None) -> None:
active = make_member("active", legacy_role="owner")
pending = make_member("pending", status="pending")
members = RecordingMemberQuery([active, pending])
roles = RecordingRoleResolver(
{
active.id: [
WorkspaceMemberRole(id="workspace.owner", name="Owner"),
WorkspaceMemberRole(id="workspace.editor", name="Editor"),
]
}
)
service = WorkspaceMemberQueryService(members=members, roles=roles)
result = service.list_current(make_context(), language=language)
by_id = {member.id: member for member in result}
assert set(by_id) == {"active", "pending"}
assert by_id["active"] == WorkspaceMemberSummary(
id=active.id,
name=active.name,
email=active.email,
avatar=active.avatar,
last_login_at=active.last_login_at,
last_active_at=active.last_active_at,
created_at=active.created_at,
role=active.legacy_role,
roles=(
WorkspaceMemberRole(id="workspace.owner", name="Owner"),
WorkspaceMemberRole(id="workspace.editor", name="Editor"),
),
status=active.status,
)
assert by_id["pending"].status == "pending"
assert by_id["pending"].roles == ()
assert members.workspace_ids == ["workspace-1"]
assert roles.languages == [language]
assert roles.calls == [
(
"workspace-1",
"actor-1",
(
WorkspaceMemberRoleSubject(account_id=active.id, legacy_role=active.legacy_role),
WorkspaceMemberRoleSubject(account_id=pending.id, legacy_role=pending.legacy_role),
),
)
]
@staticmethod
def test_list_current_propagates_role_resolution_failure() -> None:
members = RecordingMemberQuery([make_member("member-1")])
service = WorkspaceMemberQueryService(members=members, roles=FailingRoleResolver())
with pytest.raises(RoleResolutionError):
service.list_current(make_context())
@staticmethod
@pytest.mark.parametrize("operators_only", [True, False])
def test_member_listing_passes_role_filter_to_repository(operators_only: bool) -> None:
records = [make_member("operator", legacy_role="dataset_operator")]
members = RecordingMemberQuery(records)
roles = RecordingRoleResolver({})
service = WorkspaceMemberQueryService(members=members, roles=roles)
assert service.list_members("workspace-1", dataset_operators_only=operators_only) == tuple(records)
assert members.workspace_ids == ["workspace-1"]
assert members.requested_roles == [
_workspace_member_query_service_TenantAccountRole.DATASET_OPERATOR if operators_only else None
]
assert roles.calls == []
@staticmethod
@pytest.mark.parametrize(
("count", "page", "limit", "expected_ids"),
[(5, 2, 2, ["2", "3"]), (5, 3, 2, ["4"]), (5, 4, 2, []), (0, 1, 20, [])],
)
def test_member_page_preserves_total_and_order(count: int, page: int, limit: int, expected_ids: list[str]) -> None:
members = RecordingMemberQuery([make_member(str(index)) for index in range(count)])
roles = RecordingRoleResolver({})
service = WorkspaceMemberQueryService(members=members, roles=roles)
result = service.list_page(make_context(), page=page, limit=limit)
assert result.total == count
assert [member.id for member in result.members] == expected_ids
assert members.workspace_ids == ["workspace-1"]
assert roles.calls == []
@pytest.mark.parametrize("existing_member", [True, False])
def test_membership_write_repairs_missing_contact_identity_without_replacing_it(
account_domain: AccountDomain,
members: tuple[str, str, str],
sqlite_session: Session,
existing_member: bool,
) -> None:
workspace_id, _, member_id = members
if not existing_member:
membership = sqlite_session.scalars(
select(TenantAccountJoin).where(
TenantAccountJoin.tenant_id == workspace_id,
TenantAccountJoin.account_id == member_id,
)
).one()
sqlite_session.delete(membership)
sqlite_session.commit()
assert sqlite_session.scalar(select(HumanInputContactIdentity.id)) is None
account_domain.workspaces.upsert_member(
workspace_id=workspace_id, account_id=member_id, role=TenantAccountRole.NORMAL
)
contact_id = sqlite_session.scalars(
select(HumanInputContactIdentity.id).where(HumanInputContactIdentity.account_id == member_id)
).one()
account_domain.workspaces.upsert_member(
workspace_id=workspace_id, account_id=member_id, role=TenantAccountRole.EDITOR
)
assert (
sqlite_session.scalars(
select(HumanInputContactIdentity.id).where(HumanInputContactIdentity.account_id == member_id)
).one()
== contact_id
)
@pytest.fixture
def members(sqlite_session: Session) -> tuple[str, str, str]:
owner = Account(name="Owner", email="[email protected]")
member = Account(name="Member", email="[email protected]")
tenant = Tenant(name="Workspace")
sqlite_session.add_all(
[
owner,
member,
tenant,
TenantAccountJoin(
account_id=owner.id, tenant_id=tenant.id, role=_member_service_TenantAccountRole.OWNER, current=True
),
TenantAccountJoin(account_id=member.id, tenant_id=tenant.id, role=_member_service_TenantAccountRole.NORMAL),
]
)
sqlite_session.commit()
return tenant.id, owner.id, member.id