@tdengine/websocket 3.2.3 → 3.3.0

package/lib/test/stmt/v2/stmt2.type.test.js

@@ -0,0 +1,401 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wsConnectorPool_1 = require("@src/client/wsConnectorPool");
+const config_1 = require("@src/common/config");
+const log_1 = require("@src/common/log");
+const wsSql_1 = require("@src/sql/wsSql");
+const wsStmt2_1 = require("@src/stmt/wsStmt2");
+const utils_1 = require("@test-helpers/utils");
+const stable = "ws_stmt_stb";
+const table = "stmt_001";
+const db = "ws_stmt2";
+const createDB = `create database if not exists ${db} keep 3650`;
+const useDB = `use ${db}`;
+const dropDB = `drop database if exists ${db}`;
+const tableCN = "stmt_cn";
+const stableCN = "ws_stmt_stb_cn";
+const jsonTable = "stmt_json";
+const jsonTableCN = "stmt_json_cn";
+const stableTags = [
+    true,
+    -1,
+    -2,
+    -3,
+    -4,
+    1,
+    2,
+    3,
+    4,
+    parseFloat((3.1415).toFixed(5)),
+    parseFloat((3.14159265).toFixed(15)),
+    "varchar_tag_1",
+    "nchar_tag_1",
+];
+const stableCNTags = [
+    false,
+    -1 * 2,
+    -2 * 2,
+    -3 * 2,
+    -4 * 2,
+    1 * 2,
+    2 * 2,
+    3 * 2,
+    4 * 2,
+    parseFloat((3.1415 * 2).toFixed(5)),
+    parseFloat((3.14159265 * 2).toFixed(15)),
+    "varchar_标签_壹",
+    "nchar_标签_贰",
+];
+const tableValues = [
+    [1656677710000, 1656677720000, 1656677730000, 1656677740000, 1656677750000],
+    [0, -1, -2, -3, -4],
+    [-1, -2, -3, -4, -5],
+    [-3, -4, -5, -6, -7],
+    // [0, 1, 2, 3, 4],
+    [BigInt(-2), BigInt(-3), BigInt(-4), BigInt(-5), BigInt(-6)],
+    [0, 1, 2, 3, 4],
+    [1, 2, 3, 4, 5],
+    [2, 3, 4, 5, 6],
+    // [0, 1, 2, 3, 4],
+    [BigInt(3), BigInt(4), BigInt(5), BigInt(6), BigInt(7)],
+    [
+        parseFloat((3.1415).toFixed(5)),
+        parseFloat((3.1415 * 2).toFixed(5)),
+        parseFloat((3.1415 * 3).toFixed(5)),
+        parseFloat((3.1415 * 4).toFixed(5)),
+        parseFloat((3.1415 * 5).toFixed(5)),
+    ],
+    [
+        parseFloat((3.14159265).toFixed(15)),
+        parseFloat((3.14159265 * 2).toFixed(15)),
+        parseFloat((3.14159265 * 3).toFixed(15)),
+        parseFloat((3.14159265 * 4).toFixed(15)),
+        parseFloat((3.14159265 * 5).toFixed(15)),
+    ],
+    [
+        "varchar_col_1",
+        "varchar_col_2",
+        "varchar_col_3",
+        "varchar_col_4",
+        "varchar_col_5",
+    ],
+    ["nchar_col_1", "nchar_col_2", "", "nchar_col_4", "nchar_col_5"],
+    [true, false, true, false, true],
+    [null, null, null, null, null],
+];
+const tableCNValues = [
+    [
+        BigInt(1656677760000),
+        BigInt(1656677770000),
+        BigInt(1656677780000),
+        BigInt(1656677790000),
+        BigInt(1656677100000),
+    ],
+    [0, -1, -2, -3, -4],
+    [-1, -2, -3, -4, -5],
+    [-2, -3, -4, -5, -6],
+    [BigInt(-3), BigInt(-4), BigInt(-5), BigInt(-6), BigInt(-7)],
+    [0, 1, 2, 3, 4],
+    [1, 2, 3, 4, 5],
+    [2, 3, 4, 5, 6],
+    [BigInt(3), BigInt(4), BigInt(5), BigInt(6), BigInt(7)],
+    [
+        parseFloat((3.1415).toFixed(5)),
+        parseFloat((3.1415 * 2).toFixed(5)),
+        parseFloat((3.1415 * 3).toFixed(5)),
+        parseFloat((3.1415 * 4).toFixed(5)),
+        parseFloat((3.1415 * 5).toFixed(5)),
+    ],
+    [
+        parseFloat((3.14159265).toFixed(15)),
+        parseFloat((3.14159265 * 2).toFixed(15)),
+        parseFloat((3.14159265 * 3).toFixed(15)),
+        parseFloat((3.14159265 * 4).toFixed(15)),
+        parseFloat((3.14159265 * 5).toFixed(15)),
+    ],
+    [
+        "varchar_列_壹",
+        "varchar_列_贰",
+        "varchar_列_叁",
+        "varchar_列_肆",
+        "varchar_列_伍",
+    ],
+    ["nchar_列_甲", "nchar_列_乙", "nchar_列_丙", "nchar_列_丁", "nchar_列_戊"],
+    [true, false, true, false, true],
+    [null, null, null, null, null],
+];
+let geoDataArray = [];
+let varbinary = [];
+const encoder = new TextEncoder();
+for (let i = 0; i < 5; i++) {
+    let data = new Uint8Array([
+        0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59,
+        0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59, 0x40,
+    ]);
+    geoDataArray.push(data.buffer);
+    let vdata = encoder.encode(`varchar_col_${i + 1}`);
+    varbinary.push(vdata.buffer);
+}
+const jsonTags = [
+    '{"key1":"taos","key2":null,"key3":"TDengine","key4":0,"key5":false}',
+];
+const jsonTagsCN = [
+    '{"key1":"taosdata","key2":null,"key3":"TDengine涛思数据","key4":1,"key5":true}',
+];
+const selectStable = `select * from ${stable}`;
+const selectStableCN = `select * from ${stableCN}`;
+const selectTable = `select * from ${table}`;
+const selectTableCN = `select * from ${tableCN}`;
+const selectJsonTable = `select * from ${jsonTable}`;
+const selectJsonTableCN = `select * from ${jsonTableCN}`;
+let dsn = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}@localhost:6041`;
+(0, log_1.setLevel)("debug");
+beforeAll(async () => {
+    let conf = new config_1.WSConfig(dsn);
+    let ws = await wsSql_1.WsSql.open(conf);
+    await ws.exec(dropDB);
+    await ws.exec(createDB);
+    await ws.exec(useDB);
+    await ws.exec((0, utils_1.createBaseSTable)(stable));
+    await ws.exec((0, utils_1.createSTableJSON)(jsonTable));
+    await ws.close();
+});
+describe("TDWebSocket.Stmt()", () => {
+    jest.setTimeout(20 * 1000);
+    test("normal BindParam", async () => {
+        let wsConf = new config_1.WSConfig(dsn);
+        wsConf.setDb(db);
+        let connector = await wsSql_1.WsSql.open(wsConf);
+        let stmt = await connector.stmtInit();
+        expect(stmt).toBeTruthy();
+        expect(stmt).toBeInstanceOf(wsStmt2_1.WsStmt2);
+        expect(connector.state()).toBeGreaterThan(0);
+        await stmt.prepare((0, utils_1.getInsertBind)(tableValues.length + 2, stableTags.length, db, stable));
+        await stmt.setTableName(table);
+        let tagParams = stmt.newStmtParam();
+        tagParams.setBoolean([stableTags[0]]);
+        tagParams.setTinyInt([stableTags[1]]);
+        tagParams.setSmallInt([stableTags[2]]);
+        tagParams.setInt([stableTags[3]]);
+        tagParams.setBigint([BigInt(stableTags[4])]);
+        tagParams.setUTinyInt([stableTags[5]]);
+        tagParams.setUSmallInt([stableTags[6]]);
+        tagParams.setUInt([stableTags[7]]);
+        tagParams.setUBigint([BigInt(stableTags[8])]);
+        tagParams.setFloat([stableTags[9]]);
+        tagParams.setDouble([stableTags[10]]);
+        tagParams.setBinary([stableTags[11]]);
+        tagParams.setNchar([stableTags[12]]);
+        await stmt.setTags(tagParams);
+        let bindParams = stmt.newStmtParam();
+        bindParams.setTimestamp(tableValues[0]);
+        bindParams.setTinyInt(tableValues[1]);
+        bindParams.setSmallInt(tableValues[2]);
+        bindParams.setInt(tableValues[3]);
+        bindParams.setBigint(tableValues[4]);
+        bindParams.setUTinyInt(tableValues[5]);
+        bindParams.setUSmallInt(tableValues[6]);
+        bindParams.setUInt(tableValues[7]);
+        bindParams.setUBigint(tableValues[8]);
+        bindParams.setFloat(tableValues[9]);
+        bindParams.setDouble(tableValues[10]);
+        bindParams.setBinary(tableValues[11]);
+        bindParams.setNchar(tableValues[12]);
+        bindParams.setBoolean(tableValues[13]);
+        bindParams.setInt(tableValues[14]);
+        bindParams.setGeometry(geoDataArray);
+        bindParams.setVarBinary(varbinary);
+        await stmt.bind(bindParams);
+        await stmt.batch();
+        await stmt.exec();
+        expect(stmt.getLastAffected()).toEqual(5);
+        await stmt.close();
+        let result = await connector.exec(`select * from ${db}.${stable}`);
+        console.log(result);
+        await connector.close();
+    });
+    test("normal CN BindParam", async () => {
+        let wsConf = new config_1.WSConfig(dsn);
+        wsConf.setDb(db);
+        let connector = await wsSql_1.WsSql.open(wsConf);
+        let stmt = await (await connector).stmtInit();
+        expect(stmt).toBeTruthy();
+        expect(stmt).toBeInstanceOf(wsStmt2_1.WsStmt2);
+        expect(connector.state()).toBeGreaterThan(0);
+        await stmt.prepare((0, utils_1.getInsertBind)(tableValues.length + 2, stableTags.length, db, stable));
+        await stmt.setTableName(table);
+        let tagParams = stmt.newStmtParam();
+        tagParams.setBoolean([stableCNTags[0]]);
+        tagParams.setTinyInt([stableCNTags[1]]);
+        tagParams.setSmallInt([stableCNTags[2]]);
+        tagParams.setInt([stableCNTags[3]]);
+        tagParams.setBigint([BigInt(stableCNTags[4])]);
+        tagParams.setUTinyInt([stableCNTags[5]]);
+        tagParams.setUSmallInt([stableCNTags[6]]);
+        tagParams.setUInt([stableCNTags[7]]);
+        tagParams.setUBigint([BigInt(stableCNTags[8])]);
+        tagParams.setFloat([stableCNTags[9]]);
+        tagParams.setDouble([stableCNTags[10]]);
+        tagParams.setBinary([stableCNTags[11]]);
+        tagParams.setNchar([stableCNTags[12]]);
+        await stmt.setTags(tagParams);
+        let bindParams = stmt.newStmtParam();
+        bindParams.setTimestamp(tableCNValues[0]);
+        bindParams.setTinyInt(tableCNValues[1]);
+        bindParams.setSmallInt(tableCNValues[2]);
+        bindParams.setInt(tableCNValues[3]);
+        bindParams.setBigint(tableCNValues[4]);
+        bindParams.setUTinyInt(tableCNValues[5]);
+        bindParams.setUSmallInt(tableCNValues[6]);
+        bindParams.setUInt(tableCNValues[7]);
+        bindParams.setUBigint(tableCNValues[8]);
+        bindParams.setFloat(tableCNValues[9]);
+        bindParams.setDouble(tableCNValues[10]);
+        bindParams.setBinary(tableCNValues[11]);
+        bindParams.setNchar(tableCNValues[12]);
+        bindParams.setBoolean(tableCNValues[13]);
+        bindParams.setInt(tableCNValues[14]);
+        bindParams.setGeometry(geoDataArray);
+        bindParams.setVarBinary(varbinary);
+        await stmt.bind(bindParams);
+        await stmt.batch();
+        await stmt.exec();
+        expect(stmt.getLastAffected()).toEqual(5);
+        await stmt.close();
+        let result = await connector.exec(`select count(*) from ${db}.${stable}`);
+        console.log(result);
+        await connector.close();
+    });
+    test("normal json tag BindParam", async () => {
+        let wsConf = new config_1.WSConfig(dsn);
+        wsConf.setDb(db);
+        let connector = await wsSql_1.WsSql.open(wsConf);
+        let stmt = await (await connector).stmtInit();
+        expect(stmt).toBeTruthy();
+        expect(stmt).toBeInstanceOf(wsStmt2_1.WsStmt2);
+        expect(connector.state()).toBeGreaterThan(0);
+        await stmt.prepare((0, utils_1.getInsertBind)(tableValues.length + 2, jsonTags.length, db, jsonTable));
+        await stmt.setTableName(`${jsonTable}_001`);
+        let tagParams = stmt.newStmtParam();
+        tagParams.setJson(jsonTags);
+        await stmt.setTags(tagParams);
+        let bindParams = stmt.newStmtParam();
+        bindParams.setTimestamp(tableCNValues[0]);
+        bindParams.setTinyInt(tableCNValues[1]);
+        bindParams.setSmallInt(tableCNValues[2]);
+        bindParams.setInt(tableCNValues[3]);
+        bindParams.setBigint(tableCNValues[4]);
+        bindParams.setUTinyInt(tableCNValues[5]);
+        bindParams.setUSmallInt(tableCNValues[6]);
+        bindParams.setUInt(tableCNValues[7]);
+        bindParams.setUBigint(tableCNValues[8]);
+        bindParams.setFloat(tableCNValues[9]);
+        bindParams.setDouble(tableCNValues[10]);
+        bindParams.setBinary(tableCNValues[11]);
+        bindParams.setNchar(tableCNValues[12]);
+        bindParams.setBoolean(tableCNValues[13]);
+        bindParams.setInt(tableCNValues[14]);
+        bindParams.setGeometry(geoDataArray);
+        bindParams.setVarBinary(varbinary);
+        await stmt.bind(bindParams);
+        await stmt.batch();
+        await stmt.exec();
+        expect(stmt.getLastAffected()).toEqual(5);
+        await stmt.close();
+        let result = await connector.exec(`select * from ${db}.${jsonTable}`);
+        console.log(result);
+        await connector.close();
+    });
+    test("normal json cn tag BindParam", async () => {
+        let wsConf = new config_1.WSConfig(dsn);
+        wsConf.setDb(db);
+        let connector = await wsSql_1.WsSql.open(wsConf);
+        let stmt = await connector.stmtInit();
+        expect(stmt).toBeTruthy();
+        expect(stmt).toBeInstanceOf(wsStmt2_1.WsStmt2);
+        expect(connector.state()).toBeGreaterThan(0);
+        await stmt.prepare((0, utils_1.getInsertBind)(tableValues.length + 2, jsonTags.length, db, jsonTable));
+        await stmt.setTableName(`${jsonTable}_001`);
+        let tagParams = stmt.newStmtParam();
+        tagParams.setJson(jsonTagsCN);
+        await stmt.setTags(tagParams);
+        let bindParams = stmt.newStmtParam();
+        bindParams.setTimestamp(tableCNValues[0]);
+        bindParams.setTinyInt(tableCNValues[1]);
+        bindParams.setSmallInt(tableCNValues[2]);
+        bindParams.setInt(tableCNValues[3]);
+        bindParams.setBigint(tableCNValues[4]);
+        bindParams.setUTinyInt(tableCNValues[5]);
+        bindParams.setUSmallInt(tableCNValues[6]);
+        bindParams.setUInt(tableCNValues[7]);
+        bindParams.setUBigint(tableCNValues[8]);
+        bindParams.setFloat(tableCNValues[9]);
+        bindParams.setDouble(tableCNValues[10]);
+        bindParams.setBinary(tableCNValues[11]);
+        bindParams.setNchar(tableCNValues[12]);
+        bindParams.setBoolean(tableCNValues[13]);
+        bindParams.setInt(tableCNValues[14]);
+        bindParams.setGeometry(geoDataArray);
+        bindParams.setVarBinary(varbinary);
+        await stmt.bind(bindParams);
+        await stmt.batch();
+        await stmt.exec();
+        expect(stmt.getLastAffected()).toEqual(5);
+        await stmt.close();
+        let result = await connector.exec(`select * from ${db}.${jsonTable}`);
+        console.log(result);
+        await connector.close();
+    });
+});
+test("test bind exception cases", async () => {
+    let wsConf = new config_1.WSConfig(dsn);
+    let connector = await wsSql_1.WsSql.open(wsConf);
+    let stmt = await connector.stmtInit();
+    expect(stmt).toBeInstanceOf(wsStmt2_1.WsStmt2);
+    const params = stmt.newStmtParam();
+    const emptyArrayMethods = [
+        { method: "setBoolean", name: "SetBooleanColumn" },
+        { method: "setTinyInt", name: "SetTinyIntColumn" },
+        { method: "setUTinyInt", name: "SetUTinyIntColumn" },
+        { method: "setSmallInt", name: "SetSmallIntColumn" },
+        { method: "setUSmallInt", name: "SetSmallIntColumn" },
+        { method: "setInt", name: "SetIntColumn" },
+        { method: "setUInt", name: "SetUIntColumn" },
+        { method: "setBigint", name: "SetBigIntColumn" },
+        { method: "setUBigint", name: "SetUBigIntColumn" },
+        { method: "setFloat", name: "SetFloatColumn" },
+        { method: "setDouble", name: "SetDoubleColumn" },
+        { method: "setTimestamp", name: "SeTimestampColumn" },
+    ];
+    emptyArrayMethods.forEach(({ method, name }) => {
+        expect(() => {
+            params[method]([]);
+        }).toThrow(`${name} params is invalid!`);
+        expect(() => {
+            params[method](null);
+        }).toThrow(`${name} params is invalid!`);
+        expect(() => {
+            params[method](undefined);
+        }).toThrow(`${name} params is invalid!`);
+    });
+    expect(() => {
+        params.setBoolean(["not boolean"]);
+        params.encode();
+    }).toThrow("SetTinyIntColumn params is invalid!");
+    expect(() => {
+        params.setTinyInt(["not number"]);
+        params.encode();
+    }).toThrow("SetTinyIntColumn params is invalid!");
+    expect(() => {
+        params.setBigint(["not bigint"]);
+        params.encode();
+    }).toThrow("SetTinyIntColumn params is invalid!");
+    await connector.close();
+});
+afterAll(async () => {
+    let conf = new config_1.WSConfig(dsn);
+    let ws = await wsSql_1.WsSql.open(conf);
+    await ws.exec(dropDB);
+    await ws.close();
+    wsConnectorPool_1.WebSocketConnectionPool.instance().destroyed();
+});

package/lib/test/tmq/cloud/cloud.tmq.test.d.ts

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

package/lib/test/tmq/cloud/cloud.tmq.test.d.ts.map

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

package/lib/test/tmq/cloud/cloud.tmq.test.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constant_1 = require("@src/tmq/constant");
+const wsTmq_1 = require("@src/tmq/wsTmq");
+const wsConnectorPool_1 = require("@src/client/wsConnectorPool");
+const log_1 = require("@src/common/log");
+const config_1 = require("@src/common/config");
+const wsSql_1 = require("@src/sql/wsSql");
+const utils_1 = require("@test-helpers/utils");
+const cloudWsUrl = (0, utils_1.testCloudWsUrl)();
+const testWithCloudEnv = utils_1.testCloudEnv;
+beforeAll(async () => {
+    if (!cloudWsUrl) {
+        return;
+    }
+    let wsSql = null;
+    try {
+        const conf = new config_1.WSConfig(cloudWsUrl);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        wsSql = await wsSql_1.WsSql.open(conf);
+        let sql = `INSERT INTO dmeters.d1001 USING dmeters.meters (groupid, location) TAGS(2, 'SanFrancisco')
+            VALUES (NOW + 1a, 10.30000, 219, 0.31000) (NOW + 2a, 12.60000, 218, 0.33000) (NOW + 3a, 12.30000, 221, 0.31000)
+            dmeters.d1002 USING dmeters.meters (groupid, location) TAGS(3, 'SanFrancisco') 
+            VALUES (NOW + 1a, 10.30000, 218, 0.25000)`;
+        let res = await wsSql.exec(sql);
+        console.log(res);
+        expect(res.getAffectRows()).toBeGreaterThanOrEqual(3);
+    }
+    catch (err) {
+        throw err;
+    }
+    finally {
+        if (wsSql) {
+            await wsSql.close();
+        }
+    }
+});
+describe("TDWebSocket.Tmq()", () => {
+    jest.setTimeout(20 * 1000);
+    testWithCloudEnv("normal connect", async () => {
+        const url = cloudWsUrl;
+        const topic = "topic_meters";
+        const topics = [topic];
+        const groupId = "group1";
+        const clientId = "client1";
+        let configMap = new Map([
+            [constant_1.TMQConstants.GROUP_ID, groupId],
+            [constant_1.TMQConstants.CLIENT_ID, clientId],
+            [constant_1.TMQConstants.AUTO_OFFSET_RESET, "earliest"],
+            [constant_1.TMQConstants.WS_URL, url],
+            [constant_1.TMQConstants.ENABLE_AUTO_COMMIT, "true"],
+            [constant_1.TMQConstants.AUTO_COMMIT_INTERVAL_MS, "1000"],
+        ]);
+        (0, log_1.setLevel)("debug");
+        // create consumer
+        let consumer = await wsTmq_1.WsConsumer.newConsumer(configMap);
+        console.log(`Create consumer successfully, host: ${url}, groupId: ${groupId}, clientId: ${clientId}`);
+        // subscribe
+        await consumer.subscribe(topics);
+        console.log(`Subscribe topics successfully, topics: ${topics}`);
+        let res = new Map();
+        while (res.size == 0) {
+            // poll
+            res = await consumer.poll(1000);
+            for (let [key, value] of res) {
+                // Add your data processing logic here
+                console.log(`data: ${key} ${value}`);
+            }
+            // commit
+            await consumer.commit();
+        }
+        // seek
+        let assignment = await consumer.assignment();
+        await consumer.seekToBeginning(assignment);
+        console.log("Assignment seek to beginning successfully");
+        // clean
+        await consumer.unsubscribe();
+        await consumer.close();
+    });
+});
+afterAll(async () => {
+    wsConnectorPool_1.WebSocketConnectionPool.instance().destroyed();
+});

package/lib/test/tmq/cloud/tmq.cloud.test.d.ts

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

package/lib/test/tmq/cloud/tmq.cloud.test.d.ts.map

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

package/lib/test/tmq/cloud/tmq.cloud.test.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constant_1 = require("@src/tmq/constant");
+const wsTmq_1 = require("@src/tmq/wsTmq");
+const wsConnectorPool_1 = require("@src/client/wsConnectorPool");
+const log_1 = require("@src/common/log");
+const config_1 = require("@src/common/config");
+const wsSql_1 = require("@src/sql/wsSql");
+const utils_1 = require("@test-helpers/utils");
+const url = (0, utils_1.testCloudWsUrl)();
+beforeAll(async () => {
+    if (!url) {
+        return;
+    }
+    let wsSql = null;
+    try {
+        const conf = new config_1.WSConfig(url);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        wsSql = await wsSql_1.WsSql.open(conf);
+        let sql = `INSERT INTO dmeters.d1001 USING dmeters.meters (groupid, location) TAGS(2, 'SanFrancisco')
+            VALUES (NOW + 1a, 10.30000, 219, 0.31000) (NOW + 2a, 12.60000, 218, 0.33000) (NOW + 3a, 12.30000, 221, 0.31000)
+            dmeters.d1002 USING dmeters.meters (groupid, location) TAGS(3, 'SanFrancisco') 
+            VALUES (NOW + 1a, 10.30000, 218, 0.25000)`;
+        let res = await wsSql.exec(sql);
+        console.log(res);
+        expect(res.getAffectRows()).toBeGreaterThanOrEqual(3);
+    }
+    catch (err) {
+        throw err;
+    }
+    finally {
+        if (wsSql) {
+            await wsSql.close();
+        }
+    }
+});
+describe("TDWebSocket.Tmq()", () => {
+    jest.setTimeout(20 * 1000);
+    (0, utils_1.testCloud)("normal connect", async () => {
+        const topic = "topic_meters";
+        const topics = [topic];
+        const groupId = "group1";
+        const clientId = "client1";
+        let configMap = new Map([
+            [constant_1.TMQConstants.GROUP_ID, groupId],
+            [constant_1.TMQConstants.CLIENT_ID, clientId],
+            [constant_1.TMQConstants.AUTO_OFFSET_RESET, "earliest"],
+            [constant_1.TMQConstants.WS_URL, url],
+            [constant_1.TMQConstants.ENABLE_AUTO_COMMIT, "true"],
+            [constant_1.TMQConstants.AUTO_COMMIT_INTERVAL_MS, "1000"],
+        ]);
+        (0, log_1.setLevel)("debug");
+        // create consumer
+        let consumer = await wsTmq_1.WsConsumer.newConsumer(configMap);
+        console.log(`Create consumer successfully, host: ${url}, groupId: ${groupId}, clientId: ${clientId}`);
+        // subscribe
+        await consumer.subscribe(topics);
+        console.log(`Subscribe topics successfully, topics: ${topics}`);
+        let res = new Map();
+        while (res.size == 0) {
+            // poll
+            res = await consumer.poll(1000);
+            for (let [key, value] of res) {
+                // Add your data processing logic here
+                console.log(`data: ${key} ${value}`);
+            }
+            // commit
+            await consumer.commit();
+        }
+        // seek
+        let assignment = await consumer.assignment();
+        await consumer.seekToBeginning(assignment);
+        console.log("Assignment seek to beginning successfully");
+        // clean
+        await consumer.unsubscribe();
+        await consumer.close();
+    });
+});
+afterAll(async () => {
+    wsConnectorPool_1.WebSocketConnectionPool.instance().destroyed();
+});

package/lib/test/tmq/core/tmq.config.test.d.ts

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

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

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

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

@@ -0,0 +1,83 @@
+"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("@test-helpers/utils");
+const dsn_1 = require("@src/common/dsn");
+describe("TmqConfig with dsn", () => {
+    const baseDsn = "ws://localhost:6041";
+    test("token field is null when CONNECT_TOKEN is not provided", () => {
+        const configMap = new Map([
+            [constant_1.TMQConstants.WS_URL, baseDsn],
+            [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, baseDsn],
+            [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("writes token into dsn params for both tmq and sql dsn", () => {
+        const configMap = new Map([
+            [constant_1.TMQConstants.WS_URL, baseDsn],
+            [constant_1.TMQConstants.CONNECT_TOKEN, "mytoken123"],
+            [constant_1.TMQConstants.GROUP_ID, "g1"],
+        ]);
+        const cfg = new config_1.TmqConfig(configMap);
+        expect(cfg.dsn?.params.get("bearer_token")).toBe("mytoken123");
+        expect(cfg.sqlDsn?.params.get("bearer_token")).toBe("mytoken123");
+    });
+    test("parses multi-address dsn and keeps connector-level params", () => {
+        const configMap = new Map([
+            [
+                constant_1.TMQConstants.WS_URL,
+                "ws://u:p@host1:6041,host2:6042/topicdb?retries=5&retry_backoff_ms=120"
+            ],
+            [constant_1.TMQConstants.GROUP_ID, "g1"],
+        ]);
+        const cfg = new config_1.TmqConfig(configMap);
+        expect(cfg.dsn?.addresses).toEqual([
+            { host: "host1", port: 6041 },
+            { host: "host2", port: 6042 },
+        ]);
+        expect(cfg.dsn?.endpoint).toBe(dsn_1.WS_TMQ_ENDPOINT);
+        expect(cfg.sqlDsn?.endpoint).toBe(dsn_1.WS_SQL_ENDPOINT);
+        expect(cfg.dsn?.params.get("retries")).toBe("5");
+        expect(cfg.dsn?.params.get("retry_backoff_ms")).toBe("120");
+    });
+    test("applies CONNECT_USER and CONNECT_PASS overrides on top of dsn", () => {
+        const configMap = new Map([
+            [constant_1.TMQConstants.WS_URL, "ws://raw_user:raw_pass@localhost:6041"],
+            [constant_1.TMQConstants.CONNECT_USER, "override_user"],
+            [constant_1.TMQConstants.CONNECT_PASS, "override_pass"],
+            [constant_1.TMQConstants.GROUP_ID, "g1"],
+        ]);
+        const cfg = new config_1.TmqConfig(configMap);
+        expect(cfg.user).toBe("override_user");
+        expect(cfg.password).toBe("override_pass");
+        expect(cfg.dsn?.username).toBe("override_user");
+        expect(cfg.dsn?.password).toBe("override_pass");
+        expect(cfg.sqlDsn?.username).toBe("override_user");
+        expect(cfg.sqlDsn?.password).toBe("override_pass");
+    });
+    test("loads bearer_token from ws.url when CONNECT_TOKEN is absent", () => {
+        const configMap = new Map([
+            [constant_1.TMQConstants.WS_URL, "ws://localhost:6041?bearer_token=url_token"],
+            [constant_1.TMQConstants.GROUP_ID, "g1"],
+        ]);
+        const cfg = new config_1.TmqConfig(configMap);
+        expect(cfg.token).toBe("url_token");
+        expect(cfg.otherConfigs.get(constant_1.TMQConstants.CONNECT_TOKEN)).toBe("url_token");
+    });
+    test("CONNECT_TOKEN constant value is td.connect.token", () => {
+        expect(constant_1.TMQConstants.CONNECT_TOKEN).toBe("td.connect.token");
+    });
+});

package/lib/test/tmq/core/tmq.test.d.ts

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

package/lib/test/tmq/core/tmq.test.d.ts.map

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