import { appendFile, readdir, readFile } from "node:fs/promises"; import path from "node:path"; 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/product-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. * * Premises (0929/11-03): the helper's three, listed in * `support/service-worker-builds.ts`, plus one here: build B changes * `CHANGED_ROUTE_SOURCE`, so a product that deletes that page points the * constant at another route page. Run both Service Worker specs after turning * the worker on (Service Worker checklist in * `docs/architecture/optional-adapter-recipes.md`). */ type Probe = typeof globalThis & { __caServiceWorkerTest?: { host: { requestActivation(): Promise }; events: string[]; }; }; let builds: ServiceWorkerBuilds | undefined; // 1103/11-09. Once a worker controls the page it answers the page's script // requests, so the fixture cannot mark them and cannot tell whether a // preload made then was run. It names those preloads instead of calling them // unused; here they are expected. Preloads made before the worker took // control are still checked. test.use({ allowedBrowserFailure: /^preloadunverifiable:service-worker:\/assets\/[\w-]+\.js$/u, }); // 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. const CHANGED_ROUTE_SOURCE = "src/presentation/pages/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(); } 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); // 0929/11-03. The list A's build generated, not `dist/assets`: a product // may precache more (or fewer) files than the template does. expect(cached.paths.sort()).toEqual(requireBuilds().precached.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(); } }); /** The route chunk of A that B no longer has: `CHANGED_ROUTE_SOURCE`'s. */ async function removedRouteChunk( dist: ServiceWorkerBuilds["dist"], ): Promise { 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."); return removedChunk; } 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 removedChunk = await removedRouteChunk(dist); 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(); } }); type SameDocumentProbe = typeof globalThis & { __swE2eSameDocument?: boolean }; // 1105/06-03. The old tab's real path, not only `fetch()`: A's page, now // controlled by B's worker, opens the route whose chunk B removed // (`CHANGED_ROUTE_SOURCE` is the not-found page, so any unmatched path // imports it). Under the worker the preload fixture cannot judge preloads // (the 11-09 allowance above), so this test asserts the outcome: the route // renders in the same document, the chunk never reaches the server, and the // strict fixture sees no failure outside the allowance. A worker that cannot // answer the chunk makes the app's chunk recovery reload into B, which also // renders the not-found page; only the same-document check tells them apart // (review 06-R10). test("opens A's removed route in the old tab without a reload once B controls it", async ({ page, browserName, }) => { test.skip(browserName === "firefox", NO_CONTROLLED_PAGES); const { dist } = requireBuilds(); const removedChunk = await removedRouteChunk(dist); const server = await startBuildServer(dist); try { const { controlled } = await updateFromAToB(page, server); expect(controlled).toBe(true); const entryScript = () => page.evaluate( () => document.querySelector('script[type="module"][src]') ?.src ?? null, ); const entryBefore = await entryScript(); await page.evaluate(() => { (globalThis as SameDocumentProbe).__swE2eSameDocument = true; }); const servedBefore = server.served.length; // A client-side navigation, as a link inside the app makes. await page.evaluate(() => { history.pushState({}, "", "/sw-e2e-removed-route"); dispatchEvent(new PopStateEvent("popstate")); }); await expect( page.getByRole("heading", { name: /페이지를 찾을 수 없습니다|Page not found/u }), ).toBeVisible({ timeout: 30_000 }); const after = await page.evaluate((chunk) => ({ sameDocument: (globalThis as SameDocumentProbe).__swE2eSameDocument === true, chunkRequested: performance.getEntriesByName(new URL(chunk, location.origin).href) .length > 0, }), removedChunk); expect(after).toEqual({ sameDocument: true, chunkRequested: true }); expect(await entryScript()).toBe(entryBefore); expect( server.served.slice(servedBefore).map((response) => response.path), ).not.toContain(removedChunk); } 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"); } });