@tdengine/websocket 3.2.1 → 3.2.3

package/lib/test/bulkPulling/tmq.config.test.d.ts.map

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

package/lib/test/bulkPulling/tmq.config.test.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../src/tmq/config");
+const constant_1 = require("../../src/tmq/constant");
+const utils_1 = require("../utils");
+describe("TmqConfig - td.connect.token", () => {
+    const baseUrl = "ws://localhost:6041";
+    test("token field is null when CONNECT_TOKEN not provided", () => {
+        const configMap = new Map([
+            [constant_1.TMQConstants.WS_URL, baseUrl],
+            [constant_1.TMQConstants.CONNECT_USER, (0, utils_1.testUsername)()],
+            [constant_1.TMQConstants.CONNECT_PASS, (0, utils_1.testPassword)()],
+            [constant_1.TMQConstants.GROUP_ID, "g1"],
+        ]);
+        const cfg = new config_1.TmqConfig(configMap);
+        expect(cfg.token).toBeNull();
+    });
+    test("token field is set when CONNECT_TOKEN is provided", () => {
+        const configMap = new Map([
+            [constant_1.TMQConstants.WS_URL, baseUrl],
+            [constant_1.TMQConstants.CONNECT_TOKEN, "mytoken123"],
+            [constant_1.TMQConstants.GROUP_ID, "g1"],
+        ]);
+        const cfg = new config_1.TmqConfig(configMap);
+        expect(cfg.token).toBe("mytoken123");
+    });
+    test("bearer_token is appended to url search params when token is provided", () => {
+        const configMap = new Map([
+            [constant_1.TMQConstants.WS_URL, baseUrl],
+            [constant_1.TMQConstants.CONNECT_TOKEN, "mytoken123"],
+            [constant_1.TMQConstants.GROUP_ID, "g1"],
+        ]);
+        const cfg = new config_1.TmqConfig(configMap);
+        expect(cfg.url?.searchParams.get("bearer_token")).toBe("mytoken123");
+    });
+    test("bearer_token is appended to sql_url search params when token is provided", () => {
+        const configMap = new Map([
+            [constant_1.TMQConstants.WS_URL, baseUrl],
+            [constant_1.TMQConstants.CONNECT_TOKEN, "mytoken123"],
+            [constant_1.TMQConstants.GROUP_ID, "g1"],
+        ]);
+        const cfg = new config_1.TmqConfig(configMap);
+        expect(cfg.sql_url?.searchParams.get("bearer_token")).toBe("mytoken123");
+    });
+    test("sql_url pathname is /ws when token is provided", () => {
+        const configMap = new Map([
+            [constant_1.TMQConstants.WS_URL, baseUrl],
+            [constant_1.TMQConstants.CONNECT_TOKEN, "mytoken123"],
+            [constant_1.TMQConstants.GROUP_ID, "g1"],
+        ]);
+        const cfg = new config_1.TmqConfig(configMap);
+        expect(cfg.sql_url?.pathname).toBe("/ws");
+    });
+    test("url pathname is /rest/tmq when token is provided", () => {
+        const configMap = new Map([
+            [constant_1.TMQConstants.WS_URL, baseUrl],
+            [constant_1.TMQConstants.CONNECT_TOKEN, "mytoken123"],
+            [constant_1.TMQConstants.GROUP_ID, "g1"],
+        ]);
+        const cfg = new config_1.TmqConfig(configMap);
+        expect(cfg.url?.pathname).toBe("/rest/tmq");
+    });
+    test("bearer_token not set on urls when token is not provided", () => {
+        const configMap = new Map([
+            [constant_1.TMQConstants.WS_URL, baseUrl],
+            [constant_1.TMQConstants.CONNECT_USER, (0, utils_1.testUsername)()],
+            [constant_1.TMQConstants.CONNECT_PASS, (0, utils_1.testPassword)()],
+            [constant_1.TMQConstants.GROUP_ID, "g1"],
+        ]);
+        const cfg = new config_1.TmqConfig(configMap);
+        expect(cfg.url?.searchParams.has("bearer_token")).toBe(false);
+        expect(cfg.sql_url?.searchParams.has("bearer_token")).toBe(false);
+    });
+    test("CONNECT_TOKEN constant value is td.connect.token", () => {
+        expect(constant_1.TMQConstants.CONNECT_TOKEN).toBe("td.connect.token");
+    });
+});

package/lib/test/bulkPulling/tmq.test.js

@@ -11,13 +11,10 @@ const log_1 = require("../../src/common/log");
 const stable = "st";
 const db = "ws_tmq_test";
 const topics = ["topic_ws_bean"];
-// const topic2 = 'topic_ws_bean_2'
-// let createTopic = `create topic if not exists ${topic} as select ts, c1, c2, c3, c4, c5, t1 from ${db}.${stable}`
-// let createTopic2 = `create topic if not exists ${topic2} as select ts, c1, c4, c5, t1 from ${db}.${stable}`
+const tokenTopic = "topic_token_test";
 let createTopic = `create topic if not exists ${topics[0]} as select * from ${db}.${stable}`;
 let dropTopic = `DROP TOPIC IF EXISTS ${topics[0]};`;
-// let dropTopic2 = `DROP TOPIC IF EXISTS ${topic2};`
-let dsn = "ws://root:taosdata@localhost:6041";
+let dsn = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}@localhost:6041`;
 let tmqDsn = "ws://localhost:6041";
 beforeAll(async () => {
     let conf = new config_1.WSConfig(dsn);
@@ -235,25 +232,24 @@ beforeAll(async () => {
     ];
     let ws = await wsSql_1.WsSql.open(conf);
     await ws.exec(dropTopic);
-    // await ws.Exec(dropTopic2);
     await ws.exec(dropDB);
     await ws.exec(createDB);
     await ws.exec(useDB);
     await ws.exec((0, utils_1.createSTable)(stable));
     await ws.exec(createTopic);
-    // await ws.Exec(createTopic2);
     let insert = (0, utils_1.insertStable)(tableValues, stableTags, stable);
     let insertRes = await ws.exec(insert);
     insert = (0, utils_1.insertStable)(tableCNValues, stableTags, stable);
     insertRes = await ws.exec(insert);
+    await ws.exec(`create topic if not exists ${tokenTopic} as select * from ${db}.${stable}`);
     await ws.close();
 });
 describe("TDWebSocket.Tmq()", () => {
     jest.setTimeout(20 * 1000);
     let configMap = new Map([
         [constant_1.TMQConstants.GROUP_ID, "gId"],
-        [constant_1.TMQConstants.CONNECT_USER, "root"],
-        [constant_1.TMQConstants.CONNECT_PASS, "taosdata"],
+        [constant_1.TMQConstants.CONNECT_USER, (0, utils_1.testUsername)()],
+        [constant_1.TMQConstants.CONNECT_PASS, (0, utils_1.testPassword)()],
         [constant_1.TMQConstants.AUTO_OFFSET_RESET, "earliest"],
         [constant_1.TMQConstants.CLIENT_ID, "test_tmq_client"],
         [constant_1.TMQConstants.WS_URL, tmqDsn],
@@ -290,7 +286,7 @@ describe("TDWebSocket.Tmq()", () => {
         }
         catch (e) {
             console.log(e);
-            expect(e.code).toBe(280);
+            expect([280, 65535]).toContain(e.code);
         }
         finally {
             if (consumer) {
@@ -320,7 +316,6 @@ describe("TDWebSocket.Tmq()", () => {
                     console.log("-----===>>", record);
                 }
             }
-            // await Sleep(100)
         }
         await consumer.seekToBeginning(assignment);
         for (let i = 0; i < 5; i++) {
@@ -336,7 +331,6 @@ describe("TDWebSocket.Tmq()", () => {
                 }
                 counts += data.length;
             }
-            // await Sleep(100)
         }
         let topicArray = await consumer.subscription();
         expect(topics.length).toEqual(topicArray.length);
@@ -380,12 +374,139 @@ describe("TDWebSocket.Tmq()", () => {
         await consumer.unsubscribe();
         await consumer.close();
     });
+    (0, utils_1.testEnterprise)("connect with token", async () => {
+        const conf = new config_1.WSConfig(dsn);
+        const wsSql = await wsSql_1.WsSql.open(conf);
+        await wsSql.exec("drop token if exists test_tmq_token");
+        const wsRows = await wsSql.query(`create token test_tmq_token from user ${(0, utils_1.testUsername)()}`);
+        await wsRows.next();
+        const token = wsRows.getData()?.[0];
+        expect(token).toBeTruthy();
+        await wsRows.close();
+        const tmqConf = new Map([
+            [constant_1.TMQConstants.WS_URL, "ws://localhost:6041"],
+            [constant_1.TMQConstants.CONNECT_USER, "invalid_user"],
+            [constant_1.TMQConstants.CONNECT_PASS, "invalid_pass"],
+            [constant_1.TMQConstants.CONNECT_TOKEN, token],
+            [constant_1.TMQConstants.GROUP_ID, "g1101"],
+            [constant_1.TMQConstants.CLIENT_ID, "c1101"],
+            [constant_1.TMQConstants.AUTO_OFFSET_RESET, "earliest"],
+            [constant_1.TMQConstants.ENABLE_AUTO_COMMIT, "false"],
+            [constant_1.TMQConstants.AUTO_COMMIT_INTERVAL_MS, "1000"],
+        ]);
+        const consumer = await wsTmq_1.WsConsumer.newConsumer(tmqConf);
+        await consumer.subscribe([tokenTopic]);
+        let count = 0;
+        for (let i = 0; i < 5; i++) {
+            const res = await consumer.poll(500);
+            for (const [, value] of res) {
+                const data = value.getData();
+                if (data == null || data.length == 0) {
+                    break;
+                }
+                count += data.length;
+            }
+        }
+        expect(count).toEqual(10);
+        await (0, utils_1.Sleep)(3000);
+        await consumer.unsubscribe();
+        await consumer.close();
+        await wsSql.exec("drop token if exists test_tmq_token");
+        await wsSql.close();
+    });
+    (0, utils_1.testEnterprise)("connect with token url", async () => {
+        const conf = new config_1.WSConfig(dsn);
+        const wsSql = await wsSql_1.WsSql.open(conf);
+        await wsSql.exec("drop token if exists test_tmq_token_url");
+        const wsRows = await wsSql.query(`create token test_tmq_token_url from user ${(0, utils_1.testUsername)()}`);
+        await wsRows.next();
+        const token = wsRows.getData()?.[0];
+        expect(token).toBeTruthy();
+        await wsRows.close();
+        const tmqConf = new Map([
+            [constant_1.TMQConstants.WS_URL, `ws://localhost:6041?bearer_token=${token}`],
+            [constant_1.TMQConstants.CONNECT_USER, "invalid_user"],
+            [constant_1.TMQConstants.CONNECT_PASS, "invalid_pass"],
+            [constant_1.TMQConstants.GROUP_ID, "g1103"],
+            [constant_1.TMQConstants.CLIENT_ID, "c1103"],
+            [constant_1.TMQConstants.AUTO_OFFSET_RESET, "earliest"],
+            [constant_1.TMQConstants.ENABLE_AUTO_COMMIT, false],
+            [constant_1.TMQConstants.AUTO_COMMIT_INTERVAL_MS, 1000],
+        ]);
+        const consumer = await wsTmq_1.WsConsumer.newConsumer(tmqConf);
+        await consumer.subscribe([tokenTopic]);
+        let count = 0;
+        for (let i = 0; i < 5; i++) {
+            const res = await consumer.poll(500);
+            for (const [, value] of res) {
+                const data = value.getData();
+                if (data == null || data.length == 0) {
+                    break;
+                }
+                count += data.length;
+            }
+        }
+        expect(count).toEqual(10);
+        await (0, utils_1.Sleep)(3000);
+        await consumer.unsubscribe();
+        await consumer.close();
+        await wsSql.exec("drop token if exists test_tmq_token_url");
+        await wsSql.close();
+    });
+    (0, utils_1.testEnterprise)("connect with invalid token", async () => {
+        const conf = new Map([
+            [constant_1.TMQConstants.GROUP_ID, "g1102"],
+            [constant_1.TMQConstants.CLIENT_ID, "c1102"],
+            [constant_1.TMQConstants.WS_URL, "ws://localhost:6041?bearer_token=invalid_token"],
+        ]);
+        await expect(wsTmq_1.WsConsumer.newConsumer(conf)).rejects.toMatchObject({
+            message: expect.stringMatching(/invalid token/i),
+        });
+        conf.set(constant_1.TMQConstants.WS_URL, "ws://localhost:6041");
+        conf.set(constant_1.TMQConstants.CONNECT_TOKEN, "invalid_token1");
+        await expect(wsTmq_1.WsConsumer.newConsumer(conf)).rejects.toMatchObject({
+            message: expect.stringMatching(/invalid token/i),
+        });
+        conf.set(constant_1.TMQConstants.WS_URL, "ws://localhost:6041?bearer_token=");
+        conf.delete(constant_1.TMQConstants.CONNECT_TOKEN);
+        await expect(wsTmq_1.WsConsumer.newConsumer(conf)).rejects.toMatchObject({
+            message: expect.stringMatching(/invalid url/i),
+        });
+        conf.set(constant_1.TMQConstants.WS_URL, "ws://localhost:6041");
+        conf.set(constant_1.TMQConstants.CONNECT_TOKEN, "");
+        await expect(wsTmq_1.WsConsumer.newConsumer(conf)).rejects.toMatchObject({
+            message: expect.stringMatching(/invalid url/i),
+        });
+    });
+    (0, utils_1.testNon3360)("connector version info", async () => {
+        const consumer = await wsTmq_1.WsConsumer.newConsumer(configMap);
+        await consumer.subscribe(topics);
+        const conf = new config_1.WSConfig("ws://localhost:6041");
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        const wsSql = await wsSql_1.WsSql.open(conf);
+        await (0, utils_1.Sleep)(2000);
+        const wsRows = await wsSql.query("show connections");
+        let count = 0;
+        while (await wsRows.next()) {
+            const data = wsRows.getData();
+            if (Array.isArray(data) && data.some(v => typeof v === "string" && v.includes("nodejs-ws"))) {
+                count++;
+            }
+        }
+        expect(count).toBeGreaterThanOrEqual(2);
+        await wsRows.close();
+        await wsSql.close();
+        await consumer.unsubscribe();
+        await consumer.close();
+    });
 });
 afterAll(async () => {
     const dropDB = `drop database if exists ${db}`;
-    let conf = new config_1.WSConfig(dsn);
-    let ws = await wsSql_1.WsSql.open(conf);
+    const conf = new config_1.WSConfig(dsn);
+    const ws = await wsSql_1.WsSql.open(conf);
     await ws.exec(dropTopic);
+    await ws.exec(`drop topic if exists ${tokenTopic}`);
     await ws.exec(dropDB);
     await ws.close();
     wsConnectorPool_1.WebSocketConnectionPool.instance().destroyed();

package/lib/test/bulkPulling/wsClient.reconnect.integration.test.d.ts

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

package/lib/test/bulkPulling/wsClient.reconnect.integration.test.d.ts.map

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

package/lib/test/bulkPulling/wsClient.reconnect.integration.test.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function createMockWebsocketState() {
+    let behaviors = [];
+    let sendLog = [];
+    let socketCounter = 0;
+    class FakeWebSocket {
+        constructor(url) {
+            this.readyState = FakeWebSocket.CONNECTING;
+            this.url = url;
+            this.id = ++socketCounter;
+            this.behavior = behaviors.shift() || {};
+            setTimeout(() => {
+                if (this.behavior.openFails) {
+                    this.readyState = FakeWebSocket.CLOSED;
+                    this.onerror?.(new Error("open failed"));
+                    this.onclose?.({ code: 1006, reason: "open failed" });
+                    return;
+                }
+                this.readyState = FakeWebSocket.OPEN;
+                this.onopen?.();
+            }, 0);
+        }
+        send(data) {
+            if (typeof data !== "string") {
+                throw new Error("binary is not supported in this fake");
+            }
+            const parsed = JSON.parse(data);
+            const action = parsed.action || "";
+            sendLog.push({ socketId: this.id, action, raw: data });
+            if (this.behavior.disconnectOnActions?.includes(action)) {
+                this.readyState = FakeWebSocket.CLOSED;
+                if (this.behavior.emitErrorBeforeClose) {
+                    this.onerror?.(new Error("simulated disconnection"));
+                }
+                this.onclose?.({
+                    code: 1006,
+                    reason: "simulated disconnection",
+                });
+                throw new Error("simulated disconnection");
+            }
+            setTimeout(() => {
+                const reqId = parsed?.args?.req_id;
+                this.onmessage?.({
+                    data: JSON.stringify({
+                        action,
+                        req_id: reqId,
+                        code: 0,
+                        message: "ok",
+                    }),
+                });
+            }, 0);
+        }
+        close() {
+            this.readyState = FakeWebSocket.CLOSED;
+            this.onclose?.({ code: 1000, reason: "normal close" });
+        }
+    }
+    FakeWebSocket.CONNECTING = 0;
+    FakeWebSocket.OPEN = 1;
+    FakeWebSocket.CLOSING = 2;
+    FakeWebSocket.CLOSED = 3;
+    return {
+        FakeWebSocket,
+        reset() {
+            behaviors = [];
+            sendLog = [];
+            socketCounter = 0;
+        },
+        setBehaviors(nextBehaviors) {
+            behaviors = [...nextBehaviors];
+        },
+        getSendLog() {
+            return [...sendLog];
+        },
+        getSocketCount() {
+            return socketCounter;
+        },
+    };
+}
+var mockWebsocketState;
+jest.mock("websocket", () => ({
+    w3cwebsocket: (() => {
+        mockWebsocketState = createMockWebsocketState();
+        return mockWebsocketState.FakeWebSocket;
+    })(),
+}));
+const dsn_1 = require("../../src/common/dsn");
+const wsClient_1 = require("../../src/client/wsClient");
+const wsConnectorPool_1 = require("../../src/client/wsConnectorPool");
+const constant_1 = require("../../src/common/constant");
+const wsEventCallback_1 = require("../../src/client/wsEventCallback");
+function resetPoolSingleton() {
+    const PoolClass = wsConnectorPool_1.WebSocketConnectionPool;
+    if (PoolClass._instance) {
+        PoolClass._instance.destroyed();
+        PoolClass._instance = undefined;
+    }
+}
+function resetEventCallbacks() {
+    wsEventCallback_1.WsEventCallback._msgActionRegister = new Map();
+}
+describe("WsClient reconnect integration", () => {
+    beforeEach(() => {
+        mockWebsocketState.reset();
+        resetPoolSingleton();
+        resetEventCallbacks();
+        jest.spyOn(Math, "random").mockReturnValue(0);
+    });
+    afterEach(async () => {
+        jest.restoreAllMocks();
+        mockWebsocketState.reset();
+        resetEventCallbacks();
+        resetPoolSingleton();
+    });
+    test("recovers conn/options context before replaying inflight insert", async () => {
+        mockWebsocketState.setBehaviors([
+            { disconnectOnActions: ["insert"] },
+            {},
+        ]);
+        const dsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041,host2:6042/mydb?timezone=UTC&retries=0&retry_backoff_ms=1");
+        const client = new wsClient_1.WsClient(dsn, 1000);
+        await client.connect("mydb");
+        await client.setOptionConnection(constant_1.TSDB_OPTION_CONNECTION.TSDB_OPTION_CONNECTION_TIMEZONE, "UTC");
+        const pending = client.exec(JSON.stringify({
+            action: "insert",
+            args: {
+                req_id: 999001,
+                data: "insert into t values(now, 1)",
+            },
+        }), false);
+        await expect(pending).resolves.toBeDefined();
+        const secondSocketActions = mockWebsocketState
+            .getSendLog()
+            .filter((entry) => entry.socketId === 2)
+            .map((entry) => entry.action);
+        expect(secondSocketActions[0]).toBe("conn");
+        expect(secondSocketActions[1]).toBe("options_connection");
+        expect(secondSocketActions[2]).toBe("insert");
+        expect(mockWebsocketState.getSocketCount()).toBe(2);
+        await client.close();
+    });
+    test("deduplicates reconnect when both onerror and onclose are raised", async () => {
+        mockWebsocketState.setBehaviors([
+            {
+                disconnectOnActions: ["insert"],
+                emitErrorBeforeClose: true,
+            },
+            {},
+        ]);
+        const dsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041,host2:6042/mydb?retries=0&retry_backoff_ms=1");
+        const client = new wsClient_1.WsClient(dsn, 1000);
+        await client.connect("mydb");
+        const pending = client.exec(JSON.stringify({
+            action: "insert",
+            args: {
+                req_id: 999002,
+                data: "insert into t values(now, 2)",
+            },
+        }), false);
+        await expect(pending).resolves.toBeDefined();
+        expect(mockWebsocketState.getSocketCount()).toBe(2);
+        await client.close();
+    });
+    test("rejects retriable inflight request when all reconnect attempts fail", async () => {
+        mockWebsocketState.setBehaviors([
+            { disconnectOnActions: ["insert"] },
+            { openFails: true },
+            { openFails: true },
+        ]);
+        const dsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041,host2:6042/mydb?retries=0&retry_backoff_ms=1");
+        const client = new wsClient_1.WsClient(dsn, 200);
+        await client.connect("mydb");
+        const pending = client.exec(JSON.stringify({
+            action: "insert",
+            args: {
+                req_id: 999003,
+                data: "insert into t values(now, 3)",
+            },
+        }), false);
+        await expect(pending).rejects.toThrow("Failed to reconnect to any available address");
+        await client.close();
+    });
+});

package/lib/test/bulkPulling/wsConfig.dsn.test.d.ts

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

package/lib/test/bulkPulling/wsConfig.dsn.test.d.ts.map

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

package/lib/test/bulkPulling/wsConfig.dsn.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../src/common/config");
+const utils_1 = require("../../src/common/utils");
+describe("WSConfig to Dsn conversion", () => {
+    test("parses multi-address dsn and keeps connector-level params", () => {
+        const conf = new config_1.WSConfig("ws://root:taosdata@host1:6041,host2:6042/mydb?retries=5&retry_backoff_ms=120&timezone=UTC");
+        const dsn = (0, utils_1.getDsn)(conf);
+        expect(dsn.scheme).toBe("ws");
+        expect(dsn.addresses).toEqual([
+            { host: "host1", port: 6041 },
+            { host: "host2", port: 6042 },
+        ]);
+        expect(dsn.database).toBe("mydb");
+        expect(dsn.params.get("retries")).toBe("5");
+        expect(dsn.params.get("retry_backoff_ms")).toBe("120");
+        expect(dsn.params.get("timezone")).toBe("UTC");
+        expect(conf.getDb()).toBe("mydb");
+        expect(conf.getTimezone()).toBe("UTC");
+    });
+    test("applies WSConfig overrides on top of dsn", () => {
+        const conf = new config_1.WSConfig("ws://root:taosdata@host1:6041/mydb");
+        conf.setUser("admin");
+        conf.setPwd("secret");
+        conf.setToken("token-1");
+        conf.setBearerToken("bearer-1");
+        conf.setTimezone("Asia/Shanghai");
+        conf.setDb("override_db");
+        const dsn = (0, utils_1.getDsn)(conf);
+        expect(dsn.username).toBe("admin");
+        expect(dsn.password).toBe("secret");
+        expect(dsn.database).toBe("override_db");
+        expect(dsn.params.get("token")).toBe("token-1");
+        expect(dsn.params.get("bearer_token")).toBe("bearer-1");
+        expect(dsn.params.get("timezone")).toBe("Asia/Shanghai");
+    });
+});

package/lib/test/bulkPulling/wsConnectPool.test.js

@@ -8,7 +8,7 @@ const constant_1 = require("../../src/tmq/constant");
 const wsTmq_1 = require("../../src/tmq/wsTmq");
 const utils_1 = require("../utils");
 const log_1 = require("../../src/common/log");
-let dsn = "ws://root:taosdata@localhost:6041";
+let dsn = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}@localhost:6041`;
 let tags = ["California.SanFrancisco", 3];
 let multi = [
     [1709183268567, 1709183268568, 1709183268569],
@@ -18,8 +18,8 @@ let multi = [
 ];
 let configMap = new Map([
     [constant_1.TMQConstants.GROUP_ID, "gId"],
-    [constant_1.TMQConstants.CONNECT_USER, "root"],
-    [constant_1.TMQConstants.CONNECT_PASS, "taosdata"],
+    [constant_1.TMQConstants.CONNECT_USER, (0, utils_1.testUsername)()],
+    [constant_1.TMQConstants.CONNECT_PASS, (0, utils_1.testPassword)()],
     [constant_1.TMQConstants.AUTO_OFFSET_RESET, "earliest"],
     [constant_1.TMQConstants.CLIENT_ID, "test_tmq_client"],
     [constant_1.TMQConstants.WS_URL, "ws://localhost:6041"],
@@ -33,7 +33,7 @@ let createTopic = `create topic if not exists ${topics[0]} as select * from ${db
 let stmtIds = [];
 (0, log_1.setLevel)("debug");
 async function connect() {
-    let dsn = "ws://root:taosdata@localhost:6041";
+    let dsn = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}@localhost:6041`;
     let wsSql = null;
     let conf = new config_1.WSConfig(dsn);
     conf.setDb(db);
@@ -43,7 +43,7 @@ async function connect() {
     await wsSql.close();
 }
 async function stmtConnect() {
-    let dsn = "ws://root:taosdata@localhost:6041";
+    let dsn = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}@localhost:6041`;
     let wsConf = new config_1.WSConfig(dsn, "100.100.100.100");
     wsConf.setDb(db);
     // let connector = WsStmtConnect.NewConnector(wsConf)
@@ -139,8 +139,8 @@ describe("TDWebSocket.WsSql()", () => {
 });
 afterAll(async () => {
     let conf = new config_1.WSConfig(dsn);
-    conf.setUser("root");
-    conf.setPwd("taosdata");
+    conf.setUser((0, utils_1.testUsername)());
+    conf.setPwd((0, utils_1.testPassword)());
     let wsSql = await wsSql_1.WsSql.open(conf);
     await wsSql.exec(`drop topic if exists ${topics[0]};`);
     await wsSql.exec(`drop database if exists ${db};`);

package/lib/test/bulkPulling/wsConnector.failover.test.d.ts

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

package/lib/test/bulkPulling/wsConnector.failover.test.d.ts.map

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