Files
clean-architecture-frontend…/tests/unit/realtime/result.test.ts
T
DongHyeonkaandClaude Opus 5.5 ae2f006b6d refactor(realtime): merge snapshot and race helpers, move shared parsers to kernel (Q-6.4-8)
Realtime kept three DataSnapshot readers and about ten hand-written
abort/timeout races, and two parsers had drifted copies in other adapters.

Snapshot: reconnect-coordinator and bounded-poll now use result.ts
captureRealtimeDataSnapshot (+ `source`, variadic hasExactSnapshotKeys).
Kept the result.ts rules, the stricter ones: Object.hasOwn instead of
`"value" in` (prototype pollution), enumerable fields only, keys read from
one descriptor snapshot, frozen computed at snapshot time instead of a
later Object.isFrozen. Poll therefore now rejects non-enumerable fields;
it also accepts null-prototype records, which the other two copies
already did (pure data, no inherited accessors). Characterization test
added for both in bounded-poll-coordinator.test.ts.

Race: one raceRealtimeTask(task, signal, deadline) in result.ts, built on
kernel createAbortableOperation, replaces fetch-sse timed/cancelReader,
reconnect race/drain (the drain keeps a host timer via timerDeadline,
since the clock itself may hang), poll awaitTaskOrAbort/awaitWithinLease,
live-poll checkpoint + two quiescence races (now one), stream-coordinator
deadline/recovery-wait/close-drain, and the two WS inline races. Kept
semantics: deadline armed first and wins a tie (poll lease), task still
starts when the clock throws (reader cancel), collaborator rejections
still reach stream-coordinator callers, scheduler install failure still
fails closed as a timeout. Small change: nothing starts once the signal is
already aborted (WS apply / SSE onEvent / reader.read could run just
before being reported ABORTED). The mapping adds one microtask per race,
so the reconnect test flush() helper gets 16 turns instead of 8.

Kernel: parseRetryAfterDelay moves to platform/retry-after.ts (realtime
re-exports it; http retry-policy parseRetryAfter now delegates, so it
rejects "", "  ", "1e3", "1.5", "0x10" and non-IMF dates it used to
accept). json-member-scanner moves to platform/; web-push push-codec uses
it instead of its top-level-only duplicate-key check, so nested
duplicates are rejected too. INVENTORY 136 -> 137, detail tables updated.

Tests: RED for http strict Retry-After, web-push nested duplicate, poll
snapshot rules; new direct raceRealtimeTask tests. Gates: architecture,
types app/test (+ service-worker/web-worker), lint, adapter-inventory
(abort ratchet 21/21), test:unit, test:component, realtime-boundaries,
integration/platform all pass. Realtime bundle 40346 -> 39433 gzip.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-24 13:54:42 +09:00

246 lines
6.8 KiB
TypeScript

