diff --git a/server/app.py b/server/app.py index 3df79e3..3204bf1 100644 --- a/server/app.py +++ b/server/app.py @@ -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)): diff --git a/tests/bulk_users_check.py b/tests/bulk_users_check.py new file mode 100644 index 0000000..9c6df36 --- /dev/null +++ b/tests/bulk_users_check.py @@ -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())