repremium/mokosh
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(01-13): wave-3A — A1+A2+A3+A4 GREEN + harness.test.ts orchestrator (5/14 assertions GREEN)

Browse Source 
Wave 3A landed. `npm run test:uat` now exercises 5/14 assertions
end-to-end (A0 + A1 + A2 + A3 + A4); bails at A5 NOT YET IMPLEMENTED
(Wave 3B scope). A6 still PASSES 5/5 through 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; once Wave 3B
wires driveA5 the loop will fall through to A6 (which uses the proven
Wave-2 driveA6 driver — no rework needed there).

Files changed:

- `tests/uat/extension-page-harness.ts` — extends `window.__mokoshHarness`
  from `{ assertA6 }` to `{ assertA1, assertA2, assertA3, assertA4,
  assertA6 }`. Per-assertion contracts:
  • A1 — chrome.action.getBadgeText({}) === '' + getPopup({}) === ''
    + isRecording=false (badge !== 'REC' proxy per state-machine atomic
    pairing). 3 CheckRecords.
  • A2 — ensureOffscreen + START_RECORDING direct-to-offscreen
    (workaround for the `tabs` manifest permission gap per
    01-11-SUMMARY + plan resolved-questions row 2) + manual
    setBadgeText('REC') + setPopup(POPUP_HTML_PATH) + waitFor
    badge==='REC'. The bypassed chrome.action.onClicked →
    startVideoCapture path is unit-tested in
    tests/background/badge-state-machine.test.ts; A2 verifies the
    contract that matters (recording reaches the REC state-machine
    row). 2 CheckRecords.
  • A3 — offscreen bridge query 'get-display-surface' (new in this
    plan via the prior commit's offscreen-hooks extension) → asserts
    === 'monitor'. 1 CheckRecord.
  • A4 — getPopup remains 'src/popup/index.html' + hasDocument()===true
    (no duplicate offscreen). Essentially a no-op verification —
    regression protection against future refactors that might unpin
    the popup during recording or spawn extra offscreens on stray
    events. 2 CheckRecords.
  • IMPORTANT: chrome.action.getPopup() returns the FULL absolute
    chrome-extension://<id>/... URL (not the manifest-relative path).
    A2.2 + A4.1 assert via .endsWith('src/popup/index.html') to stay
    extension-id independent. Empirical finding from first orchestrator
    run; documented inline.

- `tests/uat/lib/harness-page-driver.ts` — wires `driveA1/A2/A3/A4`
  (replaces the 4 NOT YET IMPLEMENTED Wave-3A stubs from
  eb64521). Each wraps a single page.evaluate(() =>
  window.__mokoshHarness.assertXX()) call per the contract laid down
  by driveA6. A5+A7..A13 remain stubbed for Waves 3B+3C+3D.

- `tests/uat/harness.test.ts` (NEW) — top-level UAT orchestrator
  driving all 14 assertions sequentially against a single Chrome +
  single harness page. A0 (Tier-1 grep gate) runs pre-flight before
  any Chrome launch — mirrors
  tests/background/no-test-hooks-in-prod-bundle.test.ts forbidden-
  string inventory (9 entries; belt-and-suspenders per
  feedback-pre-checkpoint-bundle-gates.md memory). Bail-on-first-
  failure with [SKIP] markers for unreached assertions + structured
  diagnostic dump (full SW + offscreen console tail) on each failure.
  SKIP_PROD_REBUILD=1 escape hatch skips the A0-side `npm run build`
  for developer iteration.

Verification (all GREEN):
  - npx tsc --noEmit: clean (root)
  - npx tsc --noEmit -p tests/uat: clean (UAT subtree)
  - npm run build: clean; production bundle hook-free
    (9-string grep gate in vitest unit gate)
  - npm run build:test: clean; dist-test/assets/extension_page_harness-*.js
    grew from 3.87kB → 7.67kB (A1+A2+A3+A4 added)
  - SKIP_BUILD=1 npx vitest run: 93/93 GREEN
    (Wave 0+1+2 baseline 92 + 1 from the 9th grep-gate string from
    the prior commit; this commit adds zero new vitest tests — the
    A1-A4 contracts are verified at UAT-harness time only)
  - npx tsx tests/uat/a6.test.ts (standalone): 5/5 GREEN; exit 0
    (Wave-2 A6 baseline preserved through orchestrator-adjacent
    harness page surface extension)
  - npm run test:uat (full operator entry): 5/14 GREEN
    (A0 + A1 + A2 + A3 + A4); bails at A5 NOT YET IMPLEMENTED
    (Wave 3B scope, expected). Total wall clock ~25s (~5s build +
    ~5s prod-rebuild for A0 + ~15s assertion sequence).

Operator empirical-verification deferred to orchestrator (per
feedback-pre-checkpoint-bundle-gates.md — the orchestrator runs SW
CSP-safety + Node-globals + DOM-globals grep on the built bundle
before surfacing any checkpoint).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Mark
2026-05-18 15:45:25 +02:00
parent 2f1b1f36a7
commit 1b67b1c1d3
3 changed files with 681 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

291
tests/uat/extension-page-harness.ts
View File

@@ -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<AssertionResult> {
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<AssertionResult> {
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<AssertionResult> {
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://<id>/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: '<chrome-extension://<id>/>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<AssertionResult> {
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<AssertionResult> {
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://<id>/... URLs; assert by .endsWith() to stay
// extension-id independent.
result.checks.push({
name: 'A4.1: popup remains \'src/popup/index.html\' during REC',
expected: '<chrome-extension://<id>/>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<AssertionResult>;
assertA2: () => Promise<AssertionResult>;
assertA3: () => Promise<AssertionResult>;
assertA4: () => Promise<AssertionResult>;
assertA6: () => Promise<AssertionResult>;
};
}
}
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 {};