@tdengine/websocket 3.2.2 → 3.3.0

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

@@ -0,0 +1,338 @@
+"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("../helpers/utils");
+const wsProxy_1 = require("../helpers/wsProxy");
+function parseBinaryAction(rawData) {
+    if (typeof rawData === "string" || rawData.byteLength < 24) {
+        return null;
+    }
+    return rawData.readBigInt64LE(16);
+}
+describe("sql failover", () => {
+    jest.setTimeout(120 * 1000);
+    afterEach(async () => {
+        wsConnectorPool_1.WebSocketConnectionPool.instance().destroyed();
+        jest.restoreAllMocks();
+    });
+    test("switches to next address when active proxy restarts with downtime", async () => {
+        let restartTriggered = false;
+        let proxyBHadActivity = false;
+        let wsSql = 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" || !event.isBinary) {
+                    return;
+                }
+                const action = parseBinaryAction(event.rawData);
+                if (action === 6n && !restartTriggered) {
+                    restartTriggered = true;
+                    void control.restart({
+                        downtimeMs: 800,
+                        reason: "trigger dual-address 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 randomSpy = jest.spyOn(Math, "random").mockReturnValue(0);
+        try {
+            const dsn = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}` +
+                `@127.0.0.1:${proxyA.getPort()},127.0.0.1:${proxyB.getPort()}` +
+                `?retries=5&retry_backoff_ms=20&retry_backoff_max_ms=20`;
+            const conf = new config_1.WSConfig(dsn);
+            conf.setTimeOut(6000);
+            wsSql = await wsSql_1.WsSql.open(conf);
+            const result = await wsSql.exec("select server_version()");
+            expect(result).toBeTruthy();
+            expect(restartTriggered).toBe(true);
+            expect(proxyBHadActivity).toBe(true);
+        }
+        finally {
+            randomSpy.mockRestore();
+            if (wsSql) {
+                await wsSql.close();
+            }
+            await proxyA.stop("test cleanup");
+            await proxyB.stop("test cleanup");
+        }
+    });
+    test("reconnects to same address after single proxy hard restart", async () => {
+        let restartCount = 0;
+        let wsSql = 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" || !event.isBinary) {
+                    return;
+                }
+                const action = parseBinaryAction(event.rawData);
+                if (action === 6n && restartCount === 0) {
+                    restartCount += 1;
+                    void control.restart({
+                        downtimeMs: 120,
+                        reason: "trigger single-address reconnect",
+                    });
+                }
+            },
+        });
+        try {
+            const dsn = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}@127.0.0.1:${proxy.getPort()}` +
+                `?retries=6&retry_backoff_ms=30&retry_backoff_max_ms=60`;
+            const conf = new config_1.WSConfig(dsn);
+            conf.setTimeOut(6000);
+            wsSql = await wsSql_1.WsSql.open(conf);
+            const result = await wsSql.exec("select server_version()");
+            expect(result).toBeTruthy();
+            expect(restartCount).toBe(1);
+        }
+        finally {
+            if (wsSql) {
+                await wsSql.close();
+            }
+            await proxy.stop("test cleanup");
+        }
+    });
+    test("keeps all 5000 rows with single-address random proxy restarts during inserts", async () => {
+        const targetRows = 5000;
+        const baseTs = 1700000000000;
+        const dbName = "test_1773988174";
+        const tableName = "t0";
+        let wsSql = null;
+        let setupSql = null;
+        let cleanupSql = null;
+        let writePhase = false;
+        let restartInFlight = false;
+        let restartCount = 0;
+        let forwardedInsertFrames = 0;
+        const localDsn = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}@127.0.0.1:6041`;
+        const setupConf = new config_1.WSConfig(localDsn);
+        setupConf.setTimeOut(6000);
+        setupSql = await wsSql_1.WsSql.open(setupConf);
+        try {
+            await setupSql.exec(`drop database if exists ${dbName}`);
+            await setupSql.exec(`create database if not exists ${dbName}`);
+        }
+        finally {
+            await setupSql.close();
+            setupSql = null;
+        }
+        const proxy = await wsProxy_1.WsProxy.create({
+            host: "127.0.0.1",
+            port: 0,
+            onEvent: (event, control) => {
+                if (!writePhase || restartInFlight) {
+                    return;
+                }
+                if (event.type !== "message") {
+                    return;
+                }
+                if (event.direction !== "client_to_upstream" || !event.isBinary) {
+                    return;
+                }
+                const action = parseBinaryAction(event.rawData);
+                if (action !== 6n) {
+                    return;
+                }
+                forwardedInsertFrames += 1;
+                if (Math.random() < 0.003) {
+                    restartInFlight = true;
+                    restartCount += 1;
+                    const downtimeMs = 10 + Math.floor(Math.random() * 60);
+                    void control.restart({
+                        downtimeMs,
+                        reason: `random restart #${restartCount}`,
+                    }).finally(() => {
+                        restartInFlight = false;
+                    });
+                }
+            },
+        });
+        try {
+            const dsn = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}@127.0.0.1:${proxy.getPort()}` +
+                `?retries=30&retry_backoff_ms=5&retry_backoff_max_ms=20`;
+            const conf = new config_1.WSConfig(dsn);
+            conf.setDb(dbName);
+            conf.setTimeOut(10000);
+            wsSql = await wsSql_1.WsSql.open(conf);
+            await wsSql.exec(`create table ${tableName}(ts timestamp, c1 int)`);
+            writePhase = true;
+            for (let i = 0; i < targetRows; i++) {
+                await wsSql.exec(`insert into ${tableName} values(${baseTs + i}, ${i})`);
+            }
+            writePhase = false;
+            const countResult = await wsSql.exec(`select count(*) from ${tableName}`);
+            const countValue = countResult.getData()?.[0]?.[0];
+            const rowCount = typeof countValue === "bigint"
+                ? Number(countValue)
+                : Number(countValue || 0);
+            expect(rowCount).toBe(targetRows);
+            expect(forwardedInsertFrames).toBeGreaterThanOrEqual(targetRows);
+            expect(restartCount).toBeGreaterThan(0);
+        }
+        finally {
+            writePhase = false;
+            if (wsSql) {
+                await wsSql.close();
+            }
+            await proxy.stop("test cleanup");
+            const cleanupConf = new config_1.WSConfig(localDsn);
+            cleanupConf.setTimeOut(6000);
+            cleanupSql = await wsSql_1.WsSql.open(cleanupConf);
+            try {
+                await cleanupSql.exec(`drop database if exists ${dbName}`);
+            }
+            finally {
+                await cleanupSql.close();
+                cleanupSql = null;
+            }
+        }
+    }, 300 * 1000);
+    test("keeps all 5000 rows with three-address random proxy restarts during inserts", async () => {
+        const targetRows = 5000;
+        const baseTs = 1700010000000;
+        const dbName = "test_1773989170";
+        const tableName = "t0";
+        const proxyStates = new Map();
+        let wsSql = null;
+        let setupSql = null;
+        let cleanupSql = null;
+        let writePhase = false;
+        const localDsn = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}@127.0.0.1:6041`;
+        const setupConf = new config_1.WSConfig(localDsn);
+        setupConf.setTimeOut(6000);
+        setupSql = await wsSql_1.WsSql.open(setupConf);
+        try {
+            await setupSql.exec(`drop database if exists ${dbName}`);
+            await setupSql.exec(`create database if not exists ${dbName}`);
+        }
+        finally {
+            await setupSql.close();
+            setupSql = null;
+        }
+        const createRandomRestartProxy = async (name) => {
+            proxyStates.set(name, {
+                forwarded: 0,
+                restarting: false,
+                restarts: 0,
+            });
+            return wsProxy_1.WsProxy.create({
+                host: "127.0.0.1",
+                port: 0,
+                onEvent: (event, control) => {
+                    if (!writePhase) {
+                        return;
+                    }
+                    if (event.type !== "message") {
+                        return;
+                    }
+                    if (event.direction !== "client_to_upstream" || !event.isBinary) {
+                        return;
+                    }
+                    const action = parseBinaryAction(event.rawData);
+                    if (action !== 6n) {
+                        return;
+                    }
+                    const state = proxyStates.get(name);
+                    if (!state) {
+                        return;
+                    }
+                    state.forwarded += 1;
+                    if (state.restarting) {
+                        return;
+                    }
+                    if (Math.random() >= 0.003) {
+                        return;
+                    }
+                    state.restarting = true;
+                    state.restarts += 1;
+                    const downtimeMs = 80 + Math.floor(Math.random() * 120);
+                    void control
+                        .restart({
+                        downtimeMs,
+                        reason: `${name} random restart #${state.restarts}`,
+                    })
+                        .finally(() => {
+                        const latestState = proxyStates.get(name);
+                        if (latestState) {
+                            latestState.restarting = false;
+                        }
+                    });
+                },
+            });
+        };
+        const proxyA = await createRandomRestartProxy("proxy_a");
+        const proxyB = await createRandomRestartProxy("proxy_b");
+        const proxyC = await createRandomRestartProxy("proxy_c");
+        try {
+            const dsn = `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=24&retry_backoff_ms=8&retry_backoff_max_ms=25`;
+            const conf = new config_1.WSConfig(dsn);
+            conf.setDb(dbName);
+            conf.setTimeOut(10000);
+            wsSql = await wsSql_1.WsSql.open(conf);
+            await wsSql.exec(`create table ${tableName}(ts timestamp, c1 int)`);
+            writePhase = true;
+            for (let i = 0; i < targetRows; i++) {
+                await wsSql.exec(`insert into ${tableName} values(${baseTs + i}, ${i})`);
+            }
+            writePhase = false;
+            const countResult = await wsSql.exec(`select count(*) from ${tableName}`);
+            const countValue = countResult.getData()?.[0]?.[0];
+            const rowCount = typeof countValue === "bigint"
+                ? Number(countValue)
+                : Number(countValue || 0);
+            const totalForwarded = Array.from(proxyStates.values()).reduce((sum, state) => sum + state.forwarded, 0);
+            const totalRestarts = Array.from(proxyStates.values()).reduce((sum, state) => sum + state.restarts, 0);
+            expect(rowCount).toBe(targetRows);
+            expect(totalForwarded).toBeGreaterThanOrEqual(targetRows);
+            expect(totalRestarts).toBeGreaterThan(0);
+        }
+        finally {
+            writePhase = false;
+            if (wsSql) {
+                await wsSql.close();
+            }
+            await Promise.all([
+                proxyA.stop("test cleanup"),
+                proxyB.stop("test cleanup"),
+                proxyC.stop("test cleanup"),
+            ]);
+            const cleanupConf = new config_1.WSConfig(localDsn);
+            cleanupConf.setTimeOut(6000);
+            cleanupSql = await wsSql_1.WsSql.open(cleanupConf);
+            try {
+                await cleanupSql.exec(`drop database if exists ${dbName}`);
+            }
+            finally {
+                await cleanupSql.close();
+                cleanupSql = null;
+            }
+        }
+    }, 300 * 1000);
+});

