@tdengine/websocket 3.2.2 → 3.3.0

package/lib/test/bulkPulling/wsConnector.failover.test.js

@@ -0,0 +1,497 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wsConnector_1 = require("../../src/client/wsConnector");
+const wsEventCallback_1 = require("../../src/client/wsEventCallback");
+const dsn_1 = require("../../src/common/dsn");
+function createInflightStore() {
+    let nextMsgId = 1n;
+    const reqIdToMsgId = new Map();
+    const msgIdToRequest = new Map();
+    return {
+        insert(req) {
+            const msgId = nextMsgId;
+            nextMsgId += 1n;
+            reqIdToMsgId.set(req.reqId, msgId);
+            msgIdToRequest.set(msgId, req);
+        },
+        remove(reqId) {
+            const msgId = reqIdToMsgId.get(reqId);
+            if (msgId === undefined) {
+                return;
+            }
+            reqIdToMsgId.delete(reqId);
+            msgIdToRequest.delete(msgId);
+        },
+        getRequests() {
+            return Array.from(msgIdToRequest.entries())
+                .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+                .map(([, req]) => req);
+        },
+        clear() {
+            nextMsgId = 1n;
+            reqIdToMsgId.clear();
+            msgIdToRequest.clear();
+        },
+    };
+}
+function createBareConnector() {
+    const connector = Object.create(wsConnector_1.WebSocketConnector.prototype);
+    connector._timeout = 5000;
+    connector._dsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041,host2:6042");
+    connector._currentAddressIndex = 0;
+    connector._retryConfig = new wsConnector_1.RetryConfig(1, 1, 8);
+    connector._reconnectLock = null;
+    connector._isReconnecting = false;
+    connector._allowReconnect = true;
+    connector._connectionReady = Promise.resolve();
+    connector._suppressedSockets = new WeakSet();
+    connector._sessionRecoveryHook = null;
+    connector._inflightStore = createInflightStore();
+    connector._conn = {
+        readyState: 1,
+        send: jest.fn(),
+        close: jest.fn(),
+    };
+    return connector;
+}
+function buildBinaryMessage(action) {
+    const buffer = new ArrayBuffer(26);
+    const view = new DataView(buffer);
+    view.setBigInt64(16, action, true);
+    return buffer;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function hasInflightRequest(connector, reqId) {
+    return connector
+        ._inflightStore
+        .getRequests()
+        .some((req) => req.reqId === reqId);
+}
+function listInflightReqIds(connector) {
+    return connector
+        ._inflightStore
+        .getRequests()
+        .map((req) => req.reqId);
+}
+describe("WebSocketConnector failover and retry", () => {
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    test("deduplicates concurrent reconnect triggers with reconnect lock", async () => {
+        const connector = createBareConnector();
+        const reconnectImpl = jest.fn(async () => {
+            await delay(20);
+        });
+        connector._doReconnect = reconnectImpl;
+        await Promise.all([
+            connector.triggerReconnect(),
+            connector.triggerReconnect(),
+            connector.triggerReconnect(),
+        ]);
+        expect(reconnectImpl).toHaveBeenCalledTimes(1);
+    });
+    test("switches to next address after retries are exhausted", async () => {
+        const connector = createBareConnector();
+        const attempts = [];
+        connector.sleep = jest.fn(async () => { });
+        connector.reconnect = jest.fn(async () => {
+            const current = connector._dsn.addresses[connector._currentAddressIndex];
+            const addr = `${current.host}:${current.port}`;
+            attempts.push(addr);
+            if (addr === "host1:6041") {
+                throw new Error("host1 down");
+            }
+        });
+        await connector.attemptReconnect();
+        expect(attempts).toEqual([
+            "host1:6041",
+            "host2:6042",
+        ]);
+        expect(connector._currentAddressIndex).toBe(1);
+    });
+    test("attemptReconnect throws after all addresses and retries are exhausted", async () => {
+        const connector = createBareConnector();
+        connector.sleep = jest.fn(async () => { });
+        connector.reconnect = jest.fn(async () => {
+            throw new Error("all down");
+        });
+        await expect(connector.attemptReconnect()).rejects.toThrow("Failed to reconnect to any available address");
+        expect(connector.reconnect).toHaveBeenCalledTimes(2);
+        expect(connector._currentAddressIndex).toBe(1);
+    });
+    test("handleDisconnect skips reconnect when reconnect is disabled", async () => {
+        const connector = createBareConnector();
+        connector._allowReconnect = false;
+        connector.triggerReconnect = jest.fn();
+        await connector.handleDisconnect(connector._conn);
+        expect(connector.triggerReconnect).not.toHaveBeenCalled();
+    });
+    test("handleDisconnect skips reconnect on normal close", async () => {
+        const connector = createBareConnector();
+        connector.triggerReconnect = jest.fn();
+        await connector.handleDisconnect(connector._conn, { code: 1000, reason: "normal close" });
+        expect(connector.triggerReconnect).not.toHaveBeenCalled();
+    });
+    test("handleDisconnect swallows reconnect failure", async () => {
+        const connector = createBareConnector();
+        connector.triggerReconnect = jest.fn(async () => {
+            throw new Error("reconnect failed");
+        });
+        await expect(connector.handleDisconnect(connector._conn, { code: 1006, reason: "abnormal close" })).resolves.toBeUndefined();
+        expect(connector.triggerReconnect).toHaveBeenCalledTimes(1);
+    });
+    test("_doReconnect fails all inflight requests when reconnect fails", async () => {
+        const connector = createBareConnector();
+        const rejectSpy = jest.fn();
+        connector.attemptReconnect = jest.fn(async () => {
+            throw new Error("reconnect failed");
+        });
+        connector._inflightStore.insert({
+            reqId: 901n,
+            action: "insert",
+            message: JSON.stringify({
+                action: "insert",
+                args: { req_id: 901 },
+            }),
+            resolve: jest.fn(),
+            reject: rejectSpy,
+        });
+        await expect(connector._doReconnect()).rejects.toThrow("reconnect failed");
+        expect(rejectSpy).toHaveBeenCalledTimes(1);
+        expect(hasInflightRequest(connector, 901n)).toBe(false);
+    });
+    test("close disables reconnect and closes current socket", () => {
+        const connector = createBareConnector();
+        connector.close();
+        expect(connector._allowReconnect).toBe(false);
+        expect(connector._conn.close).toHaveBeenCalledTimes(1);
+        expect(connector._suppressedSockets.has(connector._conn)).toBe(true);
+    });
+    test("triggers reconnect and keeps retriable string request inflight when send throws", async () => {
+        const connector = createBareConnector();
+        connector.triggerReconnect = jest.fn(() => new Promise(() => { }));
+        connector._conn.send = jest.fn(() => {
+            throw new Error("cannot call send() while not connected");
+        });
+        const pending = connector.sendMsg(JSON.stringify({
+            action: "insert",
+            args: {
+                req_id: 101,
+            },
+        }));
+        void pending.catch(() => { });
+        const state = await Promise.race([
+            pending.then(() => "resolved").catch(() => "rejected"),
+            delay(20).then(() => "pending"),
+        ]);
+        expect(state).toBe("pending");
+        expect(connector.triggerReconnect).toHaveBeenCalledTimes(1);
+        expect(hasInflightRequest(connector, 101n)).toBe(true);
+        connector.failAllInflightRequests(new Error("cleanup"));
+    });
+    test("triggers reconnect and keeps retriable poll request inflight when send throws", async () => {
+        const connector = createBareConnector();
+        connector.triggerReconnect = jest.fn(() => new Promise(() => { }));
+        connector._conn.send = jest.fn(() => {
+            throw new Error("cannot call send() while not connected");
+        });
+        const pending = connector.sendMsg(JSON.stringify({
+            action: "poll",
+            args: {
+                req_id: 109,
+                blocking_time: 500,
+                message_id: 0,
+            },
+        }));
+        void pending.catch(() => { });
+        const state = await Promise.race([
+            pending.then(() => "resolved").catch(() => "rejected"),
+            delay(20).then(() => "pending"),
+        ]);
+        expect(state).toBe("pending");
+        expect(connector.triggerReconnect).toHaveBeenCalledTimes(1);
+        expect(hasInflightRequest(connector, 109n)).toBe(true);
+        connector.failAllInflightRequests(new Error("cleanup"));
+    });
+    test("triggers reconnect and keeps retriable subscribe request inflight when send throws", async () => {
+        const connector = createBareConnector();
+        connector.triggerReconnect = jest.fn(() => new Promise(() => { }));
+        connector._conn.send = jest.fn(() => {
+            throw new Error("cannot call send() while not connected");
+        });
+        const pending = connector.sendMsg(JSON.stringify({
+            action: "subscribe",
+            args: {
+                req_id: 110,
+                topics: ["topic_a"],
+            },
+        }));
+        void pending.catch(() => { });
+        const state = await Promise.race([
+            pending.then(() => "resolved").catch(() => "rejected"),
+            delay(20).then(() => "pending"),
+        ]);
+        expect(state).toBe("pending");
+        expect(connector.triggerReconnect).toHaveBeenCalledTimes(1);
+        expect(hasInflightRequest(connector, 110n)).toBe(true);
+        connector.failAllInflightRequests(new Error("cleanup"));
+    });
+    test("rejects non-retriable string request immediately when send throws", async () => {
+        const connector = createBareConnector();
+        connector._conn.send = jest.fn(() => {
+            throw new Error("send failed");
+        });
+        await expect(connector.sendMsg(JSON.stringify({
+            action: "query",
+            args: {
+                req_id: 102,
+            },
+        }))).rejects.toThrow("send failed");
+        expect(hasInflightRequest(connector, 102n)).toBe(false);
+    });
+    test("rejects retriable string request immediately when send throws with non-network error", async () => {
+        const connector = createBareConnector();
+        connector.triggerReconnect = jest.fn(() => new Promise(() => { }));
+        connector._conn.send = jest.fn(() => {
+            throw new Error("serialize failed");
+        });
+        const pending = connector.sendMsg(JSON.stringify({
+            action: "insert",
+            args: {
+                req_id: 111,
+            },
+        }));
+        void pending.catch(() => { });
+        const state = await Promise.race([
+            pending.then(() => "resolved").catch(() => "rejected"),
+            delay(20).then(() => "pending"),
+        ]);
+        expect(state).toBe("rejected");
+        expect(connector.triggerReconnect).not.toHaveBeenCalled();
+        expect(hasInflightRequest(connector, 111n)).toBe(false);
+    });
+    test("rejects retriable subscribe request immediately when send throws with non-network error", async () => {
+        const connector = createBareConnector();
+        connector.triggerReconnect = jest.fn(() => new Promise(() => { }));
+        connector._conn.send = jest.fn(() => {
+            throw new Error("serialize failed");
+        });
+        const pending = connector.sendMsg(JSON.stringify({
+            action: "subscribe",
+            args: {
+                req_id: 113,
+                topics: ["topic_a"],
+            },
+        }));
+        void pending.catch(() => { });
+        const state = await Promise.race([
+            pending.then(() => "resolved").catch(() => "rejected"),
+            delay(20).then(() => "pending"),
+        ]);
+        expect(state).toBe("rejected");
+        expect(connector.triggerReconnect).not.toHaveBeenCalled();
+        expect(hasInflightRequest(connector, 113n)).toBe(false);
+    });
+    test("triggers reconnect and rejects non-retriable string request on network send error", async () => {
+        const connector = createBareConnector();
+        connector.triggerReconnect = jest.fn(() => new Promise(() => { }));
+        connector._conn.send = jest.fn(() => {
+            throw new Error("cannot call send() while not connected");
+        });
+        await expect(connector.sendMsg(JSON.stringify({
+            action: "query",
+            args: {
+                req_id: 112,
+            },
+        }))).rejects.toThrow("cannot call send() while not connected");
+        expect(connector.triggerReconnect).toHaveBeenCalledTimes(1);
+        expect(hasInflightRequest(connector, 112n)).toBe(false);
+    });
+    test("triggers reconnect and keeps retriable binary request inflight when send throws", async () => {
+        const connector = createBareConnector();
+        connector.triggerReconnect = jest.fn(() => new Promise(() => { }));
+        connector._conn.send = jest.fn(() => {
+            throw new Error("cannot call send() while not connected");
+        });
+        const message = buildBinaryMessage(6n);
+        const pending = connector.sendBinaryMsg(201n, "binary_query", message);
+        void pending.catch(() => { });
+        const state = await Promise.race([
+            pending.then(() => "resolved").catch(() => "rejected"),
+            delay(20).then(() => "pending"),
+        ]);
+        expect(state).toBe("pending");
+        expect(connector.triggerReconnect).toHaveBeenCalledTimes(1);
+        expect(hasInflightRequest(connector, 201n)).toBe(true);
+        connector.failAllInflightRequests(new Error("cleanup"));
+    });
+    test("rejects non-retriable binary request immediately when send throws", async () => {
+        const connector = createBareConnector();
+        connector._conn.send = jest.fn(() => {
+            throw new Error("send failed");
+        });
+        const message = buildBinaryMessage(7n);
+        await expect(connector.sendBinaryMsg(202n, "fetch", message)).rejects.toThrow("send failed");
+        expect(hasInflightRequest(connector, 202n)).toBe(false);
+    });
+    test("sendMsgDirect unregisters callback on network send error without reconnect", async () => {
+        const connector = createBareConnector();
+        connector.triggerReconnect = jest.fn(() => new Promise(() => { }));
+        connector._conn.send = jest.fn(() => {
+            throw new Error("cannot call send() while not connected");
+        });
+        const registerSpy = jest
+            .spyOn(wsEventCallback_1.WsEventCallback.instance(), "registerCallback")
+            .mockResolvedValue();
+        const unregisterSpy = jest
+            .spyOn(wsEventCallback_1.WsEventCallback.instance(), "unregisterCallback")
+            .mockResolvedValue();
+        await expect(connector.sendMsgDirect(JSON.stringify({
+            action: "conn",
+            args: {
+                req_id: 3001,
+            },
+        }))).rejects.toThrow("cannot call send() while not connected");
+        expect(registerSpy).toHaveBeenCalledTimes(1);
+        expect(unregisterSpy).toHaveBeenCalledWith(3001n);
+        expect(connector.triggerReconnect).not.toHaveBeenCalled();
+    });
+    test("sendMsgNoResp rejects on network send error and triggers reconnect", async () => {
+        const connector = createBareConnector();
+        connector.triggerReconnect = jest.fn(() => new Promise(() => { }));
+        connector._conn.send = jest.fn(() => {
+            throw new Error("cannot call send() while not connected");
+        });
+        await expect(connector.sendMsgNoResp(JSON.stringify({
+            action: "query",
+            args: {
+                req_id: 3002,
+            },
+        }))).rejects.toThrow("cannot call send() while not connected");
+        expect(connector.triggerReconnect).toHaveBeenCalledTimes(1);
+    });
+    test("keeps inflight store consistent when retriable requests are enqueued concurrently", async () => {
+        const connector = createBareConnector();
+        connector.triggerReconnect = jest.fn(() => new Promise(() => { }));
+        connector._conn.send = jest.fn(() => {
+            throw new Error("cannot call send() while not connected");
+        });
+        const reqIds = [301, 302, 303, 304];
+        await Promise.all(reqIds.map(async (reqId) => {
+            const pending = connector.sendMsg(JSON.stringify({
+                action: "insert",
+                args: {
+                    req_id: reqId,
+                    data: `insert into t values(now, ${reqId})`,
+                },
+            }));
+            void pending.catch(() => { });
+        }));
+        await delay(20);
+        expect(listInflightReqIds(connector)).toEqual([301n, 302n, 303n, 304n]);
+        for (const reqId of reqIds) {
+            expect(hasInflightRequest(connector, BigInt(reqId))).toBe(true);
+        }
+        connector.failAllInflightRequests(new Error("cleanup"));
+    });
+    test("replays inflight requests in the same put order", async () => {
+        const connector = createBareConnector();
+        connector.triggerReconnect = jest.fn(() => new Promise(() => { }));
+        connector._conn.send = jest.fn(() => {
+            throw new Error("cannot call send() while not connected");
+        });
+        const reqIds = [101, 102, 103, 104];
+        for (const reqId of reqIds) {
+            const pending = connector.sendMsg(JSON.stringify({
+                action: "insert",
+                args: {
+                    req_id: reqId,
+                    data: `insert into t values(now, ${reqId})`,
+                },
+            }));
+            void pending.catch(() => { });
+        }
+        await delay(20);
+        const replaySend = jest.fn();
+        connector._conn.send = replaySend;
+        await connector.replayRequests();
+        const replayedReqIds = replaySend.mock.calls.map(([payload]) => {
+            const parsed = JSON.parse(payload);
+            return parsed.args.req_id;
+        });
+        expect(replayedReqIds).toEqual([101, 102, 103, 104]);
+        connector.failAllInflightRequests(new Error("cleanup"));
+    });
+    test("replayRequests stops current round and keeps inflight when network send error happens", async () => {
+        const connector = createBareConnector();
+        const reject1 = jest.fn();
+        const reject2 = jest.fn();
+        connector._inflightStore.insert({
+            reqId: 501n,
+            action: "insert",
+            registerCallback: false,
+            message: JSON.stringify({
+                action: "insert",
+                args: {
+                    req_id: 501,
+                },
+            }),
+            resolve: jest.fn(),
+            reject: reject1,
+        });
+        connector._inflightStore.insert({
+            reqId: 502n,
+            action: "insert",
+            registerCallback: false,
+            message: JSON.stringify({
+                action: "insert",
+                args: {
+                    req_id: 502,
+                },
+            }),
+            resolve: jest.fn(),
+            reject: reject2,
+        });
+        connector._conn.readyState = 3;
+        connector._conn.send = jest.fn(() => {
+            throw new Error("cannot call send() while not connected");
+        });
+        await expect(connector.replayRequests()).rejects.toThrow("cannot call send() while not connected");
+        expect(hasInflightRequest(connector, 501n)).toBe(true);
+        expect(hasInflightRequest(connector, 502n)).toBe(true);
+        expect(reject1).not.toHaveBeenCalled();
+        expect(reject2).not.toHaveBeenCalled();
+    });
+});
+describe("RetryConfig", () => {
+    test("uses defaults when retry params are not provided", () => {
+        const dsn = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041");
+        const config = wsConnector_1.RetryConfig.fromDsn(dsn);
+        expect(config.retries).toBe(5);
+        expect(config.retryBackoffMs).toBe(200);
+        expect(config.retryBackoffMaxMs).toBe(2000);
+    });
+    test("reads retry params from dsn", () => {
+        const dsn = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041?retries=7&retry_backoff_ms=150&retry_backoff_max_ms=3200");
+        const config = wsConnector_1.RetryConfig.fromDsn(dsn);
+        expect(config.retries).toBe(7);
+        expect(config.retryBackoffMs).toBe(150);
+        expect(config.retryBackoffMaxMs).toBe(3200);
+    });
+    test("normalizes invalid params to safe defaults", () => {
+        const dsn = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041?retries=-1&retry_backoff_ms=abc&retry_backoff_max_ms=0");
+        const config = wsConnector_1.RetryConfig.fromDsn(dsn);
+        expect(config.retries).toBe(5);
+        expect(config.retryBackoffMs).toBe(200);
+        expect(config.retryBackoffMaxMs).toBe(2000);
+    });
+    test("computes exponential backoff and caps at max", () => {
+        const config = new wsConnector_1.RetryConfig(3, 100, 350);
+        expect(config.getBackoffDelay(0)).toBe(100);
+        expect(config.getBackoffDelay(1)).toBe(200);
+        expect(config.getBackoffDelay(2)).toBe(350);
+        expect(config.getBackoffDelay(10)).toBe(350);
+    });
+});

package/lib/test/bulkPulling/wsConnectorPool.key.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wsConnectorPool.key.test.d.ts.map

package/lib/test/bulkPulling/wsConnectorPool.key.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsConnectorPool.key.test.d.ts","sourceRoot":"","sources":["../../../test/bulkPulling/wsConnectorPool.key.test.ts"],"names":[],"mappings":""}

package/lib/test/bulkPulling/wsConnectorPool.key.test.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wsConnectorPool_1 = require("../../src/client/wsConnectorPool");
+const dsn_1 = require("../../src/common/dsn");
+function resetPoolSingleton() {
+    const PoolClass = wsConnectorPool_1.WebSocketConnectionPool;
+    if (PoolClass._instance) {
+        PoolClass._instance.destroyed();
+        PoolClass._instance = undefined;
+    }
+}
+describe("WebSocketConnectionPool key generation", () => {
+    beforeEach(() => {
+        resetPoolSingleton();
+    });
+    afterEach(() => {
+        resetPoolSingleton();
+    });
+    test("normalizes address order when generating pool key", () => {
+        const pool = wsConnectorPool_1.WebSocketConnectionPool.instance();
+        const dsnA = (0, dsn_1.parse)("ws://root:taosdata@host2:6042,host1:6041/mydb?timezone=UTC&token=abc");
+        const dsnB = (0, dsn_1.parse)("ws://root:taosdata@host1:6041,host2:6042/mydb?token=abc&timezone=UTC");
+        const keyA = pool.getPoolKey(dsnA);
+        const keyB = pool.getPoolKey(dsnB);
+        expect(keyA).toBe(keyB);
+    });
+    test("isolates connections for different auth identities", () => {
+        const pool = wsConnectorPool_1.WebSocketConnectionPool.instance();
+        const dsnUserA = (0, dsn_1.parse)("ws://root:taosdata@host1:6041/mydb");
+        const dsnUserB = (0, dsn_1.parse)("ws://admin:taosdata@host1:6041/mydb");
+        const keyA = pool.getPoolKey(dsnUserA);
+        const keyB = pool.getPoolKey(dsnUserB);
+        expect(keyA).not.toBe(keyB);
+    });
+    test("isolates connections for different token values", () => {
+        const pool = wsConnectorPool_1.WebSocketConnectionPool.instance();
+        const dsnA = (0, dsn_1.parse)("ws://host1:6041/mydb?token=token-a");
+        const dsnB = (0, dsn_1.parse)("ws://host1:6041/mydb?token=token-b");
+        const keyA = pool.getPoolKey(dsnA);
+        const keyB = pool.getPoolKey(dsnB);
+        expect(keyA).not.toBe(keyB);
+    });
+    test("includes endpoint-derived websocket path in the pool key scope", () => {
+        const pool = wsConnectorPool_1.WebSocketConnectionPool.instance();
+        const sqlDsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041/mydb");
+        const tmqDsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041/mydb");
+        tmqDsn.endpoint = dsn_1.WS_TMQ_ENDPOINT;
+        const sqlKey = pool.getPoolKey(sqlDsn);
+        const tmqKey = pool.getPoolKey(tmqDsn);
+        expect(sqlKey).not.toBe(tmqKey);
+    });
+});

package/lib/test/bulkPulling/wsConnectorPool.keyAuth.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wsConnectorPool.keyAuth.test.d.ts.map

package/lib/test/bulkPulling/wsConnectorPool.keyAuth.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsConnectorPool.keyAuth.test.d.ts","sourceRoot":"","sources":["../../../test/bulkPulling/wsConnectorPool.keyAuth.test.ts"],"names":[],"mappings":""}

package/lib/test/bulkPulling/wsConnectorPool.keyAuth.test.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wsConnectorPool_1 = require("../../src/client/wsConnectorPool");
+const config_1 = require("../../src/common/config");
+const wsSql_1 = require("../../src/sql/wsSql");
+const utils_1 = require("../helpers/utils");
+afterAll(() => {
+    wsConnectorPool_1.WebSocketConnectionPool.instance().destroyed();
+});
+describe("Security: pool key must include auth identity", () => {
+    test("username/password: different credentials must not share a pool entry", async () => {
+        const validDsn = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}@localhost:6041`;
+        const wrongPasswordDsn = `ws://${(0, utils_1.testUsername)()}:WRONG_PASSWORD_SENTINEL@localhost:6041`;
+        const validConn = await wsSql_1.WsSql.open(new config_1.WSConfig(validDsn));
+        expect(validConn.state()).toBeGreaterThan(0);
+        await validConn.close();
+        await expect(wsSql_1.WsSql.open(new config_1.WSConfig(wrongPasswordDsn))).rejects.toThrow();
+    });
+    test("same credentials should share a pool entry (sanity check)", async () => {
+        const dsn = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}@localhost:6041`;
+        const conn1 = await wsSql_1.WsSql.open(new config_1.WSConfig(dsn));
+        expect(conn1.state()).toBeGreaterThan(0);
+        await conn1.close();
+        const conn2 = await wsSql_1.WsSql.open(new config_1.WSConfig(dsn));
+        expect(conn2.state()).toBeGreaterThan(0);
+        await conn2.close();
+    });
+});

package/lib/test/bulkPulling/wsEventCallback.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wsEventCallback.test.d.ts.map

package/lib/test/bulkPulling/wsEventCallback.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsEventCallback.test.d.ts","sourceRoot":"","sources":["../../../test/bulkPulling/wsEventCallback.test.ts"],"names":[],"mappings":""}

package/lib/test/bulkPulling/wsEventCallback.test.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wsEventCallback_1 = require("../../src/client/wsEventCallback");
+function resetCallbackRegistry() {
+    const CallbackClass = wsEventCallback_1.WsEventCallback;
+    CallbackClass._msgActionRegister = new Map();
+}
+describe("WsEventCallback lifecycle", () => {
+    beforeEach(() => {
+        resetCallbackRegistry();
+    });
+    afterEach(() => {
+        resetCallbackRegistry();
+        jest.restoreAllMocks();
+    });
+    test("clears timeout when callback is matched", async () => {
+        const callback = wsEventCallback_1.WsEventCallback.instance();
+        const resolve = jest.fn();
+        const reject = jest.fn();
+        const clearSpy = jest.spyOn(global, "clearTimeout");
+        await callback.registerCallback({
+            action: "insert",
+            req_id: 11n,
+            timeout: 2000,
+        }, resolve, reject);
+        await callback.handleEventCallback({
+            action: "insert",
+            req_id: 11n,
+        }, wsEventCallback_1.OnMessageType.MESSAGE_TYPE_STRING, {
+            action: "insert",
+            req_id: 11n,
+            code: 0,
+        });
+        expect(resolve).toHaveBeenCalledTimes(1);
+        expect(reject).not.toHaveBeenCalled();
+        expect(clearSpy).toHaveBeenCalled();
+        expect(wsEventCallback_1.WsEventCallback._msgActionRegister.size).toBe(0);
+    });
+    test("unregisterCallback removes entry and clears its timeout", async () => {
+        const callback = wsEventCallback_1.WsEventCallback.instance();
+        const resolve = jest.fn();
+        const reject = jest.fn();
+        const clearSpy = jest.spyOn(global, "clearTimeout");
+        await callback.registerCallback({
+            action: "options_connection",
+            req_id: 22n,
+            timeout: 2000,
+            id: 22n,
+        }, resolve, reject);
+        await callback.unregisterCallback(22n);
+        expect(clearSpy).toHaveBeenCalled();
+        expect(wsEventCallback_1.WsEventCallback._msgActionRegister.size).toBe(0);
+    });
+});

package/lib/test/bulkPulling/wsProxy.failover.integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wsProxy.failover.integration.test.d.ts.map

package/lib/test/bulkPulling/wsProxy.failover.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsProxy.failover.integration.test.d.ts","sourceRoot":"","sources":["../../../test/bulkPulling/wsProxy.failover.integration.test.ts"],"names":[],"mappings":""}