@tdengine/websocket 3.2.3 → 3.3.0

package/lib/test/sql/queryTables.test.js

@@ -0,0 +1,506 @@
+"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");
+let dsn = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}@localhost:6041`;
+let conf = new config_1.WSConfig(dsn);
+const resultMap = new Map();
+resultMap.set("POINT (4.0 8.0)", (0, utils_1.hexToBytes)("010100000000000000000010400000000000002040"));
+resultMap.set("POINT (3.0 5.0)", (0, utils_1.hexToBytes)("010100000000000000000008400000000000001440"));
+resultMap.set("LINESTRING (1.000000 1.000000, 2.000000 2.000000, 5.000000 5.000000)", (0, utils_1.hexToBytes)("010200000003000000000000000000f03f000000000000f03f0000000000000040000000000000004000000000000014400000000000001440"));
+resultMap.set("POLYGON ((3.000000 6.000000, 5.000000 6.000000, 5.000000 8.000000, 3.000000 8.000000, 3.000000 6.000000))", (0, utils_1.hexToBytes)("010300000001000000050000000000000000000840000000000000184000000000000014400000000000001840000000000000144000000000000020400000000000000840000000000000204000000000000008400000000000001840"));
+resultMap.set("POINT (7.0 9.0)", (0, utils_1.hexToBytes)("01010000000000000000001c400000000000002240"));
+resultMap.set("0x7661726332", (0, utils_1.hexToBytes)("307837363631373236333332"));
+resultMap.set("0x7661726333", (0, utils_1.hexToBytes)("307837363631373236333333"));
+resultMap.set("0x7661726334", (0, utils_1.hexToBytes)("307837363631373236333334"));
+resultMap.set("0x7661726335", (0, utils_1.hexToBytes)("307837363631373236333335"));
+const table = "ws_q_n";
+const stable = "ws_q_s";
+const tableCN = "ws_q_n_cn";
+const stableCN = "ws_q_s_cn";
+const db = "ws_q_db";
+const jsonTable = "ws_q_j";
+const jsonTableCN = "ws_q_j_cn";
+const createDB = `create database if not exists ${db} keep 3650`;
+const dropDB = `drop database if exists ${db}`;
+const useDB = `use ${db}`;
+const stableTags = [
+    true,
+    -1,
+    -2,
+    -3,
+    BigInt(-4),
+    1,
+    2,
+    3,
+    BigInt(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,
+    BigInt(-4 * 2),
+    1 * 2,
+    2 * 2,
+    3 * 2,
+    BigInt(4 * 2),
+    parseFloat((3.1415 * 2).toFixed(5)),
+    parseFloat((3.14159265 * 2).toFixed(15)),
+    "varchar_标签_壹",
+    "nchar_标签_贰",
+];
+const tableValues = [
+    [
+        BigInt(1656677710000),
+        0,
+        -1,
+        -2,
+        BigInt(-3),
+        0,
+        1,
+        2,
+        BigInt(3),
+        parseFloat((3.1415).toFixed(5)),
+        parseFloat((3.14159265).toFixed(15)),
+        "varchar_col_1",
+        "nchar_col_1",
+        true,
+        "NULL",
+        "POINT (4.0 8.0)",
+        "0x7661726332",
+    ],
+    [
+        BigInt(1656677720000),
+        -1,
+        -2,
+        -3,
+        BigInt(-4),
+        1,
+        2,
+        3,
+        BigInt(4),
+        parseFloat((3.1415 * 2).toFixed(5)),
+        parseFloat((3.14159265 * 2).toFixed(15)),
+        "varchar_col_2",
+        "nchar_col_2",
+        false,
+        "NULL",
+        "POINT (3.0 5.0)",
+        "0x7661726333",
+    ],
+    [
+        BigInt(1656677730000),
+        -2,
+        -3,
+        -4,
+        BigInt(-5),
+        2,
+        3,
+        4,
+        BigInt(5),
+        parseFloat((3.1415 * 3).toFixed(5)),
+        parseFloat((3.14159265 * 3).toFixed(15)),
+        "varchar_col_3",
+        "nchar_col_3",
+        true,
+        "NULL",
+        "LINESTRING (1.000000 1.000000, 2.000000 2.000000, 5.000000 5.000000)",
+        "0x7661726334",
+    ],
+    [
+        BigInt(1656677740000),
+        -3,
+        -4,
+        -5,
+        BigInt(-6),
+        3,
+        4,
+        5,
+        BigInt(6),
+        parseFloat((3.1415 * 4).toFixed(5)),
+        parseFloat((3.14159265 * 4).toFixed(15)),
+        "varchar_col_4",
+        "nchar_col_4",
+        false,
+        "NULL",
+        "POLYGON ((3.000000 6.000000, 5.000000 6.000000, 5.000000 8.000000, 3.000000 8.000000, 3.000000 6.000000))",
+        "0x7661726335",
+    ],
+    [
+        BigInt(1656677750000),
+        -4,
+        -5,
+        -6,
+        BigInt(-7),
+        4,
+        5,
+        6,
+        BigInt(7),
+        parseFloat((3.1415 * 5).toFixed(5)),
+        parseFloat((3.14159265 * 5).toFixed(15)),
+        "varchar_col_5",
+        "nchar_col_5",
+        true,
+        "NULL",
+        "POINT (7.0 9.0)",
+        "0x7661726335",
+    ],
+];
+const tableCNValues = [
+    [
+        BigInt(1656677760000),
+        0,
+        -1,
+        -2,
+        BigInt(-3),
+        0,
+        1,
+        2,
+        BigInt(3),
+        parseFloat((3.1415).toFixed(5)),
+        parseFloat((3.14159265).toFixed(15)),
+        "varchar_列_壹",
+        "nchar_列_甲",
+        true,
+        "NULL",
+        "POINT (4.0 8.0)",
+        "0x7661726332",
+    ],
+    [
+        BigInt(1656677770000),
+        -1,
+        -2,
+        -3,
+        BigInt(-4),
+        1,
+        2,
+        3,
+        BigInt(4),
+        parseFloat((3.1415 * 2).toFixed(5)),
+        parseFloat((3.14159265 * 2).toFixed(15)),
+        "varchar_列_贰",
+        "nchar_列_乙",
+        false,
+        "NULL",
+        "POINT (3.0 5.0)",
+        "0x7661726333",
+    ],
+    [
+        BigInt(1656677780000),
+        -2,
+        -3,
+        -4,
+        BigInt(-5),
+        2,
+        3,
+        4,
+        BigInt(5),
+        parseFloat((3.1415 * 3).toFixed(5)),
+        parseFloat((3.14159265 * 3).toFixed(15)),
+        "varchar_列_叁",
+        "nchar_列_丙",
+        true,
+        "NULL",
+        "LINESTRING (1.000000 1.000000, 2.000000 2.000000, 5.000000 5.000000)",
+        "0x7661726334",
+    ],
+    [
+        BigInt(1656677790000),
+        -3,
+        -4,
+        -5,
+        BigInt(-6),
+        3,
+        4,
+        5,
+        BigInt(6),
+        parseFloat((3.1415 * 4).toFixed(5)),
+        parseFloat((3.14159265 * 4).toFixed(15)),
+        "varchar_列_肆",
+        "nchar_列_丁",
+        false,
+        "NULL",
+        "POLYGON ((3.000000 6.000000, 5.000000 6.000000, 5.000000 8.000000, 3.000000 8.000000, 3.000000 6.000000))",
+        "0x7661726335",
+    ],
+    [
+        BigInt(1656677800000),
+        -4,
+        -5,
+        -6,
+        BigInt(-7),
+        4,
+        5,
+        6,
+        BigInt(7),
+        parseFloat((3.1415 * 5).toFixed(5)),
+        parseFloat((3.14159265 * 5).toFixed(15)),
+        "varchar_列_伍",
+        "nchar_列_戊",
+        true,
+        "NULL",
+        "POINT (7.0 9.0)",
+        "0x7661726335",
+    ],
+];
+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}`;
+beforeAll(async () => {
+    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.createSTable)(stable));
+    await ws.exec((0, utils_1.createSTable)(stableCN));
+    await ws.exec((0, utils_1.createTable)(table));
+    await ws.exec((0, utils_1.createTable)(tableCN));
+    await ws.exec((0, utils_1.createSTableJSON)(jsonTable));
+    await ws.exec((0, utils_1.createSTableJSON)(jsonTableCN));
+    await ws.close();
+});
+describe("ws.query(stable)", () => {
+    jest.setTimeout(20 * 1000);
+    test("Insert query stable without CN character", async () => {
+        let ws = await wsSql_1.WsSql.open(conf);
+        await ws.exec(useDB);
+        let insert = (0, utils_1.insertStable)(tableValues, stableTags, stable);
+        let insertRes = await ws.exec(insert);
+        expect(insertRes.getAffectRows()).toBe(5);
+        let queryRes = await ws.exec(selectStable);
+        let expectMeta = utils_1.tableMeta.concat(utils_1.tagMeta);
+        let expectData = (0, utils_1.expectStableData)(tableValues, stableTags);
+        let actualMeta = queryRes.getMeta();
+        let actualData = queryRes.getData();
+        await ws.close();
+        if (actualData && actualMeta) {
+            actualMeta.forEach((meta, index) => {
+                expect(meta.name).toBe(expectMeta[index].name);
+                expect(meta.type).toBe(expectMeta[index].type);
+                expect(meta.length).toBe(expectMeta[index].length);
+            });
+            for (let i = 0; i < actualData.length; i++) {
+                actualData[i].forEach((d, index) => {
+                    if (expectMeta[index].name == "geo" ||
+                        expectMeta[index].name == "vbinary") {
+                        let buffer = resultMap.get(expectData[i][index]);
+                        if (buffer) {
+                            let dbData = d;
+                            console.log(i, index, dbData, expectData[i][index], buffer, (0, utils_1.compareUint8Arrays)(new Uint8Array(dbData), new Uint8Array(buffer)));
+                            expect((0, utils_1.compareUint8Arrays)(new Uint8Array(dbData), new Uint8Array(buffer))).toBe(true);
+                        }
+                    }
+                    else {
+                        expect(d).toBe(expectData[i][index]);
+                    }
+                });
+            }
+        }
+        else {
+            throw new Error("retrieve empty result");
+        }
+    });
+    test("query stable with CN character", async () => {
+        let ws = await wsSql_1.WsSql.open(conf);
+        await ws.exec(useDB);
+        let insertCN = (0, utils_1.insertStable)(tableCNValues, stableCNTags, stableCN);
+        let insertRes = await ws.exec(insertCN);
+        expect(insertRes.getAffectRows()).toBe(5);
+        let queryRes = await ws.exec(selectStableCN);
+        let expectMeta = utils_1.tableMeta.concat(utils_1.tagMeta);
+        let expectData = (0, utils_1.expectStableData)(tableCNValues, stableCNTags);
+        let actualMeta = queryRes.getMeta();
+        let actualData = queryRes.getData();
+        await ws.close();
+        if (actualData && actualMeta) {
+            actualMeta.forEach((meta, index) => {
+                expect(meta.name).toBe(expectMeta[index].name);
+                expect(meta.type).toBe(expectMeta[index].type);
+                expect(meta.length).toBe(expectMeta[index].length);
+            });
+            for (let i = 0; i < actualData.length; i++) {
+                actualData[i].forEach((d, index) => {
+                    if (expectMeta[index].name == "geo" ||
+                        expectMeta[index].name == "vbinary") {
+                        let buffer = resultMap.get(expectData[i][index]);
+                        if (buffer) {
+                            let dbData = d;
+                            console.log(i, index, dbData, expectData[i][index], buffer, (0, utils_1.compareUint8Arrays)(new Uint8Array(dbData), new Uint8Array(buffer)));
+                            expect((0, utils_1.compareUint8Arrays)(new Uint8Array(dbData), new Uint8Array(buffer))).toBe(true);
+                        }
+                    }
+                    else {
+                        expect(d).toBe(expectData[i][index]);
+                    }
+                });
+            }
+        }
+        else {
+            throw new Error("retrieve empty result");
+        }
+    });
+});
+describe("ws.query(table)", () => {
+    test("Insert query normal table without CN character", async () => {
+        let ws = await wsSql_1.WsSql.open(conf);
+        await ws.exec(useDB);
+        let insert = (0, utils_1.insertNTable)(tableValues, table);
+        let insertRes = await ws.exec(insert);
+        expect(insertRes.getAffectRows()).toBe(5);
+        let queryRes = await ws.exec(selectTable);
+        let expectMeta = utils_1.tableMeta;
+        let expectData = tableValues;
+        let actualMeta = queryRes.getMeta();
+        let actualData = queryRes.getData();
+        await ws.close();
+        if (actualData && actualMeta) {
+            actualMeta.forEach((meta, index) => {
+                expect(meta.name).toBe(expectMeta[index].name);
+                expect(meta.type).toBe(expectMeta[index].type);
+                expect(meta.length).toBe(expectMeta[index].length);
+            });
+            for (let i = 0; i < actualData.length; i++) {
+                actualData[i].forEach((d, index) => {
+                    if (expectMeta[index].name == "geo" ||
+                        expectMeta[index].name == "vbinary") {
+                        expect(d).toBeTruthy();
+                    }
+                    else {
+                        expect(d).toBe(expectData[i][index]);
+                    }
+                });
+            }
+        }
+        else {
+            throw new Error("retrieve empty result");
+        }
+    });
+    test("Insert query normal table with CN character", async () => {
+        let ws = await wsSql_1.WsSql.open(conf);
+        await ws.exec(useDB);
+        let insertCN = (0, utils_1.insertNTable)(tableCNValues, tableCN);
+        let insertRes = await ws.exec(insertCN);
+        expect(insertRes.getAffectRows()).toBe(5);
+        let queryRes = await ws.exec(selectTableCN);
+        let expectMeta = utils_1.tableMeta;
+        let expectData = tableCNValues;
+        let actualMeta = queryRes.getMeta();
+        let actualData = queryRes.getData();
+        await ws.close();
+        if (actualData && actualMeta) {
+            actualMeta.forEach((meta, index) => {
+                expect(meta.name).toBe(expectMeta[index].name);
+                expect(meta.type).toBe(expectMeta[index].type);
+                expect(meta.length).toBe(expectMeta[index].length);
+            });
+            for (let i = 0; i < actualData.length; i++) {
+                actualData[i].forEach((d, index) => {
+                    if (expectMeta[index].name == "geo" ||
+                        expectMeta[index].name == "vbinary") {
+                        expect(d).toBeTruthy();
+                    }
+                    else {
+                        expect(d).toBe(expectData[i][index]);
+                    }
+                });
+            }
+        }
+        else {
+            throw new Error("retrieve empty result");
+        }
+    });
+});
+describe("ws.query(jsonTable)", () => {
+    test("Insert and query json data from table without CN", async () => {
+        let ws = await wsSql_1.WsSql.open(conf);
+        await ws.exec(useDB);
+        let insert = (0, utils_1.insertStable)(tableValues, jsonTags, jsonTable);
+        let insertRes = await ws.exec(insert);
+        expect(insertRes.getAffectRows()).toBe(5);
+        let queryRes = await ws.exec(selectJsonTable);
+        let expectMeta = utils_1.tableMeta.concat(utils_1.jsonMeta);
+        let expectData = (0, utils_1.expectStableData)(tableValues, jsonTags);
+        let actualMeta = queryRes.getMeta();
+        let actualData = queryRes.getData();
+        await ws.close();
+        if (actualData && actualMeta) {
+            actualMeta.forEach((meta, index) => {
+                //   console.log(meta);
+                expect(meta.name).toBe(expectMeta[index].name);
+                expect(meta.type).toBe(expectMeta[index].type);
+                expect(meta.length).toBe(expectMeta[index].length);
+            });
+            for (let i = 0; i < actualData.length; i++) {
+                actualData[i].forEach((d, index) => {
+                    if (expectMeta[index].name == "geo" ||
+                        expectMeta[index].name == "vbinary") {
+                        expect(d).toBeTruthy();
+                    }
+                    else {
+                        expect(d).toBe(expectData[i][index]);
+                    }
+                });
+            }
+        }
+        else {
+            throw new Error("retrieve empty result");
+        }
+    });
+    test("Insert and query json data from table with CN", async () => {
+        let ws = await wsSql_1.WsSql.open(conf);
+        await ws.exec(useDB);
+        let insert = (0, utils_1.insertStable)(tableCNValues, jsonTagsCN, jsonTableCN);
+        let insertRes = await ws.exec(insert);
+        expect(insertRes.getAffectRows()).toBe(5);
+        let queryRes = await ws.exec(selectJsonTableCN);
+        let expectMeta = utils_1.tableMeta.concat(utils_1.jsonMeta);
+        let expectData = (0, utils_1.expectStableData)(tableCNValues, jsonTagsCN);
+        let actualMeta = queryRes.getMeta();
+        let actualData = queryRes.getData();
+        await ws.close();
+        if (actualData && actualMeta) {
+            actualMeta.forEach((meta, index) => {
+                //   console.log(meta);
+                expect(meta.name).toBe(expectMeta[index].name);
+                expect(meta.type).toBe(expectMeta[index].type);
+                expect(meta.length).toBe(expectMeta[index].length);
+            });
+            for (let i = 0; i < actualData.length; i++) {
+                actualData[i].forEach((d, index) => {
+                    if (expectMeta[index].name == "geo" ||
+                        expectMeta[index].name == "vbinary") {
+                        expect(d).toBeTruthy();
+                    }
+                    else {
+                        expect(d).toBe(expectData[i][index]);
+                    }
+                });
+            }
+        }
+        else {
+            throw new Error("retrieve empty result");
+        }
+    });
+});
+afterAll(async () => {
+    let ws = await wsSql_1.WsSql.open(conf);
+    await ws.exec(dropDB);
+    await ws.close();
+    wsConnectorPool_1.WebSocketConnectionPool.instance().destroyed();
+});

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

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

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

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

