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>
246 lines
6.8 KiB
TypeScript
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();
|
|
}
|
|
});
|
|
});
|