T12.1: CR-020 bulk user endpoints

POST /api/auth/bulk-users/{active,role,projects,delete} take a list of
user ids (max 500) and run each row through the same guards and audit
as the single-user route: the rules now live once, in guard_target and
apply_user_{active,role,delete,projects}, which the single-user routes
call too.

- A refused row is reported with its reason; the rest still run; the
  response counts ok / unchanged / failed. Never a blanket success.
- The caller's own account is refused only on its own row.
- One AuditLog row per changed account, same action and shape as the
  single route. A row already in the requested state is 'unchanged'
  and writes no audit row.
- Project assignment is add/remove to ONE project with a per-project
  role (confirmed 2026-10-06); roles on the user's other projects are
  carried over as stored.
- Routes sit under /api/auth/bulk-users/ because /api/auth/users/bulk/
  would match {user_id}='bulk'.

New tests/bulk_users_check.py (no browser): 47/47. Against main: the
7 single-route checks pass, every bulk check fails.
Single-user routes compared before/after on 16 calls (200/400/403/404):
identical responses, audit rows and memberships. Smoke test 27/27.
This commit is contained in:
2026-10-06 10:57:48 -07:00
parent 286e629782
commit 0e79e17a57
2 changed files with 519 additions and 58 deletions

View File

@@ -1013,16 +1013,100 @@ def create_user(body: NewUserIn, actor: models.User = Depends(require_user_manag
return directory_entry(db, u, actor)
# ── One account-level change, used by the single-user routes AND the bulk routes ──
# CR-020 (T12.1): a bulk action is the single-user action, once per row. So each
# rule lives in exactly one function below, and both kinds of route call it: a
# bulk request cannot reach further than a one-at-a-time request, because there
# is no second copy of the rules for it to reach through. Every function checks
# all of its guards BEFORE it changes anything, so a row that is refused leaves
# nothing half-written, and writes its AuditLog row the way the single route
# always has. None of them commits; the route owns the transaction.
def guard_target(db: Session, actor: "models.User", u: "models.User") -> None:
"""The two checks every account change starts with: may the caller see this
account (404 if not, so existence does not leak), and may they change it."""
require_see_user(db, actor, u)
require_manage_user(db, actor, u)
def apply_user_active(db: Session, actor: "models.User", u: "models.User", is_active: bool) -> None:
if u.id == actor.id and not is_active:
raise HTTPException(status_code=400, detail="You cannot disable your own account")
u.is_active = is_active
log_event(db, actor, "user_enabled" if is_active else "user_disabled", "user", u.id,
summary=u.username, detail={"is_active": bool(is_active)})
def apply_user_role(db: Session, actor: "models.User", u: "models.User", role: str) -> None:
"""The role guards: never your own role, never the last active admin. The
grantable-roles check is the caller's, made once per request before this."""
if u.id == actor.id:
raise HTTPException(status_code=400, detail="You cannot change your own role")
if auth.is_admin(u) and role != auth.ROLE_ADMIN:
other_admins = db.scalars(
select(models.User.id).where(
(models.User.role == auth.ROLE_ADMIN)
& (models.User.id != u.id)
& (models.User.is_active.is_(True))
)
).all()
if not other_admins:
raise HTTPException(status_code=400, detail="Can't remove the last admin account")
old_role = u.role
u.role = role
detail = {"from": old_role, "to": role}
# Promoting someone to admin retires their default-member flag: an admin already
# reaches every project, so the flag would do nothing except sit there invisibly
# (the console shows admins no controls) and come back to life the day they are
# demoted. Same reasoning as clearing the role in set_user_auto_add.
if role == auth.ROLE_ADMIN and (u.auto_add_projects or u.auto_add_role):
u.auto_add_projects = False
u.auto_add_role = ""
detail["auto_add_cleared"] = True
log_event(db, actor, "role_changed", "user", u.id, summary=u.username, detail=detail)
def apply_user_delete(db: Session, actor: "models.User", u: "models.User") -> None:
if u.id == actor.id:
raise HTTPException(status_code=400, detail="You cannot delete your own account")
log_event(db, actor, "user_deleted", "user", u.id, summary=u.username, detail={"role": u.role})
db.delete(u)
def apply_user_projects(db: Session, actor: "models.User", u: "models.User",
managed: Optional[set], valid: set, roles: dict) -> None:
"""Replace the caller's slice of `u`'s memberships with `valid`, each carrying
its role from `roles` ('' = inherit). `valid` must already be checked to exist
and to sit inside `managed`."""
# Rebuild only the rows this caller owns. Scoping the DELETE is the whole of the
# "leave other jobs alone" guarantee — get it wrong and a super user's save
# silently revokes access everywhere else.
doomed = delete(models.ProjectMember).where(models.ProjectMember.user_id == u.id)
if managed is not None:
# in_() on an empty set is a valid always-false predicate, so a caller who
# administers nothing deletes nothing (require_manage_user already refused them).
doomed = doomed.where(models.ProjectMember.project_id.in_(managed))
db.execute(doomed)
for pid in valid:
db.add(models.ProjectMember(id=gen_id("pm"), user_id=u.id, project_id=pid,
role=roles.get(pid, "")))
log_event(db, actor, "project_access_changed", "user", u.id, summary=u.username,
detail={"projects": len(valid),
"scope": "all" if managed is None else "managed",
"overrides": {p: r for p, r in roles.items() if p in valid}})
def project_scoped_grantable(actor: "models.User") -> tuple:
"""Per-project roles `actor` may hand out. Only an app admin can make someone a
super user on a project. user_scope and get_user_projects still spell the same
rule inline for the console; left as they are to keep this diff to CR-020."""
return auth.PROJECT_SCOPED_ROLES if auth.is_admin(actor) else (auth.ROLE_PROJECT_ADMIN, auth.ROLE_PROJECT_USER)
@app.post("/api/auth/users/{user_id}/active")
def set_user_active(user_id: str, body: ActiveIn, actor: models.User = Depends(require_user_manager), db: Session = Depends(get_db)):
u = load_target_user(db, user_id)
require_see_user(db, actor, u)
require_manage_user(db, actor, u)
if u.id == actor.id and not body.is_active:
raise HTTPException(status_code=400, detail="You cannot disable your own account")
u.is_active = body.is_active
log_event(db, actor, "user_enabled" if body.is_active else "user_disabled", "user", u.id,
summary=u.username, detail={"is_active": bool(body.is_active)})
guard_target(db, actor, u)
apply_user_active(db, actor, u, body.is_active)
db.commit()
return directory_entry(db, u, actor)
@@ -1039,32 +1123,8 @@ def set_user_role(user_id: str, body: RoleIn, actor: models.User = Depends(requi
if body.role not in allowed:
raise HTTPException(status_code=400, detail=f"role must be one of {', '.join(allowed)}")
u = load_target_user(db, user_id)
require_see_user(db, actor, u)
require_manage_user(db, actor, u)
if u.id == actor.id:
raise HTTPException(status_code=400, detail="You cannot change your own role")
if auth.is_admin(u) and body.role != auth.ROLE_ADMIN:
other_admins = db.scalars(
select(models.User.id).where(
(models.User.role == auth.ROLE_ADMIN)
& (models.User.id != u.id)
& (models.User.is_active.is_(True))
)
).all()
if not other_admins:
raise HTTPException(status_code=400, detail="Can't remove the last admin account")
old_role = u.role
u.role = body.role
detail = {"from": old_role, "to": body.role}
# Promoting someone to admin retires their default-member flag: an admin already
# reaches every project, so the flag would do nothing except sit there invisibly
# (the console shows admins no controls) and come back to life the day they are
# demoted. Same reasoning as clearing the role in set_user_auto_add.
if body.role == auth.ROLE_ADMIN and (u.auto_add_projects or u.auto_add_role):
u.auto_add_projects = False
u.auto_add_role = ""
detail["auto_add_cleared"] = True
log_event(db, actor, "role_changed", "user", u.id, summary=u.username, detail=detail)
guard_target(db, actor, u)
apply_user_role(db, actor, u, body.role)
db.commit()
db.refresh(u)
return directory_entry(db, u, actor)
@@ -1121,12 +1181,8 @@ def set_user_auto_add(user_id: str, body: AutoAddIn, admin: models.User = Depend
@app.delete("/api/auth/users/{user_id}")
def delete_user(user_id: str, actor: models.User = Depends(require_user_manager), db: Session = Depends(get_db)):
u = load_target_user(db, user_id)
require_see_user(db, actor, u)
require_manage_user(db, actor, u)
if u.id == actor.id:
raise HTTPException(status_code=400, detail="You cannot delete your own account")
log_event(db, actor, "user_deleted", "user", u.id, summary=u.username, detail={"role": u.role})
db.delete(u)
guard_target(db, actor, u)
apply_user_delete(db, actor, u)
db.commit()
return {"deleted": user_id}
@@ -1179,8 +1235,7 @@ def set_user_projects(user_id: str, body: ProjectAssignIn, actor: models.User =
exactly as they were, because a payload that simply omits them would otherwise cut
someone off from a job the caller can't even see."""
u = load_target_user(db, user_id)
require_see_user(db, actor, u)
require_manage_user(db, actor, u)
guard_target(db, actor, u)
requested = [p for p in dict.fromkeys(body.project_ids) if p]
for pid in requested:
check_id(pid)
@@ -1193,28 +1248,156 @@ def set_user_projects(user_id: str, body: ProjectAssignIn, actor: models.User =
# A super user may hand out the project-scoped roles below their own; only an app
# admin can make someone a super user on a project. Anything unrecognised falls
# back to inheriting the account's own role.
allowed = auth.PROJECT_SCOPED_ROLES if auth.is_admin(actor) else (auth.ROLE_PROJECT_ADMIN, auth.ROLE_PROJECT_USER)
allowed = project_scoped_grantable(actor)
roles = {pid: r for pid, r in (body.roles or {}).items() if r in allowed}
# Rebuild only the rows this caller owns. Scoping the DELETE is the whole of the
# "leave other jobs alone" guarantee — get it wrong and a super user's save
# silently revokes access everywhere else.
doomed = delete(models.ProjectMember).where(models.ProjectMember.user_id == user_id)
if managed is not None:
# in_() on an empty set is a valid always-false predicate, so a caller who
# administers nothing deletes nothing (require_manage_user already refused them).
doomed = doomed.where(models.ProjectMember.project_id.in_(managed))
db.execute(doomed)
for pid in valid:
db.add(models.ProjectMember(id=gen_id("pm"), user_id=user_id, project_id=pid,
role=roles.get(pid, "")))
log_event(db, actor, "project_access_changed", "user", u.id, summary=u.username,
detail={"projects": len(valid),
"scope": "all" if managed is None else "managed",
"overrides": {p: r for p, r in roles.items() if p in valid}})
apply_user_projects(db, actor, u, managed, valid, roles)
db.commit()
return {"assigned": sorted(valid), "roles": {p: roles.get(p, "") for p in sorted(valid)}}
# ── Bulk user administration — CR-020 (T12.1) ─────────────────────────────────
# Four actions over a list of accounts: activate/disable, permissions role,
# project add/remove (with the per-project role), delete. Each row runs exactly
# the guards and the audit of the single-user route, through the same apply_*
# function above. Rules, decided 2026-09-17 and confirmed 2026-10-06:
# * a row that is refused is reported with its reason and the rest still run;
# a batch is never reported as a success when part of it failed;
# * one AuditLog row per changed account, the same as the single route writes -
# never one opaque "bulk" entry;
# * the caller's own account is refused only on its own row (disable, demote,
# delete), never by failing the whole batch;
# * project assignment adds to or removes from ONE project; it never replaces a
# user's whole project list.
# A row already in the requested state is reported "unchanged" and writes no
# audit row: nothing changed, so there is nothing to audit.
#
# The routes live under /api/auth/bulk-users/ rather than /api/auth/users/bulk/,
# because POST /api/auth/users/{user_id}/active would otherwise match "bulk" as
# a user id.
BULK_MAX_USERS = 500
class BulkUsersIn(BaseModel):
user_ids: list[str] = Field(default_factory=list, max_length=BULK_MAX_USERS)
class BulkActiveIn(BulkUsersIn):
is_active: bool
class BulkRoleIn(BulkUsersIn):
role: str
class BulkProjectIn(BulkUsersIn):
project_id: str
op: str # "add" | "remove"
role: str = "" # per-project role on add; '' = inherit the account's own
def run_bulk(db: Session, actor: "models.User", user_ids: list[str], action: str, apply) -> dict:
"""Run `apply(u)` once per distinct id, in the order given. `apply` returns
"ok" or "unchanged", or raises HTTPException with the reason the single-user
route would have given. The flush after every row matters: the session does
not autoflush, and a later row's guard (the last-admin count, for one) has to
see what an earlier row already changed."""
results = []
for uid in dict.fromkeys(i for i in user_ids if i):
row = {"user_id": uid, "username": "", "status": "", "reason": ""}
try:
check_id(uid)
u = load_target_user(db, uid)
row["username"] = u.username
guard_target(db, actor, u)
row["status"] = apply(u)
db.flush()
except HTTPException as exc:
row["status"] = "failed"
row["reason"] = exc.detail if isinstance(exc.detail, str) else str(exc.detail)
results.append(row)
db.commit()
counts = {s: sum(1 for r in results if r["status"] == s) for s in ("ok", "unchanged", "failed")}
return {"action": action, "requested": len(results), **counts, "results": results}
@app.post("/api/auth/bulk-users/active")
def bulk_set_active(body: BulkActiveIn, actor: models.User = Depends(require_user_manager), db: Session = Depends(get_db)):
def apply(u):
if bool(u.is_active) == bool(body.is_active):
return "unchanged"
apply_user_active(db, actor, u, body.is_active)
return "ok"
return run_bulk(db, actor, body.user_ids, "enable" if body.is_active else "disable", apply)
@app.post("/api/auth/bulk-users/role")
def bulk_set_role(body: BulkRoleIn, actor: models.User = Depends(require_user_manager), db: Session = Depends(get_db)):
allowed = grantable_roles(actor)
if body.role not in allowed:
raise HTTPException(status_code=400, detail=f"role must be one of {', '.join(allowed)}")
def apply(u):
# Compared as stored: a legacy 'user' row moved to 'project_user' is a real
# change of the stored value, so it is applied and audited, as one at a time.
if u.role == body.role:
return "unchanged"
apply_user_role(db, actor, u, body.role)
return "ok"
return run_bulk(db, actor, body.user_ids, "role", apply)
@app.post("/api/auth/bulk-users/projects")
def bulk_set_project(body: BulkProjectIn, actor: models.User = Depends(require_user_manager), db: Session = Depends(get_db)):
"""Add every listed account to one project (with a per-project role), or remove
them from it. Implemented as the single route's replace of the caller's slice,
computed per user, so the audit row is the same shape the dialog writes."""
if body.op not in ("add", "remove"):
raise HTTPException(status_code=400, detail="op must be 'add' or 'remove'")
check_id(body.project_id)
if not db.get(models.Project, body.project_id):
raise HTTPException(status_code=404, detail="Project not found")
managed = managed_project_ids(db, actor)
if managed is not None and body.project_id not in managed:
raise HTTPException(status_code=403, detail="You don't administer the users of that project")
role = (body.role or "").strip()
if body.op == "add" and role and role not in project_scoped_grantable(actor):
raise HTTPException(
status_code=400,
detail=f"role must be '' (inherit) or one of {', '.join(project_scoped_grantable(actor))}")
pid = body.project_id
def apply(u):
mine = [m for m in db.scalars(select(models.ProjectMember)
.where(models.ProjectMember.user_id == u.id)).all()
if managed is None or m.project_id in managed]
current = {m.project_id: (m.role or "") for m in mine}
if body.op == "add":
if current.get(pid) == role:
return "unchanged"
current[pid] = role
else:
if pid not in current:
return "unchanged"
current.pop(pid)
# Roles on the caller's OTHER projects are carried over exactly as stored -
# adding someone to one job must never reset their role on another.
apply_user_projects(db, actor, u, managed, set(current),
{p: r for p, r in current.items() if r})
return "ok"
return run_bulk(db, actor, body.user_ids, "project_" + body.op, apply)
@app.post("/api/auth/bulk-users/delete")
def bulk_delete(body: BulkUsersIn, actor: models.User = Depends(require_user_manager), db: Session = Depends(get_db)):
"""Hard delete, the same as DELETE /api/auth/users/{id} (decided 2026-09-17:
no soft delete invented for the bulk case). The console asks for the typed
word DELETE first; the server's guard is the per-row rules, as for one."""
def apply(u):
apply_user_delete(db, actor, u)
return "ok"
return run_bulk(db, actor, body.user_ids, "delete", apply)
# ── Projects ─────────────────────────────────────────────────────────────────
@app.post("/api/projects")
def upsert_project(body: ProjectIn, user: models.User = Depends(auth.get_current_user), db: Session = Depends(get_db)):

278
tests/bulk_users_check.py Normal file
View File

@@ -0,0 +1,278 @@
#!/usr/bin/env python3
"""CR-020 (wave 12): bulk user administration, server side.
python tests/bulk_users_check.py
Self-contained and needs NO browser: a throwaway SQLite database in a temp
folder, the API driven in-process with FastAPI's TestClient, everything deleted
afterward. Your real wpsuite.db is never touched.
What it proves is the wave's own exit criteria, measured on the server, where
they are enforced:
- every bulk action works on a list, row by row, with the single-user rules;
- the caller's own account is refused on its own row, never the whole batch;
- a super user's batch cannot reach an account or project outside their scope;
- one AuditLog row per changed account, the same shape the single route writes;
- a partial failure is reported row by row, never as a clean success;
- project add/remove never touches the user's other projects or their roles;
- the single-user routes, now built on the same functions, behave as before.
Exit codes: 0 all passed, 1 a check failed, 2 the run could not start.
"""
import os
import shutil
import sys
import tempfile
import warnings
warnings.filterwarnings("ignore")
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
TMP = tempfile.mkdtemp(prefix="wp-bulk-users-check-")
os.environ["DATABASE_URL"] = "sqlite:///" + os.path.join(TMP, "bulk.db").replace("\\", "/")
os.environ["AUTH_SECRET_KEY"] = "bulk-users-check-key-bulk-users-check-0000"
os.environ.pop("WP_OKTA_FAKE_DIRECTORY", None)
sys.path.insert(0, ROOT)
try:
from fastapi.testclient import TestClient
from sqlalchemy import select
from server import app as A, auth, models
from server.db import SessionLocal
except Exception as exc: # noqa: BLE001
print("could not start:", exc)
sys.exit(2)
RESULTS = []
def check(name, ok, detail=""):
RESULTS.append(bool(ok))
print(f" {'PASS' if ok else 'FAIL'} {name}" + (f" ({detail})" if detail and not ok else ""))
db = SessionLocal()
def account(uid, role="project_user"):
u = models.User(id=uid, username=uid[5:], role=role, email=uid[5:] + "@example.test")
db.add(u)
db.commit()
return u
def member(uid, pid, role=""):
db.add(models.ProjectMember(id=f"pm_{uid}_{pid}", user_id=uid, project_id=pid, role=role))
db.commit()
def client(user):
c = TestClient(A.app, base_url="http://127.0.0.1", raise_server_exceptions=False)
c.cookies.set(auth.COOKIE_NAME, auth.create_token(user))
return c
def fresh():
s = SessionLocal()
s.expire_all()
return s
def audit(action, entity_id=None):
s = fresh()
q = select(models.AuditLog).where(models.AuditLog.action == action)
if entity_id:
q = q.where(models.AuditLog.entity_id == entity_id)
return s.scalars(q.order_by(models.AuditLog.at)).all()
def roles_of(uid):
s = fresh()
return {m.project_id: (m.role or "") for m in
s.scalars(select(models.ProjectMember).where(models.ProjectMember.user_id == uid))}
def by_user(resp):
return {r["user_id"]: r for r in resp.json().get("results", [])}
# ── fixture ──────────────────────────────────────────────────────────────────
admin = account("user_admin", "admin")
admin2 = account("user_admin2", "admin")
superu = account("user_super") # super user on proj1 and proj4 by membership
pu = account("user_pu") # plain project user: manages nobody
for n in range(1, 10):
account(f"user_u{n}")
for pid in ("proj1", "proj2", "proj3", "proj4"):
db.add(models.Project(id=pid, name=pid))
db.commit()
member("user_super", "proj1", "project_super_user")
member("user_super", "proj4", "project_super_user")
member("user_pu", "proj1")
for n in (1, 2, 3, 4, 5):
member(f"user_u{n}", "proj1")
member("user_u6", "proj1"); member("user_u6", "proj2", "project_admin") # partly outside super's scope
member("user_u7", "proj2") # wholly outside it
member("user_u8", "proj1"); member("user_u8", "proj4", "project_super_user") # a role super may not grant
ca, cs, cp = client(admin), client(superu), client(pu)
def single_routes():
print("\n0. the single-user routes still behave as before (now on the shared functions)")
r = ca.post("/api/auth/users/user_admin/role", json={"role": "project_user"})
check("changing your own role: 400, same words", r.status_code == 400 and "own role" in r.json()["detail"])
r = ca.post("/api/auth/users/user_admin/active", json={"is_active": False})
check("disabling yourself: 400, same words", r.status_code == 400 and "disable your own" in r.json()["detail"])
r = ca.delete("/api/auth/users/user_admin")
check("deleting yourself: 400, same words", r.status_code == 400 and "delete your own" in r.json()["detail"])
r = cs.post("/api/auth/users/user_u6/role", json={"role": "project_admin"})
check("a super user changing an account outside their scope: 403", r.status_code == 403)
r = cs.put("/api/auth/users/user_u3/projects", json={"project_ids": ["proj1", "proj2"]})
check("a super user assigning a project they don't run: 403", r.status_code == 403)
r = ca.post("/api/auth/users/user_u9/role", json={"role": "project_admin"})
check("a single role change still works and returns the directory row",
r.status_code == 200 and r.json().get("role") == "project_admin")
one = audit("role_changed", "user_u9")
check("...and writes one role_changed row", len(one) == 1 and one[0].detail == {"from": "project_user", "to": "project_admin"},
str([e.detail for e in one]))
ca.post("/api/auth/users/user_u9/role", json={"role": "project_user"})
def bulk_role():
print("\n1. bulk permissions role")
r = ca.post("/api/auth/bulk-users/role", json={
"user_ids": ["user_u1", "user_u2", "user_admin", "user_nobody", "user_u1", "bad id!"],
"role": "project_admin"})
res = by_user(r)
check("200 even though some rows fail (a partial failure is a result, not an error)", r.status_code == 200)
check("u1 and u2 changed", res["user_u1"]["status"] == "ok" and res["user_u2"]["status"] == "ok")
check("your own row is refused with its reason; the rest still ran",
res["user_admin"]["status"] == "failed" and "own role" in res["user_admin"]["reason"])
check("an unknown account is refused as 'User not found'",
res["user_nobody"]["status"] == "failed" and res["user_nobody"]["reason"] == "User not found")
check("a malformed id is refused, not crashed on", res["bad id!"]["status"] == "failed")
check("a duplicated id is applied once", r.json()["requested"] == 5)
check("counts match the rows", (r.json()["ok"], r.json()["failed"]) == (2, 3), str(r.json()))
rows = audit("role_changed", "user_u1")
check("one role_changed audit row per changed account, same shape as the single route",
len(rows) == 1 and rows[0].detail == {"from": "project_user", "to": "project_admin"}
and rows[0].actor == "admin" and rows[0].entity_type == "user", str([e.detail for e in rows]))
r = ca.post("/api/auth/bulk-users/role", json={"user_ids": ["user_u1"], "role": "project_admin"})
check("a row already in that role is 'unchanged' and writes no audit row",
by_user(r)["user_u1"]["status"] == "unchanged" and len(audit("role_changed", "user_u1")) == 1)
r = cs.post("/api/auth/bulk-users/role", json={"user_ids": ["user_u3"], "role": "admin"})
check("a super user cannot grant admin in bulk either (grantable_roles, whole request 400)",
r.status_code == 400)
r = cs.post("/api/auth/bulk-users/role", json={"user_ids": ["user_u3", "user_u6", "user_u7"],
"role": "project_admin"})
res = by_user(r)
check("super user: an account wholly inside their projects changes", res["user_u3"]["status"] == "ok")
check("super user: an account also on a project they don't run is refused, with the reason",
res["user_u6"]["status"] == "failed" and "don't administer" in res["user_u6"]["reason"],
res["user_u6"]["reason"])
check("super user: an account they cannot see is 'User not found' (no existence leak)",
res["user_u7"]["status"] == "failed" and res["user_u7"]["reason"] == "User not found")
r = ca.post("/api/auth/bulk-users/role", json={"user_ids": ["user_admin2"], "role": "project_user"})
check("demoting another admin works while one active admin remains (the caller)",
by_user(r)["user_admin2"]["status"] == "ok")
def bulk_active():
print("\n2. bulk activate / disable")
r = ca.post("/api/auth/bulk-users/active", json={"user_ids": ["user_u4", "user_admin", "user_u5"],
"is_active": False})
res = by_user(r)
check("u4 and u5 disabled", res["user_u4"]["status"] == "ok" and res["user_u5"]["status"] == "ok"
and not fresh().get(models.User, "user_u4").is_active)
check("your own account is refused on its own row",
res["user_admin"]["status"] == "failed" and "disable your own" in res["user_admin"]["reason"])
check("one user_disabled audit row each, same shape as the single route",
[e.detail for e in audit("user_disabled", "user_u4")] == [{"is_active": False}])
r = ca.post("/api/auth/bulk-users/active", json={"user_ids": ["user_u4", "user_u2"], "is_active": True})
res = by_user(r)
check("re-enable: u4 ok, u2 (already active) unchanged",
res["user_u4"]["status"] == "ok" and res["user_u2"]["status"] == "unchanged")
def bulk_projects():
print("\n3. bulk project add / remove")
r = cs.post("/api/auth/bulk-users/projects", json={"user_ids": ["user_u1", "user_u2", "user_u8"],
"project_id": "proj1", "op": "add", "role": "project_admin"})
res = by_user(r)
check("add with a per-project role: every row ok", all(res[u]["status"] == "ok" for u in ("user_u1", "user_u2", "user_u8")),
str(res))
check("the role landed on that project", roles_of("user_u1").get("proj1") == "project_admin")
check("the user's OTHER project and its role are untouched - even a role the caller could not grant",
roles_of("user_u8").get("proj4") == "project_super_user", str(roles_of("user_u8")))
rows = audit("project_access_changed", "user_u1")
check("one project_access_changed row per account, in the single route's shape",
len(rows) == 1 and set(rows[0].detail) == {"projects", "scope", "overrides"}
and rows[0].detail["scope"] == "managed", str([e.detail for e in rows]))
r = cs.post("/api/auth/bulk-users/projects", json={"user_ids": ["user_u1"], "project_id": "proj2", "op": "add"})
check("a super user cannot add anyone to a project they don't run (403)", r.status_code == 403)
r = cs.post("/api/auth/bulk-users/projects", json={"user_ids": ["user_u1"], "project_id": "proj1",
"op": "add", "role": "project_super_user"})
check("a super user cannot hand out super user on a project (400)", r.status_code == 400)
r = ca.post("/api/auth/bulk-users/projects", json={"user_ids": ["user_u6"], "project_id": "proj3", "op": "add"})
check("admin adds u6 to proj3; proj1 and proj2 memberships and roles stay",
by_user(r)["user_u6"]["status"] == "ok"
and roles_of("user_u6") == {"proj1": "", "proj2": "project_admin", "proj3": ""}, str(roles_of("user_u6")))
r = cs.post("/api/auth/bulk-users/projects", json={"user_ids": ["user_u2", "user_u9"], "project_id": "proj1", "op": "remove"})
res = by_user(r)
check("remove: u2 taken off proj1", res["user_u2"]["status"] == "ok" and "proj1" not in roles_of("user_u2"))
check("remove: someone not on it is 'User not found' to a super user who cannot see them",
res["user_u9"]["status"] == "failed")
r = ca.post("/api/auth/bulk-users/projects", json={"user_ids": ["user_u9"], "project_id": "proj1", "op": "remove"})
check("remove: an admin removing someone not on the project gets 'unchanged'",
by_user(r)["user_u9"]["status"] == "unchanged")
r = ca.post("/api/auth/bulk-users/projects", json={"user_ids": ["user_u1"], "project_id": "proj1", "op": "replace"})
check("only add and remove exist: no replace-the-whole-list (400)", r.status_code == 400)
def bulk_delete():
print("\n4. bulk delete")
r = ca.post("/api/auth/bulk-users/delete", json={"user_ids": ["user_u5", "user_admin", "user_gone"]})
res = by_user(r)
check("u5 deleted", res["user_u5"]["status"] == "ok" and fresh().get(models.User, "user_u5") is None)
check("your own account is refused on its own row, the others still ran",
res["user_admin"]["status"] == "failed" and "delete your own" in res["user_admin"]["reason"])
check("an account that no longer exists is reported, not hidden",
res["user_gone"]["status"] == "failed" and res["user_gone"]["reason"] == "User not found")
check("one user_deleted audit row, same shape as the single route",
[e.detail for e in audit("user_deleted", "user_u5")] == [{"role": "project_user"}])
check("the deleted account's memberships went with it", roles_of("user_u5") == {})
def gates():
print("\n5. who may call, and how much")
for path, body in (("role", {"role": "project_user"}), ("active", {"is_active": False}),
("projects", {"project_id": "proj1", "op": "add"}), ("delete", {})):
r = cp.post(f"/api/auth/bulk-users/{path}", json={"user_ids": ["user_u3"], **body})
check(f"a plain project user is refused /bulk-users/{path} (403)", r.status_code == 403, str(r.status_code))
anon = TestClient(A.app, base_url="http://127.0.0.1", raise_server_exceptions=False)
check("no session: 401", anon.post("/api/auth/bulk-users/delete", json={"user_ids": ["user_u3"]}).status_code == 401)
r = ca.post("/api/auth/bulk-users/active", json={"user_ids": [f"user_x{i}" for i in range(501)], "is_active": False})
check("more than 500 ids in one request is refused (422)", r.status_code == 422, str(r.status_code))
SECTIONS = [single_routes, bulk_role, bulk_active, bulk_projects, bulk_delete, gates]
def main() -> int:
print("Wave 12 bulk user administration - server checks")
try:
for section in SECTIONS:
try:
section()
except Exception as exc: # noqa: BLE001 - a missing route must read as FAIL, not a traceback
check(f"section {section.__name__} ran to the end", False, f"{type(exc).__name__}: {exc}")
finally:
db.close()
A.engine.dispose()
shutil.rmtree(TMP, ignore_errors=True)
passed = sum(RESULTS)
print(f"\n{passed}/{len(RESULTS)} checks passed.")
return 0 if passed == len(RESULTS) else 1
if __name__ == "__main__":
sys.exit(main())