import type { ResolvedClickClackAccount } from "./types.js";

class FakeSocket extends EventEmitter {

emitErrorOnClose = false;

close = vi.fn(() => {

if (this.emitErrorOnClose) {

this.emit("error", new Error("socket closed while connecting"));

}

this.emit("close");

});

}

await run;

});

it("reconnects after ClickClack websocket errors", async () => {

const firstSocket = new FakeSocket();

firstSocket.emitErrorOnClose = true;

const secondSocket = new FakeSocket();

mocks.client.websocket.mockReturnValueOnce(firstSocket).mockReturnValueOnce(secondSocket);

const abort = new AbortController();

const ctx = createGatewayContext(abort.signal);

const run = startClickClackGatewayAccount(ctx);

await vi.waitFor(() => expect(mocks.client.websocket).toHaveBeenCalledTimes(1));

firstSocket.emit("error", new Error("gateway dropped"));

await vi.waitFor(() => expect(mocks.client.websocket).toHaveBeenCalledTimes(2));

expect(ctx.log?.warn).toHaveBeenCalledWith(

"[default] ClickClack websocket error; reconnecting: gateway dropped",

);

abort.abort();

await run;

});

it("does not log reconnect warnings when abort closes a connecting websocket", async () => {

const socket = new FakeSocket();

socket.emitErrorOnClose = true;

mocks.client.websocket.mockReturnValue(socket);

const abort = new AbortController();

const ctx = createGatewayContext(abort.signal);

const run = startClickClackGatewayAccount(ctx);

await vi.waitFor(() => expect(mocks.client.websocket).toHaveBeenCalledTimes(1));

abort.abort();

await run;

expect(ctx.log?.warn).not.toHaveBeenCalledWith(

"[default] ClickClack websocket error; reconnecting: socket closed while connecting",

);

expect(mocks.client.websocket).toHaveBeenCalledTimes(1);

});

it("clears running status when backlog polling fails", async () => {

mocks.client.events.mockRejectedValue(new Error("clickclack unavailable"));

const abort = new AbortController();

}

const socket = client.websocket(workspaceId, afterCursor);

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

let settled = false;

let removeAbortListener: (() => void) | undefined;

const finishSocketCycle = () => {

if (settled) {

return;

}

settled = true;

removeAbortListener?.();

removeAbortListener = undefined;

resolve();

};

const abort = () => {

socket.close();

resolve();

finishSocketCycle();

};

ctx.abortSignal.addEventListener("abort", abort, { once: true });

removeAbortListener = () => ctx.abortSignal.removeEventListener("abort", abort);

socket.on("message", (data) => {

void (async () => {

const event = parseSocketEvent(data);

});

})().catch(reject);

});

socket.on("close", () => {

ctx.abortSignal.removeEventListener("abort", abort);

resolve();

socket.on("close", finishSocketCycle);

socket.on("error", (error) => {

if (settled || ctx.abortSignal.aborted) {

finishSocketCycle();

return;

}

ctx.log?.warn?.(

`[${account.accountId}] ClickClack websocket error; reconnecting: ${

error instanceof Error ? error.message : String(error)

}`,

);

finishSocketCycle();

socket.close();

});

socket.on("error", reject);

});

if (!ctx.abortSignal.aborted) {

await new Promise((resolve) => {