mosaicstack/stack
25
0 Fork 1
Code Issues 404 Pull Requests 13 Packages Projects Releases 15 Wiki Activity
Files
org-cb2
stack/packages/webui/tests/decide-browser.test.mjs
T

427 lines
27 KiB
JavaScript
Raw Permalink Blame History

// Row 252 (#1753, design section 5, J16 and J17): Approve and Deny on a decision page, in a browser.
// A loopback page has no sign-in, so a script added before the page loads sets `sso` and `decide`
// in /api/config from the page URL, and answers each POST /api/decisions/... from a queue, recording
// what the page sent. Server-side checks are decision-http.test.mjs's and the bus side is
// packages/bus/tests/console-decide.test.mjs's. The decisions come from an in-process broker
// through its reader session. Refresh timers fire after 150 ms.
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { randomUUID } from 'node:crypto';
import { mkdtempSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { Store } from '../../bus/src/store.mjs';
import { Broker } from '../../bus/src/broker.mjs';
import { views } from '../../bus/src/views.mjs';
import { grantDecision } from '../../bus/tests/host-fixtures.mjs';
import { startServer } from '../src/serve.mjs';
import { browser } from './browser.mjs';
import { fixture, close } from './fixture.mjs';
const HOSTILE = '<script>window.injected=1</script><img src=x onerror="window.injected=2">';
const businesses = { demo: { id: 'demo', human: 'jason', arbiters: { technical: 'pm', delivery: 'pm' }, roles: { chief: { authority: { withinRole: ['message.send'], crossRole: [] } }, pm: { authority: { withinRole: ['message.send'], crossRole: [] } } } } };
// Answers in order; `hold` waits for window.__release(), `reject` is a network failure, `redirect`
// what fetch gives for the sign-in proxy's redirect under redirect: 'manual'.
const STUB = `(() => {
const real = window.fetch.bind(window);
window.__posts = []; window.__answers = [];
const timeout = window.setTimeout.bind(window);
window.setTimeout = (f, ms, ...rest) => timeout(f, ms === 10000 ? 150 : ms, ...rest);
const q = new URLSearchParams(location.search);
const answer = (status, body) => new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json' } });
window.fetch = async (url, init = {}) => {
const u = String(url);
if (u === '/api/config') {
const c = await (await real(url, init)).json();
return answer(200, { ...c, ...(q.has('sso') ? { sso: true } : {}), ...(q.has('send') ? { send: true } : {}), ...(q.has('decide') ? { send: true, decide: true } : {}), ...(q.has('tester') ? { tester: true } : {}) });
}
if (window.__delayRead?.url === u) {
const delay = window.__delayRead;
window.__delayRead = null;
const response = await real(url, init);
window.__readHeld = true;
await new Promise(resolve => { window.__releaseRead = resolve; });
if (delay.reject) throw new TypeError('Delayed read failed');
return response;
}
if (u === '/api/bus/inbox' && window.__changedDecision) {
const body = await (await real(url, init)).json();
body.rows = body.rows.map(row => row.id === window.__changedDecision ? { ...row, console: { ...row.console, digest: 'e'.repeat(64) } } : row);
return answer(200, body);
}
if (!u.startsWith('/api/decisions/')) return real(url, init);
window.__posts.push({ url: u, method: init.method, headers: init.headers, body: init.body, cache: init.cache, redirect: init.redirect });
const a = window.__answers.shift();
if (!a) throw new TypeError('no answer queued');
if (a.hold) await new Promise(r => { window.__release = r; });
if (a.reject) throw new TypeError('Failed to fetch');
if (a.redirect) return { type: 'opaqueredirect', ok: false, status: 0, json: async () => { throw new SyntaxError('no body'); } };
return answer(a.status, a.body);
};
})();`;
// The open grant request, as host-fixtures' grantDecision writes it but with the hostile question.
// decisions is append-only (migration 3b), so the question goes in with the row, not by an UPDATE.
function hostileGrant(store, grant) {
const id = randomUUID(), at = '2026-10-21T00:00:00.000Z';
store.run(
'INSERT INTO decisions(id,at,business,raised_by_role,raised_by_run,class,action,route_to,question,options,recommendation,blocking) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)',
id, at, 'demo', 'chief', 'chief-run', 'gated', 'credential.mint', 'human', `Enroll web1? ${HOSTILE}`,
JSON.stringify([{ key: 'yes', text: 'Yes' }, { key: 'no', text: 'No' }]), 'yes', 0,
);
store.run(
"INSERT INTO events(id,at,business,kind,actor_role,actor_run,subject,body) VALUES(?,?,?,'action.allowed',?,?,?,?)",
randomUUID(), at, 'demo', 'chief', 'chief-run', id,
JSON.stringify({ decision: id, action: 'credential.mint', operation: 'decision.raise', approvalChoice: 'yes', grant }),
);
return id;
}
async function setup({ ordinary = false, paired = false } = {}) {
const root = mkdtempSync(join(tmpdir(), 'webui-decide-browser-'));
const store = new Store(root), b0 = new Broker({ store, businesses });
const grant = { method: 'host-enroll', host: 'web1', address: '192.0.2.10', port: 22, user: 'jarvis', sudo: true, fingerprints: [] };
const open = hostileGrant(store, grant);
const deploy = grantDecision(store, { action: 'deploy', grant, close: null });
const bare = grantDecision(store, { close: null });
const chief = b0.bindLaunch({ business: 'demo', role: 'chief', run: 'chief-run', harness: 'pi', address: 'chief' });
b0.request(chief, { verb: 'role.claim' });
const normal = ordinary ? b0.request(chief, { verb: 'decision.raise', args: {
action: 'prd.approve', question: `Choose a project ${HOSTILE}`, blocking: false,
options: [{ key: 'new/autonomous', text: 'New project — autonomous' }, { key: 'new/guided', text: 'New project — guided' }, { key: 'existing:project', text: `Add to existing project ${HOSTILE}` }],
recommendation: 'new/autonomous', approvalChoice: 'new/autonomous',
} }).id : null;
const other = paired ? b0.request(chief, { verb: 'decision.raise', args: {
action: 'prd.approve', question: 'Decision B: choose a project', blocking: false,
options: [{ key: 'B-0', text: 'B autonomous' }, { key: 'B-1', text: 'B guided' }, { key: 'B-2', text: 'B existing project' }],
recommendation: 'B-0', approvalChoice: 'B-0',
} }).id : null;
const reader = b0.bindReader({ business: 'demo' });
const bus = views({ call: async (verb, args = {}) => structuredClone(b0.request(reader, { verb, args })) });
const f = await fixture(), b = await browser();
const web = await startServer({ port: 0, board: f.boardURL, bus }), base = `http://127.0.0.1:${web.address().port}/`;
await b.call('Page.addScriptToEvaluateOnNewDocument', { source: STUB });
await b.viewport(1280);
const wait = expr => b.evaluate(`(async()=>{for(let i=0;i<100;i++){if(${expr})return true;await new Promise(r=>setTimeout(r,50))}throw new Error('Condition timed out: '+${JSON.stringify(expr)})})()`);
const text = sel => b.evaluate(`document.querySelector(${JSON.stringify(sel)})?.textContent ?? null`);
const has = sel => b.evaluate(`!!document.querySelector(${JSON.stringify(sel)})`);
const posts = () => b.evaluate('window.__posts');
const queue = a => b.evaluate(`window.__answers.push(${JSON.stringify(a)}), true`);
const click = step => b.evaluate(`document.querySelector('#decide-section [data-decide="${step}"]').click(), true`);
const page = async (query, id) => {
// The same URL again is a same-document hash change, not a load, so load about:blank first (as editor-browser does).
await b.navigate('about:blank');
await b.navigate(`${base}?${query}#/inbox/${id}`);
await wait('document.querySelector("#bus-view h1")?.textContent.startsWith("Decision") && !document.querySelector("#bus-view [aria-busy]")');
// The config read redraws once it lands; a refresh tick after it settles the page.
await new Promise(r => setTimeout(r, 400));
};
const settle = () => new Promise(r => setTimeout(r, 600));
const done = async () => { await b.close(); await close(web); await f.close(); store.close(); rmSync(root, { recursive: true, force: true }); };
return { b, store, base, open, deploy, bare, normal, other, wait, text, has, posts, queue, click, page, settle, done };
}
const CONFIRM = (s, action, choice, text) => ({ status: 200, body: { id: s.open, question: `Enroll web1? ${HOSTILE}`, action, choice, text, grant: { method: 'host-enroll', host: 'web1' }, confirmation: 'c'.repeat(64) } });
test('J16: no controls without sso and decide, read-only reasons, terminal lines kept, and only an eligible grant gets the panel', { timeout: 120000 }, async () => {
const s = await setup();
try {
// Without SSO: no panel, no button, and the reason names both flags.
await s.page('x', s.open);
assert.equal(await s.has('#decide-section'), false);
assert.equal(await s.has('[data-decide]'), false);
assert.match(await s.text('#bus-view'), /needs sign-in \(--sso\) and writes enabled \(--send\)/);
assert.equal(await s.b.evaluate('document.querySelectorAll("#bus-view [data-copy]").length'), 2);
// SSO without --send: read-only, still the terminal lines.
await s.page('sso', s.open);
assert.equal(await s.has('#decide-section'), false);
assert.match(await s.text('#bus-view'), /read-only for decisions: it was started without writes enabled \(--send\)/);
// send alone, without decide, still draws nothing.
await s.page('sso&send', s.open);
assert.equal(await s.has('#decide-section'), false);
// A tester Console never answers, whatever the config says.
await s.page('sso&decide&tester', s.open);
assert.equal(await s.has('#decide-section'), false);
// Eligible: the panel, both buttons, the escaped question and the terminal lines too.
await s.page('sso&decide', s.open);
assert.equal(await s.text('#decide-section h2'), 'Answer in Console');
assert.deepEqual(await s.b.evaluate('[...document.querySelectorAll("#decide-section [data-decide]")].map(e => [e.dataset.decide, e.textContent, e.disabled])'), [['approve', 'Approve', false], ['deny', 'Deny', false]]);
assert.match(await s.text('#decide-section'), /Grant: method host-enroll · host web1\./);
assert.equal(await s.b.evaluate('document.querySelectorAll("#bus-view [data-copy]").length'), 2);
assert.equal(await s.b.evaluate('window.injected ?? null'), null);
assert.ok((await s.text('#bus-view .s1-q')).includes(HOSTILE));
// A grant raise with another action, and a credential.mint with no grant, keep the terminal only.
for (const id of [s.deploy, s.bare]) {
await s.page('sso&decide', id);
assert.equal(await s.has('#decide-section'), false);
assert.equal(await s.has('[data-decide]'), false);
}
// The Inbox says so, and marks only the eligible row.
await s.b.navigate(`${s.base}?sso&decide#/inbox`);
await s.wait('document.querySelector("#bus-view h1")?.textContent.startsWith("Inbox") && document.querySelectorAll("#bus-view .s1-decs > li").length === 3');
await s.settle();
assert.match(await s.text('#bus-view'), /Open an eligible decision to answer any of its options here, after a confirmation\./);
assert.equal(await s.b.evaluate('[...document.querySelectorAll("#bus-view .s1-decs > li")].filter(li => li.textContent.includes("Approve or Deny here")).length'), 1);
assert.deepEqual(await s.posts(), []);
} finally { await s.done(); }
});
test('J17: one POST per click, confirm then answer, cancel, refusals and an unknown outcome never retry', { timeout: 120000 }, async () => {
const s = await setup();
const enc = encodeURIComponent;
try {
await s.page('sso&decide', s.open);
// Approve asks for a confirmation and answers nothing. The button holds while the request is out.
await s.queue({ ...CONFIRM(s, 'approve', 'yes', 'Yes'), hold: true });
await s.click('approve');
await s.wait('document.querySelector("#decide-section [data-decide=approve]")?.textContent === "Checking…"');
assert.equal(await s.b.evaluate('[...document.querySelectorAll("#decide-section [data-decide]")].every(e => e.disabled)'), true);
await s.click('approve');
await s.b.evaluate('window.__release(), true');
await s.wait('document.querySelector("#decide-section [data-decide=confirm]")');
let sent = await s.posts();
assert.equal(sent.length, 1);
assert.deepEqual(sent[0], { url: `/api/decisions/${enc(s.open)}/confirmation`, method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ choice: 'yes' }), cache: 'no-store', redirect: 'manual' });
assert.equal(await s.text('#decide-section [data-decide=confirm]'), 'Confirm approve');
assert.match(await s.text('#decide-section .s1-confirm'), /Approving starts this grant\./);
assert.equal(await s.b.evaluate('document.activeElement?.dataset.decide ?? null'), 'confirm');
assert.equal(await s.b.evaluate('window.injected ?? null'), null);
// A refresh keeps the confirmation open.
await s.settle();
assert.equal(await s.has('#decide-section [data-decide=confirm]'), true);
// Cancel drops it without a request.
await s.click('cancel');
await s.wait('document.querySelector("#decide-section [data-decide=approve]")');
assert.equal((await s.posts()).length, 1);
// A refusal the Console wrote shows its code and message; a 408 or a lost answer is unavailable.
await s.queue({ status: 409, body: { error: 'decision-stale', message: 'The choices changed. Review the decision again.' } });
await s.click('deny');
await s.wait('document.querySelector("#decide-status")');
assert.equal(await s.text('#decide-status'), 'Not answered here: The choices changed. Review the decision again. (decision-stale).');
await s.queue({ status: 408, body: { error: 'x', message: 'y' } });
await s.click('deny');
await s.wait('document.querySelector("#decide-status code")?.textContent === "confirmation-unavailable"');
await s.queue({ reject: true });
await s.click('deny');
await s.wait('document.querySelectorAll("#decide-section [data-decide]:not([disabled])").length === 2');
assert.equal(await s.b.evaluate('document.querySelector("#decide-status code")?.textContent'), 'confirmation-unavailable');
assert.equal((await s.posts()).length, 4);
// A reply that doesn't match what was asked is not a confirmation.
await s.queue({ status: 200, body: { ...CONFIRM(s, 'approve', 'yes', 'Yes').body } });
await s.click('deny');
await s.wait('document.querySelector("#decide-status code")?.textContent === "confirmation-unavailable" && document.querySelectorAll("#decide-section [data-decide]:not([disabled])").length === 2');
assert.equal(await s.has('#decide-section [data-decide=confirm]'), false);
// An unknown outcome at the answer says to refresh, drops the confirmation and sends nothing again.
await s.queue(CONFIRM(s, 'deny', 'no', 'No'));
await s.click('deny');
await s.wait('document.querySelector("#decide-section [data-decide=confirm]")');
assert.match(await s.text('#decide-section .s1-confirm'), /Denying starts nothing\./);
await s.queue({ status: 503, body: { error: 'outcome-unknown', message: 'The answer may have reached the bus. Refresh before trying again.' } });
await s.click('confirm');
await s.wait('document.querySelector("#decide-status code")?.textContent === "outcome-unknown"');
assert.match(await s.text('#decide-status'), /Nothing was sent again\.$/);
sent = await s.posts();
assert.equal(sent.length, 7);
assert.deepEqual(sent[6], { url: `/api/decisions/${enc(s.open)}/resolve`, method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ choice: 'no', confirmation: 'c'.repeat(64) }), cache: 'no-store', redirect: 'manual' });
assert.equal(await s.has('#decide-section [data-decide=confirm]'), false);
await s.settle();
await s.settle();
assert.equal((await s.posts()).length, 7, 'the page sent again by itself');
// A confirmed approve: one answer, a receipt, and no buttons after it, across refreshes.
await s.queue(CONFIRM(s, 'approve', 'yes', 'Yes'));
await s.click('approve');
await s.wait('document.querySelector("#decide-section [data-decide=confirm]")');
await s.queue({ status: 200, body: { id: s.open, op: 'resolved', choice: 'yes', grant: 'started' } });
await s.click('confirm');
await s.wait('document.querySelector("#decide-status")?.textContent.startsWith("Approved")');
assert.equal(await s.text('#decide-status'), 'Approved: you chose “yes”, Yes. The grant executor started. History below shows it once the bus is read again.');
await s.settle();
assert.equal(await s.has('[data-decide]'), false);
assert.equal((await s.posts()).length, 9);
// Closed elsewhere: the next read drops the panel and shows the recorded answer with its provenance.
s.store.run('INSERT INTO decision_events(decision,at,op,by,choice,via) VALUES(?,?,?,?,?,?)', s.open, '2026-10-22T00:00:00.000Z', 'resolved', 'jason', 'yes', 'console');
await s.page('sso&decide', s.open);
assert.equal(await s.has('#decide-section'), false);
assert.match(await s.text('#bus-view'), /Resolved: jason chose “yes” via console/);
assert.equal(await s.b.evaluate('document.querySelectorAll("#bus-view [data-copy]").length'), 0);
} finally { await s.done(); }
});
test('a sign-in redirect at either step signs the page out and answers nothing', { timeout: 120000 }, async () => {
const s = await setup();
try {
await s.page('sso&decide', s.open);
await s.queue({ redirect: true });
await s.click('approve');
await s.wait('document.body.classList.contains("signed-out")');
assert.equal((await s.posts()).length, 1);
await s.page('sso&decide', s.open);
await s.queue(CONFIRM(s, 'approve', 'yes', 'Yes'));
await s.click('approve');
await s.wait('document.querySelector("#decide-section [data-decide=confirm]")');
await s.queue({ redirect: true });
await s.click('confirm');
await s.wait('document.body.classList.contains("signed-out")');
assert.equal((await s.posts()).length, 2);
} finally { await s.done(); }
});
test('ordinary choices render every key/text, cancel and navigation discard confirmations, and the third option records an accurate receipt', { timeout: 120000 }, async () => {
const s = await setup({ ordinary: true });
const confirmation = { status: 200, body: { id: s.normal, kind: 'decision', action: 'answer', question: `Choose a project ${HOSTILE}`, choice: 'existing:project', text: `Add to existing project ${HOSTILE}`, confirmation: 'd'.repeat(64) } };
try {
await s.page('sso&decide', s.normal);
assert.equal(await s.has('#decide-section'), true);
assert.deepEqual(await s.b.evaluate('[...document.querySelectorAll("#decide-section [data-decide]")].map(e => e.textContent)'), ['New project — autonomous', 'New project — guided', `Add to existing project ${HOSTILE}`]);
assert.equal(await s.b.evaluate('window.injected ?? null'), null);
assert.doesNotMatch(await s.text('#decide-section'), /Grant:|Approve|Deny/);
await s.queue({ ...confirmation, hold: true });
await s.click('option-2');
await s.click('option-2');
await s.b.evaluate('window.__release(), true');
await s.wait('document.querySelector("[data-decide=confirm]")');
assert.equal((await s.posts()).length, 1);
assert.match(await s.text('.s1-confirm'), /Confirm answer/);
assert.doesNotMatch(await s.text('.s1-confirm'), /Grant|Approving|Denying/);
await s.settle();
assert.equal(await s.has('[data-decide=confirm]'), true);
await s.click('cancel');
assert.equal(await s.has('[data-decide=confirm]'), false);
assert.equal((await s.posts()).length, 1);
await s.queue(confirmation);
await s.click('option-2');
await s.wait('document.querySelector("[data-decide=confirm]")');
await s.b.navigate(`${s.base}?sso&decide#/inbox`);
await s.wait('document.querySelector("#bus-view h1")?.textContent.startsWith("Inbox")');
await s.b.navigate(`${s.base}?sso&decide#/inbox/${s.normal}`);
await s.wait('document.querySelector("#decide-section")');
assert.equal(await s.has('[data-decide=confirm]'), false, 'leaving the decision must discard its confirmation');
assert.equal((await s.posts()).length, 2);
// Navigation while the preview is in flight must also discard the late answer.
await s.queue({ ...confirmation, hold: true });
await s.click('option-2');
await s.b.navigate(`${s.base}?sso&decide#/inbox`);
await s.wait('document.querySelector("#bus-view h1")?.textContent.startsWith("Inbox")');
await s.b.evaluate('window.__release(), true');
await s.b.navigate(`${s.base}?sso&decide#/inbox/${s.normal}`);
await s.wait('document.querySelector("#decide-section")');
assert.equal(await s.has('[data-decide=confirm]'), false);
await s.queue(confirmation);
await s.click('option-2');
await s.wait('document.querySelector("[data-decide=confirm]")');
await s.queue({ status: 200, hold: true, body: { id: s.normal, op: 'resolved', choice: 'existing:project' } });
await s.click('confirm');
await s.click('confirm');
await s.b.evaluate('window.__release(), true');
await s.wait('document.querySelector("#decide-status")?.textContent.startsWith("Recorded")');
assert.match(await s.text('#decide-status'), /Recorded: you chose “existing:project”, Add to existing project/);
assert.doesNotMatch(await s.text('#decide-status'), /grant|denial|Approved|Denied|Nothing starts/);
await s.settle();
const posts = await s.posts();
assert.equal(posts.filter(p => p.url.endsWith('/resolve')).length, 1);
assert.equal(await s.has('[data-decide]'), false);
} finally { await s.done(); }
});
test('ordinary confirmation is dropped on closure, reload, session expiry and uncertain outcome without automatic replay', { timeout: 120000 }, async () => {
const s = await setup({ ordinary: true });
const confirmation = { status: 200, body: { id: s.normal, kind: 'decision', action: 'answer', question: 'Choose a project', choice: 'new/guided', text: 'New project — guided', confirmation: 'd'.repeat(64) } };
try {
await s.page('sso&decide', s.normal);
assert.equal(await s.has('#decide-section'), true);
await s.queue(confirmation);
await s.click('option-1');
await s.wait('document.querySelector("[data-decide=confirm]")');
await s.page('sso&decide', s.normal);
assert.equal(await s.has('[data-decide=confirm]'), false);
assert.equal((await s.posts()).length, 0);
await s.queue(confirmation);
await s.click('option-1');
await s.wait('document.querySelector("[data-decide=confirm]")');
await s.queue({ reject: true });
await s.click('confirm');
await s.wait('document.querySelector("#decide-status code")?.textContent === "outcome-unknown"');
await s.settle();
assert.equal((await s.posts()).length, 2);
assert.equal(await s.has('[data-decide=confirm]'), false);
await s.queue(confirmation);
await s.click('option-1');
await s.wait('document.querySelector("[data-decide=confirm]")');
await s.queue({ status: 401, body: { error: 'sign-in-required', message: 'Sign in again before answering.' } });
await s.click('confirm');
await s.wait('document.querySelector("#decide-status code")?.textContent === "sign-in-required" || document.body.classList.contains("signed-out")');
assert.equal(await s.has('[data-decide=confirm]'), false);
assert.equal((await s.posts()).length, 4);
await s.page('sso&decide', s.normal);
await s.queue(confirmation);
await s.click('option-1');
await s.wait('document.querySelector("[data-decide=confirm]")');
s.store.run('INSERT INTO decision_events(decision,at,op,by,choice,via) VALUES(?,?,?,?,?,?)', s.normal, '2026-11-03T00:00:00.000Z', 'resolved', 'jason', 'new/autonomous', 'cli');
await s.wait('!document.querySelector("#decide-section")');
assert.equal((await s.posts()).filter(p => p.url.endsWith('/resolve')).length, 0);
} finally { await s.done(); }
});
test('a changed authoritative context drops an open ordinary confirmation before another answer can be submitted', { timeout: 120000 }, async () => {
const s = await setup({ ordinary: true });
try {
await s.page('sso&decide', s.normal);
await s.queue({ status: 200, body: { id: s.normal, kind: 'decision', action: 'answer', question: 'Choose a project', choice: 'new/autonomous', text: 'New project — autonomous', confirmation: 'c'.repeat(64) } });
await s.click('option-0');
await s.wait('document.querySelector("[data-decide=confirm]")');
await s.b.evaluate(`window.__changedDecision = ${JSON.stringify(s.normal)}`);
await s.wait('!document.querySelector("[data-decide=confirm]") && document.querySelector("[data-decide=option-0]")');
assert.equal((await s.posts()).length, 1);
assert.equal((await s.posts()).filter(p => p.url.endsWith('/resolve')).length, 0);
} finally { await s.done(); }
});
for (const [read, reject] of [['inbox', false], ['trail', false], ['trail', true]]) {
test(`I1: obsolete A ${read} read${reject ? ' failure with cached fallback' : ' completion'} cannot redirect B answer controls`, { timeout: 120000 }, async () => {
const s = await setup({ ordinary: true, paired: true });
try {
// Warm A's cache so the failed read also exercises the kept-data continuation.
await s.page('sso&decide', s.normal);
await s.b.evaluate('document.querySelector("#pause").click(), true');
assert.equal(await s.b.evaluate('document.querySelector("#pause").getAttribute("aria-pressed")'), 'true');
const url = read === 'inbox' ? '/api/bus/inbox' : `/api/bus/trail?subject=${encodeURIComponent(s.normal)}`;
await s.b.evaluate(`window.__delayRead = ${JSON.stringify({ url, reject })}; document.querySelector('#refresh').click(); true`);
await s.wait('window.__readHeld === true');
await s.b.navigate(`${s.base}?sso&decide#/inbox/${s.other}`);
await s.wait('document.querySelector("#bus-view .s1-q")?.textContent === "Decision B: choose a project" && document.querySelector("[data-decide=option-2]")?.textContent === "B existing project"');
await s.b.evaluate('window.__releaseRead(), true');
await s.settle();
assert.equal(await s.text('#bus-view .s1-q'), 'Decision B: choose a project');
assert.equal(await s.text('[data-decide=option-2]'), 'B existing project');
await s.queue({ status: 200, body: { id: s.other, kind: 'decision', action: 'answer', question: 'Decision B: choose a project', choice: 'B-2', text: 'B existing project', confirmation: 'b'.repeat(64) } });
await s.click('option-2');
const [preview] = await s.posts();
assert.equal(preview.url, `/api/decisions/${encodeURIComponent(s.other)}/confirmation`, 'B controls must request confirmation for B after the obsolete A continuation');
assert.deepEqual(JSON.parse(preview.body), { choice: 'B-2' });
await s.wait('document.querySelector("[data-decide=confirm]")');
assert.equal(await s.text('#bus-view .s1-q'), 'Decision B: choose a project');
assert.match(await s.text('.s1-confirm'), /B-2.*B existing project/);
await s.queue({ status: 200, body: { id: s.other, op: 'resolved', choice: 'B-2' } });
await s.click('confirm');
await s.wait('document.querySelector("#decide-status")?.textContent.startsWith("Recorded")');
const posts = await s.posts();
assert.equal(posts.length, 2);
assert.equal(posts[1].url, `/api/decisions/${encodeURIComponent(s.other)}/resolve`);
assert.deepEqual(JSON.parse(posts[1].body), { choice: 'B-2', confirmation: 'b'.repeat(64) });
} finally { await s.done(); }
});
}
Reference in new issue View Git Blame Copy Permalink