From f9dcdf7f6dcdf2979693a9f179eda2b9995d57ae Mon Sep 17 00:00:00 2001 From: amankumarsingh77 Date: Tue, 28 Jul 2026 01:19:58 +0530 Subject: refactor: close the remaining unguarded type assertions MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Types the event-queue iterator's TReturn as undefined so the terminal result needs no cast; declares the isError field the pi runtime reads by duck-typing; binds socket to a local const in the daemon transport; replaces the @ts-ignore on the optional sharp import with a non-literal specifier so src/ still typechecks where sharp was not installed. Adds src/util/guards.ts as the single home for narrowing over unknown — isRecord plus scalar/array readers — and converts the two private isObject copies in cdp/types.ts and daemon/protocol.ts along with every inline `as Record` in domains/js.ts and domains/render.ts. Gives Accessibility.getFullAXTree a real result schema, closing the last unvalidated CDP boundary: only nodeId is required, every object carries additionalProperties, and each AX value stays Unknown, so the tree decodes as a whole or fails as a whole rather than being filtered. Guards the five tool-result `details` readers, the daemon attach response, the persisted session state, the browser-namespace flag, and the fs errno narrowing, each feeding an already-present failure path. The daemon-transport socket binding is not a bug fix: send() runs synchronously inside sendWithTimeout's promise executor, so socket cannot be reassigned between the check and the write. It removes the assertion and makes the write immune to a later refactor that adds an await. Two assertions survive by design and are documented in the task report: the never->unknown re-widening in util/tool.ts, which the type-erased tool registry makes unavoidable, and the AsyncFunction constructor lookup in domains/js.ts, which JavaScript exposes no typed binding for. Co-Authored-By: Claude Opus 5 (1M context) --- test/cdp/event-queue-test.ts | 136 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 136 insertions(+) create mode 100644 test/cdp/event-queue-test.ts (limited to 'test/cdp/event-queue-test.ts') diff --git a/test/cdp/event-queue-test.ts b/test/cdp/event-queue-test.ts new file mode 100644 index 0000000..cae8143 --- /dev/null +++ b/test/cdp/event-queue-test.ts @@ -0,0 +1,136 @@ +import { test, describe } from "node:test"; +import assert from "node:assert/strict"; +import { makeEventQueue, rejectAllPending, sendWithTimeout, type Pending } from "../../src/cdp/event-queue"; + +describe("event queue iteration", () => { + test("yields pushed events in order", async () => { + const q = makeEventQueue(); + q.push({ method: "Page.loadEventFired", params: {} }); + q.push({ method: "Page.frameNavigated", params: {} }); + const seen: string[] = []; + for await (const ev of q.iter) { + seen.push(ev.method); + if (seen.length === 2) break; + } + assert.deepEqual(seen, ["Page.loadEventFired", "Page.frameNavigated"]); + }); + + test("ending the queue terminates the iteration after draining the buffer", async () => { + const q = makeEventQueue(); + q.push({ method: "Page.loadEventFired", params: {} }); + q.end(); + const seen: string[] = []; + for await (const ev of q.iter) seen.push(ev.method); + assert.deepEqual(seen, ["Page.loadEventFired"]); + }); + + test("a waiter pending at end() is released", async () => { + const q = makeEventQueue(); + const done = (async () => { + const seen: string[] = []; + for await (const ev of q.iter) seen.push(ev.method); + return seen; + })(); + await Promise.resolve(); + q.end(); + assert.deepEqual(await done, []); + }); + + test("push after end() is dropped", async () => { + const q = makeEventQueue(); + q.end(); + q.push({ method: "Page.loadEventFired", params: {} }); + const seen: string[] = []; + for await (const ev of q.iter) seen.push(ev.method); + assert.deepEqual(seen, []); + }); + + test("a waiter is handed the next pushed event directly", async () => { + const q = makeEventQueue(); + const it = q.iter[Symbol.asyncIterator](); + const pending = it.next(); + await Promise.resolve(); + q.push({ method: "Runtime.consoleAPICalled", params: { a: 1 } }); + const r = await pending; + assert.equal(r.done, false); + assert.deepEqual(r.value, { method: "Runtime.consoleAPICalled", params: { a: 1 } }); + }); + + test("the terminal result reports done with an undefined value", async () => { + const q = makeEventQueue(); + q.end(); + const it = q.iter[Symbol.asyncIterator](); + const r = await it.next(); + assert.equal(r.done, true); + assert.equal(r.value, undefined); + }); + + test("sessionId is preserved on yielded events", async () => { + const q = makeEventQueue(); + q.push({ method: "Page.loadEventFired", params: {}, sessionId: "s1" }); + q.end(); + const seen: Array = []; + for await (const ev of q.iter) seen.push(ev.sessionId); + assert.deepEqual(seen, ["s1"]); + }); +}); + +describe("pending request bookkeeping", () => { + test("rejectAllPending settles every entry with transport_closed and clears the map", () => { + const pending = new Map(); + const settled: string[] = []; + for (const id of [1, 2]) { + pending.set(id, { + resolve: (r) => settled.push(r.success ? "ok" : r.error.kind), + timer: setTimeout(() => {}, 10_000), + method: `M.m${id}`, + }); + } + rejectAllPending(pending, "gone"); + assert.deepEqual(settled, ["transport_closed", "transport_closed"]); + assert.equal(pending.size, 0); + }); + + test("sendWithTimeout resolves transport_closed when send throws synchronously", async () => { + const pending = new Map(); + const r = await sendWithTimeout(pending, 7, "M.m", 10_000, "Test", () => { + throw new Error("socket gone"); + }); + assert.equal(r.success, false); + if (!r.success) { + assert.equal(r.error.kind, "transport_closed"); + assert.equal(r.error.message, "socket gone"); + assert.equal(r.error.method, "M.m"); + } + assert.equal(pending.size, 0); + }); + + test("sendWithTimeout registers a pending entry the caller can resolve", async () => { + const pending = new Map(); + let sent = false; + const p = sendWithTimeout(pending, 9, "M.m", 10_000, "Test", () => { + sent = true; + }); + assert.equal(sent, true); + const entry = pending.get(9); + assert.notEqual(entry, undefined); + if (entry) { + clearTimeout(entry.timer); + entry.resolve({ success: true, data: { hello: "world" } }); + } + const r = await p; + assert.equal(r.success, true); + if (r.success) assert.deepEqual(r.data, { hello: "world" }); + }); + + test("sendWithTimeout resolves a timeout error and drops the pending entry", async () => { + const pending = new Map(); + const r = await sendWithTimeout(pending, 11, "M.slow", 1, "Test", () => {}); + assert.equal(r.success, false); + if (!r.success) { + assert.equal(r.error.kind, "timeout"); + assert.match(r.error.message, /Test timeout after 1ms: M\.slow/); + } + assert.equal(pending.size, 0); + }); +}); -- cgit v1.2.3