import { appendFile, readdir, readFile } from "node:fs/promises"; import path from "node:path"; import { collectStaticAssets } from "../../scripts/generate-service-worker-assets.ts"; import { expect, test, type Page } from "../support/browser/strict-browser-test.ts"; import { prepareServiceWorkerBuilds, removeServiceWorkerBuilds, startBuildServer, type ServiceWorkerBuilds, } from "./support/service-worker-builds.ts"; /** * R3-6. Real-browser Service Worker checks, against real production builds. * * How the worker is enabled: the template's default build has * `serviceWorker: null`, and the only supported switch is the static * capability selection in `src/features/installed-runtime-capabilities.ts` * (`{ mode: "ACTIVE", scriptPath: "service-worker.js", handlers: * ["PWA_STATIC_ASSETS"] }`); `scripts/build-frontend.ts` then adds the worker * build. `support/service-worker-builds.ts` applies that selection in a temp * copy of the repo, builds it twice (`VITE_BUILD_ID` sw-e2e-a / sw-e2e-b), * and serves either dist from its own port per test. The copy also records * the worker host's `onUpdateWaiting` / `onReloadRequired` callbacks, which * the app itself does not subscribe to yet. * * The preview server of this suite is not used; each test uses absolute URLs. */ type Probe = typeof globalThis & { __caServiceWorkerTest?: { host: { requestActivation(): Promise }; events: string[]; }; }; let builds: ServiceWorkerBuilds | undefined; // B changes one route chunk on purpose. Route chunks used to differ only // because they embedded the build ID; since 09-02 they do not, so two builds // of the same source emit the same route chunks. A dynamically imported // module keeps all its exports, so the extra export survives the bundler. // Template sync (af3d8e6): upstream's not-found page is TechLog's Public one, // lazy-loaded like upstream's by `tech-log-route-runtime.tsx`. const CHANGED_ROUTE_SOURCE = "src/features/tech-log/presentation/public/pages/public-not-found-page.tsx"; test.beforeAll(async () => { test.setTimeout(180_000); builds = await prepareServiceWorkerBuilds({ beforeBuild: async (name, root) => { if (name !== "b") return; await appendFile( path.join(root, CHANGED_ROUTE_SOURCE), '\nexport const serviceWorkerE2eBuild = "b";\n', ); }, }); }); test.afterAll(async () => { await removeServiceWorkerBuilds(builds); }); function requireBuilds(): ServiceWorkerBuilds { if (!builds) throw new Error("Service Worker builds were not prepared."); return builds; } async function waitForEvent(page: Page, prefix: string): Promise { await page.waitForFunction( (expected) => (globalThis as Probe).__caServiceWorkerTest?.events.some((event) => event.startsWith(expected), ) === true, prefix, { timeout: 60_000 }, ); const events = await page.evaluate(() => [ ...((globalThis as Probe).__caServiceWorkerTest?.events ?? []), ]); return events.find((event) => event.startsWith(prefix))!; } async function startOutcome(page: Page): Promise { return JSON.parse((await waitForEvent(page, "start:")).slice("start:".length)); } async function hashedAssets(dist: string): Promise { return (await readdir(path.join(dist, "assets"))) .map((file) => `/assets/${file}`) .sort(); } // Template sync (af3d8e6). Upstream compares the cache with every file under // assets/, which is its whole static asset set. This product's set differs // from that folder both ways: IBM Plex Mono's `.woff` fallbacks there are not // cacheable (SW-RR-03), and `media/` files outside it are. So the expected set // is the one the build declares, from the generator's own scan. async function staticAssetSet(dist: string): Promise { const manifest = await collectStaticAssets(dist, "expected", "expected"); return manifest.assets.map((asset) => asset.url).sort(); } const headerCases = [ { name: "Content-Type: application/javascript", headers: { javascriptContentType: "application/javascript", gzip: false }, }, { name: "Content-Encoding: gzip with the compressed Content-Length", headers: { javascriptContentType: "text/javascript", gzip: true }, }, ] as const; for (const { name, headers } of headerCases) { test(`installs the static asset set served with ${name}`, async ({ page }) => { const { dist } = requireBuilds(); const server = await startBuildServer(dist, headers); try { await page.goto(`${server.origin}/`); // A failed install (CONTENT_TYPE_INVALID, BYTES_MISMATCH, ...) ends as // FAILED/INSTALL_FAILED; a first install that worked asks for a reload. expect(await startOutcome(page)).toEqual({ kind: "RELOAD_TO_ENABLE" }); const cached = await page.evaluate(async () => { const names = (await caches.keys()).filter((cacheName) => cacheName.startsWith("ca-static-v1-"), ); const cache = await caches.open(names[0] ?? "missing"); const paths = (await cache.keys()) .map((request) => new URL(request.url)) .filter((url) => url.origin === location.origin) .map((url) => url.pathname); return { names, paths }; }); expect(cached.names).toHaveLength(1); expect(cached.paths.sort()).toEqual(await staticAssetSet(dist.a)); // The server really sent the headers under test. const assets = server.served.filter((response) => response.path.startsWith("/assets/"), ); expect(assets.length).toBeGreaterThan(0); if (headers.gzip) { expect(assets.every((response) => response.contentEncoding === "gzip")) .toBe(true); expect( assets.some( (response) => response.contentLength < response.decodedLength, ), ).toBe(true); } else { expect( assets .filter((response) => response.path.endsWith(".js")) .every( (response) => response.contentType === "application/javascript", ), ).toBe(true); } } finally { await server.close(); } }); } type BuildServer = Awaited>; // Playwright's Firefox never lets a worker control a page: even a trivial // classic worker leaves `navigator.serviceWorker.controller` null after a new // navigation (checked by hand with Playwright 1.62). With no controlled // client, B skips `waiting` and activates by itself (`requestActivation()` then // returns NO_WAITING_WORKER), and the fetch handler is never reached. The // update tests therefore run where a page can be controlled. Not a product // defect. // quarantine(owner=frontend-platform, defect=playwright-firefox-no-sw-control, expires=2027-03-31) const NO_CONTROLLED_PAGES = "Playwright Firefox pages are never controlled by a service worker."; /** * Loads build A twice (first install, then a normal navigation), switches the * server to B, runs the update check and activates B through the app host. * Returns whether the second load of A was controlled by the worker. */ async function updateFromAToB( page: Page, server: BuildServer, ): Promise<{ secondLoad: unknown; controlled: boolean }> { await page.goto(`${server.origin}/`); expect(await startOutcome(page)).toEqual({ kind: "RELOAD_TO_ENABLE" }); await page.evaluate(async () => { await navigator.serviceWorker.ready; }); // A normal navigation. (`page.reload()` would not change anything here.) await page.goto(`${server.origin}/`); const secondLoad = await startOutcome(page); const controlled = await page.evaluate( () => navigator.serviceWorker.controller !== null, ); server.serve("b"); await page.evaluate(async () => { await (await navigator.serviceWorker.getRegistration())?.update(); }); await waitForEvent(page, "update-waiting"); const activation = await page.evaluate(() => (globalThis as Probe).__caServiceWorkerTest!.host.requestActivation(), ); expect(activation).toEqual({ kind: "ACTIVATED_RELOAD_REQUIRED" }); await waitForEvent(page, "reload-required"); return { secondLoad, controlled }; } test("announces update-waiting and reload-required through the host when build B replaces A", async ({ page, browserName, }) => { test.skip(browserName === "firefox", NO_CONTROLLED_PAGES); const server = await startBuildServer(requireBuilds().dist); try { await updateFromAToB(page, server); const registration = await page.evaluate(async () => { const current = await navigator.serviceWorker.getRegistration(); return { active: current?.active?.state ?? null, waiting: current?.waiting ?? null, }; }); expect(registration).toEqual({ active: "activated", waiting: null }); } finally { await server.close(); } }); test("serves A's removed chunk from the previous cache once B controls the page", async ({ page, browserName, }) => { test.skip(browserName === "firefox", NO_CONTROLLED_PAGES); const { dist } = requireBuilds(); const routeChunks = Object.values( ( JSON.parse( await readFile(path.join(dist.a, "release-manifest.json"), "utf8"), ) as { routeChunks: Record } ).routeChunks, ); const inB = new Set(await hashedAssets(dist.b)); const removedChunk = routeChunks .map((chunk) => `/${chunk}`) .find((chunk) => !inB.has(chunk)); if (!removedChunk) throw new Error("Build B kept every route chunk of A."); const server = await startBuildServer(dist); try { const { secondLoad, controlled } = await updateFromAToB(page, server); expect(secondLoad).toEqual({ kind: "ACTIVE", buildId: "sw-e2e-a" }); expect(controlled).toBe(true); // B's worker now controls the page. The chunk is not in B's manifest and // not on the server any more, so only A's retained cache can answer. const fromWorker = await page.evaluate(async (url) => { const response = await fetch(url); return { status: response.status, body: await response.text() }; }, removedChunk); expect(fromWorker).toEqual({ status: 200, body: await readFile(path.join(dist.a, removedChunk), "utf8"), }); expect((await page.request.get(`${server.origin}${removedChunk}`)).status()) .toBe(404); } finally { await server.close(); } }); // `beforeAll` already ran `scripts/build-frontend.ts` unmodified (default // `bundle` config loader); this pins that both builds emitted the worker. test("builds the ACTIVE worker with the repo's unmodified build script", async () => { const { dist } = requireBuilds(); for (const root of [dist.a, dist.b]) { expect(await readdir(root)).toContain("service-worker.js"); } });