π OpenHands: AI-Driven Development
feat(backend): implement org member patch api (#12800)
Hiep Lef20c956196ee
diff --git a/enterprise/server/constants.py b/enterprise/server/constants.pyindex ae06918665..f75dde750d 100644--- a/enterprise/server/constants.py+++ b/enterprise/server/constants.py@@ -15,6 +15,11 @@ IS_FEATURE_ENV = () # Does not include the staging deploymentIS_LOCAL_ENV = bool(HOST == 'localhost')+# Role name constants+ROLE_OWNER = 'owner'+ROLE_ADMIN = 'admin'+ROLE_USER = 'user'+# Deprecated - billing margins are now handled internally in litellmDEFAULT_BILLING_MARGIN = float(os.environ.get('DEFAULT_BILLING_MARGIN', '1.0'))diff --git a/enterprise/server/routes/org_models.py b/enterprise/server/routes/org_models.pyindex 07efec52be..89362c3d46 100644--- a/enterprise/server/routes/org_models.py+++ b/enterprise/server/routes/org_models.py@@ -59,7 +59,7 @@ class OrgMemberNotFoundError(Exception):def __init__(self, org_id: str, user_id: str):self.org_id = org_idself.user_id = user_id- super().__init__(f'Member not found in organization "{org_id}"')+ super().__init__(f'Member "{user_id}" not found in organization "{org_id}"')class RoleNotFoundError(Exception):@@ -70,6 +70,44 @@ class RoleNotFoundError(Exception):super().__init__(f'Role with id "{role_id}" not found')+class InvalidRoleError(Exception):+ """Raised when an invalid role name is specified."""++ def __init__(self, role_name: str):+ self.role_name = role_name+ super().__init__(f'Invalid role: "{role_name}"')+++class InsufficientPermissionError(Exception):+ """Raised when user lacks permission to perform an operation."""++ def __init__(self, message: str = 'Insufficient permission'):+ super().__init__(message)+++class CannotModifySelfError(Exception):+ """Raised when user attempts to modify their own membership."""++ def __init__(self, action: str = 'modify'):+ self.action = action+ super().__init__(f'Cannot {action} your own membership')+++class LastOwnerError(Exception):+ """Raised when attempting to remove or demote the last owner."""++ def __init__(self, action: str = 'remove'):+ self.action = action+ super().__init__(f'Cannot {action} the last owner of an organization')+++class MemberUpdateError(Exception):+ """Raised when member update operation fails."""++ def __init__(self, message: str = 'Failed to update member'):+ super().__init__(message)++class OrgCreate(BaseModel):"""Request model for creating a new organization."""@@ -217,6 +255,12 @@ class OrgMemberPage(BaseModel):next_page_id: str | None = None+class OrgMemberUpdate(BaseModel):+ """Request model for updating an organization member."""++ role: str | None = None # Role name: 'owner', 'admin', or 'user'++class MeResponse(BaseModel):"""Response model for the current user's membership in an organization."""diff --git a/enterprise/server/routes/orgs.py b/enterprise/server/routes/orgs.pyindex 44b2fdc513..dd2e2af68c 100644--- a/enterprise/server/routes/orgs.py+++ b/enterprise/server/routes/orgs.py@@ -4,13 +4,20 @@ from uuid import UUIDfrom fastapi import APIRouter, Depends, HTTPException, Query, statusfrom server.email_validation import get_admin_user_idfrom server.routes.org_models import (+ CannotModifySelfError,+ InsufficientPermissionError,+ InvalidRoleError,+ LastOwnerError,LiteLLMIntegrationError,+ MemberUpdateError,MeResponse,OrgAuthorizationError,OrgCreate,OrgDatabaseError,OrgMemberNotFoundError,OrgMemberPage,+ OrgMemberResponse,+ OrgMemberUpdate,OrgNameExistsError,OrgNotFoundError,OrgPage,@@ -678,3 +685,82 @@ async def switch_org(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,detail='An unexpected error occurred',)+++@org_router.patch('/{org_id}/members/{user_id}', response_model=OrgMemberResponse)+async def update_org_member(+ org_id: str,+ user_id: str,+ update_data: OrgMemberUpdate,+ current_user_id: str = Depends(get_user_id),+) -> OrgMemberResponse:+ """Update a member's role in an organization.++ Permission rules:+ - Admins can change roles of regular users to Admin or User+ - Admins cannot modify other Admins or Owners+ - Owners can change roles of Admins and Users to any role (Owner, Admin, User)+ - Owners cannot modify other Owners++ Users cannot modify their own role. The last owner cannot be demoted.+ """+ try:+ return await OrgMemberService.update_org_member(+ org_id=UUID(org_id),+ target_user_id=UUID(user_id),+ current_user_id=UUID(current_user_id),+ update_data=update_data,+ )+ except OrgMemberNotFoundError as e:+ # Distinguish between requester not being a member vs target not found+ if str(current_user_id) in str(e):+ raise HTTPException(+ status_code=status.HTTP_403_FORBIDDEN,+ detail='You are not a member of this organization',+ )+ raise HTTPException(+ status_code=status.HTTP_404_NOT_FOUND,+ detail='Member not found in this organization',+ )+ except CannotModifySelfError:+ raise HTTPException(+ status_code=status.HTTP_403_FORBIDDEN,+ detail='Cannot modify your own role',+ )+ except RoleNotFoundError:+ raise HTTPException(+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,+ detail='Role configuration error',+ )+ except InvalidRoleError:+ raise HTTPException(+ status_code=status.HTTP_400_BAD_REQUEST,+ detail='Invalid role specified',+ )+ except InsufficientPermissionError:+ raise HTTPException(+ status_code=status.HTTP_403_FORBIDDEN,+ detail='You do not have permission to modify this member',+ )+ except LastOwnerError:+ raise HTTPException(+ status_code=status.HTTP_400_BAD_REQUEST,+ detail='Cannot demote the last owner of an organization',+ )+ except MemberUpdateError:+ raise HTTPException(+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,+ detail='Failed to update member',+ )+ except ValueError:+ logger.exception('Invalid UUID format')+ raise HTTPException(+ status_code=status.HTTP_400_BAD_REQUEST,+ detail='Invalid organization or user ID format',+ )+ except Exception:+ logger.exception('Error updating organization member')+ raise HTTPException(+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,+ detail='Failed to update member',+ )diff --git a/enterprise/server/services/org_member_service.py b/enterprise/server/services/org_member_service.pyindex b33e80c167..7e281ad1e0 100644--- a/enterprise/server/services/org_member_service.py+++ b/enterprise/server/services/org_member_service.py@@ -2,11 +2,18 @@from uuid import UUID+from server.constants import ROLE_ADMIN, ROLE_OWNER, ROLE_USERfrom server.routes.org_models import (+ CannotModifySelfError,+ InsufficientPermissionError,+ InvalidRoleError,+ LastOwnerError,+ MemberUpdateError,MeResponse,OrgMemberNotFoundError,OrgMemberPage,OrgMemberResponse,+ OrgMemberUpdate,RoleNotFoundError,)from storage.org_member_store import OrgMemberStore@@ -15,10 +22,6 @@ from storage.user_store import UserStorefrom openhands.utils.async_utils import call_sync_from_async-# Role rank constants-OWNER_RANK = 10-ADMIN_RANK = 20-class OrgMemberService:"""Service for organization member operations."""@@ -149,14 +152,14 @@ class OrgMemberService:if not requester_role or not target_role:return False, 'role_not_found'- # Check permission based on role ranks+ # Check permission based on rolesif not OrgMemberService._can_remove_member(- requester_role.rank, target_role.rank+ requester_role.name, target_role.name):return False, 'insufficient_permission'# Check if removing the last owner- if target_role.rank == OWNER_RANK:+ if target_role.name == ROLE_OWNER:if OrgMemberService._is_last_owner(org_id, target_user_id):return False, 'cannot_remove_last_owner'@@ -170,12 +173,160 @@ class OrgMemberService:return await call_sync_from_async(_remove_member)@staticmethod- def _can_remove_member(requester_rank: int, target_rank: int) -> bool:- """Check if requester can remove target based on role ranks."""- if requester_rank == OWNER_RANK:+ async def update_org_member(+ org_id: UUID,+ target_user_id: UUID,+ current_user_id: UUID,+ update_data: OrgMemberUpdate,+ ) -> OrgMemberResponse:+ """Update a member's role in an organization.++ Permission rules:+ - Admins can change roles of users (rank > ADMIN_RANK) to Admin or User+ - Admins cannot modify other Admins or Owners+ - Owners can change roles of non-owners (rank > OWNER_RANK) to any role+ - Owners cannot modify other Owners++ Args:+ org_id: Organization ID+ target_user_id: User ID of the member to update+ current_user_id: User ID of the requester+ update_data: Update data containing fields to modify++ Returns:+ OrgMemberResponse: The updated member data++ Raises:+ OrgMemberNotFoundError: If requester or target is not a member+ CannotModifySelfError: If trying to modify self+ RoleNotFoundError: If role configuration is invalid+ InvalidRoleError: If new_role_name is not a valid role+ InsufficientPermissionError: If requester lacks permission+ LastOwnerError: If trying to demote the last owner+ MemberUpdateError: If update operation fails+ """+ new_role_name = update_data.role++ def _update_member():+ # Get current user's membership in the org+ requester_membership = OrgMemberStore.get_org_member(+ org_id, current_user_id+ )+ if not requester_membership:+ raise OrgMemberNotFoundError(str(org_id), str(current_user_id))++ # Check if trying to modify self+ if str(current_user_id) == str(target_user_id):+ raise CannotModifySelfError('modify')++ # Get target user's membership+ target_membership = OrgMemberStore.get_org_member(org_id, target_user_id)+ if not target_membership:+ raise OrgMemberNotFoundError(str(org_id), str(target_user_id))++ # Get roles+ requester_role = RoleStore.get_role_by_id(requester_membership.role_id)+ target_role = RoleStore.get_role_by_id(target_membership.role_id)++ if not requester_role:+ raise RoleNotFoundError(requester_membership.role_id)+ if not target_role:+ raise RoleNotFoundError(target_membership.role_id)++ # If no role change requested, return current state+ if new_role_name is None:+ user = UserStore.get_user_by_id(str(target_user_id))+ return OrgMemberResponse(+ user_id=str(target_membership.user_id),+ email=user.email if user else None,+ role_id=target_membership.role_id,+ role_name=target_role.name,+ role_rank=target_role.rank,+ status=target_membership.status,+ )++ # Validate new role exists+ new_role = RoleStore.get_role_by_name(new_role_name.lower())+ if not new_role:+ raise InvalidRoleError(new_role_name)++ # Check permission to modify target+ if not OrgMemberService._can_update_member_role(+ requester_role.name, target_role.name, new_role.name+ ):+ raise InsufficientPermissionError(+ 'You do not have permission to modify this member'+ )++ # Check if demoting the last owner+ if (+ target_role.name == ROLE_OWNER+ and new_role.name != ROLE_OWNER+ and OrgMemberService._is_last_owner(org_id, target_user_id)+ ):+ raise LastOwnerError('demote')++ # Perform the update+ updated_member = OrgMemberStore.update_user_role_in_org(+ org_id, target_user_id, new_role.id+ )+ if not updated_member:+ raise MemberUpdateError('Failed to update member')++ # Get user email for response+ user = UserStore.get_user_by_id(str(target_user_id))++ return OrgMemberResponse(+ user_id=str(updated_member.user_id),+ email=user.email if user else None,+ role_id=updated_member.role_id,+ role_name=new_role.name,+ role_rank=new_role.rank,+ status=updated_member.status,+ )++ return await call_sync_from_async(_update_member)++ @staticmethod+ def _can_update_member_role(+ requester_role_name: str, target_role_name: str, new_role_name: str+ ) -> bool:+ """Check if requester can change target's role to new_role.++ Permission rules:+ - Owners can modify admins and users, can set any role+ - Owners cannot modify other owners+ - Admins can only modify users+ - Admins can only set admin or user roles (not owner)+ """+ is_requester_owner = requester_role_name == ROLE_OWNER+ is_requester_admin = requester_role_name == ROLE_ADMIN+ is_target_owner = target_role_name == ROLE_OWNER+ is_target_admin = target_role_name == ROLE_ADMIN+ is_new_role_owner = new_role_name == ROLE_OWNER++ if is_requester_owner:+ # Owners cannot modify other owners+ if is_target_owner:+ return False+ # Owners can set any role (owner, admin, user)+ return True+ elif is_requester_admin:+ # Admins cannot modify owners or other admins+ if is_target_owner or is_target_admin:+ return False+ # Admins can only set admin or user roles (not owner)+ return not is_new_role_owner+ return False++ @staticmethod+ def _can_remove_member(requester_role_name: str, target_role_name: str) -> bool:+ """Check if requester can remove target based on roles."""+ if requester_role_name == ROLE_OWNER:return True- elif requester_rank == ADMIN_RANK:- return target_rank > ADMIN_RANK+ elif requester_role_name == ROLE_ADMIN:+ # Admins can only remove users (not owners or other admins)+ return target_role_name == ROLE_USERreturn False@staticmethod@@ -186,6 +337,6 @@ class OrgMemberService:for m in members:# Use role_id (column) instead of role (relationship) to avoid DetachedInstanceErrorrole = RoleStore.get_role_by_id(m.role_id)- if role and role.rank == OWNER_RANK:+ if role and role.name == ROLE_OWNER:owners.append(m)return len(owners) == 1 and str(owners[0].user_id) == str(user_id)diff --git a/enterprise/tests/unit/server/routes/test_orgs.py b/enterprise/tests/unit/server/routes/test_orgs.pyindex 4364737109..ccb6e67496 100644--- a/enterprise/tests/unit/server/routes/test_orgs.py+++ b/enterprise/tests/unit/server/routes/test_orgs.py@@ -18,6 +18,10 @@ with patch('storage.database.engine', create=True), patch():from server.email_validation import get_admin_user_idfrom server.routes.org_models import (+ CannotModifySelfError,+ InsufficientPermissionError,+ InvalidRoleError,+ LastOwnerError,LiteLLMIntegrationError,MeResponse,OrgAuthorizationError,@@ -25,6 +29,7 @@ with patch('storage.database.engine', create=True), patch(OrgMemberNotFoundError,OrgMemberPage,OrgMemberResponse,+ OrgMemberUpdate,OrgNameExistsError,OrgNotFoundError,RoleNotFoundError,@@ -34,6 +39,7 @@ with patch('storage.database.engine', create=True), patch(get_org_members,org_router,remove_org_member,+ update_org_member,)from storage.org import Org@@ -2299,6 +2305,195 @@ class TestRemoveOrgMemberEndpoint:assert exc_info.value.detail == 'Service temporarily unavailable'+class TestUpdateOrgMemberEndpoint:+ """Test cases for PATCH /api/organizations/{org_id}/members/{user_id} endpoint."""++ @pytest.mark.asyncio+ async def test_update_member_role_succeeds_returns_member_response(+ self, org_id, current_user_id, target_user_id+ ):+ """GIVEN valid role update request WHEN PATCH is called THEN returns 200 with updated OrgMemberResponse."""+ # Arrange+ updated = OrgMemberResponse(+ user_id=target_user_id,+ email='[email protected]',+ role_id=2,+ role_name='admin',+ role_rank=20,+ status='active',+ )+ with patch(+ 'server.routes.orgs.OrgMemberService.update_org_member'+ ) as mock_update:+ mock_update.return_value = updated++ # Act+ result = await update_org_member(+ org_id=org_id,+ user_id=target_user_id,+ update_data=OrgMemberUpdate(role='admin'),+ current_user_id=current_user_id,+ )++ # Assert+ assert result == updated+ mock_update.assert_called_once_with(+ org_id=uuid.UUID(org_id),+ target_user_id=uuid.UUID(target_user_id),+ current_user_id=uuid.UUID(current_user_id),+ update_data=OrgMemberUpdate(role='admin'),+ )++ @pytest.mark.asyncio+ async def test_not_a_member_returns_403(+ self, org_id, current_user_id, target_user_id+ ):+ """GIVEN requester is not a member WHEN PATCH is called THEN returns 403."""+ # Arrange+ with patch(+ 'server.routes.orgs.OrgMemberService.update_org_member'+ ) as mock_update:+ mock_update.side_effect = OrgMemberNotFoundError(org_id, current_user_id)++ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await update_org_member(+ org_id=org_id,+ user_id=target_user_id,+ update_data=OrgMemberUpdate(role='user'),+ current_user_id=current_user_id,+ )+ assert exc_info.value.status_code == status.HTTP_403_FORBIDDEN+ assert 'not a member' in exc_info.value.detail++ @pytest.mark.asyncio+ async def test_cannot_modify_self_returns_403(self, org_id, current_user_id):+ """GIVEN target user is self WHEN PATCH is called THEN returns 403."""+ # Arrange+ with patch(+ 'server.routes.orgs.OrgMemberService.update_org_member'+ ) as mock_update:+ mock_update.side_effect = CannotModifySelfError('modify')++ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await update_org_member(+ org_id=org_id,+ user_id=current_user_id,+ update_data=OrgMemberUpdate(role='admin'),+ current_user_id=current_user_id,+ )+ assert exc_info.value.status_code == status.HTTP_403_FORBIDDEN+ assert 'Cannot modify your own role' in exc_info.value.detail++ @pytest.mark.asyncio+ async def test_member_not_found_returns_404(+ self, org_id, current_user_id, target_user_id+ ):+ """GIVEN target member does not exist WHEN PATCH is called THEN returns 404."""+ # Arrange+ with patch(+ 'server.routes.orgs.OrgMemberService.update_org_member'+ ) as mock_update:+ mock_update.side_effect = OrgMemberNotFoundError(org_id, target_user_id)++ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await update_org_member(+ org_id=org_id,+ user_id=target_user_id,+ update_data=OrgMemberUpdate(role='user'),+ current_user_id=current_user_id,+ )+ assert exc_info.value.status_code == status.HTTP_404_NOT_FOUND+ assert 'Member not found' in exc_info.value.detail++ @pytest.mark.asyncio+ async def test_invalid_role_returns_400(+ self, org_id, current_user_id, target_user_id+ ):+ """GIVEN invalid role name WHEN PATCH is called THEN returns 400."""+ # Arrange+ with patch(+ 'server.routes.orgs.OrgMemberService.update_org_member'+ ) as mock_update:+ mock_update.side_effect = InvalidRoleError('superuser')++ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await update_org_member(+ org_id=org_id,+ user_id=target_user_id,+ update_data=OrgMemberUpdate(role='superuser'),+ current_user_id=current_user_id,+ )+ assert exc_info.value.status_code == status.HTTP_400_BAD_REQUEST+ assert 'Invalid role' in exc_info.value.detail++ @pytest.mark.asyncio+ async def test_insufficient_permission_returns_403(+ self, org_id, current_user_id, target_user_id+ ):+ """GIVEN requester lacks permission to change target WHEN PATCH is called THEN returns 403."""+ # Arrange+ with patch(+ 'server.routes.orgs.OrgMemberService.update_org_member'+ ) as mock_update:+ mock_update.side_effect = InsufficientPermissionError(+ 'You do not have permission to modify this member'+ )++ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await update_org_member(+ org_id=org_id,+ user_id=target_user_id,+ update_data=OrgMemberUpdate(role='admin'),+ current_user_id=current_user_id,+ )+ assert exc_info.value.status_code == status.HTTP_403_FORBIDDEN+ assert 'do not have permission' in exc_info.value.detail++ @pytest.mark.asyncio+ async def test_cannot_demote_last_owner_returns_400(+ self, org_id, current_user_id, target_user_id+ ):+ """GIVEN demoting last owner WHEN PATCH is called THEN returns 400."""+ # Arrange+ with patch(+ 'server.routes.orgs.OrgMemberService.update_org_member'+ ) as mock_update:+ mock_update.side_effect = LastOwnerError('demote')++ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await update_org_member(+ org_id=org_id,+ user_id=target_user_id,+ update_data=OrgMemberUpdate(role='admin'),+ current_user_id=current_user_id,+ )+ assert exc_info.value.status_code == status.HTTP_400_BAD_REQUEST+ assert 'Cannot demote the last owner' in exc_info.value.detail++ @pytest.mark.asyncio+ async def test_invalid_org_id_returns_400(self, current_user_id, target_user_id):+ """GIVEN invalid org_id UUID WHEN PATCH is called THEN returns 400."""+ # Arrange+ invalid_org_id = 'not-a-uuid'++ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await update_org_member(+ org_id=invalid_org_id,+ user_id=target_user_id,+ update_data=OrgMemberUpdate(role='user'),+ current_user_id=current_user_id,+ )+ assert exc_info.value.status_code == status.HTTP_400_BAD_REQUEST+ assert 'Invalid organization or user ID format' in exc_info.value.detail++class TestGetMeEndpoint:"""Tests for GET /api/organizations/{org_id}/me endpoint.diff --git a/enterprise/tests/unit/server/services/test_org_member_service.py b/enterprise/tests/unit/server/services/test_org_member_service.pyindex 7bf99d72dd..a17c312a4f 100644--- a/enterprise/tests/unit/server/services/test_org_member_service.py+++ b/enterprise/tests/unit/server/services/test_org_member_service.py@@ -6,8 +6,14 @@ from unittest.mock import AsyncMock, MagicMock, patchimport pytestfrom pydantic import SecretStrfrom server.routes.org_models import (+ CannotModifySelfError,+ InsufficientPermissionError,+ InvalidRoleError,+ LastOwnerError,MeResponse,OrgMemberNotFoundError,+ OrgMemberResponse,+ OrgMemberUpdate,RoleNotFoundError,)from server.services.org_member_service import OrgMemberService@@ -989,78 +995,496 @@ class TestOrgMemberServiceCanRemoveMember:"""Test cases for OrgMemberService._can_remove_member."""def test_owner_can_remove_admin(self):- """Test that owner (rank 10) can remove admin (rank 20)."""- # Arrange- requester_rank = 10- target_rank = 20-+ """Test that owner can remove admin."""# Act- result = OrgMemberService._can_remove_member(requester_rank, target_rank)+ result = OrgMemberService._can_remove_member('owner', 'admin')# Assertassert result is Truedef test_owner_can_remove_user(self):- """Test that owner (rank 10) can remove user (rank 1000)."""- # Arrange- requester_rank = 10- target_rank = 1000-+ """Test that owner can remove user."""# Act- result = OrgMemberService._can_remove_member(requester_rank, target_rank)+ result = OrgMemberService._can_remove_member('owner', 'user')# Assertassert result is Truedef test_admin_can_remove_user(self):- """Test that admin (rank 20) can remove user (rank 1000)."""- # Arrange- requester_rank = 20- target_rank = 1000-+ """Test that admin can remove user."""# Act- result = OrgMemberService._can_remove_member(requester_rank, target_rank)+ result = OrgMemberService._can_remove_member('admin', 'user')# Assertassert result is Truedef test_admin_cannot_remove_admin(self):- """Test that admin (rank 20) cannot remove another admin (rank 20)."""- # Arrange- requester_rank = 20- target_rank = 20-+ """Test that admin cannot remove another admin."""# Act- result = OrgMemberService._can_remove_member(requester_rank, target_rank)+ result = OrgMemberService._can_remove_member('admin', 'admin')# Assertassert result is Falsedef test_admin_cannot_remove_owner(self):- """Test that admin (rank 20) cannot remove owner (rank 10)."""- # Arrange- requester_rank = 20- target_rank = 10-+ """Test that admin cannot remove owner."""# Act- result = OrgMemberService._can_remove_member(requester_rank, target_rank)+ result = OrgMemberService._can_remove_member('admin', 'owner')# Assertassert result is Falsedef test_user_cannot_remove_anyone(self):- """Test that user (rank 1000) cannot remove anyone."""- # Arrange- requester_rank = 1000- target_rank = 1000-+ """Test that user cannot remove anyone."""# Act- result = OrgMemberService._can_remove_member(requester_rank, target_rank)+ result = OrgMemberService._can_remove_member('user', 'user')# Assertassert result is False+class TestOrgMemberServiceUpdateOrgMember:+ """Test cases for OrgMemberService.update_org_member."""++ @pytest.mark.asyncio+ async def test_owner_updates_user_to_admin_succeeds(+ self,+ org_id,+ current_user_id,+ target_user_id,+ requester_membership_owner,+ target_membership_user,+ owner_role,+ user_role,+ admin_role,+ ):+ """GIVEN owner and target user WHEN owner sets target role to admin THEN update succeeds and returns OrgMemberResponse."""+ # Arrange+ updated_member = MagicMock(spec=OrgMember)+ updated_member.user_id = target_user_id+ updated_member.role_id = admin_role.id+ updated_member.status = 'active'+ mock_user = MagicMock()+ mock_user.email = '[email protected]'+ with (+ patch(+ 'server.services.org_member_service.OrgMemberStore.get_org_member'+ ) as mock_get_member,+ patch(+ 'server.services.org_member_service.RoleStore.get_role_by_id'+ ) as mock_get_role,+ patch(+ 'server.services.org_member_service.RoleStore.get_role_by_name'+ ) as mock_get_role_by_name,+ patch(+ 'server.services.org_member_service.OrgMemberStore.update_user_role_in_org'+ ) as mock_update,+ patch(+ 'server.services.org_member_service.UserStore.get_user_by_id'+ ) as mock_get_user,+ ):+ mock_get_member.side_effect = [+ requester_membership_owner,+ target_membership_user,+ ]+ mock_get_role.side_effect = [owner_role, user_role]+ mock_get_role_by_name.return_value = admin_role+ mock_update.return_value = updated_member+ mock_get_user.return_value = mock_user++ # Act+ data = await OrgMemberService.update_org_member(+ org_id, target_user_id, current_user_id, OrgMemberUpdate(role='admin')+ )++ # Assert+ assert isinstance(data, OrgMemberResponse)+ assert data.role_name == 'admin'+ assert data.role_rank == 20+ mock_update.assert_called_once_with(org_id, target_user_id, admin_role.id)++ @pytest.mark.asyncio+ async def test_admin_updates_user_to_admin_succeeds(+ self,+ org_id,+ current_user_id,+ target_user_id,+ requester_membership_admin,+ target_membership_user,+ admin_role,+ user_role,+ ):+ """GIVEN admin and target user WHEN admin sets target role to admin THEN update succeeds."""+ # Arrange+ updated_member = MagicMock(spec=OrgMember)+ updated_member.user_id = target_user_id+ updated_member.role_id = admin_role.id+ updated_member.status = 'active'+ mock_user = MagicMock()+ mock_user.email = '[email protected]'+ with (+ patch(+ 'server.services.org_member_service.OrgMemberStore.get_org_member'+ ) as mock_get_member,+ patch(+ 'server.services.org_member_service.RoleStore.get_role_by_id'+ ) as mock_get_role,+ patch(+ 'server.services.org_member_service.RoleStore.get_role_by_name'+ ) as mock_get_role_by_name,+ patch(+ 'server.services.org_member_service.OrgMemberStore.update_user_role_in_org'+ ) as mock_update,+ patch(+ 'server.services.org_member_service.UserStore.get_user_by_id'+ ) as mock_get_user,+ ):+ mock_get_member.side_effect = [+ requester_membership_admin,+ target_membership_user,+ ]+ mock_get_role.side_effect = [admin_role, user_role]+ mock_get_role_by_name.return_value = admin_role+ mock_update.return_value = updated_member+ mock_get_user.return_value = mock_user++ # Act+ data = await OrgMemberService.update_org_member(+ org_id, target_user_id, current_user_id, OrgMemberUpdate(role='admin')+ )++ # Assert+ assert data is not None+ mock_update.assert_called_once_with(org_id, target_user_id, admin_role.id)++ @pytest.mark.asyncio+ async def test_admin_cannot_update_admin_raises_insufficient_permission(+ self,+ org_id,+ current_user_id,+ target_user_id,+ requester_membership_admin,+ target_membership_admin,+ admin_role,+ user_role,+ ):+ """GIVEN admin and target admin WHEN admin tries to change target role THEN raises InsufficientPermissionError."""+ # Arrange+ with (+ patch(+ 'server.services.org_member_service.OrgMemberStore.get_org_member'+ ) as mock_get_member,+ patch(+ 'server.services.org_member_service.RoleStore.get_role_by_id'+ ) as mock_get_role,+ patch(+ 'server.services.org_member_service.RoleStore.get_role_by_name'+ ) as mock_get_role_by_name,+ ):+ mock_get_member.side_effect = [+ requester_membership_admin,+ target_membership_admin,+ ]+ mock_get_role.side_effect = [admin_role, admin_role]+ mock_get_role_by_name.return_value = user_role++ # Act & Assert+ with pytest.raises(InsufficientPermissionError):+ await OrgMemberService.update_org_member(+ org_id,+ target_user_id,+ current_user_id,+ OrgMemberUpdate(role='user'),+ )++ @pytest.mark.asyncio+ async def test_owner_cannot_update_owner_raises_insufficient_permission(+ self,+ org_id,+ current_user_id,+ target_user_id,+ requester_membership_owner,+ target_membership_owner,+ owner_role,+ admin_role,+ ):+ """GIVEN owner and target owner WHEN owner tries to change target role THEN raises InsufficientPermissionError."""+ # Arrange+ with (+ patch(+ 'server.services.org_member_service.OrgMemberStore.get_org_member'+ ) as mock_get_member,+ patch(+ 'server.services.org_member_service.RoleStore.get_role_by_id'+ ) as mock_get_role,+ patch(+ 'server.services.org_member_service.RoleStore.get_role_by_name'+ ) as mock_get_role_by_name,+ ):+ mock_get_member.side_effect = [+ requester_membership_owner,+ target_membership_owner,+ ]+ mock_get_role.side_effect = [owner_role, owner_role]+ mock_get_role_by_name.return_value = admin_role++ # Act & Assert+ with pytest.raises(InsufficientPermissionError):+ await OrgMemberService.update_org_member(+ org_id,+ target_user_id,+ current_user_id,+ OrgMemberUpdate(role='admin'),+ )++ @pytest.mark.asyncio+ async def test_requester_not_a_member_raises_error(+ self, org_id, current_user_id, target_user_id+ ):+ """GIVEN requester not in org WHEN update_org_member THEN raises OrgMemberNotFoundError."""+ # Arrange+ with patch(+ 'server.services.org_member_service.OrgMemberStore.get_org_member'+ ) as mock_get_member:+ mock_get_member.return_value = None++ # Act & Assert+ with pytest.raises(OrgMemberNotFoundError):+ await OrgMemberService.update_org_member(+ org_id,+ target_user_id,+ current_user_id,+ OrgMemberUpdate(role='user'),+ )++ @pytest.mark.asyncio+ async def test_cannot_modify_self_raises_error(+ self, org_id, current_user_id, requester_membership_owner, owner_role+ ):+ """GIVEN requester updates self WHEN update_org_member THEN raises CannotModifySelfError."""+ # Arrange+ with patch(+ 'server.services.org_member_service.OrgMemberStore.get_org_member'+ ) as mock_get_member:+ mock_get_member.return_value = requester_membership_owner++ # Act & Assert+ with pytest.raises(CannotModifySelfError):+ await OrgMemberService.update_org_member(+ org_id,+ current_user_id,+ current_user_id,+ OrgMemberUpdate(role='user'),+ )++ @pytest.mark.asyncio+ async def test_target_member_not_found_raises_error(+ self,+ org_id,+ current_user_id,+ target_user_id,+ requester_membership_owner,+ owner_role,+ ):+ """GIVEN target not in org WHEN update_org_member THEN raises OrgMemberNotFoundError."""+ # Arrange+ with patch(+ 'server.services.org_member_service.OrgMemberStore.get_org_member'+ ) as mock_get_member:+ mock_get_member.side_effect = [requester_membership_owner, None]++ # Act & Assert+ with pytest.raises(OrgMemberNotFoundError):+ await OrgMemberService.update_org_member(+ org_id,+ target_user_id,+ current_user_id,+ OrgMemberUpdate(role='user'),+ )++ @pytest.mark.asyncio+ async def test_invalid_role_name_raises_error(+ self,+ org_id,+ current_user_id,+ target_user_id,+ requester_membership_owner,+ target_membership_user,+ owner_role,+ user_role,+ ):+ """GIVEN unknown role name WHEN update_org_member THEN raises InvalidRoleError."""+ # Arrange+ with (+ patch(+ 'server.services.org_member_service.OrgMemberStore.get_org_member'+ ) as mock_get_member,+ patch(+ 'server.services.org_member_service.RoleStore.get_role_by_id'+ ) as mock_get_role,+ patch(+ 'server.services.org_member_service.RoleStore.get_role_by_name'+ ) as mock_get_role_by_name,+ ):+ mock_get_member.side_effect = [+ requester_membership_owner,+ target_membership_user,+ ]+ mock_get_role.side_effect = [owner_role, user_role]+ mock_get_role_by_name.return_value = None++ # Act & Assert+ with pytest.raises(InvalidRoleError):+ await OrgMemberService.update_org_member(+ org_id,+ target_user_id,+ current_user_id,+ OrgMemberUpdate(role='superuser'),+ )++ @pytest.mark.asyncio+ async def test_cannot_demote_last_owner_raises_error(+ self,+ org_id,+ current_user_id,+ target_user_id,+ requester_membership_owner,+ target_membership_owner,+ owner_role,+ admin_role,+ ):+ """GIVEN last owner would be demoted WHEN update_org_member THEN raises LastOwnerError."""+ # Arrange: patch _can_update_member_role so we reach the last-owner check (owner cannot normally modify owner)+ with (+ patch(+ 'server.services.org_member_service.OrgMemberStore.get_org_member'+ ) as mock_get_member,+ patch(+ 'server.services.org_member_service.RoleStore.get_role_by_id'+ ) as mock_get_role,+ patch(+ 'server.services.org_member_service.RoleStore.get_role_by_name'+ ) as mock_get_role_by_name,+ patch(+ 'server.services.org_member_service.OrgMemberService._can_update_member_role'+ ) as mock_can_update,+ patch(+ 'server.services.org_member_service.OrgMemberService._is_last_owner'+ ) as mock_is_last_owner,+ ):+ mock_get_member.side_effect = [+ requester_membership_owner,+ target_membership_owner,+ ]+ mock_get_role.side_effect = [owner_role, owner_role]+ mock_get_role_by_name.return_value = admin_role+ mock_can_update.return_value = True+ mock_is_last_owner.return_value = True++ # Act & Assert+ with pytest.raises(LastOwnerError):+ await OrgMemberService.update_org_member(+ org_id,+ target_user_id,+ current_user_id,+ OrgMemberUpdate(role='admin'),+ )++ @pytest.mark.asyncio+ async def test_no_role_in_body_returns_current_member_state(+ self,+ org_id,+ current_user_id,+ target_user_id,+ requester_membership_owner,+ target_membership_user,+ owner_role,+ user_role,+ ):+ """GIVEN update with no role WHEN update_org_member THEN returns current member without changing role."""+ # Arrange+ mock_user = MagicMock()+ mock_user.email = '[email protected]'+ target_membership_user.status = 'active'+ with (+ patch(+ 'server.services.org_member_service.OrgMemberStore.get_org_member'+ ) as mock_get_member,+ patch(+ 'server.services.org_member_service.RoleStore.get_role_by_id'+ ) as mock_get_role,+ patch(+ 'server.services.org_member_service.UserStore.get_user_by_id'+ ) as mock_get_user,+ ):+ mock_get_member.side_effect = [+ requester_membership_owner,+ target_membership_user,+ ]+ mock_get_role.side_effect = [owner_role, user_role]+ mock_get_user.return_value = mock_user++ # Act+ data = await OrgMemberService.update_org_member(+ org_id, target_user_id, current_user_id, OrgMemberUpdate(role=None)+ )++ # Assert+ assert data is not None+ assert data.role_name == 'user'+ assert data.role_rank == 1000+++class TestOrgMemberServiceCanUpdateMemberRole:+ """Test cases for OrgMemberService._can_update_member_role."""++ def test_owner_can_set_any_role_for_non_owner(self):+ """Owner can change admin/user target to any role."""+ assert (+ OrgMemberService._can_update_member_role('owner', 'admin', 'owner') is True+ )+ assert (+ OrgMemberService._can_update_member_role('owner', 'admin', 'admin') is True+ )+ assert (+ OrgMemberService._can_update_member_role('owner', 'user', 'owner') is True+ )++ def test_owner_cannot_modify_owner(self):+ """Owner cannot change another owner's role."""+ assert (+ OrgMemberService._can_update_member_role('owner', 'owner', 'admin') is False+ )++ def test_admin_can_set_admin_or_user_for_user(self):+ """Admin can set admin or user role for a user target."""+ assert (+ OrgMemberService._can_update_member_role('admin', 'user', 'admin') is True+ )+ assert OrgMemberService._can_update_member_role('admin', 'user', 'user') is True++ def test_admin_cannot_modify_admin_or_owner(self):+ """Admin cannot modify admin or owner targets."""+ assert (+ OrgMemberService._can_update_member_role('admin', 'admin', 'user') is False+ )+ assert (+ OrgMemberService._can_update_member_role('admin', 'owner', 'admin') is False+ )++ def test_admin_cannot_set_owner_role(self):+ """Admin cannot set role to owner."""+ assert (+ OrgMemberService._can_update_member_role('admin', 'user', 'owner') is False+ )++ def test_user_cannot_update_anyone(self):+ """User cannot update any member's role."""+ assert (+ OrgMemberService._can_update_member_role('user', 'user', 'admin') is False+ )++class TestOrgMemberServiceIsLastOwner:"""Test cases for OrgMemberService._is_last_owner."""