@tdengine/websocket 3.2.2 → 3.3.0

package/lib/test/client/wsConnector.leastConnections.test.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wsConnector_1 = require("@src/client/wsConnector");
+const addressConnectionTracker_1 = require("@src/common/addressConnectionTracker");
+const dsn_1 = require("@src/common/dsn");
+function resetAddressTracker() {
+    const tracker = addressConnectionTracker_1.AddressConnectionTracker.instance();
+    tracker._counts.clear();
+}
+function installWebSocketMock(autoOpen) {
+    const websocketModule = require("websocket");
+    const openState = websocketModule.w3cwebsocket.OPEN ?? 1;
+    const connectingState = websocketModule.w3cwebsocket.CONNECTING ?? 0;
+    const sockets = [];
+    jest
+        .spyOn(websocketModule, "w3cwebsocket")
+        .mockImplementation(function (...args) {
+        const url = args[0];
+        const socket = {
+            url,
+            readyState: connectingState,
+            send: jest.fn(),
+            close: jest.fn(),
+        };
+        sockets.push(socket);
+        if (autoOpen) {
+            setTimeout(() => {
+                socket.readyState = openState;
+                socket.onopen?.();
+            }, 0);
+        }
+        return socket;
+    });
+    websocketModule.w3cwebsocket.OPEN = openState;
+    return { sockets };
+}
+describe("WebSocketConnector least-connections selection", () => {
+    beforeEach(() => {
+        resetAddressTracker();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+        resetAddressTracker();
+    });
+    test("constructor chooses least-connected address for initial connection", async () => {
+        const tracker = addressConnectionTracker_1.AddressConnectionTracker.instance();
+        tracker.increment("host1:6041");
+        tracker.increment("host1:6041");
+        tracker.increment("host1:6041");
+        jest.spyOn(Math, "random").mockReturnValue(0);
+        const { sockets } = installWebSocketMock(true);
+        const connector = new wsConnector_1.WebSocketConnector((0, dsn_1.parse)("ws://root:taosdata@host1:6041,host2:6042"), "pool-key-test", 3000);
+        await connector.ready();
+        expect(sockets).toHaveLength(1);
+        expect(sockets[0].url).toContain("host2:6042");
+        expect(tracker.getCount("host2:6042")).toBe(1);
+        connector.close();
+    });
+    test("increments address count when socket onopen fires", async () => {
+        const tracker = addressConnectionTracker_1.AddressConnectionTracker.instance();
+        const { sockets } = installWebSocketMock(false);
+        const connector = new wsConnector_1.WebSocketConnector((0, dsn_1.parse)("ws://root:taosdata@host1:6041"), "pool-key-onopen", 3000);
+        expect(tracker.getCount("host1:6041")).toBe(0);
+        expect(sockets).toHaveLength(1);
+        sockets[0].readyState = 1;
+        sockets[0].onopen?.();
+        await connector.ready();
+        expect(tracker.getCount("host1:6041")).toBe(1);
+        connector.close();
+    });
+});

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

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

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

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

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

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wsConnectorPool_1 = require("@src/client/wsConnectorPool");
+const wsConnector_1 = require("@src/client/wsConnector");
+const config_1 = require("@src/common/config");
+const dsn_1 = require("@src/common/dsn");
+const wsSql_1 = require("@src/sql/wsSql");
+const utils_1 = require("@test-helpers/utils");
+const websocket_1 = require("websocket");
+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("does not collide auth scope when credentials contain colon", () => {
+        const pool = wsConnectorPool_1.WebSocketConnectionPool.instance();
+        const dsnA = (0, dsn_1.parse)("ws://host1:6041/mydb");
+        dsnA.username = "a:b";
+        dsnA.password = "c";
+        const dsnB = (0, dsn_1.parse)("ws://host1:6041/mydb");
+        dsnB.username = "a";
+        dsnB.password = "b:c";
+        const keyA = pool.getPoolKey(dsnA);
+        const keyB = pool.getPoolKey(dsnB);
+        expect(keyA).not.toBe(keyB);
+    });
+    test("does not split pool key by reconnect policy", () => {
+        const pool = wsConnectorPool_1.WebSocketConnectionPool.instance();
+        const lowRetryDsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041/mydb?retries=1&retry_backoff_ms=10&retry_backoff_max_ms=20");
+        const highRetryDsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041/mydb?retries=60&retry_backoff_ms=100&retry_backoff_max_ms=500");
+        const lowRetryKey = pool.getPoolKey(lowRetryDsn);
+        const highRetryKey = pool.getPoolKey(highRetryDsn);
+        expect(lowRetryKey).toBe(highRetryKey);
+    });
+    test("updates connector retry policy when reusing pooled connector", async () => {
+        const pool = wsConnectorPool_1.WebSocketConnectionPool.instance();
+        const lowRetryDsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041/mydb?retries=1&retry_backoff_ms=10&retry_backoff_max_ms=20");
+        const highRetryDsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041/mydb?retries=60&retry_backoff_ms=100&retry_backoff_max_ms=500");
+        const poolKey = pool.getPoolKey(lowRetryDsn);
+        let retries = 1;
+        const connector = {
+            readyState: jest.fn(() => websocket_1.w3cwebsocket.OPEN),
+            close: jest.fn(),
+            refreshRetryConfig: jest.fn((dsn) => {
+                retries = wsConnector_1.RetryConfig.fromDsn(dsn).retries;
+            }),
+            getReconnectRetries: jest.fn(() => retries),
+            getPoolKey: jest.fn(() => poolKey),
+        };
+        pool.pool.set(poolKey, [connector]);
+        const reused = await pool.getConnection(highRetryDsn, 3000);
+        expect(reused).toBe(connector);
+        expect(connector.refreshRetryConfig).toHaveBeenCalledWith(highRetryDsn);
+        expect(reused.getReconnectRetries()).toBe(60);
+    });
+    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);
+    });
+});
+describe("Security: pool key must include auth identity", () => {
+    beforeEach(() => {
+        resetPoolSingleton();
+    });
+    afterEach(() => {
+        resetPoolSingleton();
+    });
+    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);
+        const connector1 = conn1._wsClient._wsConnector;
+        expect(connector1).toBeDefined();
+        await conn1.close();
+        const conn2 = await wsSql_1.WsSql.open(new config_1.WSConfig(dsn));
+        expect(conn2.state()).toBeGreaterThan(0);
+        const connector2 = conn2._wsClient._wsConnector;
+        expect(connector2).toBe(connector1);
+        await conn2.close();
+    });
+});

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

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

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

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

package/lib/test/client/wsEventCallback.test.js

@@ -0,0 +1,98 @@
+"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);
+    });
+    test("timeout callback does not reject if response already handled", async () => {
+        const callback = wsEventCallback_1.WsEventCallback.instance();
+        const resolve = jest.fn();
+        const reject = jest.fn();
+        let capturedTimeoutHandler = null;
+        jest.spyOn(global, "setTimeout").mockImplementation(((handler) => {
+            capturedTimeoutHandler = handler;
+            return 1;
+        }));
+        await callback.registerCallback({
+            action: "insert",
+            req_id: 33n,
+            timeout: 2000,
+        }, resolve, reject);
+        await callback.handleEventCallback({
+            action: "insert",
+            req_id: 33n,
+        }, wsEventCallback_1.OnMessageType.MESSAGE_TYPE_STRING, {
+            action: "insert",
+            req_id: 33n,
+            code: 0,
+        });
+        expect(resolve).toHaveBeenCalledTimes(1);
+        expect(reject).not.toHaveBeenCalled();
+        expect(capturedTimeoutHandler).toBeTruthy();
+        await capturedTimeoutHandler();
+        expect(reject).not.toHaveBeenCalled();
+    });
+    test("timeout handler removes callback entry when timer fires", async () => {
+        jest.useFakeTimers();
+        const callback = wsEventCallback_1.WsEventCallback.instance();
+        const resolve = jest.fn();
+        const reject = jest.fn();
+        await callback.registerCallback({
+            action: "insert",
+            req_id: 44n,
+            timeout: 20,
+        }, resolve, reject);
+        expect(wsEventCallback_1.WsEventCallback._msgActionRegister.size).toBe(1);
+        await jest.advanceTimersByTimeAsync(20);
+        expect(wsEventCallback_1.WsEventCallback._msgActionRegister.size).toBe(0);
+        expect(resolve).not.toHaveBeenCalled();
+        expect(reject).toHaveBeenCalledTimes(1);
+    });
+});

package/lib/test/common/addressConnectionTracker.test.d.ts

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

package/lib/test/common/addressConnectionTracker.test.d.ts.map

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

package/lib/test/common/addressConnectionTracker.test.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const addressConnectionTracker_1 = require("@src/common/addressConnectionTracker");
+const dsn_1 = require("@src/common/dsn");
+function resetTracker() {
+    const tracker = addressConnectionTracker_1.AddressConnectionTracker.instance();
+    tracker._counts.clear();
+    return tracker;
+}
+describe("AddressConnectionTracker", () => {
+    beforeEach(() => {
+        resetTracker();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+        resetTracker();
+    });
+    test("increment/decrement updates counts correctly", () => {
+        const tracker = resetTracker();
+        tracker.increment("host1:6041");
+        tracker.increment("host1:6041");
+        tracker.increment("host2:6042");
+        expect(tracker.getCount("host1:6041")).toBe(2);
+        expect(tracker.getCount("host2:6042")).toBe(1);
+        tracker.decrement("host1:6041");
+        expect(tracker.getCount("host1:6041")).toBe(1);
+    });
+    test("decrement never makes count negative", () => {
+        const tracker = resetTracker();
+        tracker.decrement("host1:6041");
+        tracker.increment("host1:6041");
+        tracker.decrement("host1:6041");
+        tracker.decrement("host1:6041");
+        expect(tracker.getCount("host1:6041")).toBe(0);
+    });
+    test("selectLeastConnected returns index with minimum count", () => {
+        const tracker = resetTracker();
+        const addresses = [
+            new dsn_1.Address("host1", 6041),
+            new dsn_1.Address("host2", 6042),
+            new dsn_1.Address("host3", 6043),
+        ];
+        tracker.increment("host1:6041");
+        tracker.increment("host1:6041");
+        tracker.increment("host3:6043");
+        const index = tracker.selectLeastConnected(addresses);
+        expect(index).toBe(1);
+    });
+    test("selectLeastConnected uses random tie-break among least-connected addresses", () => {
+        const tracker = resetTracker();
+        const addresses = [
+            new dsn_1.Address("host1", 6041),
+            new dsn_1.Address("host2", 6042),
+            new dsn_1.Address("host3", 6043),
+        ];
+        tracker.increment("host3:6043");
+        tracker.increment("host3:6043");
+        const rounds = 400;
+        let host1Count = 0;
+        let host2Count = 0;
+        for (let i = 0; i < rounds; i++) {
+            const selected = tracker.selectLeastConnected(addresses);
+            if (selected === 0) {
+                host1Count += 1;
+            }
+            if (selected === 1) {
+                host2Count += 1;
+            }
+            expect(selected).not.toBe(2);
+        }
+        expect(host1Count).toBeGreaterThan(80);
+        expect(host2Count).toBeGreaterThan(80);
+    });
+});

package/lib/test/common/dsn.test.d.ts

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

package/lib/test/common/dsn.test.d.ts.map

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