package/lib/test/sql/schemaless.test.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wsConnectorPool_1 = require("@src/client/wsConnectorPool");
+const config_1 = require("@src/common/config");
+const wsProto_1 = require("@src/sql/wsProto");
+const wsSql_1 = require("@src/sql/wsSql");
+const utils_1 = require("@test-helpers/utils");
+let dns = "ws://localhost:6041";
+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("drop database if exists power_schemaless;");
+    await wsSql.exec("create database if not exists power_schemaless KEEP 3650 DURATION 10 BUFFER 16 WAL_LEVEL 1;");
+    await wsSql.exec("CREATE STABLE if not exists power_schemaless.meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int);");
+    await wsSql.close();
+});
+describe("TDWebSocket.WsSchemaless()", () => {
+    jest.setTimeout(20 * 1000);
+    let influxdbData = 'st,t1=3i64,t2=4f64,t3="t3" c1=3i64,c3=L"passit",c2=false,c4=4f64 1626006833639000000';
+    let telnetData = "stb0_0 1626006833 4 host=host0 interface=eth0";
+    let jsonData = '{"metric": "meter_current","timestamp": 1626846400,"value": 10.3, "tags": {"groupid": 2, "location": "California.SanFrancisco", "id": "d1001"}}';
+    test("normal connect", async () => {
+        let conf = new config_1.WSConfig(dns);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        conf.setDb("power_schemaless");
+        let wsSchemaless = await wsSql_1.WsSql.open(conf);
+        expect(wsSchemaless.state()).toBeGreaterThan(0);
+        await wsSchemaless.close();
+    });
+    test("connect db with error", async () => {
+        expect.assertions(1);
+        let wsSchemaless = null;
+        try {
+            let conf = new config_1.WSConfig(dns);
+            conf.setUser((0, utils_1.testUsername)());
+            conf.setPwd((0, utils_1.testPassword)());
+            conf.setDb("jest");
+            wsSchemaless = await wsSql_1.WsSql.open(conf);
+        }
+        catch (e) {
+            console.log(e);
+            expect(e.message).toMatch("Database not exist");
+        }
+        finally {
+            if (wsSchemaless) {
+                await wsSchemaless.close();
+            }
+        }
+    });
+    test("normal insert", async () => {
+        let conf = new config_1.WSConfig(dns);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        conf.setDb("power_schemaless");
+        let wsSchemaless = await wsSql_1.WsSql.open(conf);
+        expect(wsSchemaless.state()).toBeGreaterThan(0);
+        await wsSchemaless.schemalessInsert([influxdbData], wsProto_1.SchemalessProto.InfluxDBLineProtocol, wsProto_1.Precision.NANO_SECONDS, 0);
+        await wsSchemaless.schemalessInsert([telnetData], wsProto_1.SchemalessProto.OpenTSDBTelnetLineProtocol, wsProto_1.Precision.SECONDS, 0);
+        await wsSchemaless.schemalessInsert([jsonData], wsProto_1.SchemalessProto.OpenTSDBJsonFormatProtocol, wsProto_1.Precision.SECONDS, 0);
+        await wsSchemaless.close();
+    });
+    test("normal wsSql insert", async () => {
+        let conf = new config_1.WSConfig(dns);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        conf.setDb("power_schemaless");
+        let wsSchemaless = await wsSql_1.WsSql.open(conf);
+        expect(wsSchemaless.state()).toBeGreaterThan(0);
+        await wsSchemaless.schemalessInsert([influxdbData], wsProto_1.SchemalessProto.InfluxDBLineProtocol, wsProto_1.Precision.NOT_CONFIGURED, 0);
+        await wsSchemaless.schemalessInsert([influxdbData], wsProto_1.SchemalessProto.InfluxDBLineProtocol, wsProto_1.Precision.NANO_SECONDS, 0);
+        await wsSchemaless.schemalessInsert([telnetData], wsProto_1.SchemalessProto.OpenTSDBTelnetLineProtocol, wsProto_1.Precision.SECONDS, 0);
+        await wsSchemaless.schemalessInsert([jsonData], wsProto_1.SchemalessProto.OpenTSDBJsonFormatProtocol, wsProto_1.Precision.SECONDS, 0);
+        await wsSchemaless.close();
+    });
+    test("SchemalessProto error", async () => {
+        let conf = new config_1.WSConfig(dns);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        conf.setDb("power_schemaless");
+        let wsSchemaless = await wsSql_1.WsSql.open(conf);
+        expect(wsSchemaless.state()).toBeGreaterThan(0);
+        try {
+            await wsSchemaless.schemalessInsert([influxdbData], wsProto_1.SchemalessProto.OpenTSDBTelnetLineProtocol, wsProto_1.Precision.NANO_SECONDS, 0);
+        }
+        catch (e) {
+            expect(e.message).toMatch("parse timestamp failed");
+        }
+        await wsSchemaless.close();
+    });
+});
+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("drop database if exists power_schemaless;");
+    await wsSql.close();
+    wsConnectorPool_1.WebSocketConnectionPool.instance().destroyed();
+});

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

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

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

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