@tdengine/websocket 3.2.2 → 3.3.0

package/lib/test/common/dsn.test.js

@@ -0,0 +1,406 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dsn_1 = require("@src/common/dsn");
+describe("dsn", () => {
+    describe("parse", () => {
+        test("single host with port", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+            expect(result.endpoint).toBe(dsn_1.WS_SQL_ENDPOINT);
+        });
+        test("single host with database", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041/power");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("power");
+            expect(result.params.size).toBe(0);
+        });
+        test("multiple addresses", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@host1:6041,host2:6042,host3:6043/mydb");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toHaveLength(3);
+            expect(result.addresses[0]).toEqual({ host: "host1", port: 6041 });
+            expect(result.addresses[1]).toEqual({ host: "host2", port: 6042 });
+            expect(result.addresses[2]).toEqual({ host: "host3", port: 6043 });
+            expect(result.database).toBe("mydb");
+            expect(result.params.size).toBe(0);
+        });
+        test("IPv6 address in brackets", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@[::1]:6041,host2:6042/db");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toHaveLength(2);
+            expect(result.addresses[0]).toEqual({ host: "[::1]", port: 6041 });
+            expect(result.addresses[1]).toEqual({ host: "host2", port: 6042 });
+            expect(result.database).toBe("db");
+            expect(result.params.size).toBe(0);
+        });
+        test("multiple IPv6 addresses", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@[::1]:6041,[fe80::1]:6042");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toHaveLength(2);
+            expect(result.addresses[0]).toEqual({ host: "[::1]", port: 6041 });
+            expect(result.addresses[1]).toEqual({ host: "[fe80::1]", port: 6042 });
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("wss scheme", () => {
+            const result = (0, dsn_1.parse)("wss://root:taosdata@localhost:6041");
+            expect(result.scheme).toBe("wss");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("query parameters", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@host1:6041/db?retries=5&retry_backoff_ms=300&timezone=UTC");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "host1", port: 6041 }]);
+            expect(result.database).toBe("db");
+            expect(result.params.get("retries")).toBe("5");
+            expect(result.params.get("retry_backoff_ms")).toBe("300");
+            expect(result.params.get("timezone")).toBe("UTC");
+        });
+        test("deduplicates addresses", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@host1:6041,host2:6042,host1:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toHaveLength(2);
+            expect(result.addresses[0]).toEqual({ host: "host1", port: 6041 });
+            expect(result.addresses[1]).toEqual({ host: "host2", port: 6042 });
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("no user info", () => {
+            const result = (0, dsn_1.parse)("ws://host1:6041?token=mytoken");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("");
+            expect(result.password).toBe("");
+            expect(result.addresses).toEqual([{ host: "host1", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.get("token")).toBe("mytoken");
+        });
+        test("username only (no password)", () => {
+            const result = (0, dsn_1.parse)("ws://root@host1:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("");
+            expect(result.addresses).toEqual([{ host: "host1", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("host without port uses default 6041", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@myhost");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "myhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("complex URL with all features", () => {
+            const result = (0, dsn_1.parse)("ws://user:p%40ss@host1:6041,host2:6042,[::1]:6043/testdb?retries=5&retry_backoff_ms=100&retry_backoff_max_ms=5000&resend_write=true&token=abc");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("user");
+            expect(result.password).toBe("p%40ss");
+            expect(result.addresses).toHaveLength(3);
+            expect(result.addresses[0]).toEqual({ host: "host1", port: 6041 });
+            expect(result.addresses[1]).toEqual({ host: "host2", port: 6042 });
+            expect(result.addresses[2]).toEqual({ host: "[::1]", port: 6043 });
+            expect(result.database).toBe("testdb");
+            expect(result.params.get("retries")).toBe("5");
+            expect(result.params.get("retry_backoff_ms")).toBe("100");
+            expect(result.params.get("retry_backoff_max_ms")).toBe("5000");
+            expect(result.params.get("resend_write")).toBe("true");
+            expect(result.params.get("token")).toBe("abc");
+        });
+        // Additional normal test cases
+        test("empty password with colon", () => {
+            const result = (0, dsn_1.parse)("ws://root:@localhost:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("");
+            expect(result.addresses).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("database with special characters", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041/test_db-123");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("test_db-123");
+            expect(result.params.size).toBe(0);
+        });
+        test("empty database path with slash", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041/");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("multiple addresses without ports use default", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@host1,host2,host3");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toHaveLength(3);
+            expect(result.addresses[0]).toEqual({ host: "host1", port: 6041 });
+            expect(result.addresses[1]).toEqual({ host: "host2", port: 6041 });
+            expect(result.addresses[2]).toEqual({ host: "host3", port: 6041 });
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("IPv6 without port uses default", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@[::1]");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "[::1]", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("scheme is case insensitive", () => {
+            const result = (0, dsn_1.parse)("WS://root:taosdata@localhost:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("WSS scheme is case insensitive", () => {
+            const result = (0, dsn_1.parse)("WSS://root:taosdata@localhost:6041");
+            expect(result.scheme).toBe("wss");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("single query parameter", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041?token=abc123");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(1);
+            expect(result.params.get("token")).toBe("abc123");
+        });
+        test("does not parse @ in query parameter as userinfo delimiter", () => {
+            const result = (0, dsn_1.parse)("ws://localhost:6041?bearer_token=a@b");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("");
+            expect(result.password).toBe("");
+            expect(result.addresses).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.get("bearer_token")).toBe("a@b");
+        });
+        test("database with query parameters", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041/mydb?timezone=UTC");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("mydb");
+            expect(result.params.get("timezone")).toBe("UTC");
+        });
+        test("full IPv6 address (not abbreviated)", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "[2001:0db8:85a3:0000:0000:8a2e:0370:7334]", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("full IPv6 address without port uses default", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "[2001:0db8:85a3:0000:0000:8a2e:0370:7334]", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("no username only password", () => {
+            const result = (0, dsn_1.parse)("ws://:pass@localhost:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("");
+            expect(result.password).toBe("pass");
+            expect(result.addresses).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("no username only password with database", () => {
+            const result = (0, dsn_1.parse)("ws://:taosdata@localhost:6041/mydb");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("mydb");
+            expect(result.params.size).toBe(0);
+        });
+        test("empty port uses default 6041", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@host1:");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "host1", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("IPv4 with empty port uses default 6041", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@127.0.1.0:");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "127.0.1.0", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("multiple addresses with empty ports use default", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@host1:,host2:,127.0.0.1:");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toHaveLength(3);
+            expect(result.addresses[0]).toEqual({ host: "host1", port: 6041 });
+            expect(result.addresses[1]).toEqual({ host: "host2", port: 6041 });
+            expect(result.addresses[2]).toEqual({ host: "127.0.0.1", port: 6041 });
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        // Boundary test cases
+        test("port boundary - minimum valid port 1", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@localhost:1");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "localhost", port: 1 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("port boundary - maximum valid port 65535", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@localhost:65535");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "localhost", port: 65535 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("very long username", () => {
+            const longUsername = "a".repeat(100);
+            const result = (0, dsn_1.parse)(`ws://${longUsername}:pass@localhost:6041`);
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe(longUsername);
+            expect(result.password).toBe("pass");
+            expect(result.addresses).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("very long password", () => {
+            const longPassword = "p".repeat(100);
+            const result = (0, dsn_1.parse)(`ws://user:${longPassword}@localhost:6041`);
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("user");
+            expect(result.password).toBe(longPassword);
+            expect(result.addresses).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("many addresses", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@h1:6041,h2:6042,h3:6043,h4:6044,h5:6045,h6:6046,h7:6047,h8:6048");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toHaveLength(8);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("many query parameters", () => {
+            const result = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041?p1=v1&p2=v2&p3=v3&p4=v4&p5=v5");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.addresses).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(5);
+            expect(result.params.get("p1")).toBe("v1");
+            expect(result.params.get("p5")).toBe("v5");
+        });
+        // Exception test cases
+        test("empty URL throws", () => {
+            expect(() => (0, dsn_1.parse)("")).toThrow("URL must not be empty");
+        });
+        test("whitespace only URL throws", () => {
+            expect(() => (0, dsn_1.parse)("   ")).toThrow("URL must not be empty");
+        });
+        test("invalid scheme throws", () => {
+            expect(() => (0, dsn_1.parse)("http://host:6041")).toThrow("Invalid URL scheme");
+        });
+        test("missing scheme throws", () => {
+            expect(() => (0, dsn_1.parse)("root:taosdata@host:6041")).toThrow("Invalid URL scheme");
+        });
+        test("unclosed IPv6 bracket throws", () => {
+            expect(() => (0, dsn_1.parse)("ws://root:taosdata@[::1:6041")).toThrow("Unclosed bracket");
+        });
+        test("invalid port throws", () => {
+            expect(() => (0, dsn_1.parse)("ws://root:taosdata@host1:abc")).toThrow("Invalid port");
+        });
+        test("port out of range throws", () => {
+            expect(() => (0, dsn_1.parse)("ws://root:taosdata@host1:70000")).toThrow("Invalid port");
+        });
+        test("port zero throws", () => {
+            expect(() => (0, dsn_1.parse)("ws://root:taosdata@host1:0")).toThrow("Invalid port");
+        });
+        test("negative port throws", () => {
+            expect(() => (0, dsn_1.parse)("ws://root:taosdata@host1:-1")).toThrow("Invalid port");
+        });
+        test("port with spaces throws", () => {
+            expect(() => (0, dsn_1.parse)("ws://root:taosdata@host1:60 41")).toThrow("Invalid port");
+        });
+        test("IPv6 with unclosed bracket in middle of host list throws", () => {
+            expect(() => (0, dsn_1.parse)("ws://root:taosdata@host1:6041,[::1:6042,host2:6043")).toThrow("Unclosed bracket");
+        });
+    });
+    describe("toString", () => {
+        test("masks password and sensitive params", () => {
+            const dsn = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041/mydb?token=t1&bearer_token=b1&td.connect.token=c1&timezone=UTC");
+            const masked = JSON.parse(dsn.toString());
+            expect(masked.password).toBe("[REDACTED]");
+            expect(masked.params.token).toBe("[REDACTED]");
+            expect(masked.params.bearer_token).toBe("[REDACTED]");
+            expect(masked.params["td.connect.token"]).toBe("[REDACTED]");
+            expect(masked.params.timezone).toBe("UTC");
+        });
+        test("treats sensitive param keys as case-insensitive", () => {
+            const dsn = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041?Token=t1&Bearer_Token=b1&TD.CONNECT.TOKEN=c1");
+            const masked = JSON.parse(dsn.toString());
+            expect(masked.params.Token).toBe("[REDACTED]");
+            expect(masked.params.Bearer_Token).toBe("[REDACTED]");
+            expect(masked.params["TD.CONNECT.TOKEN"]).toBe("[REDACTED]");
+        });
+    });
+});

package/lib/test/common/log.test.d.ts

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

package/lib/test/common/log.test.d.ts.map

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

package/lib/test/common/log.test.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = __importStar(require("@src/common/log"));
+describe("log level print", () => {
+    test("normal connect", async () => {
+        log_1.default.info("log level is info");
+        log_1.default.debug("log level is debug");
+        log_1.default.error("log level is error");
+        let isLevel = log_1.default.isLevelEnabled("info");
+        expect(isLevel).toEqual(true);
+        (0, log_1.setLevel)("debug");
+        log_1.default.debug("log level is debug");
+        isLevel = log_1.default.isLevelEnabled("debug");
+        expect(isLevel).toEqual(true);
+        (0, log_1.setLevel)("error");
+        log_1.default.error("log level is error");
+        log_1.default.debug("log level is debug");
+        isLevel = log_1.default.isLevelEnabled("error");
+        expect(isLevel).toEqual(true);
+    });
+});

package/lib/test/common/utils.test.d.ts

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

package/lib/test/common/utils.test.d.ts.map

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

package/lib/test/common/utils.test.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@src/common/utils");
+describe("utils test", () => {
+    test("compare versions test", async () => {
+        expect((0, utils_1.compareVersions)("3.3.6.3-alpha", "3.3.6.2")).toBe(1);
+        expect((0, utils_1.compareVersions)("3.3.6.2", "3.3.6.3")).toBe(-1);
+        expect((0, utils_1.compareVersions)("3.3.6.3", "3.3.6.3")).toBe(0);
+        expect((0, utils_1.compareVersions)("3.3.6.3", "3.3.6.3-alpha")).toBe(1);
+        expect((0, utils_1.compareVersions)("3.3.6.3-beta", "3.3.6.3-alpha")).toBe(1);
+        expect((0, utils_1.compareVersions)("3.3", "3.3.0.0")).toBe(0);
+    });
+});

package/lib/test/common/wsConfig.dsn.test.d.ts

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

package/lib/test/common/wsConfig.dsn.test.d.ts.map

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

package/lib/test/common/wsConfig.dsn.test.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("@src/common/config");
+const utils_1 = require("@src/common/utils");
+const dsn_1 = require("@src/common/dsn");
+describe("WSConfig to Dsn conversion", () => {
+    test("parses multi-address dsn and keeps connector-level params", () => {
+        const conf = new config_1.WSConfig("ws://root:taosdata@host1:6041,host2:6042/mydb?retries=5&retry_backoff_ms=120&timezone=UTC");
+        const dsn = (0, utils_1.getDsn)(conf);
+        expect(dsn.scheme).toBe("ws");
+        expect(dsn.addresses).toEqual([
+            { host: "host1", port: 6041 },
+            { host: "host2", port: 6042 },
+        ]);
+        expect(dsn.database).toBe("mydb");
+        expect(dsn.endpoint).toBe(dsn_1.WS_SQL_ENDPOINT);
+        expect(dsn.params.get("retries")).toBe("5");
+        expect(dsn.params.get("retry_backoff_ms")).toBe("120");
+        expect(dsn.params.get("timezone")).toBe("UTC");
+        expect(conf.getDb()).toBe("mydb");
+        expect(conf.getTimezone()).toBe("UTC");
+    });
+    test("applies WSConfig overrides on top of dsn", () => {
+        const conf = new config_1.WSConfig("ws://root:taosdata@host1:6041/mydb");
+        conf.setUser("admin");
+        conf.setPwd("secret");
+        conf.setToken("token-1");
+        conf.setBearerToken("bearer-1");
+        conf.setTimezone("Asia/Shanghai");
+        conf.setDb("override_db");
+        const dsn = (0, utils_1.getDsn)(conf);
+        expect(dsn.username).toBe("admin");
+        expect(dsn.password).toBe("secret");
+        expect(dsn.database).toBe("override_db");
+        expect(dsn.params.get("token")).toBe("token-1");
+        expect(dsn.params.get("bearer_token")).toBe("bearer-1");
+        expect(dsn.params.get("timezone")).toBe("Asia/Shanghai");
+    });
+});

package/lib/test/helpers/utils.d.ts

@@ -0,0 +1,27 @@
+import { TDengineMeta } from "@src/common/taosResult";
+export declare function getInsertBind(valuesLen: number, tagsLen: number, db: string, stable: string): string;
+export declare function insertStable(values: Array<Array<any>>, tags: Array<any>, stable: string, table?: string): string;
+export declare function insertNTable(values: Array<Array<any>>, table: string): string;
+export declare const tableMeta: Array<TDengineMeta>;
+export declare const jsonMeta: Array<TDengineMeta>;
+export declare const tagMeta: Array<TDengineMeta>;
+export declare function createBaseSTable(stable: string): string;
+export declare function createBaseSTableJSON(stable: string): string;
+export declare function createBaseTable(table: string): string;
+export declare function createSTable(stable: string): string;
+export declare function createSTableJSON(stable: string): string;
+export declare function createTable(table: string): string;
+export declare function expectStableData(rows: Array<Array<any>>, tags: Array<any>): Array<Array<any>>;
+export declare function hexToBytes(hex: string): ArrayBuffer;
+export declare function compareUint8Arrays(arr1: Uint8Array, arr2: Uint8Array): boolean;
+export declare function Sleep(ms: number): Promise<void>;
+export declare function testUsername(): string;
+export declare function testPassword(): string;
+export declare function testCloudUrl(): string | undefined;
+export declare function testCloudToken(): string | undefined;
+export declare function testCloudWsUrl(): string | undefined;
+export declare function hasTestCloudEnv(): boolean;
+export declare const testCloud: jest.It;
+export declare const testEnterprise: jest.It;
+export declare const testNon3360: jest.It;
+//# sourceMappingURL=utils.d.ts.map

package/lib/test/helpers/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../test/helpers/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEtD,wBAAgB,aAAa,CACzB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,GACf,MAAM,CAcR;AAED,wBAAgB,YAAY,CACxB,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EACzB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,EAChB,MAAM,EAAE,MAAM,EACd,KAAK,GAAE,MAAgB,GACxB,MAAM,CAkCR;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAqB7E;AAED,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,YAAY,CAsFzC,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,YAAY,CAMxC,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,KAAK,CAAC,YAAY,CAkEvC,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAKvD;AACD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAK3D;AACD,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAKnD;AACD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAKvD;AACD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,wBAAgB,gBAAgB,CAC5B,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EACvB,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,GACjB,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAMnB;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAQnD;AAED,wBAAgB,kBAAkB,CAC9B,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,UAAU,GACjB,OAAO,CAYT;AAED,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED,wBAAgB,YAAY,IAAI,MAAM,GAAG,SAAS,CAGjD;AAED,wBAAgB,cAAc,IAAI,MAAM,GAAG,SAAS,CAGnD;AAED,wBAAgB,cAAc,IAAI,MAAM,GAAG,SAAS,CAOnD;AAED,wBAAgB,eAAe,IAAI,OAAO,CAEzC;AAED,eAAO,MAAM,SAAS,SAAuC,CAAC;AAC9D,eAAO,MAAM,cAAc,SAA2E,CAAC;AACvG,eAAO,MAAM,WAAW,SAAqE,CAAC"}