import { describe, expect, it, vi } from "vitest";
import {
isRealtimeResult,
raceRealtimeTask,
realtimeFailure,
realtimeSuccess,
snapshotRealtimeResult,
timerDeadline,
} from "../../../src/adapters/realtime/result.ts";
function isString(value: unknown): value is string {
return typeof value === "string";
}
describe("realtime result boundary", () => {
it("uses an immutable one-shot snapshot instead of rereading a mutable result", () => {
const source = { ok: true, value: "captured" };
const captured = snapshotRealtimeResult(source, (value): value is string => {
source.value = "changed-during-validation";
return value === "captured";
});
source.value = "changed-after-validation";
expect(captured).toEqual(
realtimeSuccess("captured"),
);
expect(Object.isFrozen(captured)).toBe(true);
expect(isRealtimeResult(source, isString)).toBe(false);
});
it("canonicalizes failure fields before the source can change", () => {
const source = {
ok: false,
error: {
kind: "FORBIDDEN",
operation: "RECOVER",
retryable: false,
},
};
const captured = snapshotRealtimeResult(
source,
(_value): _value is never => false,
);
source.error.kind = "PROVIDER_UNAVAILABLE";
source.error.operation = "CONNECT";
source.error.retryable = true;
expect(captured).toEqual(
realtimeFailure("FORBIDDEN", "RECOVER", false),
);
expect(
captured && !captured.ok
? Object.isFrozen(captured.error)
: false,
).toBe(true);
});
it("rejects accessors without invoking them", () => {
let outerReads = 0;
const outerAccessor = Object.defineProperties(
{},
{
ok: {
enumerable: true,
get() {
outerReads += 1;
return true;
},
},
value: {
enumerable: true,
value: "safe",
},
},
);
let nestedReads = 0;
const nestedAccessor = Object.defineProperties(
{},
{
kind: {
enumerable: true,
get() {
nestedReads += 1;
return "FORBIDDEN";
},
},
operation: {
enumerable: true,
value: "RECOVER",
},
retryable: {
enumerable: true,
value: false,
},
},
);
expect(
snapshotRealtimeResult(outerAccessor, isString),
).toBeNull();
expect(
snapshotRealtimeResult(
{ ok: false, error: nestedAccessor },
(_value): _value is never => false,
),
).toBeNull();
expect(outerReads).toBe(0);
expect(nestedReads).toBe(0);
});
it("consumes proxy fields only from one descriptor snapshot", () => {
const propertyReads: PropertyKey[] = [];
const descriptorReads = new Map<PropertyKey, number>();
const source = new Proxy(
{ ok: true, value: "descriptor-value" },
{
get(_target, key) {
propertyReads.push(key);
return key === "value" ? "get-trap-value" : false;
},
getOwnPropertyDescriptor(target, key) {
descriptorReads.set(
key,
(descriptorReads.get(key) ?? 0) + 1,
);
return Reflect.getOwnPropertyDescriptor(target, key);
},
},
);
expect(snapshotRealtimeResult(source, isString)).toEqual(
realtimeSuccess("descriptor-value"),
);
expect(propertyReads).toEqual([]);
expect(descriptorReads).toEqual(
new Map<PropertyKey, number>([
["ok", 1],
["value", 1],
]),
);
});
it("fails closed when a proxy is revoked", () => {
const revocable = Proxy.revocable(
{ ok: true, value: "safe" },
{},
);
revocable.revoke();
expect(
snapshotRealtimeResult(revocable.proxy, isString),
).toBeNull();
expect(isRealtimeResult(revocable.proxy, isString)).toBe(false);
});
it.each([
{ ok: true, value: "safe", extra: true },
Object.assign(
Object.create({ inherited: true }) as Record<string, unknown>,
{ ok: true, value: "safe" },
),
Object.assign(
{ ok: true, value: "safe" },
{ [Symbol("hidden")]: true },
),
])("rejects extra, inherited and symbol-key shapes", (source) => {
expect(snapshotRealtimeResult(source, isString)).toBeNull();
});
});
describe("realtime abort/deadline race", () => {
const never = () => new Promise<never>(() => undefined);
it("settles with the value, a rejection or a synchronous throw", async () => {
await expect(raceRealtimeTask(() => 7)).resolves.toEqual({
kind: "VALUE",
value: 7,
});
await expect(
raceRealtimeTask(() => Promise.reject(new Error("no"))),
).resolves.toEqual({ kind: "REJECTED" });
await expect(
raceRealtimeTask(() => {
throw new Error("sync");
}),
).resolves.toEqual({ kind: "REJECTED" });
});
it("aborts without starting, or mid-flight with cleanup", async () => {
const task = vi.fn(never);
await expect(
raceRealtimeTask(task, AbortSignal.abort()),
).resolves.toEqual({ kind: "ABORTED" });
expect(task).not.toHaveBeenCalled();
const caller = new AbortController();
const remove = vi.spyOn(caller.signal, "removeEventListener");
let lease: AbortSignal | undefined;
const running = raceRealtimeTask((signal) => {
lease = signal;
return never();
}, caller.signal);
caller.abort();
await expect(running).resolves.toEqual({ kind: "ABORTED" });
expect(lease?.aborted).toBe(true);
expect(remove).toHaveBeenCalledWith("abort", expect.any(Function));
});
it("times out on the deadline and reports a broken deadline", async () => {
let deadlineSignal: AbortSignal | undefined;
await expect(
raceRealtimeTask(never, undefined, (signal) => {
deadlineSignal = signal;
return Promise.resolve();
}),
).resolves.toEqual({ kind: "TIMEOUT" });
expect(deadlineSignal?.aborted).toBe(true);
await expect(
raceRealtimeTask(never, undefined, () => Promise.reject(new Error())),
).resolves.toEqual({ kind: "CLOCK_FAILED" });
// A deadline that throws still lets the task start (e.g. a cancel).
const task = vi.fn(never);
await expect(
raceRealtimeTask(task, undefined, () => {
throw new Error("clock");
}),
).resolves.toEqual({ kind: "CLOCK_FAILED" });
expect(task).toHaveBeenCalledOnce();
});
it("clears a host-timer deadline when the task wins", async () => {
vi.useFakeTimers();
try {
await expect(
raceRealtimeTask(() => "done", undefined, timerDeadline(1_000)),
).resolves.toEqual({ kind: "VALUE", value: "done" });
expect(vi.getTimerCount()).toBe(0);
} finally {
vi.useRealTimers();
}
});
});