Skip to content

Open-source AI teammates in Slack, Teams, Discord, Telegram and Mattermost. Self-host it, with any agent harness and any model.

[CHOO-3906] Organization members API; org admins administer but do not own

Petr Bauch983f75dc0ae3
diff --git a/core/switch_core/accounts/deletion.py b/core/switch_core/accounts/deletion.py
index 47def6dc8..1a72e2443 100644
--- a/core/switch_core/accounts/deletion.py
+++ b/core/switch_core/accounts/deletion.py
@@ -377,7 +377,10 @@ class AccountDeletion:
target_type="user",
target_id=user_id,
details={
- "role": workspace.role,
+ "role": await self.users.tenant_role(session, tenant_id, user_id),
+ "organization_role": await self.users.organization_role(
+ session, tenant_id, user_id
+ ),
"agents_deleted": len(agent_ids),
"machines_deleted": len(controller_ids),
"handed_to": successor,
diff --git a/core/switch_core/authz.py b/core/switch_core/authz.py
index 1efe2919d..51ed907db 100644
--- a/core/switch_core/authz.py
+++ b/core/switch_core/authz.py
@@ -61,9 +61,8 @@ TENANT_ADMIN_ROLES = ("owner", "admin")
ORGANIZATION_ADMIN_ROLE = "org_admin"
# The workspace role an organization's `org_admin` is reported as holding in
-# each of its workspaces, membership row or not: everything `owns_tenant`
-# allows an `owner`, it allows them.
-ORGANIZATION_ADMIN_TENANT_ROLE = "owner"
+# each of its workspaces, membership row or not.
+ORGANIZATION_ADMIN_TENANT_ROLE = "admin"
def administers_tenant(
@@ -87,9 +86,7 @@ def administers_tenant(
)
-def owns_tenant(
- *, is_operator: bool, tenant_role: str | None, organization_role: str | None
-) -> bool:
+def owns_tenant(*, is_operator: bool, tenant_role: str | None) -> bool:
"""Whether a caller may dispose of the tenant they hold `tenant_role` in.
Narrower than `administers_tenant` on purpose. An `admin` runs a workspace;
@@ -99,15 +96,10 @@ def owns_tenant(
remove one, then an admin may take the workspace, and each of those steps
passes a last-owner guard on its own. Gate those three on this.
- The organization's `org_admin` owns every workspace in it: the
- organization decides who runs its workspaces, and a workspace owner
- cannot take one away from it.
+ An organization's `org_admin` administers its workspaces but does not own
+ them: the organization's role is `admin`-level in each workspace.
"""
- return (
- is_operator
- or organization_role == ORGANIZATION_ADMIN_ROLE
- or tenant_role == "owner"
- )
+ return is_operator or tenant_role == "owner"
@runtime_checkable
diff --git a/core/switch_core/chats/service.py b/core/switch_core/chats/service.py
index 7f21eaba0..95915543f 100644
--- a/core/switch_core/chats/service.py
+++ b/core/switch_core/chats/service.py
@@ -337,8 +337,11 @@ class ChatService:
async def has_tenant_role(
self, session: AsyncSession, tenant_id: str, user_id: str
) -> bool:
+ """Whether `user_id` stands in `tenant_id`: a membership row, or
+ `org_admin` of its organization."""
return (
- await self._user_store.tenant_role(session, tenant_id, user_id) is not None
+ await self._user_store.effective_tenant_role(session, tenant_id, user_id)
+ is not None
)
async def _room(self, session: AsyncSession, tenant_id: str, room_id: str) -> Room:
diff --git a/core/switch_core/db/audit.py b/core/switch_core/db/audit.py
index a60c20af1..eceaa3f46 100644
--- a/core/switch_core/db/audit.py
+++ b/core/switch_core/db/audit.py
@@ -28,6 +28,7 @@ class AuditAction(StrEnum):
MEMBER_JOINED_BY_DOMAIN = "member.joined_by_domain"
MEMBER_ROLE_CHANGED = "member.role_changed"
MEMBER_REMOVED = "member.removed"
+ ORGANIZATION_ROLE_CHANGED = "organization.role_changed"
ACCOUNT_DELETED = "account.deleted"
JOIN_DOMAIN_ADDED = "join_domain.added"
JOIN_DOMAIN_REMOVED = "join_domain.removed"
diff --git a/core/switch_core/db/stores/organization_store.py b/core/switch_core/db/stores/organization_store.py
index daf8bb0a3..5cd70b54d 100644
--- a/core/switch_core/db/stores/organization_store.py
+++ b/core/switch_core/db/stores/organization_store.py
@@ -1,10 +1,10 @@
from __future__ import annotations
-from sqlalchemy import delete
+from sqlalchemy import delete, func, select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession
-from switch_core.db.models import Organization, OrganizationMember
+from switch_core.db.models import Organization, OrganizationMember, User
# Postgres's default name for `organizations.slug`'s unique constraint.
_SLUG_CONSTRAINT = "organizations_slug_key"
@@ -64,3 +64,24 @@ class OrganizationStore:
"""`user_id`'s role in `organization_id`, or None if not a member."""
member = await session.get(OrganizationMember, (organization_id, user_id))
return member.role if member is not None else None
+
+ async def list_members(
+ self, session: AsyncSession
+ ) -> list[tuple[User, OrganizationMember]]:
+ """Every member of the bound organization, with their user row."""
+ result = await session.execute(
+ select(User, OrganizationMember)
+ .join(OrganizationMember, OrganizationMember.user_id == User.id)
+ .order_by(User.name, User.id)
+ )
+ return [(row[0], row[1]) for row in result.all()]
+
+ async def count_admins(self, session: AsyncSession) -> int:
+ """How many `org_admin`s the bound organization has."""
+ return (
+ await session.execute(
+ select(func.count())
+ .select_from(OrganizationMember)
+ .where(OrganizationMember.role == "org_admin")
+ )
+ ).scalar_one()
diff --git a/core/switch_core/db/stores/user_store.py b/core/switch_core/db/stores/user_store.py
index e170e7b2b..014d9a25e 100644
--- a/core/switch_core/db/stores/user_store.py
+++ b/core/switch_core/db/stores/user_store.py
@@ -12,6 +12,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
from switch_core.authz import (
ORGANIZATION_ADMIN_ROLE,
ORGANIZATION_ADMIN_TENANT_ROLE,
+ TENANT_ADMIN_ROLES,
administers_tenant,
owns_tenant,
)
@@ -527,13 +528,17 @@ class UserStore:
) -> str | None:
"""The role `user_id` acts with in `tenant_id`: their membership role,
or `ORGANIZATION_ADMIN_TENANT_ROLE` when they are the organization's
- `org_admin`, membership row or not. None when they hold neither."""
+ `org_admin` and hold no higher role there. None when they hold
+ neither."""
+ role = await self.tenant_role(session, tenant_id, user_id)
+ if role in TENANT_ADMIN_ROLES:
+ return role
if (
await self.organization_role(session, tenant_id, user_id)
== ORGANIZATION_ADMIN_ROLE
):
return ORGANIZATION_ADMIN_TENANT_ROLE
- return await self.tenant_role(session, tenant_id, user_id)
+ return role
async def list_tenant_members(
self, session: AsyncSession
@@ -594,8 +599,7 @@ class UserStore:
async def owns(self, session: AsyncSession, user: User) -> bool:
"""Whether `user` may decide who owns the tenant bound to `session`'s
- context — the operator bypass, an `owner` membership in it, or
- `org_admin` of its organization.
+ context — the operator bypass, or an `owner` membership in it.
The same composition as `administers`, over `authz.owns_tenant`; see
there for why the two are separate bits rather than one.
@@ -610,8 +614,5 @@ class UserStore:
"owns requires a bound tenant; whether someone owns a "
"workspace is only answerable about a particular one"
)
- return owns_tenant(
- is_operator=user.role == "admin",
- tenant_role=await self.tenant_role(session, tenant_id, user.id),
- organization_role=await self.organization_role(session, tenant_id, user.id),
- )
+ role = await self.tenant_role(session, tenant_id, user.id)
+ return owns_tenant(is_operator=user.role == "admin", tenant_role=role)
diff --git a/core/switch_core/gateway/app.py b/core/switch_core/gateway/app.py
index fcc7b3ee9..6def599a6 100644
--- a/core/switch_core/gateway/app.py
+++ b/core/switch_core/gateway/app.py
@@ -58,6 +58,7 @@ from switch_core.gateway.messaging_installs import (
)
from switch_core.gateway.oidc_routes import register_oidc_client
from switch_core.gateway.oidc_routes import router as oidc_router
+from switch_core.gateway.organizations import router as organizations_router
from switch_core.gateway.packages import router as packages_router
from switch_core.gateway.providers import router as providers_router
from switch_core.gateway.references import router as references_router
@@ -201,6 +202,7 @@ def create_gateway_app(
app.include_router(auth_router, tags=["auth"])
app.include_router(oidc_router, tags=["auth"])
app.include_router(tenants_router, tags=["tenants"])
+ app.include_router(organizations_router, tags=["organizations"])
app.include_router(rooms_router, prefix="/rooms", tags=["rooms"])
app.include_router(changes_router, tags=["changes"])
app.include_router(chats_router, prefix="/chats", tags=["chats"])
diff --git a/core/switch_core/gateway/collaborations.py b/core/switch_core/gateway/collaborations.py
index cad9e017c..61d04cc87 100644
--- a/core/switch_core/gateway/collaborations.py
+++ b/core/switch_core/gateway/collaborations.py
@@ -854,10 +854,13 @@ async def claim_bridge_identity(
status_code=403,
detail="Only an admin may claim a messaging identity for another user",
)
- # Membership, not existence: `users` is deployment-wide, and a claim
- # names who the account is recognised as inside this tenant.
+ # Standing in this tenant, not existence: `users` is deployment-wide, and
+ # a claim names who the account is recognised as inside this tenant. An
+ # organization's `org_admin` stands in every workspace of it.
if (
- await user_store.tenant_role(session, require_tenant_id(), target_user_id)
+ await user_store.effective_tenant_role(
+ session, require_tenant_id(), target_user_id
+ )
is None
):
raise HTTPException(status_code=404, detail="Switch user not found")
diff --git a/core/switch_core/gateway/organizations.py b/core/switch_core/gateway/organizations.py
new file mode 100644
index 000000000..88d29bffa
--- /dev/null
+++ b/core/switch_core/gateway/organizations.py
@@ -0,0 +1,127 @@
+"""The organization above the bound workspace: its members and their roles.
+
+Every route acts on the organization the request's workspace belongs to
+(`current`), which the policy on `organization_members` derives from the bound
+workspace, and only its `org_admin`s may use them. Creating organizations and
+workspaces in them comes later; see `docs/design/organizations-v1.md`.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from switch_core.authz import ORGANIZATION_ADMIN_ROLE
+from switch_core.db.audit import AuditAction, record_audit_event
+from switch_core.db.models import OrganizationMember, Tenant, User, require_tenant_id
+from switch_core.db.stores.organization_store import OrganizationStore
+from switch_core.db.stores.user_store import UserStore
+from switch_core.gateway.auth import get_current_user
+from switch_core.gateway.dependencies import (
+ get_organization_store,
+ get_session,
+ get_user_store,
+)
+from switch_core.gateway.schemas import (
+ OrganizationMemberDetail,
+ OrganizationMemberUpdateRequest,
+)
+
+router = APIRouter()
+
+
+def _member_detail(user: User, member: OrganizationMember) -> OrganizationMemberDetail:
+ return OrganizationMemberDetail(
+ user_id=user.id,
+ name=user.name,
+ email=user.email,
+ role=member.role,
+ created_at=str(member.created_at),
+ )
+
+
+async def _require_organization_admin(
+ session: AsyncSession, user_store: UserStore, user: User
+) -> str:
+ """The bound workspace's organization id; 403 unless `user` is its
+ `org_admin`, 404 when the workspace belongs to no organization."""
+ tenant_id = require_tenant_id()
+ tenant = await session.get(Tenant, tenant_id)
+ if tenant is None or tenant.organization_id is None:
+ raise HTTPException(
+ status_code=404, detail="This workspace belongs to no organization"
+ )
+ if (
+ await user_store.organization_role(session, tenant_id, user.id)
+ != ORGANIZATION_ADMIN_ROLE
+ ):
+ raise HTTPException(
+ status_code=403, detail="Only an organization admin may do this"
+ )
+ return tenant.organization_id
+
+
[email protected]("/organizations/current/members")
+async def list_organization_members(
+ session: Annotated[AsyncSession, Depends(get_session)],
+ user_store: Annotated[UserStore, Depends(get_user_store)],
+ organization_store: Annotated[OrganizationStore, Depends(get_organization_store)],
+ user: Annotated[User, Depends(get_current_user)],
+) -> list[OrganizationMemberDetail]:
+ """Every member of the organization and their role in it. `org_admin` only:
+ the list spans every workspace of the organization, not only this one."""
+ await _require_organization_admin(session, user_store, user)
+ members = await organization_store.list_members(session)
+ return [_member_detail(member_user, member) for member_user, member in members]
+
+
[email protected]("/organizations/current/members/{user_id}")
+async def update_organization_member_role(
+ user_id: str,
+ req: OrganizationMemberUpdateRequest,
+ session: Annotated[AsyncSession, Depends(get_session)],
+ user_store: Annotated[UserStore, Depends(get_user_store)],
+ organization_store: Annotated[OrganizationStore, Depends(get_organization_store)],
+ user: Annotated[User, Depends(get_current_user)],
+) -> OrganizationMemberDetail:
+ """Make a member `org_admin`, or an `org_admin` a `member`. `org_admin` only,
+ the one role that grants `org_admin`.
+
+ Refuses to demote the last `org_admin`: nobody else could grant the role
+ again. Recorded in the bound workspace's audit log.
+ """
+ organization_id = await _require_organization_admin(session, user_store, user)
+ member = await session.get(OrganizationMember, (organization_id, user_id))
+ if member is None:
+ raise HTTPException(status_code=404, detail="Not a member of this organization")
+ if (
+ member.role == ORGANIZATION_ADMIN_ROLE
+ and req.role != ORGANIZATION_ADMIN_ROLE
+ and await organization_store.count_admins(session) <= 1
+ ):
+ raise HTTPException(
+ status_code=409, detail="Cannot demote the last organization admin"
+ )
+
+ if member.role != req.role:
+ await record_audit_event(
+ session,
+ tenant_id=require_tenant_id(),
+ actor_user_id=user.id,
+ action=AuditAction.ORGANIZATION_ROLE_CHANGED,
+ target_type="user",
+ target_id=user_id,
+ details={
+ "organization_id": organization_id,
+ "from": member.role,
+ "to": req.role,
+ },
+ )
+ member.role = req.role
+ await session.commit()
+
+ target = await user_store.get(session, user_id)
+ assert target is not None
+ return _member_detail(target, member)
diff --git a/core/switch_core/gateway/schemas.py b/core/switch_core/gateway/schemas.py
index 17e2e610f..1ebfd7d42 100644
--- a/core/switch_core/gateway/schemas.py
+++ b/core/switch_core/gateway/schemas.py
@@ -907,7 +907,8 @@ class TenantMembershipResponse(BaseModel):
slug: str
name: str
# The role the caller acts with here: an organization's `org_admin` is
- # reported as `owner` of each of its workspaces, membership row or not.
+ # reported as at least `admin` of each of its workspaces, membership row
+ # or not.
role: str
organization_role: str | None
@@ -1122,6 +1123,18 @@ class MemberUpdateRequest(BaseModel):
role: str
+class OrganizationMemberDetail(BaseModel):
+ user_id: str
+ name: str
+ email: str
+ role: str
+ created_at: str
+
+
+class OrganizationMemberUpdateRequest(BaseModel):
+ role: Literal["org_admin", "member"]
+
+
class OidcLoginOptionView(BaseModel):
id: str
label: str
diff --git a/core/switch_core/gateway/tenants.py b/core/switch_core/gateway/tenants.py
index 093ff60ec..d8099d6c8 100644
--- a/core/switch_core/gateway/tenants.py
+++ b/core/switch_core/gateway/tenants.py
@@ -224,7 +224,7 @@ async def _refuse_organization_admin(
detail=(
"This member administers the workspace's organization, which "
"gives them admin rights in every one of its workspaces. Change "
- "their role in the organization instead."
+ "their role in the organization's members first."
),
)
diff --git a/core/tests/switch_core/gateway/test_organization_routes.py b/core/tests/switch_core/gateway/test_organization_routes.py
new file mode 100644
index 000000000..0105dfb53
--- /dev/null
+++ b/core/tests/switch_core/gateway/test_organization_routes.py
@@ -0,0 +1,236 @@
+"""`/organizations/current/members`: an organization's `org_admin`s list its
+members and grant or take back `org_admin`, never below one."""
+
+from __future__ import annotations
+
+import uuid
+from types import SimpleNamespace
+
+import httpx
+from fastapi import FastAPI
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from switch_core.db.audit import AuditAction
+from switch_core.db.models import (
+ AuditEvent,
+ Organization,
+ OrganizationMember,
+ Tenant,
+ TenantMember,
+ User,
+)
+from switch_core.db.session_scope import tenant_session
+from switch_core.db.stores.organization_store import OrganizationStore
+from switch_core.db.stores.user_store import UserStore
+from switch_core.gateway import dependencies as gw_deps
+from switch_core.gateway.auth import create_jwt
+from switch_core.gateway.organizations import router as organizations_router
+from switch_core.gateway.tenants import router as tenants_router
+from switch_core.keys import Keyring
+
+_KEYRING = Keyring.parse(
+ "test:" + "organization-routes-test-secret-" + "0" * 32, legacy_secret=None
+)
+
+
+def _app(session_factory: async_sessionmaker[AsyncSession]) -> FastAPI:
+ async def _session_dep():
+ async with session_factory() as session:
+ yield session
+
+ app = FastAPI()
+ app.include_router(organizations_router)
+ app.include_router(tenants_router)
+ app.dependency_overrides[gw_deps.get_session] = _session_dep
+ app.dependency_overrides[gw_deps.get_session_factory] = lambda: session_factory
+ app.dependency_overrides[gw_deps.get_user_store] = lambda: UserStore()
+ app.dependency_overrides[gw_deps.get_organization_store] = lambda: (
+ OrganizationStore()
+ )
+ app.dependency_overrides[gw_deps.get_config] = lambda: SimpleNamespace(
+ keyring=_KEYRING,
+ gateway_cookie_secure=False,
+ gateway_tenant_choice_enabled=False,
+ )
+ return app
+
+
+def _client(app: FastAPI, user_id: str, tenant_id: str) -> httpx.AsyncClient:
+ token = create_jwt(
+ user_id, f"{user_id}@example.invalid", "user", _KEYRING, tenant_id
+ )
+ return httpx.AsyncClient(
+ transport=httpx.ASGITransport(app=app),
+ base_url="http://test",
+ cookies={"switch_auth": token},
+ )
+
+
+async def _workspace(
+ session_factory: async_sessionmaker[AsyncSession],
+ members: dict[str, tuple[str, str]],
+) -> str:
+ """A workspace in an organization of its own, with `members`
+ (name -> (workspace role, organization role)). Users are named by id."""
+ organization_id = f"org-{uuid.uuid4().hex[:8]}"
+ tenant_id = f"tenant-{uuid.uuid4().hex[:8]}"
+ async with session_factory() as session:
+ session.add(Organization(id=organization_id, slug=organization_id, name="Acme"))
+ await session.flush()
+ session.add(
+ Tenant(
+ id=tenant_id,
+ slug=tenant_id,
+ name="Acme",
+ organization_id=organization_id,
+ )
+ )
+ for name, (workspace_role, organization_role) in members.items():
+ session.add(
+ User(id=name, name=name, email=f"{name}@example.invalid", role="user")
+ )
+ await session.flush()
+ session.add(
+ TenantMember(tenant_id=tenant_id, user_id=name, role=workspace_role)
+ )
+ session.add(
+ OrganizationMember(
+ organization_id=organization_id,
+ user_id=name,
+ role=organization_role,
+ )
+ )
+ await session.commit()
+ return tenant_id
+
+
+def _name(prefix: str) -> str:
+ return f"{prefix}-{uuid.uuid4().hex[:6]}"
+
+
+class TestListing:
+ async def test_an_org_admin_sees_every_member_and_their_role(
+ self, session_factory: async_sessionmaker[AsyncSession]
+ ) -> None:
+ ada, bob = _name("ada"), _name("bob")
+ tenant_id = await _workspace(
+ session_factory, {ada: ("owner", "org_admin"), bob: ("member", "member")}
+ )
+
+ async with _client(_app(session_factory), ada, tenant_id) as client:
+ response = await client.get("/organizations/current/members")
+
+ assert response.status_code == 200, response.text
+ assert {row["user_id"]: row["role"] for row in response.json()} == {
+ ada: "org_admin",
+ bob: "member",
+ }
+
+ async def test_a_workspace_admin_who_is_no_org_admin_is_refused(
+ self, session_factory: async_sessionmaker[AsyncSession]
+ ) -> None:
+ ada, bob = _name("ada"), _name("bob")
+ tenant_id = await _workspace(
+ session_factory, {ada: ("owner", "org_admin"), bob: ("admin", "member")}
+ )
+
+ async with _client(_app(session_factory), bob, tenant_id) as client:
+ response = await client.get("/organizations/current/members")
+
+ assert response.status_code == 403
+
+
+class TestChangingRoles:
+ async def test_an_org_admin_grants_org_admin_and_it_is_audited(
+ self, session_factory: async_sessionmaker[AsyncSession]
+ ) -> None:
+ ada, bob = _name("ada"), _name("bob")
+ tenant_id = await _workspace(
+ session_factory, {ada: ("owner", "org_admin"), bob: ("member", "member")}
+ )
+
+ async with _client(_app(session_factory), ada, tenant_id) as client:
+ response = await client.patch(
+ f"/organizations/current/members/{bob}", json={"role": "org_admin"}
+ )
+
+ assert response.status_code == 200, response.text
+ assert response.json()["role"] == "org_admin"
+ async with tenant_session(session_factory, tenant_id) as session:
+ event = await session.scalar(
+ select(AuditEvent).where(
+ AuditEvent.action == AuditAction.ORGANIZATION_ROLE_CHANGED
+ )
+ )
+ assert event is not None
+ assert event.actor_user_id == ada and event.target_id == bob
+ assert event.details is not None
+ assert (event.details["from"], event.details["to"]) == ("member", "org_admin")
+
+ async def test_a_member_cannot_grant_themselves_org_admin(
+ self, session_factory: async_sessionmaker[AsyncSession]
+ ) -> None:
+ ada, bob = _name("ada"), _name("bob")
+ tenant_id = await _workspace(
+ session_factory, {ada: ("owner", "org_admin"), bob: ("admin", "member")}
+ )
+
+ async with _client(_app(session_factory), bob, tenant_id) as client:
+ response = await client.patch(
+ f"/organizations/current/members/{bob}", json={"role": "org_admin"}
+ )
+
+ assert response.status_code == 403
+
+ async def test_the_last_org_admin_cannot_be_demoted(
+ self, session_factory: async_sessionmaker[AsyncSession]
+ ) -> None:
+ ada = _name("ada")
+ tenant_id = await _workspace(session_factory, {ada: ("owner", "org_admin")})
+
+ async with _client(_app(session_factory), ada, tenant_id) as client:
+ response = await client.patch(
+ f"/organizations/current/members/{ada}", json={"role": "member"}
+ )
+
+ assert response.status_code == 409
+
+ async def test_an_unknown_role_is_refused(
+ self, session_factory: async_sessionmaker[AsyncSession]
+ ) -> None:
+ ada = _name("ada")
+ tenant_id = await _workspace(session_factory, {ada: ("owner", "org_admin")})
+
+ async with _client(_app(session_factory), ada, tenant_id) as client:
+ response = await client.patch(
+ f"/organizations/current/members/{ada}", json={"role": "owner"}
+ )
+
+ assert response.status_code == 422
+
+ async def test_a_demoted_org_admin_can_then_be_demoted_in_the_workspace(
+ self, session_factory: async_sessionmaker[AsyncSession]
+ ) -> None:
+ """The way out of the workspace's 409: demote in the organization,
+ then in the workspace."""
+ ada, bob = _name("ada"), _name("bob")
+ tenant_id = await _workspace(
+ session_factory, {ada: ("owner", "org_admin"), bob: ("admin", "org_admin")}
+ )
+
+ async with _client(_app(session_factory), ada, tenant_id) as client:
+ refused = await client.patch(
+ f"/tenants/{tenant_id}/members/{bob}", json={"role": "member"}
+ )
+ in_organization = await client.patch(
+ f"/organizations/current/members/{bob}", json={"role": "member"}
+ )
+ in_workspace = await client.patch(
+ f"/tenants/{tenant_id}/members/{bob}", json={"role": "member"}
+ )
+
+ assert refused.status_code == 409
+ assert in_organization.status_code == 200, in_organization.text
+ assert in_workspace.status_code == 200, in_workspace.text
+ assert in_workspace.json()["role"] == "member"
diff --git a/core/tests/switch_core/gateway/test_tenant_api_routes.py b/core/tests/switch_core/gateway/test_tenant_api_routes.py
index 717324c37..e1a4cbb59 100644
--- a/core/tests/switch_core/gateway/test_tenant_api_routes.py
+++ b/core/tests/switch_core/gateway/test_tenant_api_routes.py
@@ -1841,7 +1841,7 @@ class TestOrganizationAdmins:
"id": TENANT_A,
"slug": TENANT_A,
"name": TENANT_A,
- "role": "owner",
+ "role": "admin",
"organization_role": "org_admin",
"administers": True,
}
@@ -1865,8 +1865,8 @@ class TestOrganizationAdmins:
assert {
(t["id"], t["role"], t["organization_role"]) for t in listed.json()
} == {
- (TENANT_A, "owner", "org_admin"),
- (TENANT_B, "owner", "org_admin"),
+ (TENANT_A, "admin", "org_admin"),
+ (TENANT_B, "admin", "org_admin"),
}
assert switched.status_code == 200, switched.text
assert _tenant_claim(switched) == TENANT_B
@@ -1906,30 +1906,36 @@ class TestOrganizationAdmins:
assert response.status_code == 403
- async def test_an_org_admin_manages_a_workspaces_members_and_owners(
+ async def test_an_org_admin_manages_members_as_a_workspace_admin_does(
self, session_factory: async_sessionmaker[AsyncSession]
) -> None:
+ """Admin-level, not owner-level: the ownership set is still the
+ workspace owners' own."""
admin_id = await _make_unaffiliated_user(
session_factory, name="org-admin", role="user"
)
await self._organization_of(
session_factory, TENANT_A, members={admin_id: "org_admin"}
)
+ member_id = await _make_member(
+ session_factory, name="ws-admin", tenant_id=TENANT_A, role="admin"
+ )
owner_id = await _make_member(
session_factory, name="ws-owner", tenant_id=TENANT_A, role="owner"
)
- await _make_member(
- session_factory, name="ws-owner-2", tenant_id=TENANT_A, role="owner"
- )
token = _token(admin_id, "[email protected]", TENANT_A)
async with _client(_app(session_factory), token) as client:
- response = await client.patch(
+ demoted = await client.patch(
+ f"/tenants/{TENANT_A}/members/{member_id}", json={"role": "member"}
+ )
+ owner = await client.patch(
f"/tenants/{TENANT_A}/members/{owner_id}", json={"role": "member"}
)
- assert response.status_code == 200, response.text
- assert response.json()["role"] == "member"
+ assert demoted.status_code == 200, demoted.text
+ assert demoted.json()["role"] == "member"
+ assert owner.status_code == 403
@pytest.mark.parametrize("method", ["patch", "delete"])
async def test_a_workspace_cannot_demote_or_remove_an_org_admin(
diff --git a/core/tests/switch_core/test_authz.py b/core/tests/switch_core/test_authz.py
index 9ac2ecedd..d89b99da8 100644
--- a/core/tests/switch_core/test_authz.py
+++ b/core/tests/switch_core/test_authz.py
@@ -161,15 +161,11 @@ class TestOwnsTenant:
which is not everyone who may administer the workspace."""
def test_operator_owns_regardless_of_tenant_role(self) -> None:
- assert owns_tenant(is_operator=True, tenant_role=None, organization_role=None)
- assert owns_tenant(
- is_operator=True, tenant_role="member", organization_role=None
- )
+ assert owns_tenant(is_operator=True, tenant_role=None)
+ assert owns_tenant(is_operator=True, tenant_role="member")
def test_owner_membership_owns(self) -> None:
- assert owns_tenant(
- is_operator=False, tenant_role="owner", organization_role=None
- )
+ assert owns_tenant(is_operator=False, tenant_role="owner")
def test_admin_membership_administers_but_does_not_own(self) -> None:
"""The whole point of there being two functions: an admin who also
@@ -178,27 +174,19 @@ class TestOwnsTenant:
assert administers_tenant(
is_operator=False, tenant_role="admin", organization_role=None
)
- assert not owns_tenant(
- is_operator=False, tenant_role="admin", organization_role=None
- )
+ assert not owns_tenant(is_operator=False, tenant_role="admin")
- def test_organization_admin_owns_every_workspace_of_it(self) -> None:
- """A workspace owner cannot take a workspace away from the
- organization it belongs to."""
- assert owns_tenant(
+ def test_organization_admin_does_not_own(self) -> None:
+ """`org_admin` is admin-level in each workspace of its organization:
+ it administers them but does not move their ownership set."""
+ assert administers_tenant(
is_operator=False, tenant_role=None, organization_role="org_admin"
)
- assert not owns_tenant(
- is_operator=False, tenant_role="admin", organization_role="member"
- )
+ assert not owns_tenant(is_operator=False, tenant_role=None)
def test_plain_member_and_no_membership_do_not_own(self) -> None:
- assert not owns_tenant(
- is_operator=False, tenant_role="member", organization_role=None
- )
- assert not owns_tenant(
- is_operator=False, tenant_role=None, organization_role=None
- )
+ assert not owns_tenant(is_operator=False, tenant_role="member")
+ assert not owns_tenant(is_operator=False, tenant_role=None)
class TestValidateVisibilityPair: