Files
DongHyeonka 49f7cde50e fix(platform): lifecycle 리스너 주인 규칙을 실제에 맞추고 테스트를 둔다 (05-03)
문제: browser-lifecycle.ts는 자신을 "창 lifecycle 리스너의 유일한
주인"이라 적고 어떤 capability도 visibilitychange·online·offline·focus·
pagehide·pageshow 리스너를 직접 달지 않는다고 약속한다.
optional-runtime-host.ts도 같은 말을 한다. 실제로는
- telemetry 수집기가 기본 구성에서 자기 pagehide 리스너를 단다
  (telemetry-collector.ts onPageExit).
- 네이티브 파일 선택기가 선택 창이 열린 동안 window focus 리스너를
  단다(browser-file-picker.ts, 리뷰가 세지 않은 두 번째 예외).
- lifecycle 런타임은 SW나 realtime이 있을 때만 만들어져 기본 구성에는
  없다.
또 createBrowserLifecycleRuntime을 직접 부르는 테스트가 없어 bfcache
복원 때 generation 증가(K3), dispose 때 리스너 해제(K4) 변이가
살아남았다.

고른 방법: 리뷰 권고 (a). 주석을 "런타임이 있을 때 capability는 여기에
구독한다"로 좁히고, 런타임이 생기는 조건과 알려진 예외 둘을 적는다.
tests/unit/browser-lifecycle.test.ts를 추가해 리스너 수, generation,
visibility·connectivity, 구독자 격리, beforeunload 부착·해제·prompt,
dispose 뒤 0개를 확인한다.

버린 대안:
- (b) telemetry를 lifecycle 런타임에 연결하고 기본 구성에서도 런타임을
  만든다: "기본 구성은 부작용 없는 생성" 원칙과 조립 순서를 함께 바꿔야
  해 이번 범위를 넘는다.
- (c) lint로 이벤트 이름을 막고 예외 파일을 적는다: 예외 목록 관리 비용에
  비해 지금 이득이 작다. 다운스트림이 lifecycle 런타임을 켤 때 다시 본다.

위험·한계: 규칙은 여전히 주석뿐이고 검사가 없다(주석에 그렇게 적었다).
src 동작은 바뀌지 않는다.

검증:
- RED(주석): 주석의 "single owner"와 telemetry-collector.ts의 pagehide,
  browser-file-picker.ts의 focus 리스너를 대조해 불일치 확인.
- RED(테스트 공백): 새 테스트는 현재 코드에서 5/5 통과하고, 변이 4개를
  모두 잡는다. K3(generation += 1 제거) → "expected {...} to match
  object { generation: 2 }", K4(dispose의 pagehide·pageshow 해제 제거) →
  "expected 2 to be +0", beforeunload 상시 부착 → "expected 1 to be +0",
  dirty 검사 제거 → preventDefault "to not be called".
- 회귀: browser-lifecycle, optional-runtime-host, runtime-adapters
  3파일 30/30 통과. tsc app·test 통과, eslint 통과,
  check-adapter-inventory PASS.

Refs: docs/reviews/2026-11-01-maturity-review/05-adapters-storage-kernel.md
2026-11-01 22:25:41 +09:00

167 lines
5.2 KiB
TypeScript

import { describe, expect, it, vi } from "vitest";
import {
createBrowserLifecycleRuntime,
type BrowserLifecycleEvent,
} from "../../src/adapters/platform/index.ts";
type Listener = (event: unknown) => void;
// 05-03. Records listeners per target so the test can count what the runtime
// attached and fire events without a DOM.
function createHost(initial: { hidden?: boolean; online?: boolean } = {}) {
const listeners = new Map<string, Set<Listener>>();
const target = (scope: string) => ({
addEventListener: (type: string, listener: Listener) => {
const key = `${scope}:${type}`;
const set = listeners.get(key) ?? new Set<Listener>();
set.add(listener);
listeners.set(key, set);
},
removeEventListener: (type: string, listener: Listener) => {
listeners.get(`${scope}:${type}`)?.delete(listener);
},
});
const document = {
...target("document"),
visibilityState: initial.hidden ? "hidden" : "visible",
};
const host = {
...target("window"),
document,
navigator: { onLine: initial.online ?? true },
};
const count = (key?: string) =>
[...listeners.entries()]
.filter(([name]) => key === undefined || name === key)
.reduce((total, [, set]) => total + set.size, 0);
const fire = (key: string, event: unknown = {}) => {
for (const listener of [...(listeners.get(key) ?? [])]) listener(event);
};
return { host, document, count, fire };
}
function create(initial?: Parameters<typeof createHost>[0]) {
const fake = createHost(initial);
const runtime = createBrowserLifecycleRuntime(
fake.host as unknown as Parameters<typeof createBrowserLifecycleRuntime>[0],
);
return { ...fake, runtime };
}
describe("browser lifecycle runtime", () => {
it("attaches one listener per lifecycle event and no beforeunload", () => {
const { count } = create();
for (const key of [
"document:visibilitychange",
"window:online",
"window:offline",
"window:focus",
"window:pagehide",
"window:pageshow",
]) {
expect(count(key)).toBe(1);
}
expect(count("window:beforeunload")).toBe(0);
expect(count()).toBe(6);
});
it("starts a new generation only on a bfcache restore", () => {
const { runtime, fire } = create();
const events: BrowserLifecycleEvent[] = [];
runtime.subscribe((event) => events.push(event));
expect(runtime.getSnapshot()).toMatchObject({
generation: 1,
pageState: "ACTIVE",
});
fire("window:pageshow", { persisted: false });
expect(runtime.getSnapshot()).toMatchObject({
generation: 1,
pageState: "ACTIVE",
});
fire("window:pagehide", { persisted: true });
expect(runtime.getSnapshot().pageState).toBe("PAGEHIDE");
fire("window:pageshow", { persisted: true });
expect(runtime.getSnapshot()).toMatchObject({
generation: 2,
pageState: "BFCACHE_RESTORED",
});
expect(events.map((event) => event.kind)).toEqual([
"PAGESHOW",
"PAGEHIDE",
"PAGESHOW",
]);
expect(events.at(-1)).toMatchObject({
persisted: true,
snapshot: { generation: 2 },
});
});
it("tracks visibility and connectivity and isolates a throwing subscriber", () => {
const { runtime, document, fire } = create({ hidden: true, online: false });
expect(runtime.getSnapshot()).toMatchObject({
visibility: "HIDDEN",
connectivityHint: "OFFLINE",
});
const received = vi.fn();
runtime.subscribe(() => {
throw new Error("subscriber defect");
});
runtime.subscribe(received);
document.visibilityState = "visible";
fire("document:visibilitychange");
fire("window:online");
expect(runtime.getSnapshot()).toMatchObject({
visibility: "VISIBLE",
connectivityHint: "ONLINE",
});
expect(received).toHaveBeenCalledTimes(2);
});
it("holds beforeunload only while a dirty source is registered", () => {
const { runtime, count, fire } = create();
let dirty = false;
const unregister = runtime.registerDirtySource(() => dirty);
const unregisterBroken = runtime.registerDirtySource(() => {
throw new Error("reporter defect");
});
expect(count("window:beforeunload")).toBe(1);
const clean = { preventDefault: vi.fn() };
fire("window:beforeunload", clean);
expect(clean.preventDefault).not.toHaveBeenCalled();
dirty = true;
const prompted = { preventDefault: vi.fn() };
fire("window:beforeunload", prompted);
expect(prompted.preventDefault).toHaveBeenCalledOnce();
unregister();
expect(count("window:beforeunload")).toBe(1);
unregisterBroken();
expect(count("window:beforeunload")).toBe(0);
});
it("removes every listener on dispose and ignores later subscriptions", () => {
const { runtime, count, fire } = create();
runtime.registerDirtySource(() => true);
const received = vi.fn();
runtime.subscribe(received);
expect(count()).toBe(7);
runtime.dispose();
expect(count()).toBe(0);
const late = vi.fn();
runtime.subscribe(late);
runtime.registerDirtySource(() => true);
fire("window:focus");
expect(count()).toBe(0);
expect(received).not.toHaveBeenCalled();
expect(late).not.toHaveBeenCalled();
});
});