diff --git a/tests/uat/extension-page-harness.ts b/tests/uat/extension-page-harness.ts index f5cacb6..4b7b366 100644 --- a/tests/uat/extension-page-harness.ts +++ b/tests/uat/extension-page-harness.ts @@ -51,8 +51,18 @@ // dispatch-ended — trigger Bug B simulation via offscreen // bridge (offscreen still uses dynamic import → works) // -// Wave 1 surface — the page exposes `window.__mokoshHarness` with one -// method (assertA6); Wave 3 extends to all 13 assertions: +// Wave 3A surface — extends `window.__mokoshHarness` from 1 → 5 methods: +// - `assertA1()` — SW bootstrap state (badge='', popup='', isRecording=false). +// - `assertA2()` — toolbar onClicked → REC (workaround: send START_RECORDING +// directly to offscreen + manually set badge/popup; +// bypasses SW startVideoCapture which needs the +// `tabs` permission per 01-11-SUMMARY workaround). +// - `assertA3()` — displaySurface === 'monitor' (via 'get-display-surface' +// offscreen bridge op; verifies the synthetic stream's +// monkey-patched getSettings()). +// - `assertA4()` — popup stays pinned during recording (REC state +// preserves setRecordingMode's setPopup; offscreen +// count remains 1 — no second offscreen spawns). // - `assertA6()` — canonical Bug B regression assertion (proven). /** @@ -406,22 +416,293 @@ async function assertA6(): Promise { return result; } +/** + * A1 — SW bootstrap state. Asserts the post-load idle state per + * src/background/index.ts:setIdleMode (badge='', popup=''). The + * `isRecording` invariant is verified via the badge-proxy: a non-REC + * badge implies isRecording=false per the state-machine contract (each + * setRecordingMode/setIdleMode/setErrorMode transition pairs badge + popup + * atomically — there is no path that desyncs badge from isRecording). + * + * IMPORTANT — A1 MUST run before A2 in any orchestrated sequence. A2 + * manually sets badge='REC' + popup=POPUP_HTML_PATH (workaround for the + * missing `tabs` permission); once A2 runs the SW is no longer in idle + * mode and the A1 contract is invalidated until reset. + * + * @returns Structured result with 3 checks (badge + popup + isRecording). + */ +async function assertA1(): Promise { + const result: AssertionResult = { + passed: false, + name: 'A1 — SW bootstrap state: badge=\'\', popup=\'\', isRecording=false', + checks: [], + diagnostics: [], + }; + + try { + diag(result, 'Step 1: read chrome.action.getBadgeText({})'); + const badge = await chrome.action.getBadgeText({}); + diag(result, `Step 1 result: badge='${badge}'`); + + diag(result, 'Step 2: read chrome.action.getPopup({})'); + const popup = await chrome.action.getPopup({}); + diag(result, `Step 2 result: popup='${popup}'`); + + result.checks.push({ + name: 'A1.1: badge text is \'\' (setIdleMode default)', + expected: '', + actual: badge, + passed: badge === '', + }); + result.checks.push({ + name: 'A1.2: popup is \'\' (setIdleMode default; enables onClicked)', + expected: '', + actual: popup, + passed: popup === '', + }); + result.checks.push({ + name: 'A1.3: isRecording=false (badge !== \'REC\' proxy)', + expected: false, + actual: badge === 'REC', + passed: badge !== 'REC', + }); + + result.passed = result.checks.every((c) => c.passed); + } catch (err) { + result.error = err instanceof Error ? err.message : String(err); + diag(result, `THREW: ${result.error}`); + } + + return result; +} + +/** + * A2 — toolbar onClicked → REC. Asserts that the recording-start path + * lands in the REC state machine row (badge='REC', popup=POPUP_HTML_PATH). + * + * WORKAROUND (documented per 01-11-SUMMARY + plan resolved-questions + * row 2): the harness sends START_RECORDING directly to the offscreen + * recorder, BYPASSING the production chrome.action.onClicked → + * startVideoCapture path. That path requires `chrome.tabs.query( + * {active: true})` to return a tab with `.url`, which it does NOT + * without the `tabs` manifest permission (out of scope for the harness + * plan — adding it would change production attack surface). The badge + * + popup transitions normally driven by setRecordingMode are emulated + * by the page calling chrome.action.setBadgeText + setPopup directly. + * + * Coverage of the bypassed SW path is preserved by unit tests: + * - tests/background/badge-state-machine.test.ts asserts + * setRecordingMode transitions setBadgeText('REC') + setPopup(...). + * - tests/background/sw-state-transitions.test.ts (or equivalent) + * asserts the onClicked → startVideoCapture wiring (no UAT-side + * re-verification needed). + * + * The contract A2 verifies is: when START_RECORDING reaches offscreen, + * recording starts AND a notional REC state is reachable. A3 + A4 chain + * off A2's REC state without re-starting recording (single launch + + * single recording per `npm run test:uat` run per plan single-browser + * decision). + * + * @returns Structured result with badge + popup checks. + */ +async function assertA2(): Promise { + const result: AssertionResult = { + passed: false, + name: 'A2 — toolbar onClicked → REC (direct-offscreen workaround for missing tabs permission)', + checks: [], + diagnostics: [], + }; + + try { + diag(result, 'Step 1: ensureOffscreen (creates offscreen if missing)'); + const ensureResp = await ensureOffscreen(); + if (!ensureResp.ok) { + throw new Error( + `ensureOffscreen failed: ${ensureResp.error ?? '(no error)'}`, + ); + } + diag(result, 'Step 1 OK — offscreen ready'); + + diag(result, 'Step 2: START_RECORDING direct-to-offscreen + manual setBadge/setPopup'); + const grantResp = await startRecording(); + if (!grantResp.granted) { + throw new Error( + 'startRecording returned granted=false — recording did not start', + ); + } + diag(result, 'Step 2 OK — granted=true'); + + diag(result, "Step 3: wait for badge === 'REC'"); + const badgeAfter = await waitFor( + () => chrome.action.getBadgeText({}), + (v) => v === 'REC', + STATE_WAIT_MS, + 'badge should transition to REC after START_RECORDING', + ); + diag(result, `Step 3 OK — badge='${badgeAfter}'`); + + diag(result, 'Step 4: read chrome.action.getPopup({})'); + const popupAfter = await chrome.action.getPopup({}); + diag(result, `Step 4 result: popup='${popupAfter}'`); + + // NOTE — Chrome's chrome.action.getPopup() returns the FULL absolute + // URL form (e.g. 'chrome-extension:///src/popup/index.html'), NOT + // the manifest-relative path that was passed to setPopup(). We assert + // .endsWith('src/popup/index.html') so the check is extension-id + // independent (the id is randomly assigned at unpacked-load time). + result.checks.push({ + name: 'A2.1: badge text is \'REC\' after START_RECORDING', + expected: 'REC', + actual: badgeAfter, + passed: badgeAfter === 'REC', + }); + result.checks.push({ + name: 'A2.2: popup ends with \'src/popup/index.html\' (REC mode SAVE-only popup)', + expected: '/>src/popup/index.html', + actual: popupAfter, + passed: popupAfter.endsWith('src/popup/index.html'), + }); + + result.passed = result.checks.every((c) => c.passed); + } catch (err) { + result.error = err instanceof Error ? err.message : String(err); + diag(result, `THREW: ${result.error}`); + } + + return result; +} + +/** + * A3 — displaySurface === 'monitor'. Assumes A2 left a recording active + * (single-browser orchestrator pattern). Queries the offscreen bridge + * `get-display-surface` op which reads the active track's + * `getSettings().displaySurface`. Production code in + * src/offscreen/recorder.ts:296 enforces this same value (tears down + + * throws 'wrong-display-surface' otherwise), so if recording is live the + * value is guaranteed monitor — A3 explicitly verifies the + * offscreen-hooks `installFakeDisplayMedia` monkey-patched getSettings() + * correctly reports 'monitor' under the synthetic stream path. + * + * @returns Structured result with the displaySurface check. + */ +async function assertA3(): Promise { + const result: AssertionResult = { + passed: false, + name: 'A3 — displaySurface === \'monitor\' (monkey-patched synthetic stream)', + checks: [], + diagnostics: [], + }; + + try { + diag(result, "Step 1: bridge query 'get-display-surface'"); + const resp = await offscreenQuery<{ + displaySurface?: string | null; + ok?: boolean; + error?: string; + }>('get-display-surface'); + diag(result, `Step 1 result: ${JSON.stringify(resp)}`); + + if (resp.ok === false) { + throw new Error( + `get-display-surface returned ok=false: ${resp.error ?? '(no error)'}`, + ); + } + const displaySurface = resp.displaySurface ?? null; + + result.checks.push({ + name: 'A3.1: displaySurface === \'monitor\' (offscreen-hooks monkey-patch)', + expected: 'monitor', + actual: displaySurface, + passed: displaySurface === 'monitor', + }); + + result.passed = result.checks.every((c) => c.passed); + } catch (err) { + result.error = err instanceof Error ? err.message : String(err); + diag(result, `THREW: ${result.error}`); + } + + return result; +} + +/** + * A4 — popup pinned during recording + no second offscreen. Assumes A2 + * left a recording active. The contract verified: + * 1. getPopup still returns 'src/popup/index.html' (REC mode preserved + * by setRecordingMode; no transition to ERROR / IDLE happened). + * 2. chrome.offscreen.hasDocument() === true (the recording's offscreen + * is alive; no duplicate offscreen was created — production code + * in src/background/index.ts:863-866 makes the toolbar-click-during- + * recording path a no-op when a recording is already live). + * + * Per the plan, A4 is essentially a no-op verification — its purpose is + * regression protection against a future refactor that might unpin the + * popup during recording or spawn a second offscreen on stray events. + * + * @returns Structured result with popup + hasDocument checks. + */ +async function assertA4(): Promise { + const result: AssertionResult = { + passed: false, + name: 'A4 — popup pinned + single offscreen during recording', + checks: [], + diagnostics: [], + }; + + try { + diag(result, 'Step 1: read chrome.action.getPopup({})'); + const popup = await chrome.action.getPopup({}); + diag(result, `Step 1 result: popup='${popup}'`); + + diag(result, 'Step 2: chrome.offscreen.hasDocument()'); + const hasDoc = await chrome.offscreen.hasDocument(); + diag(result, `Step 2 result: hasDocument=${hasDoc}`); + + // NOTE — see A2.2 NOTE: chrome.action.getPopup() returns absolute + // chrome-extension:///... URLs; assert by .endsWith() to stay + // extension-id independent. + result.checks.push({ + name: 'A4.1: popup remains \'src/popup/index.html\' during REC', + expected: '/>src/popup/index.html', + actual: popup, + passed: popup.endsWith('src/popup/index.html'), + }); + result.checks.push({ + name: 'A4.2: chrome.offscreen.hasDocument() === true (recording offscreen alive)', + expected: true, + actual: hasDoc, + passed: hasDoc === true, + }); + + result.passed = result.checks.every((c) => c.passed); + } catch (err) { + result.error = err instanceof Error ? err.message : String(err); + diag(result, `THREW: ${result.error}`); + } + + return result; +} + // Install the global harness surface. declare global { interface Window { __mokoshHarness: { + assertA1: () => Promise; + assertA2: () => Promise; + assertA3: () => Promise; + assertA4: () => Promise; assertA6: () => Promise; }; } } -window.__mokoshHarness = { assertA6 }; +window.__mokoshHarness = { assertA1, assertA2, assertA3, assertA4, assertA6 }; const statusEl = document.getElementById('status'); if (statusEl !== null) { - statusEl.textContent = 'Harness ready. window.__mokoshHarness.assertA6() available.'; + statusEl.textContent = 'Harness ready. window.__mokoshHarness.{assertA1, assertA2, assertA3, assertA4, assertA6} available.'; } -console.log('[harness-page] ready — window.__mokoshHarness installed'); +console.log('[harness-page] ready — window.__mokoshHarness installed (Wave 3A: A1+A2+A3+A4+A6)'); export {}; diff --git a/tests/uat/harness.test.ts b/tests/uat/harness.test.ts new file mode 100644 index 0000000..f36d19c --- /dev/null +++ b/tests/uat/harness.test.ts @@ -0,0 +1,342 @@ +// tests/uat/harness.test.ts — Plan 01-13 Wave 3A orchestrator. +// +// Top-level entry for the production UAT harness. Drives all 14 +// assertions sequentially against a SINGLE launched Chrome instance with +// a SINGLE harness page; bails on the first failure with a structured +// diagnostic dump. Exits 0 only when 14/14 GREEN. +// +// Wave 3A scope — wires A0+A1+A2+A3+A4+A6 (A6 via the proven Wave-2 +// driver). A5+A7..A13 throw `NOT YET IMPLEMENTED — Wave 3 wires this` +// from `tests/uat/lib/harness-page-driver.ts`; the bail-on-first-failure +// loop stops at the first such throw. Expected Wave-3A diagnostic: +// "UAT harness: 5/14 assertions passed (A0+A1+A2+A3+A4 GREEN; bail at A5)" +// A6 PASSES via the standalone `npx tsx tests/uat/a6.test.ts` entry — +// the orchestrator-level A6 won't reach in Wave 3A because the +// sequential loop bails at A5; A6 lands in the loop output once Wave 3B +// implements driveA5. The orchestrator structure is final from Wave 3A +// onward; future waves only fill in the assertion-driver stubs. +// +// Architectural commitments (per 01-11-SUMMARY.md, DO NOT REGRESS): +// - Single browser, single recording per run (state machine: idle → +// A1 reads idle → A2 transitions to REC → A3+A4 read REC → +// A5 saves archive → A6 simulates user-stop → A7 surfaces ERR → ...). +// - A0 (Tier-1 grep gate) runs PRE-FLIGHT before any Chrome launch. +// Mirrors `tests/background/no-test-hooks-in-prod-bundle.test.ts` +// FORBIDDEN_HOOK_STRINGS inventory. Belt-and-suspenders: the unit +// test gate runs in `npm test` (~15s); the UAT-level A0 runs in +// `npm run test:uat` (~60-90s). Same invariant; two independent +// verification paths. +// - Drive Chrome FROM INSIDE: each assertion is a single +// `page.evaluate(() => window.__mokoshHarness.assertXX())` call; +// no SW.evaluate, no popup-bridge (both falsified per 01-11-SUMMARY). +// +// References: +// - puppeteer.launch + extension loading: +// https://pptr.dev/api/puppeteer.launchoptions +// - Node fs.readdirSync recursive walk: +// https://nodejs.org/api/fs.html#fsreaddirsyncpath-options +// - Node child_process.execFileSync: +// https://nodejs.org/api/child_process.html#child_processexecfilesyncfile-args-options + +import { execFileSync } from 'node:child_process'; +import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'; +import { dirname, resolve as resolvePath } from 'node:path'; +import { fileURLToPath } from 'node:url'; + +import { launchHarnessBrowser } from './lib/launch'; +import { + driveA1, + driveA2, + driveA3, + driveA4, + driveA5, + driveA6, + driveA7, + driveA8, + driveA9, + driveA10, + driveA11, + driveA12, + driveA13, +} from './lib/harness-page-driver'; +import { + printAssertionResult, + runAssertion, + type AssertionRecord, +} from './lib/assertions'; + +/** + * A0 forbidden-string inventory — mirrors + * `tests/background/no-test-hooks-in-prod-bundle.test.ts:FORBIDDEN_HOOK_STRINGS`. + * Keep in sync. The two lists serving the same invariant is intentional + * (belt-and-suspenders per `feedback-pre-checkpoint-bundle-gates.md`): + * unit-test gate catches at `npm test`, UAT gate catches at `npm run test:uat`. + */ +const FORBIDDEN_HOOK_STRINGS: ReadonlyArray = [ + '__mokoshTest', + 'setCurrentStream', + 'setSegmentCountGetter', + 'installFakeDisplayMedia', + 'uninstallFakeDisplayMedia', + 'dispatchEndedOnTrack', + 'getSegmentCount', + '__mokoshOffscreenQuery', + 'get-display-surface', +]; + +/** Build timeout for the pre-flight production rebuild (matches unit-gate value). */ +const PROD_BUILD_TIMEOUT_MS = 60_000; + +/** Resolve repo-root paths from this file's location. */ +const HARNESS_FILE_DIR = dirname(fileURLToPath(import.meta.url)); +const REPO_ROOT = resolvePath(HARNESS_FILE_DIR, '..', '..'); +const DIST_DIR = resolvePath(REPO_ROOT, 'dist'); + +/** Binary extensions skipped during the grep walk (mirror of unit gate). */ +const BINARY_EXTENSIONS: ReadonlySet = new Set([ + '.png', '.jpg', '.jpeg', '.gif', '.ico', '.webp', '.woff', '.woff2', '.ttf', '.otf', +]); + +/** + * Recursively collect every regular file under `root`. Returns absolute + * paths sorted alphabetically for stable diagnostics. + * + * @param root - Absolute directory path to walk. + * @returns Sorted list of absolute file paths under `root`. + */ +function listAllFilesRecursive(root: string): ReadonlyArray { + const accumulator: string[] = []; + const stack: string[] = [root]; + while (stack.length > 0) { + const dir = stack.pop()!; + const entries = readdirSync(dir, { withFileTypes: true }); + for (const entry of entries) { + const fullPath = resolvePath(dir, entry.name); + if (entry.isSymbolicLink()) { + continue; + } + if (entry.isDirectory()) { + stack.push(fullPath); + } else if (entry.isFile()) { + accumulator.push(fullPath); + } + } + } + return accumulator.sort(); +} + +/** + * Count occurrences of `needle` in the given file. Returns 0 for binary + * file extensions (text matching against UTF-8 of a PNG would be + * meaningless and could yield spurious matches). + * + * @param filePath - Absolute file path to scan. + * @param needle - Literal substring to count. + * @returns Total occurrences in the file's text. + */ +function countOccurrencesInFile(filePath: string, needle: string): number { + const dotIdx = filePath.lastIndexOf('.'); + const ext = dotIdx >= 0 ? filePath.substring(dotIdx).toLowerCase() : ''; + if (BINARY_EXTENSIONS.has(ext)) { + return 0; + } + const stat = statSync(filePath); + if (stat.size === 0) { + return 0; + } + const text = readFileSync(filePath, 'utf8'); + let count = 0; + let from = 0; + for (;;) { + const idx = text.indexOf(needle, from); + if (idx < 0) { + break; + } + count += 1; + from = idx + needle.length; + } + return count; +} + +/** + * A0 — Tier-1 grep gate (UAT-level mirror of the unit-gate). Spawns + * `npm run build` if `SKIP_PROD_REBUILD !== '1'`, then walks `dist/` + * checking every forbidden string. Reports all matches in one pass + * (full enumeration, not bail-on-first) so the operator sees the entire + * leak surface in a single failure. + * + * @returns Structured A0 result: passed flag + list of (string, file) matches. + */ +async function assertA0_GrepGate(): Promise<{ + passed: boolean; + matches: Array<{ needle: string; filePath: string; count: number }>; +}> { + if (process.env.SKIP_PROD_REBUILD !== '1') { + process.stdout.write('A0: running `npm run build` (set SKIP_PROD_REBUILD=1 to skip)...\n'); + execFileSync('npm', ['run', 'build'], { + stdio: 'inherit', + timeout: PROD_BUILD_TIMEOUT_MS, + }); + } else { + process.stdout.write('A0: SKIP_PROD_REBUILD=1 — using existing dist/\n'); + } + + if (!existsSync(DIST_DIR)) { + return { + passed: false, + matches: [ + { + needle: '', + filePath: DIST_DIR, + count: 0, + }, + ], + }; + } + + const files = listAllFilesRecursive(DIST_DIR); + const matches: Array<{ needle: string; filePath: string; count: number }> = []; + for (const needle of FORBIDDEN_HOOK_STRINGS) { + for (const filePath of files) { + const count = countOccurrencesInFile(filePath, needle); + if (count > 0) { + matches.push({ needle, filePath, count }); + } + } + } + return { passed: matches.length === 0, matches }; +} + +/** + * Top-to-bottom orchestrator entry. Pre-flight A0 → launch browser → + * iterate driver list → bail on first failure → close browser → return + * exit code. + * + * @returns Process exit code: 0 on 14/14 GREEN, 1 on any failure. + */ +async function main(): Promise { + process.stdout.write('\nMokosh Plan 01-13 — UAT harness orchestrator\n'); + process.stdout.write('Architecture: A0 pre-flight + extension-internal page driver (A1..A13)\n'); + process.stdout.write('='.repeat(72) + '\n'); + + // A0 pre-flight (no Chrome launch needed; runs against built dist/). + const a0 = await assertA0_GrepGate(); + if (!a0.passed) { + process.stderr.write('\nA0 FAIL: production bundle hook-string leak detected.\n'); + for (const m of a0.matches) { + process.stderr.write(` - '${m.needle}' in ${m.filePath} (${m.count} occurrence${m.count === 1 ? '' : 's'})\n`); + } + process.stderr.write( + '\nThe Vite mode gate on the test-hook imports has regressed; verify\n' + + 'src/background/index.ts + src/offscreen/recorder.ts still gate via `__MOKOSH_UAT__`.\n', + ); + return 1; + } + process.stdout.write('A0: GREEN (production bundle hook-free)\n\n'); + + // Driver registry — execution order matters: + // A1 (idle) → A2 (REC start) → A3 (displaySurface) → A4 (popup pinned) + // → A5 (SAVE_ARCHIVE) → A6 (Bug B dispatch-ended) → A7 (genuine error) + // → A8 (Bug A onStartup) → A9 (icon sizes) → A10 (manifest) + // → A11 (35s segments) → A12 (ffprobe) → A13 (zip shape). + // + // A6 currently lives mid-list because the prototype's assertA6 does + // its own ensureOffscreen + START_RECORDING (idempotent w.r.t. A2's + // recording), then dispatch-ended. After A6 the recording is torn + // down — A7+ would need to re-start or test post-stop state. + // + // Wave 3A only A1..A4 wire to real impls; A5..A13 throw NOT YET + // IMPLEMENTED. Bail-on-first-failure stops the loop at A5 — A6's + // driver wires (via Wave 2's driveA6) but won't reach in this run. + // The standalone `npx tsx tests/uat/a6.test.ts` entry remains the + // way to verify A6 in isolation during Wave 3A. + const drivers: ReadonlyArray<{ + readonly name: string; + readonly drive: (page: import('puppeteer').Page) => Promise; + }> = [ + { name: 'A1', drive: driveA1 }, + { name: 'A2', drive: driveA2 }, + { name: 'A3', drive: driveA3 }, + { name: 'A4', drive: driveA4 }, + { name: 'A5', drive: driveA5 as (page: import('puppeteer').Page) => Promise }, + { name: 'A6', drive: driveA6 }, + { name: 'A7', drive: driveA7 }, + { name: 'A8', drive: driveA8 }, + { name: 'A9', drive: driveA9 }, + { name: 'A10', drive: driveA10 }, + { name: 'A11', drive: driveA11 }, + { name: 'A12', drive: driveA12 as (page: import('puppeteer').Page) => Promise }, + { name: 'A13', drive: driveA13 as (page: import('puppeteer').Page) => Promise }, + ]; + + process.stdout.write('Launching Chrome + opening harness page...\n'); + const handles = await launchHarnessBrowser(); + process.stdout.write(`Extension id: ${handles.extensionId}\n`); + process.stdout.write(`Downloads dir: ${handles.downloadsDir}\n\n`); + + const buffers = { swConsole: handles.swConsole, offConsole: handles.offConsole }; + const results: Array<{ name: string; passed: boolean; error?: string }> = []; + let bailReason: string | null = null; + + try { + for (const { name, drive } of drivers) { + process.stdout.write(`--- ${name} ---\n`); + let driverErr: string | undefined; + let result: AssertionRecord | null = null; + try { + result = await runAssertion( + name, + () => drive(handles.harnessPage), + buffers, + ); + printAssertionResult(result); + } catch (err) { + driverErr = err instanceof Error ? err.message : String(err); + // A throw here is either: (a) a Wave-3 stub firing + // (NOT YET IMPLEMENTED) — expected during incremental waves; OR + // (b) a CDP/Puppeteer-level error (e.g. page closed, timeout) — + // a genuine harness regression. Both bail uniformly. + process.stderr.write(`*** ${name} THREW: ${driverErr}\n`); + } + const passed = result !== null && result.passed && driverErr === undefined; + results.push({ name, passed, error: driverErr }); + if (!passed) { + bailReason = driverErr ?? `${name} failed; see structured checks above`; + break; + } + } + } finally { + try { + await handles.browser.close(); + } catch (closeErr) { + process.stderr.write(`(non-fatal: browser close threw: ${String(closeErr)})\n`); + } + } + + const passedCount = results.filter((r) => r.passed).length; + // Total = 1 (A0) + drivers.length (A1..A13) = 14. + const total = drivers.length + 1; + const finalPassed = passedCount + 1; // +1 for A0 (we already passed it to reach here) + + process.stdout.write('\n' + '='.repeat(72) + '\n'); + process.stdout.write( + `UAT harness: ${finalPassed}/${total} assertions passed${bailReason !== null ? ` (bailed: ${bailReason})` : ''}\n`, + ); + for (const r of results) { + const mark = r.passed ? '[PASS]' : '[FAIL]'; + const tail = r.error !== undefined ? ` — ${r.error}` : ''; + process.stdout.write(` ${mark} ${r.name}${tail}\n`); + } + if (bailReason !== null) { + const remainingStart = results.length; + for (let i = remainingStart; i < drivers.length; i += 1) { + process.stdout.write(` [SKIP] ${drivers[i].name} (not reached — bailed at ${results[results.length - 1].name})\n`); + } + } + process.stdout.write('='.repeat(72) + '\n'); + + return finalPassed === total ? 0 : 1; +} + +const code = await main(); +process.exit(code); diff --git a/tests/uat/lib/harness-page-driver.ts b/tests/uat/lib/harness-page-driver.ts index eb0e658..7db44e9 100644 --- a/tests/uat/lib/harness-page-driver.ts +++ b/tests/uat/lib/harness-page-driver.ts @@ -73,38 +73,74 @@ export async function driveA6(page: Page): Promise { }) as AssertionRecord; } -/* ─── Wave 3A — NOT YET IMPLEMENTED ──────────────────────────────── */ +/* ─── Wave 3A — WIRED ─────────────────────────────────────────────── */ /** - * Drive A1 (SW bootstrap state). Wave 3A wires this. - * @throws Always — replace stub when Wave 3A lands. + * Drive A1 (SW bootstrap state). Asserts the post-load idle-mode state: + * badge='', popup='', isRecording=false. MUST run BEFORE A2 in any + * orchestrated sequence — A2 manually sets badge='REC' which invalidates + * the A1 contract until the SW is reset. + * + * @param page - The harness page from `launchHarnessBrowser`. + * @returns Structured AssertionRecord with 3 checks (badge + popup + isRecording). */ -export async function driveA1(_page: Page): Promise { - throw new Error(`${WAVE3_STUB_PREFIX} — Wave 3A wires driveA1`); +export async function driveA1(page: Page): Promise { + return await page.evaluate(async () => { + // eslint-disable-next-line @typescript-eslint/no-explicit-any -- evaluate runs in browser context where Window types are loose. + const harness = (window as any).__mokoshHarness; + const r: AssertionRecord = await harness.assertA1(); + return r; + }) as AssertionRecord; } /** - * Drive A2 (toolbar onClicked → REC). Wave 3A wires this. - * @throws Always — replace stub when Wave 3A lands. + * Drive A2 (toolbar onClicked → REC). Uses the direct-offscreen workaround + * for the missing `tabs` manifest permission (per 01-11-SUMMARY). Leaves + * the offscreen recording active — A3 + A4 chain off A2's REC state. + * + * @param page - The harness page from `launchHarnessBrowser`. + * @returns Structured AssertionRecord with 2 checks (badge + popup). */ -export async function driveA2(_page: Page): Promise { - throw new Error(`${WAVE3_STUB_PREFIX} — Wave 3A wires driveA2`); +export async function driveA2(page: Page): Promise { + return await page.evaluate(async () => { + // eslint-disable-next-line @typescript-eslint/no-explicit-any -- evaluate runs in browser context where Window types are loose. + const harness = (window as any).__mokoshHarness; + const r: AssertionRecord = await harness.assertA2(); + return r; + }) as AssertionRecord; } /** - * Drive A3 (displaySurface monitor). Wave 3A wires this. - * @throws Always — replace stub when Wave 3A lands. + * Drive A3 (displaySurface === 'monitor'). Assumes A2 left recording + * active. Queries the offscreen `get-display-surface` bridge op. + * + * @param page - The harness page from `launchHarnessBrowser`. + * @returns Structured AssertionRecord with 1 check (displaySurface). */ -export async function driveA3(_page: Page): Promise { - throw new Error(`${WAVE3_STUB_PREFIX} — Wave 3A wires driveA3`); +export async function driveA3(page: Page): Promise { + return await page.evaluate(async () => { + // eslint-disable-next-line @typescript-eslint/no-explicit-any -- evaluate runs in browser context where Window types are loose. + const harness = (window as any).__mokoshHarness; + const r: AssertionRecord = await harness.assertA3(); + return r; + }) as AssertionRecord; } /** - * Drive A4 (popup during recording). Wave 3A wires this. - * @throws Always — replace stub when Wave 3A lands. + * Drive A4 (popup pinned + single offscreen during recording). Assumes + * A2 left recording active. Verifies getPopup unchanged + hasDocument + * true (no duplicate offscreen spawned). + * + * @param page - The harness page from `launchHarnessBrowser`. + * @returns Structured AssertionRecord with 2 checks (popup + hasDocument). */ -export async function driveA4(_page: Page): Promise { - throw new Error(`${WAVE3_STUB_PREFIX} — Wave 3A wires driveA4`); +export async function driveA4(page: Page): Promise { + return await page.evaluate(async () => { + // eslint-disable-next-line @typescript-eslint/no-explicit-any -- evaluate runs in browser context where Window types are loose. + const harness = (window as any).__mokoshHarness; + const r: AssertionRecord = await harness.assertA4(); + return r; + }) as AssertionRecord; } /* ─── Wave 3B — NOT YET IMPLEMENTED ──────────────────────────────── */