package/lib/test/bulkPulling/sql.test.js

@@ -5,19 +5,20 @@ const config_1 = require("../../src/common/config");
 const wsSql_1 = require("../../src/sql/wsSql");
 const utils_1 = require("../utils");
 const log_1 = require("../../src/common/log");
-let dns = "ws://localhost:6041";
+let dsn = "ws://localhost:6041";
 let password1 = "Ab1!@#$%,.:?<>;~";
 let password2 = "Bc%^&*()-_+=[]{}";
 (0, log_1.setLevel)("debug");
 beforeAll(async () => {
-    let conf = new config_1.WSConfig(dns);
-    conf.setUser("root");
-    conf.setPwd("taosdata");
+    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 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");
@@ -29,9 +30,9 @@ describe("TDWebSocket.WsSql()", () => {
     test("normal connect", async () => {
         let wsSql = null;
         let conf = new config_1.WSConfig("");
-        conf.setUrl(dns);
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        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);
@@ -48,7 +49,7 @@ describe("TDWebSocket.WsSql()", () => {
     });
     test("special characters connect1", async () => {
         let wsSql = null;
-        let conf = new config_1.WSConfig(dns);
+        let conf = new config_1.WSConfig(dsn);
         conf.setUser("user1");
         conf.setPwd(password1);
         wsSql = await wsSql_1.WsSql.open(conf);
@@ -60,7 +61,7 @@ describe("TDWebSocket.WsSql()", () => {
     });
     test("special characters connect2", async () => {
         let wsSql = null;
-        let conf = new config_1.WSConfig(dns);
+        let conf = new config_1.WSConfig(dsn);
         conf.setUser("user2");
         conf.setPwd(password2);
         wsSql = await wsSql_1.WsSql.open(conf);
@@ -74,9 +75,9 @@ describe("TDWebSocket.WsSql()", () => {
         expect.assertions(1);
         let wsSql = null;
         try {
-            let conf = new config_1.WSConfig(dns);
-            conf.setUser("root");
-            conf.setPwd("taosdata");
+            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);
         }
@@ -91,7 +92,7 @@ describe("TDWebSocket.WsSql()", () => {
         }
     });
     test("connect url", async () => {
-        let url = "ws://root:taosdata@localhost:6041/information_schema?timezone=Asia/Shanghai";
+        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();
@@ -107,9 +108,9 @@ describe("TDWebSocket.WsSql()", () => {
         await wsSql.close();
     });
     test("get taosc version", async () => {
-        let conf = new config_1.WSConfig(dns);
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        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();
@@ -117,9 +118,9 @@ describe("TDWebSocket.WsSql()", () => {
         expect(version).toBeTruthy();
     });
     test("show databases", async () => {
-        let conf = new config_1.WSConfig(dns);
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        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();
@@ -127,9 +128,9 @@ describe("TDWebSocket.WsSql()", () => {
         expect(taosResult).toBeTruthy();
     });
     test("create databases", async () => {
-        let conf = new config_1.WSConfig(dns);
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        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();
@@ -137,9 +138,9 @@ describe("TDWebSocket.WsSql()", () => {
         expect(taosResult).toBeTruthy();
     });
     test("create stable", async () => {
-        let conf = new config_1.WSConfig(dns);
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        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);
@@ -150,9 +151,9 @@ describe("TDWebSocket.WsSql()", () => {
         expect(taosResult).toBeTruthy();
     });
     test("insert recoder", async () => {
-        let conf = new config_1.WSConfig(dns);
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        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);
@@ -165,9 +166,9 @@ describe("TDWebSocket.WsSql()", () => {
         await wsSql.close();
     });
     test("query sql", async () => {
-        let conf = new config_1.WSConfig(dns);
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        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);
@@ -187,9 +188,9 @@ describe("TDWebSocket.WsSql()", () => {
         await wsSql.close();
     });
     test("query sql no getdata", async () => {
-        let conf = new config_1.WSConfig(dns);
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        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);
@@ -199,9 +200,9 @@ describe("TDWebSocket.WsSql()", () => {
         await wsSql.close();
     });
     test("timestamp order check", async () => {
-        const conf = new config_1.WSConfig(dns);
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        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");
@@ -237,16 +238,87 @@ describe("TDWebSocket.WsSql()", () => {
         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(dns);
-    conf.setUser("root");
-    conf.setPwd("taosdata");
+    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 user1");
+    await wsSql.exec("drop user user2");
+    await wsSql.exec("drop user token_user");
     await wsSql.close();
     wsConnectorPool_1.WebSocketConnectionPool.instance().destroyed();
 });