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(); 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([ ["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, { 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(() => 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(); } }); });