Open-source AI teammates in Slack, Teams, Discord, Telegram and Mattermost. Self-host it, with any agent harness and any model.
Python agent-orchestrationaiai-agentschatopsdiscordlangchainmcpmicrosoft-teamsmulti-agentopen-sourceopenaiself-hostedslack
[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.pyindex 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.pyindex 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 stepspasses 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_checkablediff --git a/core/switch_core/chats/service.py b/core/switch_core/chats/service.pyindex 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.pyindex 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.pyindex 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, selectfrom sqlalchemy.exc import IntegrityErrorfrom 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.pyindex 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 AsyncSessionfrom 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 roleif (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 roleasync 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`; seethere 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.pyindex 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_clientfrom switch_core.gateway.oidc_routes import router as oidc_router+from switch_core.gateway.organizations import router as organizations_routerfrom switch_core.gateway.packages import router as packages_routerfrom switch_core.gateway.providers import router as providers_routerfrom 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.pyindex 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.pynew file mode 100644index 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.pyindex 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: strname: 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: strorganization_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: strlabel: strdiff --git a/core/switch_core/gateway/tenants.py b/core/switch_core/gateway/tenants.pyindex 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.pynew file mode 100644index 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.pyindex 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.textassert _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.pyindex 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: