@tdengine/websocket 3.2.2 → 3.3.0

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

@@ -0,0 +1,404 @@
+"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 constant_1 = require("../../src/tmq/constant");
+const wsTmq_1 = require("../../src/tmq/wsTmq");
+const utils_1 = require("../helpers/utils");
+const wsProxy_1 = require("../helpers/wsProxy");
+function parseJsonAction(rawData) {
+    if (typeof rawData !== "string") {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(rawData);
+        return typeof parsed.action === "string" ? parsed.action : null;
+    }
+    catch (_err) {
+        return null;
+    }
+}
+describe("tmq failover", () => {
+    jest.setTimeout(120 * 1000);
+    afterEach(async () => {
+        wsConnectorPool_1.WebSocketConnectionPool.instance().destroyed();
+        jest.restoreAllMocks();
+    });
+    test("tmq failover recovers subscribe context and replays inflight poll", async () => {
+        const dbName = "test_1774096925";
+        const tableName = "t0";
+        const topicName = "topic_1774096925";
+        const localDsn = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}@127.0.0.1:6041`;
+        let setupSql = null;
+        let cleanupSql = null;
+        let consumer = null;
+        let restartTriggered = false;
+        let proxyBHadActivity = false;
+        setupSql = await wsSql_1.WsSql.open(new config_1.WSConfig(localDsn));
+        try {
+            await setupSql.exec(`drop topic if exists ${topicName}`);
+            await setupSql.exec(`drop database if exists ${dbName}`);
+            await setupSql.exec(`create database ${dbName}`);
+            await setupSql.exec(`create table ${dbName}.${tableName}(ts timestamp, c1 int)`);
+            await setupSql.exec(`insert into ${dbName}.${tableName} values(now - 1s, 1) (now, 2)`);
+            await setupSql.exec(`create topic ${topicName} as select * from ${dbName}.${tableName}`);
+        }
+        finally {
+            await setupSql.close();
+            setupSql = null;
+        }
+        const proxyA = await wsProxy_1.WsProxy.create({
+            host: "127.0.0.1",
+            port: 0,
+            onEvent: (event, control) => {
+                if (event.type !== "message") {
+                    return;
+                }
+                if (event.direction !== "client_to_upstream") {
+                    return;
+                }
+                const action = parseJsonAction(event.rawData);
+                if (action === "poll" && !restartTriggered) {
+                    restartTriggered = true;
+                    void control.restart({
+                        downtimeMs: 350,
+                        reason: "trigger tmq poll failover",
+                    });
+                }
+            },
+        });
+        const proxyB = await wsProxy_1.WsProxy.create({
+            host: "127.0.0.1",
+            port: 0,
+            onEvent: (event) => {
+                if (event.type === "client_connected") {
+                    proxyBHadActivity = true;
+                    return;
+                }
+                if (event.type === "message" &&
+                    event.direction === "client_to_upstream") {
+                    proxyBHadActivity = true;
+                }
+            },
+        });
+        const tmqConf = new Map([
+            [constant_1.TMQConstants.GROUP_ID, `g_${Date.now()}`],
+            [constant_1.TMQConstants.CLIENT_ID, `c_${Date.now()}`],
+            [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.ENABLE_AUTO_COMMIT, false],
+            [constant_1.TMQConstants.AUTO_COMMIT_INTERVAL_MS, 1000],
+            [constant_1.TMQConstants.WS_URL,
+                `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}` +
+                    `@127.0.0.1:${proxyA.getPort()},127.0.0.1:${proxyB.getPort()}` +
+                    `?retries=6&retry_backoff_ms=20&retry_backoff_max_ms=60`
+            ],
+        ]);
+        const randomSpy = jest.spyOn(Math, "random").mockReturnValue(0);
+        try {
+            consumer = await wsTmq_1.WsConsumer.newConsumer(tmqConf);
+            await consumer.subscribe([topicName]);
+            let rows = 0;
+            for (let i = 0; i < 8 && rows === 0; i++) {
+                const res = await consumer.poll(800);
+                for (const [, value] of res) {
+                    const data = value.getData();
+                    rows += data?.length || 0;
+                }
+            }
+            expect(restartTriggered).toBe(true);
+            expect(proxyBHadActivity).toBe(true);
+            expect(rows).toBeGreaterThan(0);
+        }
+        finally {
+            if (consumer) {
+                try {
+                    await consumer.unsubscribe();
+                }
+                catch (_err) {
+                    // ignore cleanup error
+                }
+                await consumer.close();
+            }
+            await Promise.all([
+                proxyA.stop("test cleanup"),
+                proxyB.stop("test cleanup"),
+            ]);
+            randomSpy.mockRestore();
+            cleanupSql = await wsSql_1.WsSql.open(new config_1.WSConfig(localDsn));
+            try {
+                await cleanupSql.exec(`drop topic if exists ${topicName}`);
+                await cleanupSql.exec(`drop database if exists ${dbName}`);
+            }
+            finally {
+                await cleanupSql.close();
+                cleanupSql = null;
+            }
+        }
+    }, 180 * 1000);
+    test("tmq single-address reconnect resumes poll and consumes all 5000 rows", async () => {
+        const targetRows = 5000;
+        const batchSize = 1000;
+        const baseTs = 1700020000000;
+        const dbName = "test_1774186545";
+        const tableName = "t0";
+        const topicName = "topic_1774186545";
+        const localDsn = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}@127.0.0.1:6041`;
+        let setupSql = null;
+        let cleanupSql = null;
+        let consumer = null;
+        let pollRequestCount = 0;
+        let restartInFlight = false;
+        let restartCount = 0;
+        setupSql = await wsSql_1.WsSql.open(new config_1.WSConfig(localDsn));
+        try {
+            await setupSql.exec(`drop topic if exists ${topicName}`);
+            await setupSql.exec(`drop database if exists ${dbName}`);
+            await setupSql.exec(`create database ${dbName}`);
+            await setupSql.exec(`create table ${dbName}.${tableName}(ts timestamp, c1 int)`);
+            for (let start = 0; start < targetRows; start += batchSize) {
+                const end = Math.min(start + batchSize, targetRows);
+                const values = [];
+                for (let i = start; i < end; i++) {
+                    values.push(`(${baseTs + i}, ${i})`);
+                }
+                await setupSql.exec(`insert into ${dbName}.${tableName} values ${values.join(" ")}`);
+            }
+            await setupSql.exec(`create topic ${topicName} as select * from ${dbName}.${tableName}`);
+        }
+        finally {
+            await setupSql.close();
+            setupSql = null;
+        }
+        const proxy = await wsProxy_1.WsProxy.create({
+            host: "127.0.0.1",
+            port: 0,
+            onEvent: (event, control) => {
+                if (event.type !== "message") {
+                    return;
+                }
+                if (event.direction !== "client_to_upstream") {
+                    return;
+                }
+                const action = parseJsonAction(event.rawData);
+                if (action !== "poll") {
+                    return;
+                }
+                pollRequestCount += 1;
+                if (restartInFlight) {
+                    return;
+                }
+                const shouldRestart = Math.random() < 0.18 ||
+                    (restartCount === 0 && pollRequestCount >= 1);
+                if (!shouldRestart) {
+                    return;
+                }
+                restartInFlight = true;
+                restartCount += 1;
+                const downtimeMs = 20 + Math.floor(Math.random() * 90);
+                void control.restart({
+                    downtimeMs,
+                    reason: `random poll restart #${restartCount}`,
+                }).finally(() => {
+                    restartInFlight = false;
+                });
+            },
+        });
+        const tmqConf = new Map([
+            [constant_1.TMQConstants.GROUP_ID, `g_${Date.now()}`],
+            [constant_1.TMQConstants.CLIENT_ID, `c_${Date.now()}`],
+            [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.ENABLE_AUTO_COMMIT, false],
+            [constant_1.TMQConstants.AUTO_COMMIT_INTERVAL_MS, 1000],
+            [constant_1.TMQConstants.WS_URL,
+                `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}` +
+                    `@127.0.0.1:${proxy.getPort()}` +
+                    `?retries=60&retry_backoff_ms=10&retry_backoff_max_ms=40`
+            ],
+        ]);
+        try {
+            consumer = await wsTmq_1.WsConsumer.newConsumer(tmqConf);
+            await consumer.subscribe([topicName]);
+            let consumedRows = 0;
+            const deadline = Date.now() + 120 * 1000;
+            while (Date.now() < deadline && consumedRows < targetRows) {
+                const res = await consumer.poll(1200);
+                for (const [, value] of res) {
+                    const data = value.getData();
+                    consumedRows += data?.length || 0;
+                }
+            }
+            expect(pollRequestCount).toBeGreaterThan(0);
+            expect(restartCount).toBeGreaterThan(0);
+            expect(consumedRows).toBe(targetRows);
+        }
+        finally {
+            if (consumer) {
+                try {
+                    await consumer.unsubscribe();
+                }
+                catch (_err) {
+                    // ignore cleanup error
+                }
+                await consumer.close();
+            }
+            await proxy.stop("test cleanup");
+            cleanupSql = await wsSql_1.WsSql.open(new config_1.WSConfig(localDsn));
+            try {
+                await cleanupSql.exec(`drop topic if exists ${topicName}`);
+                await cleanupSql.exec(`drop database if exists ${dbName}`);
+            }
+            finally {
+                await cleanupSql.close();
+                cleanupSql = null;
+            }
+        }
+    }, 300 * 1000);
+    test("tmq three-address failover resumes poll and consumes all 5000 rows", async () => {
+        const targetRows = 5000;
+        const batchSize = 1000;
+        const baseTs = 1700021000000;
+        const dbName = "test_1774187557";
+        const tableName = "t0";
+        const topicName = "topic_1774187557";
+        const localDsn = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}@127.0.0.1:6041`;
+        let setupSql = null;
+        let cleanupSql = null;
+        let consumer = null;
+        let totalPollRequestCount = 0;
+        let totalRestartCount = 0;
+        const proxyStates = new Map();
+        setupSql = await wsSql_1.WsSql.open(new config_1.WSConfig(localDsn));
+        try {
+            await setupSql.exec(`drop topic if exists ${topicName}`);
+            await setupSql.exec(`drop database if exists ${dbName}`);
+            await setupSql.exec(`create database ${dbName}`);
+            await setupSql.exec(`create table ${dbName}.${tableName}(ts timestamp, c1 int)`);
+            for (let start = 0; start < targetRows; start += batchSize) {
+                const end = Math.min(start + batchSize, targetRows);
+                const values = [];
+                for (let i = start; i < end; i++) {
+                    values.push(`(${baseTs + i}, ${i})`);
+                }
+                await setupSql.exec(`insert into ${dbName}.${tableName} values ${values.join(" ")}`);
+            }
+            await setupSql.exec(`create topic ${topicName} as select * from ${dbName}.${tableName}`);
+        }
+        finally {
+            await setupSql.close();
+            setupSql = null;
+        }
+        const createPollRestartProxy = async (name) => {
+            proxyStates.set(name, {
+                pollRequests: 0,
+                restarts: 0,
+                restartInFlight: false,
+            });
+            return wsProxy_1.WsProxy.create({
+                host: "127.0.0.1",
+                port: 0,
+                onEvent: (event, control) => {
+                    if (event.type !== "message") {
+                        return;
+                    }
+                    if (event.direction !== "client_to_upstream") {
+                        return;
+                    }
+                    const action = parseJsonAction(event.rawData);
+                    if (action !== "poll") {
+                        return;
+                    }
+                    const state = proxyStates.get(name);
+                    if (!state) {
+                        return;
+                    }
+                    state.pollRequests += 1;
+                    totalPollRequestCount += 1;
+                    if (state.restartInFlight) {
+                        return;
+                    }
+                    const shouldRestart = Math.random() < 0.18 ||
+                        (totalRestartCount === 0 && totalPollRequestCount >= 1);
+                    if (!shouldRestart) {
+                        return;
+                    }
+                    state.restartInFlight = true;
+                    state.restarts += 1;
+                    totalRestartCount += 1;
+                    const downtimeMs = 20 + Math.floor(Math.random() * 90);
+                    void control.restart({
+                        downtimeMs,
+                        reason: `${name} random poll restart #${state.restarts}`,
+                    }).finally(() => {
+                        const latest = proxyStates.get(name);
+                        if (latest) {
+                            latest.restartInFlight = false;
+                        }
+                    });
+                },
+            });
+        };
+        const proxyA = await createPollRestartProxy("proxy_a");
+        const proxyB = await createPollRestartProxy("proxy_b");
+        const proxyC = await createPollRestartProxy("proxy_c");
+        const tmqConf = new Map([
+            [constant_1.TMQConstants.GROUP_ID, `g_${Date.now()}`],
+            [constant_1.TMQConstants.CLIENT_ID, `c_${Date.now()}`],
+            [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.ENABLE_AUTO_COMMIT, false],
+            [constant_1.TMQConstants.AUTO_COMMIT_INTERVAL_MS, 1000],
+            [constant_1.TMQConstants.WS_URL,
+                `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}` +
+                    `@127.0.0.1:${proxyA.getPort()},127.0.0.1:${proxyB.getPort()},127.0.0.1:${proxyC.getPort()}` +
+                    `?retries=60&retry_backoff_ms=10&retry_backoff_max_ms=40`
+            ],
+        ]);
+        try {
+            consumer = await wsTmq_1.WsConsumer.newConsumer(tmqConf);
+            await consumer.subscribe([topicName]);
+            let consumedRows = 0;
+            const deadline = Date.now() + 120 * 1000;
+            while (Date.now() < deadline && consumedRows < targetRows) {
+                const res = await consumer.poll(1200);
+                for (const [, value] of res) {
+                    const data = value.getData();
+                    consumedRows += data?.length || 0;
+                }
+            }
+            expect(totalPollRequestCount).toBeGreaterThan(0);
+            expect(totalRestartCount).toBeGreaterThan(0);
+            expect(consumedRows).toBe(targetRows);
+        }
+        finally {
+            if (consumer) {
+                try {
+                    await consumer.unsubscribe();
+                }
+                catch (_err) {
+                    // ignore cleanup error
+                }
+                await consumer.close();
+            }
+            await Promise.all([
+                proxyA.stop("test cleanup"),
+                proxyB.stop("test cleanup"),
+                proxyC.stop("test cleanup"),
+            ]);
+            cleanupSql = await wsSql_1.WsSql.open(new config_1.WSConfig(localDsn));
+            try {
+                await cleanupSql.exec(`drop topic if exists ${topicName}`);
+                await cleanupSql.exec(`drop database if exists ${dbName}`);
+            }
+            finally {
+                await cleanupSql.close();
+                cleanupSql = null;
+            }
+        }
+    }, 300 * 1000);
+});

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/urlParser.test.d.ts

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

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

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