Skip to content

LLM-Driven Extraction of Unstructured Data — Built for API Deployments & ETL Pipeline Workflows

UN-4399 [FEAT] Capability permissions part 2: members, API keys and platform defaults (#2357)

Ritwik Gbb848518b5f2
diff --git a/backend/account_v2/authentication_controller.py b/backend/account_v2/authentication_controller.py
index 0e7062e3b..51bee8557 100644
--- a/backend/account_v2/authentication_controller.py
+++ b/backend/account_v2/authentication_controller.py
@@ -360,8 +360,7 @@ class AuthenticationController:
user invitation.
"""
admin_user = OrganizationMemberService.get_user_by_id(id=admin.id)
- if not self.auth_service.is_organization_admin(admin_user):
- raise Forbidden()
+ self.authorize_invite(admin_user, [item.get("role") for item in user_list])
response = []
for user_item in user_list:
email = user_item.get("email")
@@ -440,6 +439,67 @@ class AuthenticationController:
if admin_count <= 1:
raise Forbidden("Cannot demote the only admin of the organization")
+ def _member_management_open(self, actor: OrganizationMember) -> bool:
+ """Whether ``actor`` (not an admin) may manage members at all."""
+ from tenant_account_v2.capabilities import Capability, opened_to_members
+
+ return opened_to_members(
+ actor.user, UserContext.get_organization(), Capability.MANAGE_MEMBERS
+ )
+
+ def _refuse_members(self) -> None:
+ from tenant_account_v2.capabilities import SPECS_BY_KEY, Capability
+
+ raise Forbidden(SPECS_BY_KEY[Capability.MANAGE_MEMBERS].message())
+
+ def authorize_invite(self, actor: OrganizationMember | None, roles: list) -> None:
+ """Admins invite with any role. A member may, when the org lets members
+ manage members, invite with the member role only.
+ """
+ if actor is None: # not a member of this org
+ raise Forbidden()
+ if self.auth_service.is_organization_admin(actor):
+ return
+ if not self._member_management_open(actor):
+ self._refuse_members()
+ is_member_role = getattr(self.auth_service, "is_member_invite_role", None)
+ # A plugin that does not say which roles members may use refuses them
+ # (plugins need not inherit AuthenticationService).
+ if is_member_role is None or not all(is_member_role(role) for role in roles):
+ raise Forbidden("Members can invite with the user role only.")
+
+ def authorize_role_change(
+ self,
+ actor: OrganizationMember | None,
+ target: OrganizationMember,
+ role: str,
+ removing: bool = False,
+ ) -> None:
+ """Admins change any role. A member may, when the org lets members
+ manage members, grant a member-assignable role to another member who
+ is not an admin. Removing roles, granting admin, and changing one's own
+ role stay admin-only.
+
+ The check reads the target's role before the write without a lock, so
+ an admin promotion landing in between can be overwritten. Accepted: it
+ needs an admin and a member acting on the same person at once.
+ """
+ if actor is None: # not a member of this org
+ raise Forbidden()
+ if self.auth_service.is_organization_admin(actor):
+ return
+ if not self._member_management_open(actor):
+ self._refuse_members()
+ if removing:
+ raise Forbidden("Only admins can remove a member's role.")
+ if target.user_id == actor.user_id:
+ raise Forbidden("You cannot change your own role.")
+ if self.is_admin_by_role(target.role):
+ raise Forbidden("Only admins can change an admin's role.")
+ is_assignable = getattr(self.auth_service, "is_member_assignable_role", None)
+ if is_assignable is None or not is_assignable(role):
+ raise Forbidden("Only admins can grant this role.")
+
def add_user_role(
self, request: Request, org_id: str, email: str, role: str
) -> str | None:
@@ -448,6 +508,7 @@ class AuthenticationController:
admin_user = OrganizationMemberService.get_user_by_id(id=admin.id)
user = OrganizationMemberService.get_user_by_email(email=email)
if user:
+ self.authorize_role_change(admin_user, user, role)
current_roles = self.auth_service.add_organization_user_role(
admin_user, org_id, user.user.user_id, [role], request
)
@@ -470,6 +531,9 @@ class AuthenticationController:
admin_user = OrganizationMemberService.get_user_by_id(id=admin.id)
organization_member = OrganizationMemberService.get_user_by_email(email=email)
if organization_member:
+ self.authorize_role_change(
+ admin_user, organization_member, role, removing=True
+ )
current_roles = self.auth_service.remove_organization_user_role(
admin_user, org_id, organization_member.user.user_id, [role], request
)
diff --git a/backend/account_v2/authentication_service.py b/backend/account_v2/authentication_service.py
index 053a1e67a..3fc70e1e3 100644
--- a/backend/account_v2/authentication_service.py
+++ b/backend/account_v2/authentication_service.py
@@ -15,7 +15,7 @@ from utils.user_context import UserContext
from account_v2.authentication_helper import AuthenticationHelper
from account_v2.constants import DefaultOrg, ErrorMessage, UserLoginTemplate
-from account_v2.custom_exceptions import Forbidden, MethodNotImplemented
+from account_v2.custom_exceptions import MethodNotImplemented
from account_v2.dto import (
CallbackData,
MemberData,
@@ -282,9 +282,8 @@ class AuthenticationService:
role_ids: list[str],
request: Request,
) -> list[str]:
- if admin.role == UserRole.ADMIN.value:
- return role_ids
- raise Forbidden
+ # Authorised by AuthenticationController.authorize_role_change.
+ return role_ids
def remove_organization_user_role(
self,
@@ -294,9 +293,20 @@ class AuthenticationService:
role_ids: list[str],
request: Request,
) -> list[str]:
- if admin.role == UserRole.ADMIN.value:
- return role_ids
- raise Forbidden
+ # Authorised by AuthenticationController.authorize_role_change.
+ return role_ids
+
+ def is_member_invite_role(self, role: str | None) -> bool:
+ """Whether a non-admin may invite with ``role`` (when the org lets
+ members manage members). Plugins with their own role names override.
+ """
+ return role is None or role == UserRole.USER.value
+
+ def is_member_assignable_role(self, role: str | None) -> bool:
+ """Whether a non-admin may grant ``role`` to someone else.
+ Never an admin role; plugins with more roles override.
+ """
+ return role == UserRole.USER.value
def get_organization_by_org_id(self, id: str) -> OrganizationData:
organizationData: OrganizationData = OrganizationData(
diff --git a/backend/api_v2/api_deployment_views.py b/backend/api_v2/api_deployment_views.py
index 73c90ff78..32562f07c 100644
--- a/backend/api_v2/api_deployment_views.py
+++ b/backend/api_v2/api_deployment_views.py
@@ -105,7 +105,7 @@ class DeploymentExecution(views.APIView):
context={
"api": api,
"api_key": api_key,
- "is_global_key": deployment_execution_dto.is_global_key,
+ "global_key": deployment_execution_dto.global_key,
},
)
serializer.is_valid(raise_exception=True)
diff --git a/backend/api_v2/deployment_helper.py b/backend/api_v2/deployment_helper.py
index 38b1a8795..df8650813 100644
--- a/backend/api_v2/deployment_helper.py
+++ b/backend/api_v2/deployment_helper.py
@@ -91,7 +91,8 @@ class DeploymentHelper(BaseAPIKeyValidator):
Returns:
The authorizing ``GlobalApiDeploymentKey`` when the request was
authenticated via a global key, else ``None`` (deployment-specific
- key). Returning the key (not a bool) preserves audit identity.
+ key). Returning the key (not a bool) preserves audit identity and
+ lets the request serializer check a member-created key's profiles.
Raises:
APINotFound: If deployment not found
diff --git a/backend/api_v2/dto.py b/backend/api_v2/dto.py
index e7fb9203c..539dfce52 100644
--- a/backend/api_v2/dto.py
+++ b/backend/api_v2/dto.py
@@ -22,9 +22,7 @@ class DeploymentExecutionDTO:
api_key: str = field(repr=False)
# The global API deployment key that authorized this execution, if any.
# Carrying the resolved key (not just a bool) preserves audit identity —
- # "which named key authorized this?" — for downstream logging/incidents.
+ # "which named key authorized this?" — for downstream logging/incidents,
+ # and lets ExecutionRequestSerializer hold a member-created key to its
+ # creator's LLM profiles (UN-4399).
global_key: "GlobalApiDeploymentKey | None" = None
-
- @property
- def is_global_key(self) -> bool:
- return self.global_key is not None
diff --git a/backend/api_v2/key_helper.py b/backend/api_v2/key_helper.py
index cacf40faf..3f2ffa153 100644
--- a/backend/api_v2/key_helper.py
+++ b/backend/api_v2/key_helper.py
@@ -105,7 +105,7 @@ class KeyHelper:
if not global_key.has_access_to_deployment(api_deployment):
logger.warning(
"Global API key '%s' (%s) rejected: no access to deployment %s "
- "(out of scope or different organization).",
+ "(out of scope, different organization, or its creator may no longer key it).",
global_key.name,
global_key.id,
api_deployment.id,
diff --git a/backend/api_v2/serializers.py b/backend/api_v2/serializers.py
index 52dec96ab..d0c05d8ec 100644
--- a/backend/api_v2/serializers.py
+++ b/backend/api_v2/serializers.py
@@ -482,7 +482,11 @@ class ExecutionRequestSerializer(TagParamsSerializer):
# Get context from serializer
api = self.context.get("api")
api_key = self.context.get("api_key")
- is_global_key = self.context.get("is_global_key", False)
+ # One source of truth: the authorising global key itself, so the
+ # member-key check below cannot be skipped by a caller that marks the
+ # request global without passing the key.
+ global_key = self.context.get("global_key")
+ is_global_key = global_key is not None
if not api or not api_key:
raise ValidationError("Unable to validate LLM profile ownership")
@@ -493,8 +497,10 @@ class ExecutionRequestSerializer(TagParamsSerializer):
except ProfileManager.DoesNotExist:
raise ValidationError("Profile not found")
- # Global API Keys are org-level (not tied to a single user), so the
- # per-user ownership check below does not apply. We must still confirm
+ # A Global API Key an admin created is org-level, so the per-user
+ # ownership check below does not apply to it; one a member created
+ # (UN-4399) may only use profiles its creator owns, as a deployment's
+ # own key does, checked after the org check. We must still confirm
# the profile belongs to the same organization as the deployment,
# otherwise a caller could reference another org's profile by UUID.
# ``ProfileManager.objects`` is not org-scoped by default, so this
@@ -514,6 +520,11 @@ class ExecutionRequestSerializer(TagParamsSerializer):
if profile_org_id != api.organization_id:
# Generic error avoids confirming another org's profile exists.
raise ValidationError("Profile not found")
+ if (
+ global_key.created_by_member
+ and profile.created_by_id != global_key.created_by_id
+ ):
+ raise ValidationError("You can only use profiles that you own")
return value
# Get the specific API key being used
diff --git a/backend/global_api_deployment_key/migrations/0002_global_key_created_by_member.py b/backend/global_api_deployment_key/migrations/0002_global_key_created_by_member.py
new file mode 100644
index 000000000..be5eabd9d
--- /dev/null
+++ b/backend/global_api_deployment_key/migrations/0002_global_key_created_by_member.py
@@ -0,0 +1,30 @@
+# Generated by Django 4.2.30 on 2026-10-20 05:27
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("global_api_deployment_key", "0001_initial"),
+ ]
+
+ # Reversing this migration drops the column, and rolling back only the code
+ # leaves the column unread. Either way member keys stop being bound to their
+ # creator, so deactivate keys with created_by_member set first.
+ operations = [
+ migrations.AddField(
+ model_name="globalapideploymentkey",
+ name="created_by_member",
+ field=models.BooleanField(
+ db_comment="True if a non-admin created this key (UN-4399): it then works only within the deployments its creator may key (deployments_keyable_by)",
+ default=False,
+ ),
+ ),
+ # AddField drops the default it used for the backfill. Keep one in the
+ # database so pods still on the old code can create keys mid-deploy.
+ migrations.RunSQL(
+ "ALTER TABLE global_api_deployment_key "
+ "ALTER COLUMN created_by_member SET DEFAULT false",
+ reverse_sql=migrations.RunSQL.noop,
+ ),
+ ]
diff --git a/backend/global_api_deployment_key/models.py b/backend/global_api_deployment_key/models.py
index f77330ecd..8d2c7b66c 100644
--- a/backend/global_api_deployment_key/models.py
+++ b/backend/global_api_deployment_key/models.py
@@ -1,3 +1,4 @@
+import logging
import uuid
from account_v2.models import User
@@ -6,6 +7,34 @@ from django.db import models
from utils.models.base_model import BaseModel
from utils.models.organization_mixin import DefaultOrganizationMixin
+logger = logging.getLogger(__name__)
+
+
+def deployments_keyable_by(user):
+ """API deployments a global key ``user`` creates may cover (UN-4399):
+ every one for an org admin, otherwise the ones they own (creator or
+ co-owner) -- the rule for minting a deployment's own key
+ (``IsParentDeploymentOwner``). An empty queryset for anyone outside the
+ organisation.
+ """
+ # Lazy: tenant_account_v2 imports account_v2, which imports this app.
+ from permissions.roles import ResourceRole
+ from tenant_account_v2.models import OrganizationMember
+ from tenant_account_v2.organization_member_service import (
+ OrganizationMemberService,
+ )
+ from tenant_account_v2.sharing_helpers import resources_visible_via_memberships
+
+ if user is None or not OrganizationMember.objects.filter(user=user).exists():
+ return APIDeployment.objects.none()
+ if OrganizationMemberService.is_user_organization_admin(user):
+ return APIDeployment.objects.all()
+ return APIDeployment.objects.filter(
+ pk__in=resources_visible_via_memberships(
+ APIDeployment, user, role=ResourceRole.OWNER
+ )
+ )
+
class GlobalApiDeploymentKey(DefaultOrganizationMixin, BaseModel):
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
@@ -30,6 +59,13 @@ class GlobalApiDeploymentKey(DefaultOrganizationMixin, BaseModel):
null=True,
related_name="global_api_deployment_keys_created",
)
+ created_by_member = models.BooleanField(
+ default=False,
+ db_comment=(
+ "True if a non-admin created this key (UN-4399): it then works only "
+ "within the deployments its creator may key (deployments_keyable_by)"
+ ),
+ )
modified_by = models.ForeignKey(
User,
on_delete=models.SET_NULL,
@@ -65,6 +101,36 @@ class GlobalApiDeploymentKey(DefaultOrganizationMixin, BaseModel):
# ``clean()`` runs before M2M rows exist), so the serializers own the
# invariant — see ``_GlobalApiDeploymentKeyWriteSerializer`` subclasses,
# which reject/clear a list whenever allow-all is set.
+ if self.created_by_member and not self._creator_can_access(api_deployment):
+ return False
if self.allow_all_deployments:
return True
return self.api_deployments.filter(id=api_deployment.id).exists()
+
+ def _creator_can_access(self, api_deployment: APIDeployment) -> bool:
+ """A member's key works only within ``deployments_keyable_by`` its
+ creator (UN-4399), so its deployments' other owners never have to find
+ and revoke it.
+ """
+ # Lazy: tenant_account_v2 imports account_v2, which imports this app.
+ from tenant_account_v2.models import OrganizationMember
+
+ creator = self.created_by
+ if creator is None:
+ reason = "its creator was deleted"
+ # Both lookups use the organisation the request resolved, which
+ # has_access_to_deployment has already matched to this key's.
+ elif not OrganizationMember.objects.filter(user=creator).exists():
+ reason = "its creator left the organization"
+ elif not deployments_keyable_by(creator).filter(pk=api_deployment.pk).exists():
+ reason = "its creator does not own the deployment"
+ else:
+ return True
+ logger.warning(
+ "Global API key %s refused for deployment %s: %s (creator %s).",
+ self.id,
+ api_deployment.id,
+ reason,
+ self.created_by_id,
+ )
+ return False
diff --git a/backend/global_api_deployment_key/permissions.py b/backend/global_api_deployment_key/permissions.py
index 5af1675ba..63dd8de8d 100644
--- a/backend/global_api_deployment_key/permissions.py
+++ b/backend/global_api_deployment_key/permissions.py
@@ -1,3 +1,4 @@
+from platform_api.permissions import CanManageApiKeys
from platform_api.permissions import IsOrganizationAdmin as PlatformIsOrganizationAdmin
@@ -5,4 +6,4 @@ class IsOrganizationAdmin(PlatformIsOrganizationAdmin):
message = "Only organization admins can manage global API deployment keys."
-__all__ = ["IsOrganizationAdmin"]
+__all__ = ["CanManageApiKeys", "IsOrganizationAdmin"]
diff --git a/backend/global_api_deployment_key/serializers.py b/backend/global_api_deployment_key/serializers.py
index 0f22f83f7..a28529bf6 100644
--- a/backend/global_api_deployment_key/serializers.py
+++ b/backend/global_api_deployment_key/serializers.py
@@ -38,11 +38,13 @@ class GlobalApiDeploymentKeyListSerializer(serializers.ModelSerializer):
"key",
"is_active",
"allow_all_deployments",
+ "created_by_member",
"api_deployments",
"created_at",
"modified_at",
"created_by_email",
]
+ read_only_fields = ["created_by_member"]
def get_key(self, obj):
key_str = str(obj.key)
@@ -56,7 +58,9 @@ class GlobalApiDeploymentKeyDetailSerializer(serializers.ModelSerializer):
"""Exposes the full plaintext key.
Used by the create/rotate responses and by ``retrieve`` (GET keys/<pk>/),
- so the full key stays retrievable by an org admin for the key's lifetime —
+ so the full key stays retrievable for the key's lifetime by an org admin
+ (and by the member who created it, as a member, while members may manage
+ keys and they still own its deployments) —
consistent with the platform_api key flow (not a one-time reveal).
"""
@@ -189,7 +193,14 @@ class GlobalApiDeploymentKeyUpdateSerializer(_GlobalApiDeploymentKeyWriteSeriali
def update(self, instance, validated_data):
api_deployments = validated_data.pop("api_deployments", None)
- instance = super().update(instance, validated_data)
+ request = self.context.get("request")
+ if request:
+ validated_data["modified_by"] = request.user
+ for field, value in validated_data.items():
+ setattr(instance, field, value)
+ # Only the fields this edit sets: a whole-row save would write back a
+ # key value rotated while the edit was in flight.
+ instance.save(update_fields=list(validated_data))
if api_deployments is not None:
instance.api_deployments.set(api_deployments)
return instance
diff --git a/backend/global_api_deployment_key/tests/test_global_key_auth.py b/backend/global_api_deployment_key/tests/test_global_key_auth.py
index cf17a5cab..e61aecc56 100644
--- a/backend/global_api_deployment_key/tests/test_global_key_auth.py
+++ b/backend/global_api_deployment_key/tests/test_global_key_auth.py
@@ -232,8 +232,9 @@ class TestValidateApiFallbackOrdering:
class TestGlobalKeyLlmProfileScoping:
"""``llm_profile_id`` must stay org-scoped when a global key is used.
- The per-user ownership check that guards deployment-specific keys cannot
- apply to an org-level key, so the organization comparison in
+ The per-user ownership check that guards deployment-specific keys does
+ not apply to an admin-created (org-level) key, so the organization
+ comparison in
``ExecutionRequestSerializer.validate_llm_profile_id`` is what stops a
caller referencing another org's profile by UUID.
"""
@@ -245,7 +246,7 @@ class TestGlobalKeyLlmProfileScoping:
context={
"api": _deployment(organization_id),
"api_key": WELL_FORMED_UUID,
- "is_global_key": True,
+ "global_key": mock.MagicMock(created_by_member=False),
}
)
@@ -288,6 +289,59 @@ class TestGlobalKeyLlmProfileScoping:
serializer.validate_llm_profile_id(self.PROFILE_ID)
+class TestMemberGlobalKeyLlmProfileOwnership:
+ """A global key a member created carries only that member's rights
+ (UN-4399): like a deployment's own key, it may only use profiles its
+ creator owns. An admin-created key stays org-level.
+ """
+
+ PROFILE_ID = "b7c2f1de-0000-4000-8000-000000000003"
+ CREATOR, OTHER = 11, 12
+
+ def _validate(self, created_by_member: bool, profile_owner: int):
+ key = mock.MagicMock(created_by_member=created_by_member, created_by_id=self.CREATOR)
+ serializer = ExecutionRequestSerializer(
+ context={
+ "api": _deployment(ORG_A),
+ "api_key": WELL_FORMED_UUID,
+ "global_key": key,
+ }
+ )
+ profile = mock.MagicMock(prompt_studio_tool_id="tool-id", created_by_id=profile_owner)
+ profile.prompt_studio_tool.organization_id = ORG_A
+ with mock.patch.object(ProfileManager, "objects") as objects:
+ objects.get.return_value = profile
+ return serializer.validate_llm_profile_id(self.PROFILE_ID)
+
+ def test_a_member_key_uses_its_creators_profile(self) -> None:
+ assert self._validate(True, self.CREATOR) == self.PROFILE_ID
+
+ def test_a_member_key_cannot_use_another_users_profile(self) -> None:
+ with pytest.raises(DRFValidationError, match="profiles that you own"):
+ self._validate(True, self.OTHER)
+
+ def test_an_admin_key_stays_org_level(self) -> None:
+ assert self._validate(False, self.OTHER) == self.PROFILE_ID
+
+ def test_marking_a_request_global_without_the_key_grants_nothing(self) -> None:
+ # The org-level branch is chosen from the key itself, so a bare flag
+ # falls through to the deployment-key lookup.
+ api = mock.MagicMock(organization_id=ORG_A)
+ # No deployment key matches: the bare flag earns no org-level access.
+ api_key_model = APIDeployment.api_keys.rel.related_model
+ api.api_keys.model = api_key_model
+ api.api_keys.get.side_effect = api_key_model.DoesNotExist
+ serializer = ExecutionRequestSerializer(
+ context={"api": api, "api_key": WELL_FORMED_UUID, "is_global_key": True}
+ )
+ profile = mock.MagicMock(prompt_studio_tool_id="tool-id", created_by_id=self.OTHER)
+ profile.prompt_studio_tool.organization_id = ORG_A
+ with mock.patch.object(ProfileManager, "objects") as objects:
+ objects.get.return_value = profile
+ with pytest.raises(DRFValidationError, match="API key not found"):
+ serializer.validate_llm_profile_id(self.PROFILE_ID)
+
+
class TestUpdateSerializerScopeValidation:
"""PATCH must not trap callers into an unrepresentable scope.
diff --git a/backend/global_api_deployment_key/views.py b/backend/global_api_deployment_key/views.py
index d164cd382..f5bd9b8ff 100644
--- a/backend/global_api_deployment_key/views.py
+++ b/backend/global_api_deployment_key/views.py
@@ -1,6 +1,8 @@
import uuid
from api_v2.models import APIDeployment
+from django.db.models import Prefetch
+from platform_api.permissions import is_org_admin_session
from platform_audit.actions import Action, TargetType
from platform_audit.recorder import (
best_effort,
@@ -9,12 +11,16 @@ from platform_audit.recorder import (
)
from rest_framework import status, viewsets
from rest_framework.decorators import action
+from rest_framework.exceptions import PermissionDenied, ValidationError
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from utils.user_context import UserContext
-from global_api_deployment_key.models import GlobalApiDeploymentKey
-from global_api_deployment_key.permissions import IsOrganizationAdmin
+from global_api_deployment_key.models import (
+ GlobalApiDeploymentKey,
+ deployments_keyable_by,
+)
+from global_api_deployment_key.permissions import CanManageApiKeys, IsOrganizationAdmin
from global_api_deployment_key.serializers import (
ApiDeploymentMinimalSerializer,
GlobalApiDeploymentKeyCreateSerializer,
@@ -27,17 +33,70 @@ from global_api_deployment_key.serializers import (
class GlobalApiDeploymentKeyViewSet(viewsets.ModelViewSet):
permission_classes = [IsAuthenticated, IsOrganizationAdmin]
+ def get_permissions(self):
+ # Members the org lets manage keys may list, create, view and rotate,
+ # and pick deployments (UN-4399); editing and deleting stay admin-only.
+ if self.action in ("list", "create", "retrieve", "rotate", "deployments"):
+ return [IsAuthenticated(), CanManageApiKeys()]
+ return super().get_permissions()
+
+ def _is_admin(self) -> bool:
+ return is_org_admin_session(self.request, self)
+
+ def _limit_member(self, allow_all: bool, deployment_ids) -> None:
+ """A member only keys deployments they own (``deployments_keyable_by``),
+ never every deployment. Viewing or rotating
+ a key (both reveal the secret) is held to the same rule.
+ """
+ if self._is_admin():
+ return
+ if allow_all:
+ raise PermissionDenied(
+ "Only organisation admins can use keys for all deployments."
+ )
+ accessible = set(
+ deployments_keyable_by(self.request.user).values_list("pk", flat=True)
+ )
+ if not set(deployment_ids) <= accessible:
+ raise PermissionDenied("Members can only use keys for deployments they own.")
+
+ def _limit_member_to_key(self, instance: GlobalApiDeploymentKey) -> None:
+ # Only keys they created as a member: another user's key would hand
+ # them its secret (retrieve) or break their integration (rotate), and a
+ # key they created while an admin is org-level, not bound to them.
+ if not self._is_admin() and (
+ instance.created_by_id != self.request.user.id
+ or not instance.created_by_member
+ ):
+ raise PermissionDenied(
+ "Members can only view or rotate keys they created as a member."
+ )
+ self._limit_member(
+ instance.allow_all_deployments,
+ instance.api_deployments.values_list("pk", flat=True),
+ )
+
def get_queryset(self):
# ``created_by`` is select_related because the list serializer reads
# ``created_by.email`` per row; without it the unpaginated list costs
# one extra query per key.
- return (
- GlobalApiDeploymentKey.objects.filter(
- organization=UserContext.get_organization(),
+ keys = GlobalApiDeploymentKey.objects.filter(
+ organization=UserContext.get_organization(),
+ ).select_related("created_by")
+ if self.action == "list" and not self._is_admin():
+ # A member's list shows their own keys only: other keys name
+ # deployments the member may not be able to see. Within those, only
+ # the deployments they still own, so one they lost stops showing
+ # its live name and status.
+ return keys.filter(
+ created_by=self.request.user, created_by_member=True
+ ).prefetch_related(
+ Prefetch(
+ "api_deployments",
+ queryset=deployments_keyable_by(self.request.user),
+ )
)
- .select_related("created_by")
- .prefetch_related("api_deployments")
- )
+ return keys.prefetch_related("api_deployments")
def get_serializer_class(self):
# create/retrieve/partial_update/rotate are overridden and instantiate
@@ -50,7 +109,11 @@ class GlobalApiDeploymentKeyViewSet(viewsets.ModelViewSet):
data=request.data, context={"request": request}
)
serializer.is_valid(raise_exception=True)
- instance = serializer.save()
+ self._limit_member(
+ serializer.validated_data.get("allow_all_deployments", False),
+ [d.pk for d in serializer.validated_data.get("api_deployments") or []],
+ )
+ instance = serializer.save(created_by_member=not self._is_admin())
_record_key_event(
request,
Action.KEY_CREATED,
@@ -63,6 +126,7 @@ class GlobalApiDeploymentKeyViewSet(viewsets.ModelViewSet):
def retrieve(self, request, *args, **kwargs):
instance = self.get_object()
+ self._limit_member_to_key(instance)
serializer = GlobalApiDeploymentKeyDetailSerializer(instance)
return Response(serializer.data)
@@ -73,6 +137,8 @@ class GlobalApiDeploymentKeyViewSet(viewsets.ModelViewSet):
instance, data=request.data, partial=True, context={"request": request}
)
serializer.is_valid(raise_exception=True)
+ if instance.created_by_member:
+ _limit_to_creator(instance, serializer.validated_data)
updated_instance = serializer.save()
_record_key_update(request, updated_instance, before)
response_serializer = GlobalApiDeploymentKeyListSerializer(updated_instance)
@@ -80,6 +146,7 @@ class GlobalApiDeploymentKeyViewSet(viewsets.ModelViewSet):
def rotate(self, request, *args, **kwargs):
instance = self.get_object()
+ self._limit_member_to_key(instance)
instance.key = uuid.uuid4()
instance.modified_by = request.user
instance.save(update_fields=["key", "modified_by", "modified_at"])
@@ -96,9 +163,13 @@ class GlobalApiDeploymentKeyViewSet(viewsets.ModelViewSet):
@action(detail=False, methods=["get"])
def deployments(self, request):
- """List all API deployments in the org for admins to assign to keys."""
+ """API deployments the caller may assign to keys: all of the org's for
+ admins, the ones they own for members.
+ """
organization = UserContext.get_organization()
deployments = APIDeployment.objects.filter(organization=organization)
+ if not self._is_admin():
+ deployments = deployments_keyable_by(request.user)
serializer = ApiDeploymentMinimalSerializer(deployments, many=True)
return Response(serializer.data)
@@ -116,6 +187,31 @@ def _key_fields(key: GlobalApiDeploymentKey) -> dict:
}
+def _limit_to_creator(key: GlobalApiDeploymentKey, validated: dict) -> None:
+ """An edit may never open a member-created key to all deployments (a new
+ key does that), nor add a deployment its creator may not key
+ (``deployments_keyable_by``), outside which the key never works.
+ """
+ message = (
+ "This key was created by a member and only works for deployments they "
+ "own. Create a new key instead."
+ )
+ if validated.get("allow_all_deployments"):
+ raise ValidationError({"allow_all_deployments": message})
+ if "api_deployments" not in validated:
+ return
+ # Only additions: the edit form resends the current list, which may name
+ # deployments the creator has since lost (the key just stops working there).
+ added = {d.pk for d in validated["api_deployments"]} - set(
+ key.api_deployments.values_list("pk", flat=True)
+ )
+ if not added:
+ return
+ accessible = set(deployments_keyable_by(key.created_by).values_list("pk", flat=True))
+ if not added <= accessible:
+ raise ValidationError({"api_deployments": message})
+
+
def _record_key_event(request, action: Action, key_id, key_name: str, **kwargs) -> None:
record_platform_event(
action=action,
diff --git a/backend/notification_v2/views.py b/backend/notification_v2/views.py
index 42f60b4d4..ac5806158 100644
--- a/backend/notification_v2/views.py
+++ b/backend/notification_v2/views.py
@@ -15,7 +15,7 @@ from platform_audit.recorder import (
record_platform_event,
)
from rest_framework import status, viewsets
-from rest_framework.permissions import IsAuthenticated
+from rest_framework.permissions import BasePermission, IsAuthenticated
from rest_framework.request import Request
from rest_framework.response import Response
from rest_framework.views import APIView
@@ -59,6 +59,19 @@ class NotificationViewSet(viewsets.ModelViewSet):
return queryset
+class CanChangePlatformDefaults(BasePermission):
+ message = "Change platform defaults is restricted to organisation admins."
+
+ def has_permission(self, request, view):
+ from tenant_account_v2.capabilities import Capability, opened_to_members
+
+ return IsOrganizationAdmin().has_permission(request, view) or opened_to_members(
+ request.user,
+ UserContext.get_organization(),
+ Capability.CHANGE_PLATFORM_DEFAULTS,
+ )
+
+
class NotificationSettingsView(APIView):
"""Org-scoped notification batching settings — currently just the club interval.
@@ -70,7 +83,10 @@ class NotificationSettingsView(APIView):
flush_after.
"""
- permission_classes = [IsAuthenticated, IsOrganizationAdmin]
+ # Admins, or members when the org lets members change platform defaults
+ # (UN-4399). Platform defaults are otherwise per-user; this is the only
+ # organisation-level setting the capability governs.
+ permission_classes = [IsAuthenticated, CanChangePlatformDefaults]
def get(self, request: Request) -> Response:
organization = UserContext.get_organization()
diff --git a/backend/platform_api/permissions.py b/backend/platform_api/permissions.py
index 32d6de2f3..c9dc320fc 100644
--- a/backend/platform_api/permissions.py
+++ b/backend/platform_api/permissions.py
@@ -25,6 +25,42 @@ class IsOrganizationAdmin(BasePermission):
return False
+def is_org_admin_session(request, view=None) -> bool:
+ return IsOrganizationAdmin().has_permission(request, view)
+
+
+def member_may_manage_keys(request) -> bool:
+ """A non-admin the org's ``manage_api_keys`` setting admits (UN-4399).
+
+ Only global deployment keys use this. Platform API keys stay admin-only
+ whatever the setting: each acts as a service account that bypasses
+ per-resource sharing and ownership, so a member holding one would reach
+ every resource in the organisation.
+ """
+ from tenant_account_v2.capabilities import Capability, opened_to_members
+ from utils.user_context import UserContext
+
+ return opened_to_members(
+ request.user, UserContext.get_organization(), Capability.MANAGE_API_KEYS
+ )
+
+
+class CanManageApiKeys(BasePermission):
+ """Admins, or members when the org lets members manage API keys.
+
+ For the global deployment key actions members may use (list, create,
+ retrieve, rotate, deployments); the view narrows what a member may do to a given key.
+ Editing and deleting keys stay ``IsOrganizationAdmin``.
+ """
+
+ message = "Manage API keys is restricted to organisation admins."
+
+ def has_permission(self, request, view):
+ if not request.user or not request.user.is_authenticated:
+ return False
+ return is_org_admin_session(request, view) or member_may_manage_keys(request)
+
+
class CanRotatePlatformApiKey(BasePermission):
"""Permission for the ``rotate`` action (UN-3586).
diff --git a/backend/tenant_account_v2/CAPABILITIES.md b/backend/tenant_account_v2/CAPABILITIES.md
index ddc464a7b..e47d6c3f8 100644
--- a/backend/tenant_account_v2/CAPABILITIES.md
+++ b/backend/tenant_account_v2/CAPABILITIES.md
@@ -38,24 +38,24 @@ Always all seven, in this order:
| `create_llm_adapters` | `any_member` | creating an LLM adapter |
| `create_connectors` | `any_member` | creating a connector |
| `create_other_adapters` | `any_member` | creating any non-LLM adapter (embedding, vector DB, text extractor, OCR) |
-| `manage_api_keys` | `admins_only` | creating and rotating platform keys and global deployment keys (not per-deployment keys, which their owners manage) — **not yet enforced, see below** |
-| `manage_members` | `admins_only` | inviting members and changing roles — **not yet enforced** |
-| `change_platform_defaults` | `admins_only` | organisation-wide platform settings — **not yet enforced** |
+| `manage_api_keys` | `admins_only` | creating, viewing and rotating global deployment keys (platform API keys stay admin-only; per-deployment keys are their owners'); see below |
+| `manage_members` | `admins_only` | inviting members with the user role; see below |
+| `change_platform_defaults` | `admins_only` | the organisation's notification settings (`notifications/settings/`); other defaults are per-user |
| `delete_workflows_and_deployments` | `any_member` | deleting a workflow, API deployment or pipeline |
`allowed_for_me` means *the setting does not block you* — nothing more. It is
always true for admins and for service accounts (platform API keys), which no
capability setting governs. The endpoint's own rules still apply on top and
can refuse a caller this reports as allowed: deleting needs the caller to own
-(or co-own) the resource; the key, member and settings endpoints keep their
-existing admin and key-permission checks (for example, a `full_access`
-platform key can rotate keys, a lower-tier key cannot). With `admins_only`,
-owners who are not admins are refused.
+(or co-own) the resource. For the key, member and settings endpoints, see
+*What `any_member` allows* below. With `admins_only`, owners who are not
+admins are refused.
-`configurable` says whether PATCH accepts `any_member` for that capability. It
-is false for the three marked *not yet enforced* above: setting them to
-`any_member` answers 400 "Not configurable yet". A settings UI can lock those
-rows from it instead of hard-coding the keys.
+`configurable` says whether PATCH accepts `any_member` for that capability.
+Every capability is configurable now; a capability added later before its
+endpoints are ready reports false, and setting it to `any_member` answers 400
+"Not configurable yet". A settings UI can lock those rows from it instead of
+hard-coding the keys.
Only creation is governed for adapters. Changing an existing adapter's type
counts as creating one of the new type, and that check runs before the request
@@ -78,15 +78,56 @@ standard envelope (`{type, errors[{code, detail, attr}]}`):
| Status | When |
|---|---|
-| 400 | unknown key (`attr` = the key), bad value, empty body, or `any_member` for a capability that is not enforced yet |
+| 400 | unknown key (`attr` = the key), bad value or empty body |
| 403 | not an organisation admin, or a service account |
| 404 | no organisation in the request context (GET too) |
-`manage_api_keys`, `manage_members` and `change_platform_defaults` accept only
-`admins_only` until their enforcement lands (PR-2 of UN-4399, which waits on
-the product decision about what "any member" may do there). Their endpoints
-are admin-only today, so storing `any_member` would promise members something
-nothing grants.
+### What `any_member` allows for the three admin-only areas
+
+Their endpoints were admin-only. `any_member` lets members in with limits
+that keep a member from gaining more than they have; service accounts stay
+refused, as before.
+
+- **`manage_members`**: a member may invite with the user role. They may also
+ grant another non-admin member a role the auth plugin lets members hand
+ out; with the built-in roles that is only the user role, which every
+ non-admin already has, so in practice members change no one's role.
+ Removing roles, granting or revoking admin, changing an admin's role,
+ changing their own role, and removing members stay admin-only. A plugin
+ without `is_member_invite_role` refuses every member invite, and one
+ without `is_member_assignable_role` every member role grant, so
+ `allowed_for_me` can be true while those requests are refused.
+- **`manage_api_keys`**: a member may list the global deployment keys they
+ created as a member (masked) and create one only for deployments they own (as creator
+ or co-owner, the rule for a deployment's own keys), never one for all
+ deployments. They may view or rotate only keys they created, under the
+ same rule, since both return the secret, and never a key they created
+ while an admin (that key is org-level, not bound to them). A key a member
+ created may only use LLM profiles its creator owns, like a deployment's own
+ key, even after the creator becomes an admin. A key a member created
+ (`created_by_member` in the list) stops working once they leave the
+ organisation, and for each deployment it names once they stop owning it
+ (unless they have since become an org admin). They then cannot rotate it
+ either; an admin can deactivate it.
+ Setting `manage_api_keys` back to `admins_only` does not disable such keys;
+ an admin can deactivate them. An admin cannot add a deployment its creator
+ does not own to such a key, or open it to all deployments (400); a new key
+ does that. Editing and deleting keys stay admin-only.
+ **Platform API keys stay admin-only whatever the setting**:
+ each acts as a service account that bypasses per-resource sharing and
+ ownership, so a member holding one would reach every resource in the
+ organisation. The legacy Settings > Platform keys stay admin-only too.
+- **`change_platform_defaults`**: read and change the organisation's
+ notification settings. Adapter defaults are per-user and not governed.
+
+`organization/settings` stays admin-only, and so does changing
+`organization/capabilities`: changing a capability is never itself a
+capability.
+
+This repo's bundled frontend still shows the members, invite and global key
+pages to admins only; with `any_member`, members reach member management and
+global keys through the API until a frontend reads `allowed_for_me`. The
+notification settings already show to members.
## Refusals
@@ -135,5 +176,7 @@ type CapabilitiesPatchRequest = Partial<Record<CapabilityKey, CapabilitySetting>
`tenant_account_v2.capabilities.enforce_capability(request, Capability.X)`
raises the refusal; `RequiresCapability(Capability.X)` is the DRF permission
-form. Neither applies to service accounts. Set the spec's `enforced=True` in the same
+form. Neither applies to service accounts. An endpoint that was admin-only
+opens to members instead through `opened_to_members`, checked alongside its
+admin check; unlike the two above, it refuses service accounts. Set the spec's `enforced=True` in the same
change that adds the enforcement.
diff --git a/backend/tenant_account_v2/capabilities.py b/backend/tenant_account_v2/capabilities.py
index a86d7f086..2b19b9ddf 100644
--- a/backend/tenant_account_v2/capabilities.py
+++ b/backend/tenant_account_v2/capabilities.py
@@ -7,8 +7,11 @@ the first two capabilities, so ``organization/settings`` and
``organization/capabilities/`` stay in step by construction.
Service accounts (platform API keys) are never subject to a capability
-setting. That is all a capability decides: each endpoint's own rules (admin
-checks, key permission levels, ownership) still apply on top, unchanged.
+setting. For the three creation capabilities and resource deletion, the
+setting only narrows: each endpoint's own rules (ownership, key permission levels)
+still apply on top. The three formerly admin-only areas (members, API keys,
+platform defaults) are the exception: ``opened_to_members`` admits members to
+them, with the limits each endpoint sets; see CAPABILITIES.md.
"""
from dataclasses import dataclass
@@ -98,24 +101,25 @@ SPECS: tuple[CapabilitySpec, ...] = (
CapabilitySpec(
Capability.MANAGE_API_KEYS,
"Manage API keys",
- "Create and rotate platform keys and global deployment keys "
- "(not per-deployment keys, which their owners manage).",
+ "Create global deployment keys for deployments they own, and "
+ "view or rotate the keys they created. Platform API keys stay "
+ "admin-only.",
"restrict_api_key_management",
- enforced=False,
+ enforced=True,
),
CapabilitySpec(
Capability.MANAGE_MEMBERS,
"Manage members",
- "Invite members and change their roles.",
+ "Invite members with the user role.",
"restrict_member_management",
- enforced=False,
+ enforced=True,
),
CapabilitySpec(
Capability.CHANGE_PLATFORM_DEFAULTS,
"Change platform defaults",
- "Change organisation-wide platform settings.",
+ "Change the organisation's notification settings.",
"restrict_platform_defaults",
- enforced=False,
+ enforced=True,
),
CapabilitySpec(
Capability.DELETE_WORKFLOWS_AND_DEPLOYMENTS,
@@ -149,6 +153,21 @@ def is_allowed(user: Any, organization: Organization | None, key: Capability) ->
return OrganizationMemberService.is_user_organization_admin(user)
+def opened_to_members(
+ user: Any, organization: Organization | None, key: Capability
+) -> bool:
+ """Whether ``key`` admits ``user`` though they are not an admin.
+
+ For the capabilities whose endpoints were admin-only (API keys, members,
+ platform defaults): the caller's admin check stays, and this is the only
+ way past it. Service accounts never qualify; those endpoints refused them
+ before and still do.
+ """
+ if getattr(user, "is_service_account", False) or organization is None:
+ return False
+ return setting_of(organization, SPECS_BY_KEY[key]) == CapabilitySetting.ANY_MEMBER
+
+
def enforce_capability(request: Any, key: Capability) -> None:
"""Raise ``PermissionDenied`` when the org restricts ``key`` to admins and
the caller is not one.
diff --git a/backend/tenant_account_v2/test_capabilities.py b/backend/tenant_account_v2/test_capabilities.py
index 16fc9d86f..40e906aa4 100644
--- a/backend/tenant_account_v2/test_capabilities.py
+++ b/backend/tenant_account_v2/test_capabilities.py
@@ -9,17 +9,30 @@ import re
from types import SimpleNamespace
from unittest.mock import patch
+from account_v2.authentication_controller import AuthenticationController
+from account_v2.custom_exceptions import Forbidden
from account_v2.models import Organization
from adapter_processor_v2.models import AdapterInstance
from adapter_processor_v2.views import AdapterInstanceViewSet
from api_v2.api_deployment_views import APIDeploymentViewSet
+from api_v2.exceptions import UnauthorizedKey
+from api_v2.key_helper import KeyHelper
+from api_v2.models import APIDeployment
from connector_v2.models import ConnectorInstance
from connector_v2.views import ConnectorInstanceViewSet
from django.test import SimpleTestCase
from drf_spectacular.generators import SchemaGenerator
+from global_api_deployment_key.models import GlobalApiDeploymentKey
+from global_api_deployment_key.serializers import (
+ GlobalApiDeploymentKeyUpdateSerializer,
+)
+from global_api_deployment_key.views import GlobalApiDeploymentKeyViewSet
+from notification_v2.views import NotificationSettingsView
from permissions.permission import IsOwner
from permissions.roles import ResourceRole
from pipeline_v2.views import PipelineViewSet
+from platform_api.models import ApiKeyPermission, PlatformApiKey
+from platform_api.views import PlatformApiKeyViewSet
from platform_audit.tests.base import AuditTestBase, make_user
from rest_framework.exceptions import PermissionDenied
from workflow_manager.workflow_v2.models.workflow import Workflow
@@ -31,9 +44,18 @@ from tenant_account_v2.capabilities import (
Capability,
CapabilitySetting,
)
+from tenant_account_v2.models import OrganizationMember
+from tenant_account_v2.users_view import OrganizationUserViewSet
from tenant_account_v2.views import organization_capabilities, organization_settings
-ENFORCED = [spec for spec in SPECS if spec.enforced]
+# Endpoints open to members before UN-4399; service accounts pass them.
+MEMBER_OPEN = (
+ Capability.CREATE_LLM_ADAPTERS,
+ Capability.CREATE_CONNECTORS,
+ Capability.CREATE_OTHER_ADAPTERS,
+ Capability.DELETE_WORKFLOWS_AND_DEPLOYMENTS,
+)
+ENFORCED = [spec for spec in SPECS if spec.key in MEMBER_OPEN]
class CapabilityRegistryTests(SimpleTestCase):
@@ -105,6 +127,10 @@ class CapabilityTestBase(AuditTestBase):
def setUp(self) -> None:
super().setUp()
self.service_account = make_user("[email protected]", is_service_account=True)
+ # As platform_api.services gives every platform key's service account.
+ OrganizationMember.objects.create(
+ organization=self.org, user=self.service_account, role="user"
+ )
def restrict(self, key: Capability, restricted: bool) -> None:
spec = next(s for s in SPECS if s.key == key)
@@ -137,7 +163,7 @@ class CapabilitiesApiTests(CapabilityTestBase):
self.assertEqual(rows["create_connectors"]["label"], "Create connectors")
self.assertEqual(
{k for k, r in rows.items() if not r["configurable"]},
- {"manage_api_keys", "manage_members", "change_platform_defaults"},
+ set(),
)
def test_admins_are_always_allowed(self) -> None:
@@ -206,7 +232,6 @@ class CapabilitiesApiTests(CapabilityTestBase):
for body, attr in (
({"create_connectors": "admins_only", "nope": "admins_only"}, "nope"),
({"create_connectors": "admins_only", "create_llm_adapters": "x"}, None),
- ({"manage_members": "any_member", "create_connectors": "admins_only"}, None),
({}, None),
):
with self.subTest(body=str(body)):
@@ -215,23 +240,14 @@ class CapabilitiesApiTests(CapabilityTestBase):
self.org.refresh_from_db()
self.assertFalse(self.org.restrict_connector_creation)
- def test_unenforced_capabilities_accept_only_admins_only(self) -> None:
+ def test_every_capability_accepts_both_settings(self) -> None:
for spec in SPECS:
- if spec.enforced:
- continue
- with self.subTest(key=spec.key.value):
- ok = self.call(
- organization_capabilities,
- "patch",
- data={spec.key.value: "admins_only"},
- )
- self.assertEqual(ok.status_code, 200)
- refused = self.call(
- organization_capabilities,
- "patch",
- data={spec.key.value: "any_member"},
- )
- self.assertEqual(refused.status_code, 400)
+ for setting in ("any_member", "admins_only"):
+ with self.subTest(key=spec.key.value, setting=setting):
+ response = self.call(
+ organization_capabilities, "patch", data={spec.key.value: setting}
+ )
+ self.assertEqual(response.status_code, 200, response.data)
def test_legacy_settings_and_capabilities_stay_in_step(self) -> None:
self.call(
@@ -526,3 +542,703 @@ class EnforcementMatrixTests(CapabilityTestBase):
):
for permission in view.get_permissions():
permission.has_permission(request, view)
+
+
+class AdminOnlyEndpointsMatrixTests(CapabilityTestBase):
+ """API keys, members and platform defaults: endpoints that were admin-only.
+ 'Any member' opens them to members; service accounts stay refused.
+ """
+
+ def setUp(self) -> None:
+ super().setUp()
+ self.colleague = make_user("[email protected]")
+ OrganizationMember.objects.create(
+ organization=self.org, user=self.colleague, role="user"
+ )
+ workflow = Workflow.objects.create(
+ workflow_name="wf", organization=self.org, created_by=self.member
+ )
+ self.deployment = APIDeployment.objects.create(
+ api_name="api",
+ workflow=workflow,
+ organization=self.org,
+ created_by=self.member,
+ )
+ self.deployment.grant_owner(self.member)
+
+ def _allowed(self, key: Capability, user) -> bool:
+ if key == Capability.MANAGE_API_KEYS:
+ view = GlobalApiDeploymentKeyViewSet.as_view({"post": "create"})
+ data = {
+ "name": f"k-{user.pk}-{GlobalApiDeploymentKey.objects.count()}",
+ "description": "ci",
+ "allow_all_deployments": False,
+ "api_deployments": [str(self.deployment.pk)],
+ }
+ response = self.call(view, "post", user=user, data=data)
+ ok_status = 201
+ elif key == Capability.MANAGE_MEMBERS:
+ view = OrganizationUserViewSet.as_view(
+ {"post": "assign_organization_role_to_user"}
+ )
+ response = self.call(
+ view,
+ "post",
+ user=user,
+ data={"email": "[email protected]", "role": "user"},
+ )
+ ok_status = 200
+ else:
+ view = NotificationSettingsView.as_view()
+ response = self.call(
+ view, "patch", user=user, data={"club_interval_seconds": 600}
+ )
+ ok_status = 200
+ if response.status_code == 403:
+ return False
+ self.assertEqual(response.status_code, ok_status, getattr(response, "data", None))
+ return True
+
+ def test_matrix(self) -> None:
+ for key in (
+ Capability.MANAGE_API_KEYS,
+ Capability.MANAGE_MEMBERS,
+ Capability.CHANGE_PLATFORM_DEFAULTS,
+ ):
+ for restricted in (True, False):
+ self.restrict(key, restricted)
+ for name, user, expected in (
+ ("admin", self.admin, True),
+ ("member", self.member, not restricted),
+ ("service account", self.service_account, False),
+ ):
+ with self.subTest(key=key.value, restricted=restricted, user=name):
+ self.assertEqual(self._allowed(key, user), expected)
+
+
+class MemberManagementGuardrailTests(CapabilityTestBase):
+ """With 'Any member', a member manages non-admin members only."""
+
+ def setUp(self) -> None:
+ super().setUp()
+ self.restrict(Capability.MANAGE_MEMBERS, False)
+ self.colleague = make_user("[email protected]")
+ OrganizationMember.objects.create(
+ organization=self.org, user=self.colleague, role="user"
+ )
+ self.assign = OrganizationUserViewSet.as_view(
+ {"post": "assign_organization_role_to_user"}
+ )
+
+ def _assign(self, email: str, role: str):
+ return self.call(
+ self.assign, "post", user=self.member, data={"email": email, "role": role}
+ )
+
+ def test_a_member_cannot_grant_admin(self) -> None:
+ response = self._assign("[email protected]", "admin")
+ self.assertEqual(response.status_code, 403)
+ self.assertEqual(OrganizationMember.objects.get(user=self.colleague).role, "user")
+
+ def test_a_member_cannot_change_their_own_role(self) -> None:
+ self.assertEqual(self._assign("[email protected]", "user").status_code, 403)
+
+ def test_a_member_cannot_change_an_admins_role(self) -> None:
+ # A second admin, so the last-admin guard is not what refuses it.
+ second = make_user("[email protected]")
+ OrganizationMember.objects.create(
+ organization=self.org, user=second, role="admin"
+ )
+ self.assertEqual(self._assign(second.email, "user").status_code, 403)
+ self.assertEqual(OrganizationMember.objects.get(user=second).role, "admin")
+
+ def test_a_member_cannot_revoke_admin(self) -> None:
+ # A second admin, so the last-admin guard is not what refuses it.
+ second = make_user("[email protected]")
+ OrganizationMember.objects.create(
+ organization=self.org, user=second, role="admin"
+ )
+ view = OrganizationUserViewSet.as_view(
+ {"delete": "remove_organization_role_from_user"}
+ )
+ response = self.call(
+ view,
+ "delete",
+ user=self.member,
+ data={"email": second.email, "role": "admin"},
+ )
+ self.assertEqual(response.status_code, 403)
+ self.assertEqual(OrganizationMember.objects.get(user=second).role, "admin")
+
+ def test_a_member_cannot_remove_a_role(self) -> None:
+ # Removing someone's only role removes them, which stays admin-only.
+ view = OrganizationUserViewSet.as_view(
+ {"delete": "remove_organization_role_from_user"}
+ )
+ response = self.call(
+ view,
+ "delete",
+ user=self.member,
+ data={"email": "[email protected]", "role": "user"},
+ )
+ self.assertEqual(response.status_code, 403)
+ self.assertEqual(
+ str(response.data["errors"][0]["detail"]),
+ "Only admins can remove a member's role.",
+ )
+
+ def test_admins_invite_and_change_any_role_under_both_settings(self) -> None:
+ controller = AuthenticationController()
+ admin = OrganizationMember.objects.get(user=self.admin)
+ target = OrganizationMember.objects.get(user=self.colleague)
+ for restricted in (True, False):
+ self.restrict(Capability.MANAGE_MEMBERS, restricted)
+ with self.subTest(restricted=restricted):
+ controller.authorize_invite(admin, ["admin", "user", None])
+ controller.authorize_role_change(admin, target, "admin")
+ controller.authorize_role_change(admin, target, "user", removing=True)
+
+ def test_admins_only_refuses_members_removing_roles(self) -> None:
+ self.restrict(Capability.MANAGE_MEMBERS, True)
+ view = OrganizationUserViewSet.as_view(
+ {"delete": "remove_organization_role_from_user"}
+ )
+ response = self.call(
+ view,
+ "delete",
+ user=self.member,
+ data={"email": "[email protected]", "role": "user"},
+ )
+ self.assertEqual(response.status_code, 403)
+
+ def test_the_invite_endpoint_checks_before_inviting(self) -> None:
+ controller = AuthenticationController()
+ with patch.object(controller.auth_service, "invite_user") as invite:
+ with self.assertRaises(Forbidden):
+ controller.invite_user(
+ admin=self.member,
+ org_id=self.org.organization_id,
+ user_list=[{"email": "[email protected]", "role": "admin"}],
+ request=None,
+ )
+ invite.assert_not_called()
+
+ def test_a_member_invites_with_the_user_role_only(self) -> None:
+ controller = AuthenticationController()
+ actor = OrganizationMember.objects.get(user=self.member)
+ controller.authorize_invite(actor, ["user", None])
+ with self.assertRaises(Forbidden):
+ controller.authorize_invite(actor, ["user", "admin"])
+
+ def test_a_plugin_that_names_no_member_roles_refuses_members(self) -> None:
+ # A plugin that does not define the member-role hooks refuses
+ # members: plugins need not inherit AuthenticationService.
+ controller = AuthenticationController()
+ controller.auth_service = SimpleNamespace(
+ is_organization_admin=lambda member: False,
+ is_admin_by_role=lambda role: role == "admin",
+ )
+ actor = OrganizationMember.objects.get(user=self.member)
+ target = OrganizationMember.objects.get(user=self.colleague)
+ with self.assertRaises(Forbidden):
+ controller.authorize_invite(actor, ["user"])
+ with self.assertRaises(Forbidden):
+ controller.authorize_role_change(actor, target, "user")
+
+ def test_admins_only_refuses_members_everything(self) -> None:
+ self.restrict(Capability.MANAGE_MEMBERS, True)
+ actor = OrganizationMember.objects.get(user=self.member)
+ with self.assertRaises(Forbidden):
+ AuthenticationController().authorize_invite(actor, ["user"])
+ self.assertEqual(self._assign("[email protected]", "user").status_code, 403)
+
+
+class PlatformApiKeyGuardrailTests(CapabilityTestBase):
+ """Platform API keys stay admin-only even with 'Any member': each acts as
+ a service account that bypasses per-resource sharing and ownership.
+ """
+
+ def setUp(self) -> None:
+ super().setUp()
+ self.restrict(Capability.MANAGE_API_KEYS, False)
+ self.read = PlatformApiKey.objects.create(
+ name="ci-read",
+ permission=ApiKeyPermission.READ,
+ organization=self.org,
+ created_by=self.member,
+ )
+
+ def test_members_cannot_use_platform_api_keys(self) -> None:
+ pk = {"pk": str(self.read.pk)}
+ create = {"data": {"name": "m", "description": "d", "permission": "read"}}
+ for action, method, kwargs in (
+ ({"get": "list"}, "get", {}),
+ ({"post": "create"}, "post", create),
+ ({"get": "retrieve"}, "get", pk),
+ ({"post": "rotate"}, "post", pk),
+ ({"patch": "partial_update"}, "patch", {**pk, "data": {"is_active": False}}),
+ ({"delete": "destroy"}, "delete", pk),
+ ):
+ with self.subTest(action=next(iter(action.values()))):
+ view = PlatformApiKeyViewSet.as_view(action)
+ response = self.call(view, method, user=self.member, **kwargs)
+ self.assertEqual(response.status_code, 403)
+ self.assertEqual(PlatformApiKey.objects.count(), 1)
+
+
+class GlobalDeploymentKeyGuardrailTests(CapabilityTestBase):
+ """With 'Any member', a member only keys deployments they own."""
+
+ def setUp(self) -> None:
+ super().setUp()
+ self.restrict(Capability.MANAGE_API_KEYS, False)
+ workflow = Workflow.objects.create(
+ workflow_name="wf", organization=self.org, created_by=self.admin
+ )
+ self.mine = APIDeployment.objects.create(
+ api_name="mine",
+ workflow=workflow,
+ organization=self.org,
+ created_by=self.member,
+ )
+ self.mine.grant_owner(self.member)
+ self.theirs = APIDeployment.objects.create(
+ api_name="theirs",
+ workflow=workflow,
+ organization=self.org,
+ created_by=self.admin,
+ )
+ self.theirs.grant_owner(self.admin)
+ self.all_key = GlobalApiDeploymentKey.objects.create(
+ name="admin-all",
+ allow_all_deployments=True,
+ organization=self.org,
+ created_by=self.admin,
+ )
+
+ def _create(self, data: dict):
+ view = GlobalApiDeploymentKeyViewSet.as_view({"post": "create"})
+ return self.call(
+ view,
+ "post",
+ user=self.member,
+ data={"name": "k", "description": "ci", **data},
+ )
+
+ def test_a_member_cannot_create_an_allow_all_key(self) -> None:
+ response = self._create({"allow_all_deployments": True, "api_deployments": []})
+ self.assertEqual(response.status_code, 403)
+
+ def test_a_member_cannot_key_a_deployment_they_do_not_own(self) -> None:
+ response = self._create(
+ {"allow_all_deployments": False, "api_deployments": [str(self.theirs.pk)]}
+ )
+ self.assertEqual(response.status_code, 403)
+
+ def test_a_member_may_grant_their_own_deployment(self) -> None:
+ response = self._create(
+ {"allow_all_deployments": False, "api_deployments": [str(self.mine.pk)]}
+ )
+ self.assertEqual(response.status_code, 201, response.data)
+
+ def test_a_member_rotates_only_keys_they_created(self) -> None:
+ own = GlobalApiDeploymentKey.objects.create(
+ name="own",
+ organization=self.org,
+ created_by=self.member,
+ created_by_member=True,
+ )
+ own.api_deployments.add(self.mine)
+ admins = GlobalApiDeploymentKey.objects.create(
+ name="admins", organization=self.org, created_by=self.admin
+ )
+ admins.api_deployments.add(self.mine)
+ rotate = GlobalApiDeploymentKeyViewSet.as_view({"post": "rotate"})
+ response = self.call(rotate, "post", user=self.member, pk=str(own.pk))
+ self.assertEqual(response.status_code, 200, response.data)
+ key_before = admins.key
+ response = self.call(rotate, "post", user=self.member, pk=str(admins.pk))
+ self.assertEqual(response.status_code, 403)
+ admins.refresh_from_db()
+ self.assertEqual(admins.key, key_before)
+
+ def test_a_member_cannot_edit_or_delete_their_own_key(self) -> None:
+ own = GlobalApiDeploymentKey.objects.create(
+ name="own",
+ organization=self.org,
+ created_by=self.member,
+ created_by_member=True,
+ )
+ own.api_deployments.add(self.mine)
+ update = GlobalApiDeploymentKeyViewSet.as_view({"patch": "partial_update"})
+ response = self.call(
+ update,
+ "patch",
+ user=self.member,
+ pk=str(own.pk),
+ data={"allow_all_deployments": True},
+ )
+ self.assertEqual(response.status_code, 403)
+ destroy = GlobalApiDeploymentKeyViewSet.as_view({"delete": "destroy"})
+ response = self.call(destroy, "delete", user=self.member, pk=str(own.pk))
+ self.assertEqual(response.status_code, 403)
+ own.refresh_from_db()
+ self.assertFalse(own.allow_all_deployments)
+
+ def test_a_member_cannot_view_or_rotate_their_own_key_once_it_reaches_further(
+ self,
+ ) -> None:
+ # Their own key, later widened by an admin: same rule as creating it.
+ own = GlobalApiDeploymentKey.objects.create(
+ name="own",
+ organization=self.org,
+ created_by=self.member,
+ created_by_member=True,
+ )
+ own.api_deployments.add(self.mine, self.theirs)
+ rotate = GlobalApiDeploymentKeyViewSet.as_view({"post": "rotate"})
+ response = self.call(rotate, "post", user=self.member, pk=str(own.pk))
+ self.assertEqual(response.status_code, 403)
+
+ def test_a_member_cannot_view_or_rotate_an_allow_all_key(self) -> None:
+ # Their own key, so only the allow-all rule can refuse it.
+ own_all = GlobalApiDeploymentKey.objects.create(
+ name="own-all",
+ allow_all_deployments=True,
+ organization=self.org,
+ created_by=self.member,
+ created_by_member=True,
+ )
+ for action, method in (
+ ({"get": "retrieve"}, "get"),
+ ({"post": "rotate"}, "post"),
+ ):
+ with self.subTest(action=method):
+ view = GlobalApiDeploymentKeyViewSet.as_view(action)
+ response = self.call(view, method, user=self.member, pk=str(own_all.pk))
+ self.assertEqual(response.status_code, 403)
+
+ def test_a_member_lists_and_views_only_their_own_keys(self) -> None:
+ own = GlobalApiDeploymentKey.objects.create(
+ name="own",
+ organization=self.org,
+ created_by=self.member,
+ created_by_member=True,
+ )
+ own.api_deployments.add(self.mine)
+ listing = GlobalApiDeploymentKeyViewSet.as_view({"get": "list"})
+ response = self.call(listing, "get", user=self.member)
+ self.assertEqual(response.status_code, 200, response.data)
+ self.assertEqual([row["name"] for row in response.data], ["own"])
+ response = self.call(listing, "get", user=self.admin)
+ self.assertEqual(
+ sorted(row["name"] for row in response.data), ["admin-all", "own"]
+ )
+ retrieve = GlobalApiDeploymentKeyViewSet.as_view({"get": "retrieve"})
+ response = self.call(retrieve, "get", user=self.member, pk=str(own.pk))
+ self.assertEqual(response.status_code, 200, response.data)
+ self.assertEqual(response.data["key"], str(own.key))
+
+ def test_a_members_list_hides_deployments_they_no_longer_own(self) -> None:
+ own = GlobalApiDeploymentKey.objects.create(
+ name="own",
+ organization=self.org,
+ created_by=self.member,
+ created_by_member=True,
+ )
+ own.api_deployments.add(self.mine)
+ listing = GlobalApiDeploymentKeyViewSet.as_view({"get": "list"})
+
+ def listed(user) -> list[str]:
+ response = self.call(listing, "get", user=user)
+ self.assertEqual(response.status_code, 200, response.data)
+ row = next(r for r in response.data if r["name"] == "own")
+ return [d["id"] for d in row["api_deployments"]]
+
+ self.assertEqual(listed(self.member), [str(self.mine.pk)])
+ # Still a viewer: viewing is not owning.
+ self.mine.memberships.filter(user=self.member).update(role=ResourceRole.VIEWER)
+ self.assertEqual(listed(self.member), [])
+ # The link itself stays, and an admin still sees it.
+ self.assertEqual(listed(self.admin), [str(self.mine.pk)])
+
+ def _member_key(self) -> GlobalApiDeploymentKey:
+ response = self._create(
+ {"allow_all_deployments": False, "api_deployments": [str(self.mine.pk)]}
+ )
+ self.assertEqual(response.status_code, 201, response.data)
+ return GlobalApiDeploymentKey.objects.get(pk=response.data["id"])
+
+ def _authenticates(self, key: GlobalApiDeploymentKey, deployment=None) -> bool:
+ try:
+ KeyHelper.validate_global_api_deployment_key(
+ api_key=str(key.key), api_deployment=deployment or self.mine
+ )
+ except UnauthorizedKey:
+ return False
+ return True
+
+ def test_a_members_key_stops_working_when_they_stop_owning_it(self) -> None:
+ key = self._member_key()
+ self.assertTrue(key.created_by_member)
+ self.assertTrue(self._authenticates(key))
+ # Still a viewer: viewing is not owning.
+ self.mine.memberships.filter(user=self.member).update(role=ResourceRole.VIEWER)
+ self.assertFalse(self._authenticates(key))
+
+ def test_a_members_key_stops_working_when_they_leave(self) -> None:
+ key = self._member_key()
+ OrganizationMember.objects.filter(user=self.member).delete()
+ self.assertFalse(self._authenticates(key))
+
+ def test_an_admins_key_does_not_depend_on_its_creator(self) -> None:
+ view = GlobalApiDeploymentKeyViewSet.as_view({"post": "create"})
+ response = self.call(
+ view,
+ "post",
+ user=self.admin,
+ data={
+ "name": "admins",
+ "description": "ci",
+ "allow_all_deployments": False,
+ "api_deployments": [str(self.mine.pk)],
+ },
+ )
+ self.assertEqual(response.status_code, 201, response.data)
+ key = GlobalApiDeploymentKey.objects.get(pk=response.data["id"])
+ self.assertFalse(key.created_by_member)
+ OrganizationMember.objects.filter(user=self.admin).delete()
+ self.assertTrue(self._authenticates(key))
+
+ def _admin_patch(self, key: GlobalApiDeploymentKey, data: dict):
+ view = GlobalApiDeploymentKeyViewSet.as_view({"patch": "partial_update"})
+ response = self.call(view, "patch", user=self.admin, pk=str(key.pk), data=data)
+ key.refresh_from_db()
+ return response
+
+ def test_an_admin_cannot_widen_a_members_key(self) -> None:
+ key = self._member_key()
+ for data in (
+ {"allow_all_deployments": True},
+ {"api_deployments": [str(self.mine.pk), str(self.theirs.pk)]},
+ ):
+ with self.subTest(data=data):
+ response = self._admin_patch(key, data)
+ self.assertEqual(response.status_code, 400)
+ self.assertIn(next(iter(data)), str(response.data))
+ self.assertFalse(key.allow_all_deployments)
+ self.assertEqual(list(key.api_deployments.all()), [self.mine])
+ # What the edit form sends for a description-only edit.
+ response = self._admin_patch(
+ key,
+ {
+ "description": "renamed",
+ "allow_all_deployments": False,
+ "api_deployments": [str(self.mine.pk)],
+ },
+ )
+ self.assertEqual(response.status_code, 200, response.data)
+ self.assertEqual(key.description, "renamed")
+ self.assertTrue(key.created_by_member)
+ self.assertTrue(response.data["created_by_member"])
+
+ def test_an_admin_can_still_edit_a_stranded_members_key(self) -> None:
+ form = {
+ "description": "renamed",
+ "allow_all_deployments": False,
+ "api_deployments": [str(self.mine.pk)],
+ }
+ key = self._member_key()
+ self.mine.memberships.filter(user=self.member).delete()
+ self.assertEqual(self._admin_patch(key, form).status_code, 200)
+ key.created_by = None
+ key.save(update_fields=["created_by"])
+ self.assertEqual(
+ self._admin_patch(key, {**form, "description": "again"}).status_code, 200
+ )
+ # Still nothing may be added.
+ response = self._admin_patch(
+ key, {"api_deployments": [str(self.mine.pk), str(self.theirs.pk)]}
+ )
+ self.assertEqual(response.status_code, 400)
+ self.assertIn("api_deployments", str(response.data))
+ self.assertEqual(list(key.api_deployments.all()), [self.mine])
+
+ def _second_deployment(self) -> APIDeployment:
+ workflow = Workflow.objects.create(
+ workflow_name="wf2", organization=self.org, created_by=self.member
+ )
+ return APIDeployment.objects.create(
+ api_name="mine2",
+ workflow=workflow,
+ organization=self.org,
+ created_by=self.member,
+ )
+
+ def test_an_admin_may_add_a_deployment_the_creator_owns(self) -> None:
+ mine2 = self._second_deployment()
+ mine2.grant_owner(self.member)
+ key = self._member_key()
+ response = self._admin_patch(
+ key, {"api_deployments": [str(self.mine.pk), str(mine2.pk)]}
+ )
+ self.assertEqual(response.status_code, 200, response.data)
+ self.assertEqual(
+ {d.pk for d in key.api_deployments.all()}, {self.mine.pk, mine2.pk}
+ )
+ self.assertTrue(self._authenticates(key, mine2))
+
+ def test_a_creator_who_left_cannot_have_deployments_added(self) -> None:
+ mine2 = self._second_deployment()
+ mine2.grant_owner(self.member)
+ key = self._member_key()
+ OrganizationMember.objects.filter(user=self.member).delete()
+ response = self._admin_patch(
+ key, {"api_deployments": [str(self.mine.pk), str(mine2.pk)]}
+ )
+ self.assertEqual(response.status_code, 400)
+ self.assertIn("api_deployments", str(response.data))
+
+ def test_a_member_cannot_open_another_members_key(self) -> None:
+ # Both own the deployment, and the other key is a member's key: only
+ # the creator check can refuse it.
+ colleague = make_user("[email protected]")
+ OrganizationMember.objects.create(
+ organization=self.org, user=colleague, role="user"
+ )
+ self.mine.grant_owner(colleague)
+ theirs = GlobalApiDeploymentKey.objects.create(
+ name="colleague",
+ organization=self.org,
+ created_by=colleague,
+ created_by_member=True,
+ )
+ theirs.api_deployments.add(self.mine)
+ key_before = theirs.key
+ for action, method in (
+ ({"get": "retrieve"}, "get"),
+ ({"post": "rotate"}, "post"),
+ ):
+ with self.subTest(action=method):
+ response = self.call(
+ GlobalApiDeploymentKeyViewSet.as_view(action),
+ method,
+ user=self.member,
+ pk=str(theirs.pk),
+ )
+ self.assertEqual(response.status_code, 403)
+ theirs.refresh_from_db()
+ self.assertEqual(theirs.key, key_before)
+
+ def test_a_demoted_admin_cannot_view_or_rotate_their_admin_era_key(self) -> None:
+ view = GlobalApiDeploymentKeyViewSet.as_view({"post": "create"})
+ response = self.call(
+ view,
+ "post",
+ user=self.admin,
+ data={
+ "name": "admin-era",
+ "description": "ci",
+ "allow_all_deployments": False,
+ "api_deployments": [str(self.theirs.pk)],
+ },
+ )
+ self.assertEqual(response.status_code, 201, response.data)
+ key = GlobalApiDeploymentKey.objects.get(pk=response.data["id"])
+ self.assertFalse(key.created_by_member)
+ # Demoted, still owning the key's deployment.
+ OrganizationMember.objects.filter(user=self.admin).update(role="user")
+ demoted = type(self.admin).objects.get(pk=self.admin.pk)
+ for action, method in (
+ ({"get": "retrieve"}, "get"),
+ ({"post": "rotate"}, "post"),
+ ):
+ with self.subTest(action=method):
+ response = self.call(
+ GlobalApiDeploymentKeyViewSet.as_view(action),
+ method,
+ user=demoted,
+ pk=str(key.pk),
+ )
+ self.assertEqual(response.status_code, 403)
+ listing = self.call(
+ GlobalApiDeploymentKeyViewSet.as_view({"get": "list"}), "get", user=demoted
+ )
+ self.assertEqual(listing.status_code, 200, listing.data)
+ self.assertNotIn("admin-era", [row["name"] for row in listing.data])
+
+ def test_execution_checks_a_members_key_with_its_creators_rights(self) -> None:
+ # The execute view hands the authorising global key to the request
+ # serializer, which holds a member's key to its creator's profiles.
+ from api_v2.api_deployment_views import DeploymentExecution
+
+ key = self._member_key()
+ seen = {}
+
+ class Stop(Exception):
+ pass
+
+ def capture(*args, **kwargs):
+ seen.update(kwargs["context"])
+ raise Stop
+
+ request = self.factory.post(
+ "/", {}, format="json", HTTP_AUTHORIZATION=f"Bearer {key.key}"
+ )
+ with patch("api_v2.api_deployment_views.ExecutionRequestSerializer", capture):
+ # The view's error handler turns Stop into a 500; only the
+ # captured serializer context matters here.
+ DeploymentExecution.as_view()(
+ request, org_name=self.org.organization_id, api_name="mine"
+ )
+ self.assertEqual(seen["global_key"].pk, key.pk)
+ self.assertTrue(seen["global_key"].created_by_member)
+
+ def test_a_creator_promoted_to_admin_keeps_their_keys_working(self) -> None:
+ key = self._member_key()
+ self.mine.memberships.filter(user=self.member).delete()
+ OrganizationMember.objects.filter(user=self.member).update(role="admin")
+ key = GlobalApiDeploymentKey.objects.get(pk=key.pk)
+ self.assertTrue(self._authenticates(key))
+
+ def test_a_member_cannot_key_a_deployment_they_only_view(self) -> None:
+ self.theirs.memberships.create(user=self.member, role=ResourceRole.VIEWER)
+ response = self._create(
+ {"allow_all_deployments": False, "api_deployments": [str(self.theirs.pk)]}
+ )
+ self.assertEqual(response.status_code, 403)
+ picker = GlobalApiDeploymentKeyViewSet.as_view({"get": "deployments"})
+ names = [
+ row["api_name"] for row in self.call(picker, "get", user=self.member).data
+ ]
+ self.assertEqual(names, ["mine"])
+ # A key that covered it (an admin's grant before) stops working for it.
+ key = self._member_key()
+ key.api_deployments.add(self.theirs)
+ self.assertFalse(self._authenticates(key, self.theirs))
+
+ def test_an_edit_does_not_undo_a_rotate_made_meanwhile(self) -> None:
+ key = self._member_key()
+ stale = GlobalApiDeploymentKey.objects.get(pk=key.pk)
+ rotate = GlobalApiDeploymentKeyViewSet.as_view({"post": "rotate"})
+ response = self.call(rotate, "post", user=self.member, pk=str(key.pk))
+ self.assertEqual(response.status_code, 200, response.data)
+ rotated = response.data["key"]
+ request = SimpleNamespace(user=self.admin)
+ serializer = GlobalApiDeploymentKeyUpdateSerializer(
+ stale,
+ data={"description": "edited"},
+ partial=True,
+ context={"request": request},
+ )
+ serializer.is_valid(raise_exception=True)
+ serializer.save()
+ key.refresh_from_db()
+ self.assertEqual(str(key.key), str(rotated))
+ self.assertEqual(key.description, "edited")
+
+ def test_a_member_picks_from_their_own_deployments(self) -> None:
+ view = GlobalApiDeploymentKeyViewSet.as_view({"get": "deployments"})
+ response = self.call(view, "get", user=self.member)
+ self.assertEqual(response.status_code, 200, response.data)
+ self.assertEqual([row["api_name"] for row in response.data], ["mine"])