@tdengine/websocket 3.2.3 → 3.3.0

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

@@ -1,20 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const retryConfig_1 = require("../../src/client/retryConfig");
 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._addresses = [
-        { host: "host1", port: 6041 },
-        { host: "host2", port: 6042 },
-    ];
+    connector._dsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041,host2:6042");
     connector._currentAddressIndex = 0;
-    connector._retryConfig = new retryConfig_1.RetryConfig(1, 1, 8);
+    connector._retryConfig = new wsConnector_1.RetryConfig(1, 1, 8);
     connector._reconnectLock = null;
     connector._isReconnecting = false;
-    connector._inflightRequests = new Map();
-    connector._wsConn = {
+    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(),
@@ -30,6 +63,18 @@ function buildBinaryMessage(action) {
 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();
@@ -51,8 +96,8 @@ describe("WebSocketConnector failover and retry", () => {
         const connector = createBareConnector();
         const attempts = [];
         connector.sleep = jest.fn(async () => { });
-        connector.reconnectToCurrentAddress = jest.fn(async () => {
-            const current = connector._addresses[connector._currentAddressIndex];
+        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") {
@@ -61,35 +106,141 @@ describe("WebSocketConnector failover and retry", () => {
         });
         await connector.attemptReconnect();
         expect(attempts).toEqual([
-            "host1:6041",
             "host1:6041",
             "host2:6042",
         ]);
         expect(connector._currentAddressIndex).toBe(1);
     });
-    test("keeps retriable string request inflight when send throws", async () => {
+    test("attemptReconnect throws after all addresses and retries are exhausted", async () => {
         const connector = createBareConnector();
-        connector._wsConn.send = jest.fn(() => {
-            throw new Error("send failed");
+        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,
             },
-        }), false);
+        }));
+        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._inflightRequests.has(101n)).toBe(true);
+        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._wsConn.send = jest.fn(() => {
+        connector._conn.send = jest.fn(() => {
             throw new Error("send failed");
         });
         await expect(connector.sendMsg(JSON.stringify({
@@ -97,32 +248,250 @@ describe("WebSocketConnector failover and retry", () => {
             args: {
                 req_id: 102,
             },
-        }), false)).rejects.toThrow("send failed");
-        expect(connector._inflightRequests.has(102n)).toBe(false);
+        }))).rejects.toThrow("send failed");
+        expect(hasInflightRequest(connector, 102n)).toBe(false);
     });
-    test("keeps retriable binary request inflight when send throws", async () => {
+    test("rejects retriable string request immediately when send throws with non-network error", async () => {
         const connector = createBareConnector();
-        connector._wsConn.send = jest.fn(() => {
-            throw new Error("send failed");
+        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, false);
+        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._inflightRequests.has(201n)).toBe(true);
+        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._wsConn.send = jest.fn(() => {
+        connector._conn.send = jest.fn(() => {
             throw new Error("send failed");
         });
         const message = buildBinaryMessage(7n);
-        await expect(connector.sendBinaryMsg(202n, "fetch", message, false)).rejects.toThrow("send failed");
-        expect(connector._inflightRequests.has(202n)).toBe(false);
+        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.js

@@ -20,31 +20,33 @@ describe("WebSocketConnectionPool key generation", () => {
         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, "ws");
-        const keyB = pool.getPoolKey(dsnB, "ws");
+        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, "ws");
-        const keyB = pool.getPoolKey(dsnUserB, "ws");
+        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, "ws");
-        const keyB = pool.getPoolKey(dsnB, "ws");
+        const keyA = pool.getPoolKey(dsnA);
+        const keyB = pool.getPoolKey(dsnB);
         expect(keyA).not.toBe(keyB);
     });
-    test("includes websocket path in the pool key scope", () => {
+    test("includes endpoint-derived websocket path in the pool key scope", () => {
         const pool = wsConnectorPool_1.WebSocketConnectionPool.instance();
-        const dsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041/mydb");
-        const sqlKey = pool.getPoolKey(dsn, "ws");
-        const tmqKey = pool.getPoolKey(dsn, "rest/tmq");
+        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/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":""}