Files
clean-architecture-frontend…/tests/e2e/service-worker-recovery.spec.ts
T
DongHyeonka 37e5f9d682 test(e2e): SW spec이 이미 켠 worker와 생성된 사전 캐시 목록을 쓴다 (0929/11-03)
SW e2e는 템플릿의 `= null;` 줄만 바꿔 worker를 켰다. 제품이 이미 ACTIVE로
켠 트리에서는 2건이 실패하고 4건이 실행되지 않았다. 사전 캐시 목록도
템플릿 기준으로 고정돼 있어 해시 파일을 더하면 2건이 실패했다.

선택을 지금 값과 상관없이 고치되, 이미 ACTIVE면 제품의 handler를 그대로
두는 `turnOnServiceWorker` 하나로 모았다. 빌드가 만든 사전 캐시 목록을
`precached`로 돌려주고 spec이 그 목록과 비교한다. 같은 문제를 고친
0929/06-04(`96a4f68`)의 `selectActiveServiceWorker`는 ACTIVE 선택을
템플릿 값으로 덮어써 제품 handler가 빠지므로 이 함수로 바꿨고, 실패한
준비 단계에서 임시 복사본을 지우는 처리는 유지했다(두 브랜치 병합 때
오케스트레이터가 충돌을 풀었다).

위험: 테스트 도우미만 바뀐다. 0929/06-04 단위 테스트의 기대값이 "ACTIVE
선택도 템플릿 값으로 덮어쓴다"에서 "ACTIVE 선택은 그대로 둔다"로 바뀐다.
검증: ACTIVE 선택과 해시 파일 추가 트리 모두 6 passed(에이전트).
병합 뒤 service-worker-build-output 단위 테스트 5/5, SW e2e chromium·webkit
12/12, tsc(test), eslint 통과.
2026-11-01 23:20:28 +09:00

156 lines
5.1 KiB
TypeScript

import path from "node:path";
import { expect, test, type Page } from "../support/browser/strict-browser-test.ts";
import {
prepareServiceWorkerBuilds,
removeServiceWorkerBuilds,
replaceOnce,
setServiceWorkerSelection,
startBuildServer,
type ServiceWorkerBuilds,
} from "./support/service-worker-builds.ts";
/**
* 06-03 (D-5). The emergency exit for a worker that stops the page from
* booting. Page code cannot help then: the page never runs. Build A is the
* ACTIVE worker with its fetch handler broken (every intercepted request is a
* network error, the entry script included). Build B is a
* `REMOVE_REGISTRATION` release, which ships the self-unregistering
* `service-worker.js` (`scripts/lib/self-unregistering-service-worker.ts`).
* The browser's update check alone replaces A with it, and the next load boots
* B from the network.
*
* Premises (0929/11-03): the helper's, in `support/service-worker-builds.ts`,
* plus one here. Build A breaks the worker by replacing the exact fetch line
* of `src/adapters/service-worker/service-worker-entry.ts` below; a product
* that rewrites that line updates the search text.
*/
type Probe = typeof globalThis & {
__caServiceWorkerTest?: { events: string[] };
};
let builds: ServiceWorkerBuilds | undefined;
test.beforeAll(async () => {
test.setTimeout(180_000);
builds = await prepareServiceWorkerBuilds({
async beforeBuild(name, root) {
if (name === "a") {
await replaceOnce(
path.join(root, "src/adapters/service-worker/service-worker-entry.ts"),
"runtime.onFetch(described).then((cached) => cached ?? fetch(request)),",
"Promise.resolve(Response.error()),",
);
return;
}
await setServiceWorkerSelection(
root,
() => `{
mode: "REMOVE_REGISTRATION",
scriptPath: "service-worker.js",
}`,
);
},
});
});
test.afterAll(async () => {
await removeServiceWorkerBuilds(builds);
});
async function startOutcome(page: Page): Promise<unknown> {
await page.waitForFunction(
() =>
(globalThis as Probe).__caServiceWorkerTest?.events.some((event) =>
event.startsWith("start:"),
) === true,
undefined,
{ timeout: 60_000 },
);
const event = await page.evaluate(() =>
(globalThis as Probe).__caServiceWorkerTest!.events.find((entry) =>
entry.startsWith("start:"),
)!,
);
return JSON.parse(event.slice("start:".length));
}
test("a REMOVE_REGISTRATION release unregisters a worker that blocks boot", async ({
browser,
browserName,
}) => {
// Same quarantine as service-worker-update.spec.ts.
// quarantine(owner=frontend-platform, defect=playwright-firefox-no-sw-control, expires=2027-03-31)
test.skip(
browserName === "firefox",
"Playwright Firefox pages are never controlled by a service worker.",
);
if (!builds) throw new Error("Service Worker builds were not prepared.");
const server = await startBuildServer(builds.dist);
// The broken phase fails requests on purpose, so this test drives its own
// context instead of the strict `page` fixture and checks the recovered
// load for browser errors itself.
const context = await browser.newContext();
try {
const page = await context.newPage();
await page.goto(`${server.origin}/`);
expect(await startOutcome(page)).toEqual({ kind: "RELOAD_TO_ENABLE" });
await page.evaluate(async () => {
await navigator.serviceWorker.ready;
});
// Worker A controls the next load and fails the entry script.
await page.goto(`${server.origin}/`);
const blocked = await page.evaluate(async () => {
const entry = document.querySelector<HTMLScriptElement>(
'script[type="module"][src]',
);
if (!entry) return "no entry script";
try {
await fetch(entry.src);
return "loaded";
} catch {
return navigator.serviceWorker.controller ? "blocked" : "uncontrolled";
}
});
expect(blocked).toBe("blocked");
// Release B. Only the browser's update check runs; no code of B does.
server.serve("b");
await page.evaluate(async () => {
await (await navigator.serviceWorker.getRegistration())?.update();
});
await expect
.poll(
() =>
page.evaluate(
async () =>
(await navigator.serviceWorker.getRegistration()) === undefined,
),
{ timeout: 30_000 },
)
.toBe(true);
const failures: string[] = [];
page.on("console", (message) => {
if (["error", "warning"].includes(message.type())) {
failures.push(`console:${message.type()}:${message.text()}`);
}
});
page.on("pageerror", (error) => failures.push(`pageerror:${error.name}`));
page.on("requestfailed", (request) =>
failures.push(`requestfailed:${new URL(request.url()).pathname}`),
);
await page.goto(`${server.origin}/`);
expect(await startOutcome(page)).toEqual({ kind: "DISABLED" });
expect(
await page.evaluate(() => navigator.serviceWorker.controller === null),
).toBe(true);
expect(failures).toEqual([]);
} finally {
await context.close();
await server.close();
}
});