Task 3 of Plan 01-11 (Puppeteer UAT harness).
Harness file tree (tests/uat/):
- harness.test.ts: tsx-runnable top-to-bottom harness entry point.
Runs A0 inline (filesystem grep gate, abort-on-fail T-1-11-01),
then launches Chrome + opens popup bridge + queries manifest, then
iterates A1-A13 stubs. Each stub throws "NOT YET IMPLEMENTED —
Plan 01-11 Task N wires this assertion". Exit code = 0 on full
pass, 1 otherwise. Final line: "UAT harness: N/14 assertions passed".
- lib/launch.ts: launchHarnessBrowser() — wraps puppeteer.launch with
enableExtensions:[dist-test/], headless default (HEADLESS=0
override), --no-sandbox + --auto-select-desktop-capture-source flags.
Polls browser.extensions() until the extension registers (empirically
~100ms but the first call right after launch returns Map(0)).
Opens both a blank page (for triggerExtensionAction) AND the popup
page (the bridge surface). Returns { browser, extension, extensionId,
sw, downloadsDir, page, popup }.
- lib/extension.ts: waitForOffscreenTarget + attachToOffscreen +
countOffscreenTargets. Offscreen attach uses target.type() ===
'background_page' + .asPage() (NOT .page() — RESEARCH §4 Pitfall 1).
- lib/sw.ts: chrome.* state queries via the POPUP page handle (NOT
the WebWorker handle — see architecture note below). getBadgeText,
getPopup, getManifest, getIconSize, getIsRecording (side-channeled
through badge text), fireOnStartup (via __mokoshTestQuery bridge),
sendSyntheticRecordingError, getNotificationSnapshot (via bridge),
keepalivePing (no-op message to wake SW for ~30s).
- lib/offscreen.ts: getDisplaySurface, simulateUserStop (the
dispatchEvent('ended') path per RESEARCH §7 BLOCKER — DO NOT REFACTOR
to track.stop()), getSegmentCount.
- lib/assertions.ts: runAssertion(idx, name, buffers, fn) wrapper —
records pass/fail/duration; on failure dumps last 30 lines of SW
+ offscreen console buffers to stderr before rethrowing. assertEqual
/ assertMatch / assertTrue / assertGte / waitFor polling helper.
- lib/zip.ts: jszip-based assertArchiveShape + extractEntryToFile for
assertions 12 + 13.
- README.md: runtime + local-debug + CI semantics + locale gotcha
+ dev-dep size note + assertion catalog table.
- tsconfig.json: per-tree type-check config (mirrors root tsconfig.json
compiler options but includes the harness tree explicitly).
Architecture refinement (DEVIATION from RESEARCH §1 — Rule 1+3 inline fix):
- RESEARCH §1 sketched `sw.evaluate(() => chrome.action.getBadgeText({}))`
as the chrome.* query path. Empirical probes during Task 3 execution
against Puppeteer 25.0.2 + Chrome 148 + --headless=true revealed two
blockers:
1. Puppeteer's WebWorker.evaluate runs in an ISOLATED WORLD that
carries SW globals (clients, registration, ...) but NOT the
extension's full chrome.* API surface. Object.keys(chrome) inside
sw.evaluate returns ["loadTimes","csi"] — the public webpage
chrome, not the extension chrome.
2. Chrome 148's headless mode aggressively suspends MV3 service
workers; subsequent swTarget.worker() calls return
"Protocol error: No target with given id found".
- WORKAROUND: open the popup page (chrome-extension://<id>/src/popup/
index.html) as a separate Puppeteer Page. The popup has full
chrome.* access (it's an extension context with same privileges as
the SW) AND stable Puppeteer lifetime. For SW-globalThis state
(__mokoshTest in the SW isolate, NOT in the popup), bridge via
chrome.runtime.sendMessage. The popup sends
{ type: '__mokoshTestQuery', op: 'snapshot' | 'fire-on-startup' |
'handler-types' }; the SW hook's onMessage handler responds.
- Bridge implementation added to src/test-hooks/sw-hooks.ts — registers
AFTER the production listeners so it never intercepts production
messages (__mokoshTest* type is unambiguously test-only). Tier-1
grep gate (no-test-hooks-in-prod-bundle.test.ts) continues to enforce
ZERO __mokoshTest occurrences in dist/ — the bridge handler is
tree-shaken alongside the rest of the hook module via the
__MOKOSH_UAT__ gate.
Other configuration changes:
- vitest.config.ts: exclude tests/uat/** from vitest discovery. The
Puppeteer harness is invoked via `npm run test:uat` (not vitest);
running it under vitest would try to launch real Chrome inside a
vitest worker. The .test.ts suffix is retained for editor +
naming-convention consistency with the rest of the tree.
Verification:
- npx tsc --noEmit (src/): exit 0
- npx tsc --noEmit -p tests/uat: exit 0
- npm run build: exit 0
- grep -rln '__mokoshTest|simulateUserStop|getSegmentCount|setCurrentStream|setSegmentCountGetter|__mokoshTestQuery|__mokoshKeepalive' dist/: ZERO matches
- npm run build:test: exit 0; dist-test/ populated with the new bridge code
- SKIP_BUILD=1 npx vitest run: 89/89 GREEN
- SKIP_PROD_REBUILD=1 npx tsx tests/uat/harness.test.ts:
→ A0 [PASS]: production bundle has no test-hook leaks (19ms)
→ Browser launches; popup opens; manifest read succeeds
→ A1-A13 [FAIL]: NOT YET IMPLEMENTED — Plan 01-11 Task N wires this
→ "UAT harness: 1/14 assertions passed, 13 failed (first failure: A1)"
→ Exit code: 1 (expected — 13 RED stubs intentional)
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
94 lines
3.2 KiB
TypeScript
94 lines
3.2 KiB
TypeScript
// tests/uat/lib/extension.ts — Plan 01-11 harness extension/offscreen helpers.
|
|
//
|
|
// The offscreen-document attach uses a CDP-level target type that
|
|
// Puppeteer 25 surfaces as `'background_page'` — NOT `'page'`. Per
|
|
// Plan 01-11 RESEARCH §4 / Pitfall 1, finding the offscreen via
|
|
// `t.type() === 'page'` returns no matches; `'background_page'` is
|
|
// the right discriminator. After getting the target, `.asPage()`
|
|
// returns a Page-like handle (NOT `.page()` — that returns undefined).
|
|
//
|
|
// References:
|
|
// - Puppeteer Target types:
|
|
// https://pptr.dev/api/puppeteer.targettype
|
|
// - Chrome offscreen document:
|
|
// https://developer.chrome.com/docs/extensions/reference/api/offscreen
|
|
|
|
import type { Browser, Page, Target } from 'puppeteer';
|
|
|
|
/** How long to wait for the offscreen document target to appear. */
|
|
const OFFSCREEN_TARGET_TIMEOUT_MS = 5_000;
|
|
|
|
/**
|
|
* Poll the browser's target list for the offscreen document. The
|
|
* offscreen is created lazily — only when the SW issues
|
|
* `chrome.offscreen.createDocument(...)`. Caller MUST invoke a flow
|
|
* that triggers offscreen creation (e.g. start a recording) BEFORE
|
|
* calling this helper.
|
|
*
|
|
* @param browser - Puppeteer Browser handle.
|
|
* @param extensionId - The extension's runtime id (for URL filtering).
|
|
* @returns Resolved Target whose URL contains 'offscreen'.
|
|
* @throws If no offscreen target appears within OFFSCREEN_TARGET_TIMEOUT_MS.
|
|
*/
|
|
export async function waitForOffscreenTarget(
|
|
browser: Browser,
|
|
extensionId: string,
|
|
): Promise<Target> {
|
|
const predicate = (t: Target): boolean => {
|
|
const url = t.url();
|
|
// Offscreen documents are loaded as chrome-extension://<id>/...
|
|
// with a path containing 'offscreen' (matches both 'src/offscreen/'
|
|
// and the bundled equivalents). Target type 'background_page' per
|
|
// RESEARCH §4 Pitfall 1.
|
|
return (
|
|
t.type() === 'background_page' &&
|
|
url.startsWith(`chrome-extension://${extensionId}`) &&
|
|
url.includes('offscreen')
|
|
);
|
|
};
|
|
|
|
return await browser.waitForTarget(predicate, {
|
|
timeout: OFFSCREEN_TARGET_TIMEOUT_MS,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Attach to the offscreen document as a Page-like handle. Uses
|
|
* `.asPage()` (NOT `.page()` — Puppeteer 25 returns null for
|
|
* `.page()` on background_page-type targets).
|
|
*
|
|
* @param target - The offscreen Target from waitForOffscreenTarget.
|
|
* @returns Page handle for evaluate/expose/etc.
|
|
*/
|
|
export async function attachToOffscreen(target: Target): Promise<Page> {
|
|
const page = await target.asPage();
|
|
return page;
|
|
}
|
|
|
|
/**
|
|
* Count the offscreen targets currently in the browser. Used by
|
|
* assertion 4 to verify that a toolbar click while recording does
|
|
* NOT spawn a second offscreen document.
|
|
*
|
|
* @param browser - Puppeteer Browser handle.
|
|
* @param extensionId - The extension's runtime id.
|
|
* @returns Integer count of offscreen targets.
|
|
*/
|
|
export function countOffscreenTargets(
|
|
browser: Browser,
|
|
extensionId: string,
|
|
): number {
|
|
const targets = browser.targets();
|
|
let count = 0;
|
|
for (const t of targets) {
|
|
if (
|
|
t.type() === 'background_page' &&
|
|
t.url().startsWith(`chrome-extension://${extensionId}`) &&
|
|
t.url().includes('offscreen')
|
|
) {
|
|
count += 1;
|
|
}
|
|
}
|
|
return count;
|
|
}
|