@tdengine/websocket 3.2.2 → 3.3.0

package/lib/test/sql/core/sql.test.js

@@ -0,0 +1,324 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wsConnectorPool_1 = require("@src/client/wsConnectorPool");
+const config_1 = require("@src/common/config");
+const wsSql_1 = require("@src/sql/wsSql");
+const utils_1 = require("@test-helpers/utils");
+const log_1 = require("@src/common/log");
+let dsn = "ws://localhost:6041";
+let password1 = "Ab1!@#$%,.:?<>;~";
+let password2 = "Bc%^&*()-_+=[]{}";
+(0, log_1.setLevel)("debug");
+beforeAll(async () => {
+    let conf = new config_1.WSConfig(dsn);
+    conf.setUser((0, utils_1.testUsername)());
+    conf.setPwd((0, utils_1.testPassword)());
+    let wsSql = await wsSql_1.WsSql.open(conf);
+    await wsSql.exec("drop database if exists sql_test");
+    await wsSql.exec("drop database if exists sql_create");
+    await wsSql.exec(`create user user1 pass '${password1}'`);
+    await wsSql.exec(`create user user2 pass '${password2}'`);
+    await wsSql.exec("create user token_user pass 'token_pass_1'");
+    await wsSql.exec("create database if not exists sql_test KEEP 3650 DURATION 10 BUFFER 16 WAL_LEVEL 1;");
+    await (0, utils_1.Sleep)(100);
+    await wsSql.exec("use sql_test");
+    await wsSql.exec("CREATE STABLE if not exists meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int);");
+    await wsSql.close();
+});
+describe("TDWebSocket.WsSql()", () => {
+    jest.setTimeout(20 * 1000);
+    test("normal connect", async () => {
+        let wsSql = null;
+        let conf = new config_1.WSConfig("");
+        conf.setUrl(dsn);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        conf.setDb("sql_test");
+        conf.setTimezone("America/New_York");
+        conf.setTimeOut(6000);
+        wsSql = await wsSql_1.WsSql.open(conf);
+        expect(wsSql.state()).toBeGreaterThan(0);
+        let wsRows = await wsSql.query("select timezone()");
+        while (await wsRows.next()) {
+            let result = wsRows.getData();
+            console.log(result);
+            expect(result).toBeTruthy();
+            expect(JSON.stringify(result)).toContain("America/New_York");
+        }
+        await wsSql.close();
+    });
+    test("special characters connect1", async () => {
+        let wsSql = null;
+        let conf = new config_1.WSConfig(dsn);
+        conf.setUser("user1");
+        conf.setPwd(password1);
+        wsSql = await wsSql_1.WsSql.open(conf);
+        expect(wsSql.state()).toBeGreaterThan(0);
+        let version = await wsSql.version();
+        expect(version).not.toBeNull();
+        expect(version).not.toBeUndefined();
+        await wsSql.close();
+    });
+    test("special characters connect2", async () => {
+        let wsSql = null;
+        let conf = new config_1.WSConfig(dsn);
+        conf.setUser("user2");
+        conf.setPwd(password2);
+        wsSql = await wsSql_1.WsSql.open(conf);
+        expect(wsSql.state()).toBeGreaterThan(0);
+        let version = await wsSql.version();
+        expect(version).not.toBeNull();
+        expect(version).not.toBeUndefined();
+        await wsSql.close();
+    });
+    test("connect db with error", async () => {
+        expect.assertions(1);
+        let wsSql = null;
+        try {
+            let conf = new config_1.WSConfig(dsn);
+            conf.setUser((0, utils_1.testUsername)());
+            conf.setPwd((0, utils_1.testPassword)());
+            conf.setDb("jest");
+            wsSql = await wsSql_1.WsSql.open(conf);
+        }
+        catch (e) {
+            let err = e;
+            expect(err.message).toMatch("Database not exist");
+        }
+        finally {
+            if (wsSql) {
+                await wsSql.close();
+            }
+        }
+    });
+    test("connect url", async () => {
+        let url = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}@localhost:6041/information_schema?timezone=Asia/Shanghai`;
+        let conf = new config_1.WSConfig(url);
+        let wsSql = await wsSql_1.WsSql.open(conf);
+        let version = await wsSql.version();
+        console.log(version);
+        expect(version).toBeTruthy();
+        let wsRows = await wsSql.query("select timezone()");
+        while (await wsRows.next()) {
+            let result = wsRows.getData();
+            console.log(result);
+            expect(result).toBeTruthy();
+            expect(JSON.stringify(result)).toContain("Asia/Shanghai");
+        }
+        await wsSql.close();
+    });
+    test("get taosc version", async () => {
+        let conf = new config_1.WSConfig(dsn);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        let wsSql = await wsSql_1.WsSql.open(conf);
+        let version = await wsSql.version();
+        await wsSql.close();
+        console.log(version);
+        expect(version).toBeTruthy();
+    });
+    test("show databases", async () => {
+        let conf = new config_1.WSConfig(dsn);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        let wsSql = await wsSql_1.WsSql.open(conf);
+        let taosResult = await wsSql.exec("show databases");
+        await wsSql.close();
+        console.log(taosResult);
+        expect(taosResult).toBeTruthy();
+    });
+    test("create databases", async () => {
+        let conf = new config_1.WSConfig(dsn);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        let wsSql = await wsSql_1.WsSql.open(conf);
+        let taosResult = await wsSql.exec("create database if not exists sql_create KEEP 3650 DURATION 10 BUFFER 16 WAL_LEVEL 1;");
+        await wsSql.close();
+        console.log(taosResult);
+        expect(taosResult).toBeTruthy();
+    });
+    test("create stable", async () => {
+        let conf = new config_1.WSConfig(dsn);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        let wsSql = await wsSql_1.WsSql.open(conf);
+        let taosResult = await wsSql.exec("use sql_test");
+        console.log(taosResult);
+        expect(taosResult).toBeTruthy();
+        taosResult = await wsSql.exec("CREATE STABLE if not exists meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int);");
+        await wsSql.close();
+        console.log(taosResult);
+        expect(taosResult).toBeTruthy();
+    });
+    test("insert recoder", async () => {
+        let conf = new config_1.WSConfig(dsn);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        let wsSql = await wsSql_1.WsSql.open(conf);
+        let taosResult = await wsSql.exec("use sql_test");
+        console.log(taosResult);
+        expect(taosResult).toBeTruthy();
+        taosResult = await wsSql.exec("describe meters");
+        console.log(taosResult);
+        taosResult = await wsSql.exec('INSERT INTO d1001 USING meters (location, groupid) TAGS ("California", 3) VALUES (NOW, 10.2, 219, 0.32)');
+        console.log(taosResult);
+        expect(taosResult.getAffectRows()).toBeGreaterThanOrEqual(1);
+        await wsSql.close();
+    });
+    test("query sql", async () => {
+        let conf = new config_1.WSConfig(dsn);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        let wsSql = await wsSql_1.WsSql.open(conf);
+        let taosResult = await wsSql.exec("use sql_test");
+        console.log(taosResult);
+        expect(taosResult).toBeTruthy();
+        for (let i = 0; i < 10; i++) {
+            let wsRows = await wsSql.query("select * from meters limit 3");
+            expect(wsRows).toBeTruthy();
+            let meta = wsRows.getMeta();
+            expect(meta).toBeTruthy();
+            console.log("wsRow:meta:=>", meta);
+            while (await wsRows.next()) {
+                let result = await wsRows.getData();
+                expect(result).toBeTruthy();
+            }
+            await wsRows.close();
+        }
+        await wsSql.close();
+    });
+    test("query sql no getdata", async () => {
+        let conf = new config_1.WSConfig(dsn);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        let wsSql = await wsSql_1.WsSql.open(conf);
+        let taosResult = await wsSql.exec("use sql_test");
+        console.log(taosResult);
+        expect(taosResult).toBeTruthy();
+        let wsRows = await wsSql.query("select * from meters");
+        await wsRows.close();
+        await wsSql.close();
+    });
+    test("timestamp order check", async () => {
+        const conf = new config_1.WSConfig(dsn);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        const wsSql = await wsSql_1.WsSql.open(conf);
+        await wsSql.exec("use sql_test");
+        await wsSql.exec("drop table if exists t_order");
+        await wsSql.exec("create table t_order (ts timestamp, c1 int)");
+        await wsSql.exec("insert into t_order values (1726803356466, 1)");
+        await wsSql.exec("insert into t_order values (1726803357466, 2)");
+        await wsSql.exec("insert into t_order values (1726803358466, 3)");
+        const expectRowsAsc = [
+            [1726803356466n, 1],
+            [1726803357466n, 2],
+            [1726803358466n, 3],
+        ];
+        const expectRowsDesc = expectRowsAsc.slice().reverse();
+        const actualRowsAsc = [];
+        const actualRowsDesc = [];
+        const rowsAsc = await wsSql.query("select * from t_order order by ts asc");
+        while (await rowsAsc.next()) {
+            const data = rowsAsc.getData();
+            if (!data)
+                break;
+            actualRowsAsc.push(data);
+        }
+        await rowsAsc.close();
+        expect(actualRowsAsc).toEqual(expectRowsAsc);
+        const rowsDesc = await wsSql.query("select * from t_order order by ts desc");
+        while (await rowsDesc.next()) {
+            const data = rowsDesc.getData();
+            if (!data)
+                break;
+            actualRowsDesc.push(data);
+        }
+        await rowsDesc.close();
+        expect(actualRowsDesc).toEqual(expectRowsDesc);
+        await wsSql.close();
+    });
+    (0, utils_1.testEnterprise)("connect with token", async () => {
+        const conf = new config_1.WSConfig(dsn);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        const wsSql = await wsSql_1.WsSql.open(conf);
+        const wsRows = await wsSql.query("create token test_bearer_token from user token_user");
+        await wsRows.next();
+        const token = wsRows.getData()?.[0];
+        expect(token).toBeTruthy();
+        await wsRows.close();
+        await wsSql.close();
+        const assertServerVersionWithConfig = async (config) => {
+            const client = await wsSql_1.WsSql.open(config);
+            const rows = await client.query("select server_version()");
+            await rows.next();
+            const version = rows.getData()?.[0];
+            expect(version).toBeTruthy();
+            await rows.close();
+            await client.close();
+        };
+        const conf1 = new config_1.WSConfig(dsn);
+        conf1.setBearerToken(token);
+        await assertServerVersionWithConfig(conf1);
+        const conf2 = new config_1.WSConfig("ws://localhost:6041?bearer_token=" + token);
+        await assertServerVersionWithConfig(conf2);
+    });
+    (0, utils_1.testEnterprise)("connect with invalid token", async () => {
+        let conf = new config_1.WSConfig("ws://localhost:6041?bearer_token=invalid_token");
+        await expect(wsSql_1.WsSql.open(conf)).rejects.toMatchObject({
+            message: expect.stringMatching(/invalid token/i),
+        });
+        conf = new config_1.WSConfig("ws://localhost:6041");
+        conf.setBearerToken("invalid_token1");
+        await expect(wsSql_1.WsSql.open(conf)).rejects.toMatchObject({
+            message: expect.stringMatching(/invalid token/i),
+        });
+        conf = new config_1.WSConfig("ws://localhost:6041");
+        conf.setBearerToken(" ");
+        await expect(wsSql_1.WsSql.open(conf)).rejects.toMatchObject({
+            message: expect.stringMatching(/invalid token/i),
+        });
+        conf = new config_1.WSConfig("ws://localhost:6041?bearer_token=");
+        await expect(wsSql_1.WsSql.open(conf)).rejects.toMatchObject({
+            message: expect.stringMatching(/invalid url/i),
+        });
+        conf = new config_1.WSConfig("ws://localhost:6041");
+        conf.setBearerToken("");
+        await expect(wsSql_1.WsSql.open(conf)).rejects.toMatchObject({
+            message: expect.stringMatching(/invalid url/i),
+        });
+    });
+    (0, utils_1.testNon3360)("connector version info", async () => {
+        const conf = new config_1.WSConfig(dsn);
+        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 hasNodejsWs = false;
+        while (await wsRows.next()) {
+            const data = wsRows.getData();
+            if (Array.isArray(data) && data.some(v => typeof v === "string" && v.includes("nodejs-ws"))) {
+                hasNodejsWs = true;
+                break;
+            }
+        }
+        expect(hasNodejsWs).toBe(true);
+        await wsRows.close();
+        await wsSql.close();
+    });
+});
+afterAll(async () => {
+    let conf = new config_1.WSConfig(dsn);
+    conf.setUser((0, utils_1.testUsername)());
+    conf.setPwd((0, utils_1.testPassword)());
+    let wsSql = await wsSql_1.WsSql.open(conf);
+    await wsSql.exec("drop database sql_test");
+    await wsSql.exec("drop database sql_create");
+    await wsSql.exec("drop user user1");
+    await wsSql.exec("drop user user2");
+    await wsSql.exec("drop user token_user");
+    await wsSql.close();
+    wsConnectorPool_1.WebSocketConnectionPool.instance().destroyed();
+});

package/lib/test/sql/decimal.test.d.ts

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

package/lib/test/sql/decimal.test.d.ts.map

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

package/lib/test/sql/decimal.test.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wsConnectorPool_1 = require("@src/client/wsConnectorPool");
+const config_1 = require("@src/common/config");
+const wsSql_1 = require("@src/sql/wsSql");
+const utils_1 = require("@test-helpers/utils");
+const log_1 = require("@src/common/log");
+const constant_1 = require("@src/tmq/constant");
+const wsTmq_1 = require("@src/tmq/wsTmq");
+let dns = "ws://localhost:6041";
+let createTopic = `create topic if not exists topic_decimal_test as select * from power.decimal_test`;
+let dropTopic = `DROP TOPIC IF EXISTS topic_decimal_test;`;
+(0, log_1.setLevel)("debug");
+beforeAll(async () => {
+    let conf = new config_1.WSConfig(dns);
+    conf.setUser((0, utils_1.testUsername)());
+    conf.setPwd((0, utils_1.testPassword)());
+    let wsSql = await wsSql_1.WsSql.open(conf);
+    await wsSql.exec(dropTopic);
+    await wsSql.exec("drop database if exists power");
+    await wsSql.exec("create database if not exists power KEEP 3650 DURATION 10 BUFFER 16 WAL_LEVEL 1;");
+    await (0, utils_1.Sleep)(100);
+    await wsSql.exec("use power");
+    await wsSql.exec("CREATE STABLE if not exists decimal_test (ts timestamp, dec64 decimal(10,6), dec128 decimal(24,10), int1 int) TAGS (location binary(64), groupId int);");
+    await wsSql.exec(createTopic);
+    await wsSql.close();
+});
+const expectedResultsMap = new Map([
+    [
+        "-1234.654321",
+        {
+            dec128: "-123456789012.0987654321",
+            int1: 3,
+            location: "California",
+            groupId: 3,
+        },
+    ],
+    [
+        "-0.000654",
+        {
+            dec128: "-0.0009876543",
+            int1: 2,
+            location: "California",
+            groupId: 3,
+        },
+    ],
+    [
+        "9876.123456",
+        {
+            dec128: "1234567890.0987654321",
+            int1: 1,
+            location: "California",
+            groupId: 3,
+        },
+    ],
+]);
+describe("TDWebSocket.WsSql()", () => {
+    jest.setTimeout(20 * 1000);
+    test("insert recoder", async () => {
+        let conf = new config_1.WSConfig(dns);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        let wsSql = await wsSql_1.WsSql.open(conf);
+        let taosResult = await wsSql.exec("use power");
+        console.log(taosResult);
+        expect(taosResult).toBeTruthy();
+        taosResult = await wsSql.exec("describe decimal_test");
+        console.log(taosResult);
+        taosResult = await wsSql.exec('INSERT INTO d1001 USING decimal_test (location, groupid) TAGS ("California", 3) VALUES (NOW, "9876.123456", "1234567890.0987654321", 1) (NOW + 1a, "-0.000654", "-0.0009876543", 2) (NOW + 2a, "-1234.654321", "-123456789012.0987654321", 3)');
+        console.log(taosResult);
+        expect(taosResult.getAffectRows()).toBeGreaterThanOrEqual(3);
+        let wsRows = await wsSql.query("select * from decimal_test");
+        expect(wsRows).toBeTruthy();
+        let meta = wsRows.getMeta();
+        expect(meta).toBeTruthy();
+        console.log("wsRow:meta:=>", meta);
+        let count = 0;
+        while (await wsRows.next()) {
+            let result = wsRows.getData();
+            if (result != null && result.length > 0) {
+                if (expectedResultsMap.has(result[1])) {
+                    console.log("result:=>", result);
+                    const expected = expectedResultsMap.get(result[1]);
+                    expect(result[2]).toBe(expected?.dec128);
+                    expect(result[3]).toBe(expected?.int1);
+                    expect(result[4]).toBe(expected?.location);
+                    expect(result[5]).toBe(expected?.groupId);
+                    count++;
+                }
+            }
+        }
+        await wsSql.close();
+        expect(count).toBe(3);
+    });
+});
+test("normal Subscribe", async () => {
+    let configMap = new Map([
+        [constant_1.TMQConstants.GROUP_ID, "gId"],
+        [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, dns],
+        [constant_1.TMQConstants.ENABLE_AUTO_COMMIT, "true"],
+        [constant_1.TMQConstants.AUTO_COMMIT_INTERVAL_MS, "1000"],
+        ["session.timeout.ms", "10000"],
+        ["max.poll.interval.ms", "30000"],
+        ["msg.with.table.name", "true"],
+    ]);
+    let consumer = await wsTmq_1.WsConsumer.newConsumer(configMap);
+    await consumer.subscribe(["topic_decimal_test"]);
+    let assignment = await consumer.assignment();
+    console.log(assignment);
+    let useTime = [];
+    let count = 0;
+    for (let i = 0; i < 5; i++) {
+        let startTime = new Date().getTime();
+        let res = await consumer.poll(500);
+        let currTime = new Date().getTime();
+        useTime.push(Math.abs(currTime - startTime));
+        for (let [key, value] of res) {
+            console.log(key, value.getMeta());
+            let data = value.getData();
+            if (data == null || data.length == 0) {
+                break;
+            }
+            for (let record of data) {
+                console.log("record:=----------->", record);
+                if (expectedResultsMap.has(record[1])) {
+                    const expected = expectedResultsMap.get(record[1]);
+                    expect(record[2]).toBe(expected?.dec128);
+                    expect(record[3]).toBe(expected?.int1);
+                    expect(record[4]).toBe(expected?.location);
+                    expect(record[5]).toBe(expected?.groupId);
+                    count++;
+                }
+            }
+        }
+    }
+    await consumer.unsubscribe();
+    await consumer.close();
+    expect(count).toBe(3);
+});
+afterAll(async () => {
+    let conf = new config_1.WSConfig(dns);
+    conf.setUser((0, utils_1.testUsername)());
+    conf.setPwd((0, utils_1.testPassword)());
+    let wsSql = await wsSql_1.WsSql.open(conf);
+    await wsSql.exec(dropTopic);
+    await wsSql.exec("drop database power");
+    await wsSql.close();
+    wsConnectorPool_1.WebSocketConnectionPool.instance().destroyed();
+});

package/lib/test/sql/failover/sql.failover.test.d.ts

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

package/lib/test/sql/failover/sql.failover.test.d.ts.map

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