clearTimeout(timer);

ws.off?.("open", onOpen);

ws.off?.("error", onError);

ws.off?.("close", onClose);

callback();

};

const onOpen = () => settle(resolve);

const onError = (error) =>

settle(() => reject(error instanceof Error ? error : new Error(String(error))));

const onClose = (code, reason) =>

settle(() => {

const text = toText(reason);

const suffix = text.length > 0 ? `: ${text}` : "";

reject(new Error(`closed before open (${code})${suffix}`));

});

const timer = setTimeout(() => {

settle(() => {

ws.close();

if (typeof ws.terminate === "function") {

ws.terminate();

} else {

ws.close();

}

reject(new Error("gateway websocket open timeout"));

});

}, openTimeoutMs);

ws.once("open", onOpen);

ws.once("error", onError);

ws.once("close", onClose);

});

const request = async (method, params, timeoutMs = 10_000) =>

await new Promise((resolve, reject) => {

closed = false;

readyState = 0;

sent: string[] = [];

terminated = false;

constructor(

readonly url: string,

this.readyState = 3;

this.emit("close", 1000, "closed");

}

terminate(): void {

this.terminated = true;

this.close();

}

}

function jsonResponse(body: unknown, init: ResponseInit = {}): Response {

await expect(client.waitOpen()).rejects.toThrow("gateway websocket open timeout");

expect(FakeWebSocket.instances[0]?.closed).toBe(true);

expect(FakeWebSocket.instances[0]?.terminated).toBe(true);

});

it("rejects websocket closes before opening", async () => {

FakeWebSocket.instances = [];

const client = createGatewayClient({

WebSocket: FakeWebSocket,

openTimeoutMs: 10_000,

url: "ws://127.0.0.1:12345",

});

const opened = client.waitOpen();

FakeWebSocket.instances[0]?.emit("close", 1006, Buffer.from("bye"));

await expect(opened).rejects.toThrow("closed before open (1006): bye");

expect(FakeWebSocket.instances[0]?.closed).toBe(false);

});

it("rejects pending websocket requests when cleanup closes the client", async () => {