diff --git a/docs/reference/baseline/wave-12/users-1440-selected.png b/docs/reference/baseline/wave-12/users-1440-selected.png new file mode 100644 index 0000000..49afcf5 Binary files /dev/null and b/docs/reference/baseline/wave-12/users-1440-selected.png differ diff --git a/docs/reference/baseline/wave-12/users-1440.png b/docs/reference/baseline/wave-12/users-1440.png new file mode 100644 index 0000000..a72c13c Binary files /dev/null and b/docs/reference/baseline/wave-12/users-1440.png differ diff --git a/docs/reference/baseline/wave-12/users-390-selected.png b/docs/reference/baseline/wave-12/users-390-selected.png new file mode 100644 index 0000000..d4784b7 Binary files /dev/null and b/docs/reference/baseline/wave-12/users-390-selected.png differ diff --git a/docs/reference/baseline/wave-12/users-390.png b/docs/reference/baseline/wave-12/users-390.png new file mode 100644 index 0000000..495b676 Binary files /dev/null and b/docs/reference/baseline/wave-12/users-390.png differ diff --git a/docs/reference/file-map.md b/docs/reference/file-map.md index 54e6428..17667ab 100644 --- a/docs/reference/file-map.md +++ b/docs/reference/file-map.md @@ -316,6 +316,17 @@ python tests/critical_reopen_check.py # BL-021 - on-hold mail reaches PM + CM python tests/console_dialogs_check.py # BL-024 - consoles/launcher: 21 natives -> 0 17 checks ``` +Wave 12 (CR-020, bulk user editing) adds these: + +```bash +python tests/bulk_users_check.py # CR-020 - bulk routes, guards, audit, CSV; NO browser 61 checks +python tests/bulk_users_ui_check.py # CR-020 - selection, toolbar, CSV, typed delete at 1440/390px +``` + +`console_dialogs_check.py` gained section 4 (the bulk delete prompt). `tests/cdp.py` +passes `--do-not-de-elevate` on Windows so the probes start from an Administrator +shell (same change as wave 16, T16.4). + **Three probes were re-pointed at `T7.1`.** `sections_check.py` 5b drove the live cross-frame toggle hand-off, which no longer exists; it now pins the surviving path and the fact that an UNSAVED toggle correctly does not travel - a behaviour change, recorded diff --git a/docs/waves/backlog.md b/docs/waves/backlog.md index e28f292..ddb0758 100644 --- a/docs/waves/backlog.md +++ b/docs/waves/backlog.md @@ -662,3 +662,37 @@ deliberately deferred. worth confirming rather than assuming). - **Suggested wave or follow-up:** next housekeeping pass — needs Nick on whether to delete, archive, or rewrite it as historical record. + +### BL-060 — A super user is told they can change access the server then refuses + +- **Found during:** T12.6 (CR-020 verification, the CSV path) +- **Where:** `server/app.py` `manage_user_problem` (the reason text), `get_user_projects` / `set_user_projects` (the rule) +- **What:** for an account that is also on a project the super user does not + administer, the refusal reason ends "You can still change their access and + role on your own projects." Neither the project-access dialog's routes nor + the CR-020 bulk project route allow that: all of them call + `require_manage_user`, which refuses the account. The bulk route mirrors the + single route on purpose (CR-020: same rules), so the words promise something + neither path does. Either the text or the rule is wrong; which one is a + product call. +- **Why not now:** changing either is out of CR-020's scope (the wave must + not widen what a super user can do), and it needs a decision. +- **Suggested wave or follow-up:** needs Nick: should a super user be able to + add or remove a shared account on their own projects? Then fix the text or + the rule, not both. + +### BL-061 — The sync badge covers controls while it shows + +- **Found during:** T12.6 (the wave 12 screenshots) +- **Where:** `html/project-data.js` `renderSyncBadge` (fixed bottom-right, `z-index:9998`) +- **What:** for about 2 seconds after each sync the "Everything sent to the + project" badge sits over whatever is in the bottom-right corner: a Delete + button on the User Directory at 1440px, the bulk bar's "Set permissions" at + 390px. It is `pointer-events:none`, so clicks pass through, but the control is + hidden while it shows, and on the console pages there is no outbox work to + report at all. +- **Why not now:** `project-data.js` is shared by every page and owned by the + outbox work in wave 14 (T14.1 to T14.3 change this badge's states anyway). +- **Suggested wave or follow-up:** wave 14, alongside T14.1's badge changes: + do not show the badge on pages with nothing to sync, and keep it clear of + page controls. diff --git a/docs/waves/decisions-2026-09-17.md b/docs/waves/decisions-2026-09-17.md new file mode 100644 index 0000000..901385b --- /dev/null +++ b/docs/waves/decisions-2026-09-17.md @@ -0,0 +1,355 @@ +# Decisions — September 17, 2026 + +Three items. Like `D11`, `D15`, `D16` and `D17`, these are new scope raised after +R2 closed out (see `docs/reference/completion.md`, T9.7), not a reopening of +anything already decided there. + +`CR-019` and `CR-020` get `CR` ids because they are field/product-facing feature +requests — the same kind of thing `CR-001`-`CR-018` were — not internal +engineering calls made mid-build. `D18` gets a `D` id because it is exactly that: +an internal security/architecture call, the same category as `D15` (Okta vs. +LDAPS), not a feature a user asked for. + +Requested/raised by Matt Mabrey, 2026-09-17. + +--- + +## CR-019 — Usage and activity metrics (admin console) + +- **Area:** Admin Console / Monitoring +- **Priority:** proposed High — the current admin console has no reliable way to + answer "who is using this and how much," which is the same visibility gap the + original UX review found in `B4` (numbers that look authoritative but are not). +- **Source:** Matt Mabrey, 2026-09-17. + +### Why this is not already built + +`D5`/`T7.10` already shipped a usage-analytics feature — `html/wp-usage.js`, with +a report at `admin.js:666-699` — but it reads `localStorage`, which is scoped to +one browser. The report's own empty state says exactly this: *"No usage recorded +in this browser yet."* It cannot show who across the team is active or what they +use, because each person's activity exists only on their own machine. This is the +same class of defect `B4` named for the pipeline strip — a number that looks +authoritative but is not — just never generalized to this feature. `CR-019` is +therefore new server-side work, not a UI addition on top of what exists. + +Two things already in the schema are relevant and reused rather than duplicated: +`User.last_login_at` (one timestamp, no history) and `AuditLog` (append-only, +already records business mutations — WP created, status changed, role changed — +per user, with a timestamp). Neither captures navigation or feature-open events, +which is the actual gap. + +### Intent + +Give admins a real, server-backed picture of who is using the suite, what parts +of it they use, and how active they are — replacing the per-browser report as +the thing anyone actually looks at. + +### Decisions, made 2026-09-17 + +1. **Retention: indefinite.** No automatic purge of usage-event data. (Separate + from `AuditLog`'s own retention, which this does not change.) +2. **Scope: suite-wide, filterable.** Not per-project by default; the console + provides filters (date range, project, user, tool/page) rather than scoping + the data itself. +3. **Export: raw view shows real identities; export supports sanitization.** + The admin console's own tables and the CSV export both default to real + usernames — this is an internal audit tool, not a public one. But the export + also offers a "sanitize" toggle that replaces the actor with a **stable + pseudonymous id** (a per-user hash, consistent across rows and across + export runs) rather than dropping the identity field outright — so an + external system (Power BI or similar) can still group and trend "by user" + without ever receiving a real name. Flagged here as the recommended + approach rather than the only one Matt confirmed in so many words: if a + fully-anonymous (no stable id at all) export turns out to be what's + actually wanted, that is a one-line change to the same feature, raise it + in the PR rather than treating it as blocking. +4. **The old per-browser report is retired**, not kept alongside the new one. + Once `CR-019` ships, `admin.js`'s existing `usage-admin` panel (reading + `WPUsage.load(...)` per browser) is removed rather than left next to the + real report, where it would show a smaller, misleading number for whoever + happens to have it open. `html/wp-usage.js` and its two call sites + (`html/work-package-suite-app.js`'s wizard dwell-tracking, and the + creator's equivalent) are a separate question — the *recording* code can + stay or go independent of the *admin report* being retired, since dwell + events were never reliably tied to a real identity anyway. Default to + removing both unless a task finds a reason to keep the recorder; log that + reason rather than deciding it here. + +### Acceptance criteria + +- A new admin-only tab in `admin.html` (same role gate as the User Directory) + shows: active users over a selectable date range (day/week/month), each + user's last-active timestamp, and a breakdown of which tools/pages get + opened and how often. +- Server-side event capture, keyed to the authenticated session (real identity, + not a browser-local guess) — a new table, not an extension of `AuditLog`, + since page-open/navigation events are not business mutations and mixing them + in would make `AuditLog` noisy for its existing, narrower purpose. +- The console's filters cover date range, project, user, and tool/page, and + combine (e.g., "user X, last 30 days, field view only"). +- CSV export from the console, in both raw (real usernames) and sanitized + (stable pseudonymous id per user) modes. +- Retention is indefinite; nothing in this item purges data. +- View-only, refresh-on-load. No alerting — matches how the rest of the admin + console works today; if that changes later it is new scope, not a rider on + this item. +- The old per-browser "Usage" report and its admin-console panel are removed + in the same wave, not left running alongside the new one. +- Accessible per `CLAUDE.md`'s standing `C1` rules (this is a new component, + not a legacy one — it ships accessible or it is not done, same as + everything else built since wave 7). + +### Frontend/backend boundary + +This needs server work, the same way `CR-004`/`CR-018`/`B4` did: a real table, +a capture endpoint, an aggregation endpoint, and an export endpoint. If a task +under this item is being built by writing to `localStorage`, it is rebuilding +the exact defect this item exists to replace — stop and say so, per +`CLAUDE.md`. + +### Scheduling + +New wave. Wave 10 (Okta) is merged, so this does not wait on anything. +Task breakdown: `docs/waves/wave-11.md`. + +--- + +## CR-020 — Bulk editing of users in the admin console + +- **Area:** Admin Console / User Directory +- **Priority:** proposed High — three of the four actions below touch access + control (role, project assignment, active/disabled) and the fourth is a hard + delete; getting the guardrails right matters more than getting it built fast. +- **Source:** Matt Mabrey, 2026-09-17. + +### Why this is not already built + +Every user-editing action in `html/users.js` today is one row, one action: +a role ` - + + + +
+
+ + +
+
Loading…
diff --git a/html/users.js b/html/users.js index 20ecb3e..c02447f 100644 --- a/html/users.js +++ b/html/users.js @@ -23,6 +23,10 @@ let _users = []; // the directory as the server scoped it let _scope = null; // GET /api/auth/user-scope let _meId = null; +// CR-020: the rows checked for a bulk action. Client-side UI state only - every +// bulk action is decided and audited by the server, row by row (T12.1). +let _selected = new Set(); +let _shownSelectable = []; // ids the current filter shows AND this caller may select // ── boot ────────────────────────────────────────────────────────────────────── async function boot(){ @@ -40,6 +44,7 @@ async function boot(){ renderScope(); } renderCreateForm(); + renderBulkActions(); loadUsers(); } @@ -90,11 +95,309 @@ async function loadUsers(){ } banner('users-banner','', ''); _users = json; + // Fresh data: any earlier selection may name accounts that changed or are gone. + clearSelection(false); renderUsers(); } function manages(){ return !!(_scope && _scope.can_manage_users); } +// ── selection (CR-020, T12.2) ───────────────────────────────────────────────── +// A row is selectable when this caller may change the account. Your own row is +// not: every bulk action that could touch it (disable, demote, delete) is refused +// for your own account, so offering it would only produce a guaranteed failure. +function selectable(u){ return manages() && !!u.manageable && u.id !== _meId; } + +// The search box and the filter both decide which rows are shown. Changing either +// clears the selection (decided 2026-10-06), so no row hidden by the filter can +// stay selected and be acted on without being seen. +function filterChanged(){ + const had = _selected.size; + clearSelection(false); + renderUsers(); + banner('sel-banner', '', had ? 'Selection cleared: the filter changed. Select the rows again.' : ''); +} + +function clearSelection(announce){ + const had = _selected.size; + _selected = new Set(); + updateSelectionUI(); + banner('sel-banner', '', (announce && had) ? 'Selection cleared.' : ''); +} + +function setRowSelected(id, on){ + if(on) _selected.add(id); else _selected.delete(id); +} + +// Select-all acts on the rows the filter shows, never on the whole directory. +function toggleSelectAll(on){ + _shownSelectable.forEach(id => setRowSelected(id, on)); + banner('sel-banner', '', ''); + updateSelectionUI(); +} + +// Reflect _selected into the page without re-rendering the table, so keyboard +// focus stays on the checkbox that was just used. +function updateSelectionUI(){ + const wrap = document.getElementById('users-table'); + if(wrap){ + wrap.querySelectorAll('input.selbox').forEach(cb => { + const on = _selected.has(cb.dataset.id); + cb.checked = on; + const tr = cb.closest('tr'); + if(tr) tr.classList.toggle('is-selected', on); + }); + const all = document.getElementById('sel-all'); + if(all){ + const n = _shownSelectable.filter(id => _selected.has(id)).length; + all.checked = n > 0 && n === _shownSelectable.length; + all.indeterminate = n > 0 && n < _shownSelectable.length; + all.disabled = !_shownSelectable.length; + } + } + const bar = document.getElementById('bulk-bar'); + if(bar){ + const n = _selected.size; + bar.hidden = n === 0; + const c = document.getElementById('bulk-count'); + if(c) c.textContent = n + ' selected'; + } +} + +// One listener for every checkbox in the table (event delegation): no ids are +// bound into inline handlers, so there is nothing to escape. +document.addEventListener('change', e => { + const t = e.target; + if(!(t instanceof HTMLInputElement)) return; + if(t.id === 'sel-all'){ toggleSelectAll(t.checked); return; } + if(t.classList.contains('selbox')){ + setRowSelected(t.dataset.id, t.checked); + banner('sel-banner', '', ''); + updateSelectionUI(); + } +}); + +// ── bulk actions (CR-020, T12.3) ────────────────────────────────────────────── +// The toolbar offers only what this caller may do: the roles they may grant, the +// projects they administer, the per-project roles they may hand out. The server +// re-checks every row anyway (T12.1); this is so nobody is offered a choice that +// can only fail. +function renderBulkActions(){ + const box = document.getElementById('bulk-actions'); + const csvBtn = document.getElementById('csv-btn'); + if(csvBtn) csvBtn.hidden = !manages(); + if(!box || !manages()) return; + const grantable = PERM_ROLES.filter(r => (_scope.grantable_roles || []).indexOf(r) >= 0); + const projects = (_scope.managed_projects || []).slice() + .sort((a,b) => (a.archived?1:0) - (b.archived?1:0)); + const projRoles = PROJECT_SCOPED_ROLES.filter(r => (_scope.grantable_project_roles || []).indexOf(r) >= 0); + const group = (label, inner) => '
'+ + ''+uesc(label)+''+inner+'
'; + box.innerHTML = + group('Permissions', + ''+ + '') + + group('Sign-in', + ''+ + '') + + (projects.length ? group('Project access', + ''+ + ''+ + ''+ + '') : '') + + group('Delete', + ''); +} + +function selectedIds(){ return _users.filter(u => _selected.has(u.id)).map(u => u.id); } +function people(n){ return n + ' user' + (n === 1 ? '' : 's'); } +function selVal(id){ return (document.getElementById(id) || {}).value || ''; } +function selText(id){ + const s = document.getElementById(id); + return (s && s.selectedIndex >= 0) ? s.options[s.selectedIndex].text : ''; +} + +// One path for every bulk action: confirm through the dialog kit with the exact +// count, send, report row by row, reload. A reload clears the selection, which is +// right: the rows may have changed underneath it. +async function runBulk(path, body, ask){ + const ids = selectedIds(); + if(!ids.length) return; + if(!(await wpConfirmDialog({title: ask.title, okLabel: ask.ok, message: ask.message(ids.length)}))) return; + return sendBulk(path, body, ask.title, ids); +} + +async function sendBulk(path, body, title, ids){ + bannerHtml('bulk-banner', '', uesc(title)+': working on '+uesc(people(ids.length))+'…'); + const { status, json } = await api('POST', path, Object.assign({ user_ids: ids }, body)); + if(status !== 200 || !json || !Array.isArray(json.results)){ + bannerHtml('bulk-banner', 'bad', '✕ '+uesc(apiError(status, json, title+' failed'))+' Nothing was changed.'); + return; + } + showBulkResult(json, title); + loadUsers(); +} + +// T12.5: delete is permanent (a hard delete, as for one account) and one bad +// multi-select now removes many, so it asks more than the other actions do: +// every affected username is listed, and nothing is sent until the word DELETE +// is typed, whatever the count (confirmed 2026-10-06). Your own account cannot +// be selected; if it ever reached the request, the server refuses that row and +// the report names it. +async function bulkDelete(){ + const chosen = _users.filter(u => _selected.has(u.id)); + if(!chosen.length) return; + const n = chosen.length; + const typed = await wpPromptDialog({ + title: 'Delete '+people(n), + message: 'Delete '+(n === 1 ? 'this account' : 'these '+n+' accounts')+'? Each one, and every project '+ + 'assignment it has, is removed. This cannot be undone. Disable them instead if you only want to '+ + 'block sign-in.\n\n'+chosen.map(u => '• '+u.username+(u.full_name ? ' ('+u.full_name+')' : '')).join('\n'), + label: 'Type DELETE to confirm', + value: '', + okLabel: 'Delete '+people(n), + validate: v => v === 'DELETE' ? '' : 'Type DELETE, in capital letters, to confirm.', + }); + if(typed !== 'DELETE') return; + return sendBulk('/api/auth/bulk-users/delete', {}, 'Delete accounts', chosen.map(u => u.id)); +} + +// Every row is accounted for: changed, already so, or failed with the server's +// reason. A batch that partly failed never reads as a success (CR-020). +function showBulkResult(json, title){ + const failed = json.results.filter(r => r.status === 'failed'); + const parts = [json.ok+' changed']; + if(json.unchanged) parts.push(json.unchanged+' already set'); + if(failed.length) parts.push(failed.length+' failed'); + const kind = !failed.length ? 'ok' : (json.ok + json.unchanged ? 'warn' : 'bad'); + const lead = (failed.length ? (kind === 'bad' ? '✕ ' : '⚠ ') : '✓ ')+uesc(title)+': '+parts.join(', ')+'.'; + const list = failed.length + ? '' + : ''; + bannerHtml('bulk-banner', kind, lead + list); +} + +function bannerHtml(id, kind, html){ + const el = document.getElementById(id); + if(!el) return; + el.className = 'banner' + (kind ? ' '+kind : ''); + el.innerHTML = html; +} + +function bulkRole(){ + const role = selVal('bulk-role'); + if(!role) return; + return runBulk('/api/auth/bulk-users/role', { role }, { + title: 'Set permissions', ok: 'Change permissions', + message: n => 'Set permissions to '+(PERM_LABELS[role] || role)+' for '+people(n)+'?\n\n'+ + 'Each account is checked on its own. Any that cannot be changed are listed afterwards.'}); +} + +function bulkActive(on){ + return runBulk('/api/auth/bulk-users/active', { is_active: !!on }, { + title: on ? 'Enable accounts' : 'Disable accounts', ok: on ? 'Enable' : 'Disable', + message: n => (on ? 'Enable sign-in for ' : 'Disable sign-in for ')+people(n)+'?'+ + (on ? '' : '\n\nA disabled account cannot sign in. Nothing else about it changes.')}); +} + +function bulkProject(op){ + const pid = selVal('bulk-project'); + if(!pid) return; + const role = op === 'add' ? selVal('bulk-project-role') : ''; + const pname = selText('bulk-project'); + return runBulk('/api/auth/bulk-users/projects', { project_id: pid, op, role }, { + title: op === 'add' ? 'Add to project' : 'Remove from project', + ok: op === 'add' ? 'Add' : 'Remove', + message: n => op === 'add' + ? 'Add '+people(n)+' to '+pname+' with '+(role ? PERM_LABELS[role]+' on that project' : 'their account role')+'?\n\n'+ + 'Their other projects, and their roles there, stay as they are.' + : 'Remove '+people(n)+' from '+pname+'?\n\nTheir other projects stay as they are.'}); +} + +// ── CSV upload (CR-020, T12.4) ──────────────────────────────────────────────── +// The file holds usernames only (decided 2026-10-06). The server reads it and +// answers line by line; the accepted accounts become the ordinary selection, so +// the action, its confirmation and its row-by-row report are the same ones the +// checkboxes use. A CSV cannot reach an account a checkbox could not: the bulk +// route re-checks every row. +const CSV_MAX_BYTES = 1024 * 1024; + +// Blob.text() where the browser has it, FileReader where it does not (older +// tablet browsers). +function readFileText(file){ + if(typeof file.text === 'function') return file.text(); + return new Promise((resolve, reject) => { + const r = new FileReader(); + r.onload = () => resolve(String(r.result || '')); + r.onerror = () => reject(r.error); + r.readAsText(file); + }); +} + +function pickCsv(){ + const f = document.getElementById('csv-file'); + if(f){ f.value = ''; f.click(); } +} + +document.addEventListener('change', e => { + if(e.target && e.target.id === 'csv-file' && e.target.files && e.target.files[0]) loadCsv(e.target.files[0]); +}); + +async function loadCsv(file){ + if(file.size > CSV_MAX_BYTES){ + bannerHtml('csv-banner', 'bad', '✕ '+uesc(file.name)+' is larger than 1 MB. Split it and load the parts one at a time.'); + return; + } + let text = ''; + try { text = await readFileText(file); } + catch(_){ bannerHtml('csv-banner', 'bad', '✕ Could not read '+uesc(file.name)+'.'); return; } + bannerHtml('csv-banner', '', 'Reading '+uesc(file.name)+'…'); + const { status, json } = await api('POST', '/api/auth/bulk-users/resolve', { text }); + if(status !== 200 || !json || !Array.isArray(json.rows)){ + bannerHtml('csv-banner', 'bad', '✕ '+uesc(apiError(status, json, 'Could not read the list'))); + return; + } + // Show everyone, so every accepted account is a visible, checked row: a + // selection must never include a row the filter hides. + const s = document.getElementById('user-search'), f = document.getElementById('user-filter'); + if(s) s.value = ''; + if(f) f.value = ''; + await loadUsers(); + const want = new Set(json.user_ids || []); + _shownSelectable.forEach(id => { if(want.has(id)) _selected.add(id); }); + updateSelectionUI(); + const missed = [...want].filter(id => !_selected.has(id)).length; + const rejected = json.rows.filter(r => r.status !== 'ok'); + const lead = (rejected.length || missed ? '⚠ ' : '✓ ')+uesc(file.name)+': '+json.read+' line'+(json.read===1?'':'s')+' read, '+ + _selected.size+' selected'+(rejected.length ? ', '+rejected.length+' rejected' : '')+'.'+ + (missed ? ' '+missed+' accepted account'+(missed===1?' is':'s are')+' no longer in the directory; reload and try again.' : '')+ + (_selected.size ? ' Pick an action in the bulk bar to apply it to the selected accounts.' : ''); + const list = rejected.length + ? '' + : ''; + bannerHtml('csv-banner', (rejected.length || missed) ? 'warn' : 'ok', lead + list); +} + +function selCell(u){ + if(!selectable(u)){ + const why = u.id === _meId ? 'Your own account: change it one setting at a time' + : (u.manage_blocked_reason || 'You cannot change this account'); + return ''+ + ''; + } + return ''; +} + function renderUsers(){ const wrap = document.getElementById('users-table'); const q = ((document.getElementById('user-search')||{}).value||'').trim().toLowerCase(); @@ -116,7 +419,8 @@ function renderUsers(){ (u.project_role||'')+' '+roleLabel(u.role)).toLowerCase().indexOf(q) >= 0; }); const count = '
'+list.length+' of '+total+' '+(total===1?'person':'people')+'
'; - if(!list.length){ wrap.innerHTML = count+'
Nothing matches.
'; return; } + _shownSelectable = list.filter(selectable).map(u => u.id); + if(!list.length){ wrap.innerHTML = count+'
Nothing matches.
'; updateSelectionUI(); return; } const head = manages() ? ['Username','Name','Email', @@ -130,9 +434,16 @@ function renderUsers(){ 'Status']; const ths = head.map(h => Array.isArray(h) ? ''+uesc(h[0])+'' : ''+uesc(h)+'').join(''); + // CR-020: a selection column for anyone who manages accounts. Select-all names + // how many rows it covers, because it covers only what the filter shows. + const selTh = manages() + ? '' + : ''; const rows = list.map(manages() ? managerRow : readonlyRow).join(''); - wrap.innerHTML = count+'
'+ths+ + wrap.innerHTML = count+'
'+selTh+ths+ ''+rows+'
'+legend(); + updateSelectionUI(); } function legend(){ @@ -189,6 +500,7 @@ function managerRow(u){ if(!can && !me) actions.push('read-only'); return ''+ + selCell(u)+ ''+uesc(u.username)+''+(me?'you':'')+''+ ''+uesc(u.full_name||'')+''+ // The address is truncated with the full value on the title: a long one used to diff --git a/server/app.py b/server/app.py index 3df79e3..73b8666 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,227 @@ 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) + + +class BulkResolveIn(BaseModel): + text: str = Field(default="", max_length=200_000) + + +_CSV_HEADER_WORDS = ("username", "user", "login", "email", "user name") + + +@app.post("/api/auth/bulk-users/resolve") +def bulk_resolve(body: BulkResolveIn, actor: models.User = Depends(require_user_manager), db: Session = Depends(get_db)): + """CR-020 (T12.4): turn an uploaded list of usernames into the account ids a + bulk action will run on - a second way IN to the same four bulk routes, not a + third copy of their rules. The CSV holds usernames only (decided 2026-10-06); + the action is chosen in the console and applies to every accepted row. + + Validate and report, the CR-005 pattern: every line is either accepted or + rejected WITH ITS LINE NUMBER and a reason - never silently skipped. A line is + rejected when it names nobody this caller can see (the same 'not found' a + hidden account gets everywhere else), an account they may not change (with + the same reason the single route would give), their own account, or a + username already listed on an earlier line. Nothing is changed here; the + bulk route the console calls next re-checks every row anyway.""" + rows = [] + seen: dict[str, int] = {} + visible = visible_user_ids(db, actor) + cache: dict = {} + for line_no, raw in enumerate((body.text or "").splitlines(), start=1): + line = raw.strip().lstrip("") + if not line: + continue + cell = re.split(r"[,;\t]", line, maxsplit=1)[0].strip().strip('"').strip() + if not cell: + rows.append({"line": line_no, "text": line[:120], "status": "rejected", + "reason": "no username in the first column"}) + continue + if line_no == 1 and cell.lower() in _CSV_HEADER_WORDS: + continue # header row + row = {"line": line_no, "text": cell[:120], "status": "rejected", "reason": "", + "user_id": None, "username": ""} + if any(ord(ch) < 32 for ch in cell) or len(cell) > 120: + row["reason"] = "not a valid username" + rows.append(row) + continue + key = cell.lower() + if key in seen: + row["reason"] = f"duplicate of line {seen[key]}" + rows.append(row) + continue + seen[key] = line_no + u = db.scalars(select(models.User).where(func.lower(models.User.username) == key)).first() + if u is None: + # An offboarding list usually carries email addresses. Accepted only + # when exactly one account has that address, so a shared or reused + # address can never pick the wrong person. + by_mail = db.scalars(select(models.User).where(func.lower(models.User.email) == key)).all() + u = by_mail[0] if len(by_mail) == 1 else None + if u is None or (visible is not None and u.id not in visible): + row["reason"] = "User not found" + elif u.id == actor.id: + row["reason"] = "your own account - change it one setting at a time" + else: + problem = manage_user_problem(db, actor, u, cache) + if problem: + row["reason"] = problem + else: + row.update(status="ok", user_id=u.id, username=u.username) + rows.append(row) + accepted = [r for r in rows if r["status"] == "ok"] + return {"read": len(rows), "accepted": len(accepted), "rejected": len(rows) - len(accepted), + "user_ids": [r["user_id"] for r in accepted], "rows": rows} + + +@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/browser_check.py b/tests/browser_check.py index 8212657..2d43104 100644 --- a/tests/browser_check.py +++ b/tests/browser_check.py @@ -207,9 +207,12 @@ def run(page, base, tok): chk("auth resolved to the admin account", page.eval("(window.WP_USER||{}).role") == "admin") chk("the directory is visible", page.eval("getComputedStyle(document.getElementById('users-main')).display") != "none") - chk("manager table renders 9 columns", - page.eval("document.querySelectorAll('#users-table thead th').length") == 9, + # 10 since CR-020 (T12.2): the 9 data columns plus the row-selection column. + chk("manager table renders 10 columns (9 + row selection)", + page.eval("document.querySelectorAll('#users-table thead th').length") == 10, page.eval("document.querySelectorAll('#users-table thead th').length")) + chk("...the first is the selection column", + page.eval("!!document.querySelector('#users-table thead th.selcell #sel-all')")) chk("an admin sees every account in the fixture (7)", page.eval("document.querySelectorAll('#users-table tbody tr').length") == 7, page.eval("document.querySelectorAll('#users-table tbody tr').length")) @@ -237,15 +240,22 @@ def run(page, base, tok): # Your own row: permissions locked so you cannot demote yourself, job function # still editable. Asserted on the two cells, not "no select in the row". + # The cells are found by their HEADER, not by position: CR-020's selection + # column moved every column one to the right and these asserted r.cells[3] + # and [4], which then read the username and the email (T12.6). ROW = ("const r=[...document.querySelectorAll('#users-table tbody tr')]" - ".find(r=>r.querySelector('.me-tag'));") + ".find(r=>r.querySelector('.me-tag'));" + "const col=n=>[...document.querySelectorAll('#users-table thead th')]" + ".findIndex(h=>h.textContent.trim().toLowerCase()===n);") def own(q): - return "(()=>{" + ROW + "if(!r)return false;const c=r.cells[3];return " + q + "})()" + return "(()=>{" + ROW + "if(!r)return false;const c=r.cells[col('permissions')];return " + q + "})()" chk("your own permissions cell is locked, not a dropdown", page.eval(own("!c.querySelector('select') && !!c.querySelector('.tag')"))) chk("...and wears the Administrator pill", page.eval(own("!!c.querySelector('.tag.admin')"))) chk("...while your job function stays editable", - page.eval("(()=>{" + ROW + "return !!r && !!r.cells[4].querySelector('select')})()")) + page.eval("(()=>{" + ROW + "return !!r && !!r.cells[col('project role')].querySelector('select')})()")) + chk("...and your own row cannot be ticked for a bulk action", + page.eval("(()=>{" + ROW + "return !!r && !r.querySelector('input.selbox')})()")) page.eval("[...document.querySelectorAll('#users-table tbody button')]" ".find(b=>/project/i.test(b.textContent)).click()") diff --git a/tests/bulk_users_check.py b/tests/bulk_users_check.py new file mode 100644 index 0000000..8b335be --- /dev/null +++ b/tests/bulk_users_check.py @@ -0,0 +1,326 @@ +#!/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 csv_resolve(): + print("\n6. CSV upload: usernames in, a line-by-line report out (T12.4)") + text = ("username\n" # header, skipped + "u3\n" + "U3\n" # same person, different case: a duplicate + "nobody\n" + "\n" # blank lines are not rows + "u6\n" # visible to the super user, but also on a project they don't run + "u7\n" # not visible to the super user at all + "super\n" # the caller themself + "u8@example.test,extra column\n" # an email address, matched to exactly one account + ",\n") # an empty first column + r = cs.post("/api/auth/bulk-users/resolve", json={"text": text}) + j = r.json() + rows = {x["line"]: x for x in j["rows"]} + check("200 with a row for every non-blank line after the header", + r.status_code == 200 and sorted(rows) == [2, 3, 4, 6, 7, 8, 9, 10], sorted(rows)) + check("a valid username is accepted", rows[2]["status"] == "ok" and rows[2]["user_id"] == "user_u3") + check("a repeated username is rejected as a duplicate of its first line, not applied twice", + rows[3]["status"] == "rejected" and rows[3]["reason"] == "duplicate of line 2") + check("an unknown username: 'User not found', with its line number", rows[4]["reason"] == "User not found") + check("an account the caller may not change: rejected with the single route's own reason", + rows[6]["status"] == "rejected" and "don't administer" in rows[6]["reason"], rows[6]["reason"]) + check("an account the caller cannot see: 'User not found' (a CSV leaks no more than the table)", + rows[7]["reason"] == "User not found") + check("the caller's own account is rejected with a clear reason", "your own account" in rows[8]["reason"]) + check("an email address resolves when exactly one account has it", + rows[9]["status"] == "ok" and rows[9]["user_id"] == "user_u8") + check("an empty first column is rejected, not skipped", rows[10]["reason"] == "no username in the first column") + check("the ids handed back are exactly the accepted rows", + j["user_ids"] == ["user_u3", "user_u8"] and (j["accepted"], j["rejected"]) == (2, 6), str(j["user_ids"])) + r = cs.post("/api/auth/bulk-users/active", json={"user_ids": j["user_ids"] + ["user_u7"], "is_active": False}) + res = by_user(r) + check("the CSV's ids go through the same bulk route and the same guards: an id slipped in by hand " + "is still refused", res["user_u7"]["status"] == "failed" and res["user_u3"]["status"] == "ok") + ca.post("/api/auth/bulk-users/active", json={"user_ids": ["user_u3", "user_u8"], "is_active": True}) + r = cp.post("/api/auth/bulk-users/resolve", json={"text": "u3"}) + check("a plain project user cannot resolve a list (403)", r.status_code == 403) + r = cs.post("/api/auth/bulk-users/resolve", json={"text": "x" * 200_001}) + check("an oversized upload is refused (422)", r.status_code == 422) + s = fresh() + s.add(models.User(id="user_twin1", username="twin1", email="shared@example.test")) + s.add(models.User(id="user_twin2", username="twin2", email="shared@example.test")) + s.commit() + r = ca.post("/api/auth/bulk-users/resolve", json={"text": "shared@example.test"}) + check("an email shared by two accounts matches neither", r.json()["rows"][0]["reason"] == "User not found") + + +def gates(): + print("\n7. 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, csv_resolve, 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()) diff --git a/tests/bulk_users_ui_check.py b/tests/bulk_users_ui_check.py new file mode 100644 index 0000000..bccc726 --- /dev/null +++ b/tests/bulk_users_ui_check.py @@ -0,0 +1,197 @@ +#!/usr/bin/env python3 +"""CR-020 (wave 12): bulk user administration in the browser, at 1440px and 390px. + + python tests/bulk_users_ui_check.py + +Self-contained like the other probes: a throwaway SQLite database seeded by +browser_check.seed(), its own uvicorn, headless Edge or Chrome over CDP. Your +real wpsuite.db is never touched. Run it alone, not back to back with another +probe (file-map.md: chained runs exhaust the browser's ports). + +The server rules are proven in tests/bulk_users_check.py without a browser. +This file proves the page: selection, the toolbar, the CSV path and the typed +delete, end to end against the real server, operable by keyboard, and holding +together at 390px. It writes the after-screenshots CLAUDE.md asks for to +docs/reference/baseline/wave-12/; the before-shots are the existing +users-1440.png and after-wave9/users-390.png. + +Exit 0 all passed, 1 a failure, 2 could not run. +""" +import json +import os +import sys +import tempfile +import time +import urllib.request + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +import cdp # noqa: E402 +from browser_check import seed, start_server, chk, _PASS, _FAIL # noqa: E402 + +ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +SHOTS = os.path.join(ROOT, "docs", "reference", "baseline", "wave-12") +READY = "!!document.querySelector('#users-table table')" + + +def api(base, path, token): + req = urllib.request.Request(base + path, headers={"Cookie": "wp_session=" + token}) + with urllib.request.urlopen(req, timeout=10) as r: + return json.loads(r.read().decode()) + + +def user(base, token, username): + return next((u for u in api(base, "/api/auth/users", token) if u["username"] == username), None) + + +def press(page, key, code, vk): + """A REAL key event (Input.dispatchKeyEvent), not a synthetic KeyboardEvent: + only a real one triggers a checkbox's native Space toggle - the lesson + launcher_check.py records.""" + for t in ("keyDown", "keyUp"): + page.ws.call("Input.dispatchKeyEvent", {"type": t, "key": key, "code": code, + "windowsVirtualKeyCode": vk, "text": " " if t == "keyDown" else ""}) + time.sleep(0.3) + + +def answer(page, ok=True, typed=None): + time.sleep(0.4) + if typed is not None: + page.eval("document.getElementById('wp-dlg-input').value=%s" % json.dumps(typed)) + page.eval("document.getElementById('%s').click()" % ("wp-dlg-ok" if ok else "wp-dlg-cancel")) + time.sleep(1.2) + + +def tick(page, username): + page.eval("(() => { const b=[...document.querySelectorAll('input.selbox')]" + ".find(x => x.dataset.id==='user_%s'); if(b) b.click(); })()" % username) + time.sleep(0.2) + + +BAR_390 = """(function(){ + var bar=document.getElementById('bulk-bar'); var out={sw:document.documentElement.scrollWidth,under:[],clipped:[],n:0}; + bar.querySelectorAll('button, select').forEach(function(el){ + var r=el.getBoundingClientRect(); if(!r.width||!r.height) return; out.n++; + var id=el.tagName+' '+(el.textContent||el.id).trim().slice(0,20)+' '+Math.round(r.width)+'x'+Math.round(r.height); + if(Math.min(r.width,r.height)<24) out.under.push(id); + if(r.left<-2||r.right>392) out.clipped.push(id); + }); + return JSON.stringify(out); +})()""" + + +def main(): + exe = cdp.find_browser() + if not exe: + print("no headless-capable browser found; set WP_BROWSER.") + return 2 + tmpdir = tempfile.mkdtemp(prefix="wpsuite-bulkui-") + db_path = os.path.join(tmpdir, "check.db") + server = browser = None + try: + tok = seed(db_path) + port = cdp.free_port() + base = "http://127.0.0.1:%d" % port + server = start_server(port, db_path) + if server is None: + print("server would not start") + return 2 + browser = cdp.Browser(exe) + page = browser.page() + + def visit(who, width, mobile=False): + page.clear_cookies() + page.set_cookie("wp_session", tok[who]) + page.viewport(width, 900 if width > 500 else 844, mobile=mobile) + page.goto(base + "/users.html", wait_for=READY) + time.sleep(0.6) + + print("\n1. the admin at 1440px") + visit("root", 1440) + page.screenshot(os.path.join(SHOTS, "users-1440.png")) + chk("a selection column with select-all", page.eval("!!document.getElementById('sel-all')")) + chk("no bulk bar until a row is selected", page.eval("document.getElementById('bulk-bar').hidden")) + page.eval("document.querySelector('input.selbox[data-id=\"user_pat\"]').focus()") + press(page, " ", "Space", 32) + chk("Space on a focused row checkbox selects it (keyboard operable)", + page.eval("document.querySelector('input.selbox[data-id=\"user_pat\"]').checked")) + chk("the bar appears, reachable by keyboard", + page.eval("!document.getElementById('bulk-bar').hidden && document.querySelector('#bulk-bar button').tabIndex >= 0")) + tick(page, "legacy") + chk("the bar counts the selection", page.eval("document.getElementById('bulk-count').textContent") == "2 selected") + page.screenshot(os.path.join(SHOTS, "users-1440-selected.png")) + page.eval("document.getElementById('bulk-role').value='project_admin';" + "document.querySelector('[onclick=\"bulkRole()\"]').click()") + time.sleep(0.4) + chk("the confirm names the count", "for 2 users" in (page.eval("document.getElementById('wp-dlg-msg').textContent") or "")) + answer(page) + chk("both accounts changed on the server", + user(base, tok["root"], "pat")["role"] == "project_admin" and user(base, tok["root"], "legacy")["role"] == "project_admin") + chk("the result is announced", "2 changed" in page.eval("document.getElementById('bulk-banner').textContent") + and page.eval("document.getElementById('bulk-banner').getAttribute('role')") in ("status", "alert")) + tick(page, "pat") + page.eval("const f=document.getElementById('user-filter'); f.value='active'; f.dispatchEvent(new Event('change'))") + time.sleep(0.3) + chk("changing the filter clears the selection, and says so", + page.eval("document.getElementById('bulk-bar').hidden") and + "filter changed" in page.eval("document.getElementById('sel-banner').textContent")) + + print("\n2. the super user, a CSV with good and bad lines") + visit("sue", 1440) + page.eval("loadCsv(new File(['username\\npat\\nmix\\nbob\\nsue\\npat\\n'], 'list.csv', {type:'text/csv'}))") + time.sleep(1.5) + rep = page.eval("document.getElementById('csv-banner').textContent") or "" + chk("only the account she may change is selected", page.eval("document.getElementById('bulk-count').textContent") == "1 selected", rep) + chk("every bad line is reported by number and reason: another job, not found, herself, a duplicate", + all(s in rep for s in ("Line 3 (mix)", "Line 4 (bob): User not found", "Line 5 (sue)", "Line 6 (pat): duplicate of line 2")), rep) + page.eval("document.getElementById('bulk-project-role').value='project_admin';" + "document.querySelector('[onclick=\"bulkProject(\\'add\\')\"]').click()") + answer(page) + roles = api(base, "/api/auth/users/user_pat/projects", tok["root"])["roles"] + chk("add to project with a role landed on the server", roles.get("projA") == "project_admin", roles) + + print("\n3. bulk delete needs the typed word") + visit("root", 1440) + tick(page, "bob") + page.eval("document.querySelector('[onclick=\"bulkDelete()\"]').click()") + time.sleep(0.4) + chk("the dialog lists the username", "bob" in page.eval("document.getElementById('wp-dlg-msg').textContent")) + page.eval("document.getElementById('wp-dlg-input').value='delete'; document.getElementById('wp-dlg-ok').click()") + time.sleep(0.4) + chk("a wrong word sends nothing", user(base, tok["root"], "bob") is not None + and page.eval("document.getElementById('wp-dlg-overlay').classList.contains('open')")) + answer(page, typed="DELETE") + chk("DELETE deletes, and the report says so", user(base, tok["root"], "bob") is None + and "1 changed" in page.eval("document.getElementById('bulk-banner').textContent")) + + print("\n4. the gloved-hands width: 390px") + visit("root", 390, mobile=True) + page.screenshot(os.path.join(SHOTS, "users-390.png")) + tick(page, "pat") + m = json.loads(page.eval(BAR_390)) + page.screenshot(os.path.join(SHOTS, "users-390-selected.png")) + chk("390px with the bar open: no sideways scrolling", m["sw"] <= 392, m["sw"]) + chk("390px: no bar control clipped past the screen", not m["clipped"], m["clipped"]) + chk("390px: every bar control meets the 24px floor", m["n"] > 0 and not m["under"], m["under"]) + + errs = [e for e in page.js_errors() if "beforeunload" not in e] + chk("no JavaScript errors in the whole run", not errs, errs[:3]) + finally: + if browser is not None: + try: + browser.close() + except Exception: + pass + if server is not None: + server.terminate() + + print("\n" + "-" * 54) + print("%d/%d checks passed." % (len(_PASS), len(_PASS) + len(_FAIL))) + for f in _FAIL: + print(" - " + f) + return 1 if _FAIL else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/cdp.py b/tests/cdp.py index 6ace6a6..3f93bdf 100644 --- a/tests/cdp.py +++ b/tests/cdp.py @@ -190,8 +190,26 @@ class Browser: f"--user-data-dir={self.profile}", "--remote-allow-origins=*", "--no-first-run", "--no-default-browser-check", "--disable-gpu", "--disable-extensions", "--disable-sync", - "--window-size=1400,1000", "about:blank"], + "--window-size=1400,1000"] + # Run from an elevated (Administrator) shell, Edge and Chrome + # "de-elevate": they relaunch themselves as a normal user through + # Explorer and the launched process exits rc=0. The relaunch does + # not keep the debugging port, so the port is never bound (found + # 2026-10-02; Edge logs "Edge is running elevated: 1"). This + # Chromium switch keeps the process we started. Ignored when the + # shell is not elevated, and on other platforms. + + (["--do-not-de-elevate"] if sys.platform == "win32" else []) + + ["about:blank"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + # On some Windows installs msedge.exe is a launcher: it starts the real + # browser and exits rc=0 at once, and the real browser binds the port a + # moment later. Giving up the instant the launched process exited + # failed every attempt on such a machine although Edge worked when + # started by hand (found 2026-10-02 running the wave 16 probes). An + # rc=0 exit now gets a grace period to bind; a non-zero exit is still + # a failure at once. Teardown is unaffected: close() sweeps by the + # unique profile path, which also catches the handed-off process. + exited_at = None for _ in range(160): try: with urllib.request.urlopen( @@ -199,9 +217,14 @@ class Browser: json.load(r) return except Exception: - if self.proc.poll() is not None: - last = f"exited rc={self.proc.returncode} without binding the port" - break + rc = self.proc.poll() + if rc is not None: + last = f"exited rc={rc} without binding the port" + if rc != 0: + break + exited_at = exited_at or time.time() + if time.time() - exited_at > 15: + break time.sleep(0.25) else: last = "never bound the debugging port" diff --git a/tests/console_dialogs_check.py b/tests/console_dialogs_check.py index 742f611..64f3920 100644 --- a/tests/console_dialogs_check.py +++ b/tests/console_dialogs_check.py @@ -112,6 +112,33 @@ def main(): chk("cancel means no: bob is still an account", st == 200 and any(u.get("username") == "bob" for u in (users or [])), ascii_([u.get("username") for u in (users or [])])) + # CR-020 / T12.5: the bulk delete is a PROMPT-style dialog (typed DELETE), + # the kind this file's docstring says belongs back here. + print("\n4. bulk delete needs the typed word") + page.eval("(() => { const b=[...document.querySelectorAll('input.selbox')]" + ".find(x => x.dataset.id==='user_bob'); b.click(); })()") + time.sleep(0.3) + chk("ticking a row shows the bulk bar", + page.eval("!document.getElementById('bulk-bar').hidden")) + page.eval("document.querySelector('[onclick=\"bulkDelete()\"]').click()") + time.sleep(0.4) + chk("the bulk delete asks through the kit's prompt, listing the username", + page.eval("(() => { const o=document.getElementById('wp-dlg-overlay');" + " return o.classList.contains('open')" + " && document.getElementById('wp-dlg-input-wrap').style.display !== 'none'" + " && /bob/.test(document.getElementById('wp-dlg-msg').textContent); })()")) + page.eval("document.getElementById('wp-dlg-input').value='delete';" + "document.getElementById('wp-dlg-ok').click()") + time.sleep(0.3) + chk("the wrong word keeps it open and names what to type", + page.eval("document.getElementById('wp-dlg-overlay').classList.contains('open')" + " && /DELETE/.test(document.getElementById('wp-dlg-err').textContent)")) + page.eval("document.getElementById('wp-dlg-cancel').click()") + time.sleep(0.6) + st, users = api(base, "/api/auth/users", tok["root"]) + chk("cancel means no: bob is still an account after the bulk prompt", + st == 200 and any(u.get("username") == "bob" for u in (users or []))) + errs = [e for e in page.js_errors() if "beforeunload" not in e] chk("no JavaScript errors, and no path reached a native dialog (they throw here)", not errs, ascii_(errs[:3]))