@tdengine/websocket 3.2.2 → 3.3.0

package/lib/test/bulkPulling/urlParser.test.js

@@ -0,0 +1,452 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const urlParser_1 = require("../../src/common/urlParser");
+describe("urlParser", () => {
+    describe("parseMultiHostUrl", () => {
+        test("single host with port", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@localhost:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("single host with database", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@localhost:6041/power");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("power");
+            expect(result.params.size).toBe(0);
+        });
+        test("multiple hosts", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("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.hosts).toHaveLength(3);
+            expect(result.hosts[0]).toEqual({ host: "host1", port: 6041 });
+            expect(result.hosts[1]).toEqual({ host: "host2", port: 6042 });
+            expect(result.hosts[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, urlParser_1.parseMultiHostUrl)("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.hosts).toHaveLength(2);
+            expect(result.hosts[0]).toEqual({ host: "[::1]", port: 6041 });
+            expect(result.hosts[1]).toEqual({ host: "host2", port: 6042 });
+            expect(result.database).toBe("db");
+            expect(result.params.size).toBe(0);
+        });
+        test("multiple IPv6 addresses", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("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.hosts).toHaveLength(2);
+            expect(result.hosts[0]).toEqual({ host: "[::1]", port: 6041 });
+            expect(result.hosts[1]).toEqual({ host: "[fe80::1]", port: 6042 });
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("wss scheme", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("wss://root:taosdata@localhost:6041");
+            expect(result.scheme).toBe("wss");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("query parameters", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("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.hosts).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 hosts", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("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.hosts).toHaveLength(2);
+            expect(result.hosts[0]).toEqual({ host: "host1", port: 6041 });
+            expect(result.hosts[1]).toEqual({ host: "host2", port: 6042 });
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("no user info", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://host1:6041?token=mytoken");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("");
+            expect(result.password).toBe("");
+            expect(result.hosts).toEqual([{ host: "host1", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.get("token")).toBe("mytoken");
+        });
+        test("username only (no password)", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root@host1:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("");
+            expect(result.hosts).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, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@myhost");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "myhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("complex URL with all features", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("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.hosts).toHaveLength(3);
+            expect(result.hosts[0]).toEqual({ host: "host1", port: 6041 });
+            expect(result.hosts[1]).toEqual({ host: "host2", port: 6042 });
+            expect(result.hosts[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, urlParser_1.parseMultiHostUrl)("ws://root:@localhost:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("database with special characters", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("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.hosts).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, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@localhost:6041/");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("multiple hosts without ports use default", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1,host2,host3");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toHaveLength(3);
+            expect(result.hosts[0]).toEqual({ host: "host1", port: 6041 });
+            expect(result.hosts[1]).toEqual({ host: "host2", port: 6041 });
+            expect(result.hosts[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, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@[::1]");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "[::1]", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("scheme is case insensitive", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("WS://root:taosdata@localhost:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("WSS scheme is case insensitive", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("WSS://root:taosdata@localhost:6041");
+            expect(result.scheme).toBe("wss");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("single query parameter", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@localhost:6041?token=abc123");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(1);
+            expect(result.params.get("token")).toBe("abc123");
+        });
+        test("database with query parameters", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("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.hosts).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, urlParser_1.parseMultiHostUrl)("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.hosts).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, urlParser_1.parseMultiHostUrl)("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.hosts).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, urlParser_1.parseMultiHostUrl)("ws://:pass@localhost:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("");
+            expect(result.password).toBe("pass");
+            expect(result.hosts).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, urlParser_1.parseMultiHostUrl)("ws://:taosdata@localhost:6041/mydb");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).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, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).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, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@127.0.1.0:");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "127.0.1.0", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("multiple hosts with empty ports use default", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("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.hosts).toHaveLength(3);
+            expect(result.hosts[0]).toEqual({ host: "host1", port: 6041 });
+            expect(result.hosts[1]).toEqual({ host: "host2", port: 6041 });
+            expect(result.hosts[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, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@localhost:1");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).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, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@localhost:65535");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).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, urlParser_1.parseMultiHostUrl)(`ws://${longUsername}:pass@localhost:6041`);
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe(longUsername);
+            expect(result.password).toBe("pass");
+            expect(result.hosts).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, urlParser_1.parseMultiHostUrl)(`ws://user:${longPassword}@localhost:6041`);
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("user");
+            expect(result.password).toBe(longPassword);
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("many hosts", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("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.hosts).toHaveLength(8);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("many query parameters", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("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.hosts).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, urlParser_1.parseMultiHostUrl)("")).toThrow("URL must not be empty");
+        });
+        test("whitespace only URL throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("   ")).toThrow("URL must not be empty");
+        });
+        test("invalid scheme throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("http://host:6041")).toThrow("Invalid URL scheme");
+        });
+        test("missing scheme throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("root:taosdata@host:6041")).toThrow("Invalid URL scheme");
+        });
+        test("unclosed IPv6 bracket throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@[::1:6041")).toThrow("Unclosed bracket");
+        });
+        test("invalid port throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:abc")).toThrow("Invalid port");
+        });
+        test("port out of range throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:70000")).toThrow("Invalid port");
+        });
+        test("port zero throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:0")).toThrow("Invalid port");
+        });
+        test("negative port throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:-1")).toThrow("Invalid port");
+        });
+        test("port with spaces throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:60 41")).toThrow("Invalid port");
+        });
+        test("IPv6 with unclosed bracket in middle of host list throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:6041,[::1:6042,host2:6043")).toThrow("Unclosed bracket");
+        });
+    });
+    describe("buildHostUrl", () => {
+        test("builds single host URL with /ws path", () => {
+            const parsed = {
+                hosts: [{ host: "host1", port: 6041 }],
+                scheme: "ws",
+                username: "root",
+                password: "taosdata",
+                database: "mydb",
+                params: new Map([["timezone", "UTC"]]),
+            };
+            const url = (0, urlParser_1.buildHostUrl)(parsed, parsed.hosts[0]);
+            expect(url.origin).toBe("ws://host1:6041");
+            expect(url.pathname).toBe("/ws");
+            expect(url.username).toBe("root");
+            expect(url.password).toBe("taosdata");
+            expect(url.searchParams.get("timezone")).toBe("UTC");
+        });
+        test("excludes retry params from URL", () => {
+            const parsed = {
+                hosts: [{ host: "host1", port: 6041 }],
+                scheme: "ws",
+                username: "root",
+                password: "taosdata",
+                database: "",
+                params: new Map([
+                    ["retries", "5"],
+                    ["retry_backoff_ms", "200"],
+                    ["timezone", "UTC"],
+                ]),
+            };
+            const url = (0, urlParser_1.buildHostUrl)(parsed, parsed.hosts[0]);
+            expect(url.searchParams.has("retries")).toBe(false);
+            expect(url.searchParams.has("retry_backoff_ms")).toBe(false);
+            expect(url.searchParams.get("timezone")).toBe("UTC");
+        });
+        test("adds extra params", () => {
+            const parsed = {
+                hosts: [{ host: "host1", port: 6041 }],
+                scheme: "wss",
+                username: "",
+                password: "",
+                database: "",
+                params: new Map(),
+            };
+            const extras = new Map([["token", "abc123"]]);
+            const url = (0, urlParser_1.buildHostUrl)(parsed, parsed.hosts[0], extras);
+            expect(url.searchParams.get("token")).toBe("abc123");
+            expect(url.protocol).toBe("wss:");
+        });
+    });
+    describe("extractRetryOptions", () => {
+        test("extracts all retry params", () => {
+            const params = new Map([
+                ["retries", "5"],
+                ["retry_backoff_ms", "300"],
+                ["retry_backoff_max_ms", "5000"],
+                ["resend_write", "true"],
+            ]);
+            const opts = (0, urlParser_1.extractRetryOptions)(params);
+            expect(opts.retries).toBe(5);
+            expect(opts.retryBackoffMs).toBe(300);
+            expect(opts.retryBackoffMaxMs).toBe(5000);
+            expect(opts.resendWrite).toBe(true);
+        });
+        test("returns empty object for no params", () => {
+            const opts = (0, urlParser_1.extractRetryOptions)(new Map());
+            expect(opts.retries).toBeUndefined();
+            expect(opts.retryBackoffMs).toBeUndefined();
+        });
+        test("resend_write false values", () => {
+            expect((0, urlParser_1.extractRetryOptions)(new Map([["resend_write", "false"]])).resendWrite).toBe(false);
+            expect((0, urlParser_1.extractRetryOptions)(new Map([["resend_write", "0"]])).resendWrite).toBe(false);
+        });
+    });
+});

package/lib/test/bulkPulling/wsClient.reconnect.integration.test.d.ts

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

package/lib/test/bulkPulling/wsClient.reconnect.integration.test.d.ts.map

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

package/lib/test/bulkPulling/wsClient.reconnect.integration.test.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function createMockWebsocketState() {
+    let behaviors = [];
+    let sendLog = [];
+    let socketCounter = 0;
+    class FakeWebSocket {
+        constructor(url) {
+            this.readyState = FakeWebSocket.CONNECTING;
+            this.url = url;
+            this.id = ++socketCounter;
+            this.behavior = behaviors.shift() || {};
+            setTimeout(() => {
+                if (this.behavior.openFails) {
+                    this.readyState = FakeWebSocket.CLOSED;
+                    this.onerror?.(new Error("open failed"));
+                    this.onclose?.({ code: 1006, reason: "open failed" });
+                    return;
+                }
+                this.readyState = FakeWebSocket.OPEN;
+                this.onopen?.();
+            }, 0);
+        }
+        send(data) {
+            if (typeof data !== "string") {
+                throw new Error("binary is not supported in this fake");
+            }
+            const parsed = JSON.parse(data);
+            const action = parsed.action || "";
+            sendLog.push({ socketId: this.id, action, raw: data });
+            if (this.behavior.disconnectOnActions?.includes(action)) {
+                this.readyState = FakeWebSocket.CLOSED;
+                if (this.behavior.emitErrorBeforeClose) {
+                    this.onerror?.(new Error("simulated disconnection"));
+                }
+                this.onclose?.({
+                    code: 1006,
+                    reason: "simulated disconnection",
+                });
+                throw new Error("simulated disconnection");
+            }
+            setTimeout(() => {
+                const reqId = parsed?.args?.req_id;
+                this.onmessage?.({
+                    data: JSON.stringify({
+                        action,
+                        req_id: reqId,
+                        code: 0,
+                        message: "ok",
+                    }),
+                });
+            }, 0);
+        }
+        close() {
+            this.readyState = FakeWebSocket.CLOSED;
+            this.onclose?.({ code: 1000, reason: "normal close" });
+        }
+    }
+    FakeWebSocket.CONNECTING = 0;
+    FakeWebSocket.OPEN = 1;
+    FakeWebSocket.CLOSING = 2;
+    FakeWebSocket.CLOSED = 3;
+    return {
+        FakeWebSocket,
+        reset() {
+            behaviors = [];
+            sendLog = [];
+            socketCounter = 0;
+        },
+        setBehaviors(nextBehaviors) {
+            behaviors = [...nextBehaviors];
+        },
+        getSendLog() {
+            return [...sendLog];
+        },
+        getSocketCount() {
+            return socketCounter;
+        },
+    };
+}
+var mockWebsocketState;
+jest.mock("websocket", () => ({
+    w3cwebsocket: (() => {
+        mockWebsocketState = createMockWebsocketState();
+        return mockWebsocketState.FakeWebSocket;
+    })(),
+}));
+const dsn_1 = require("../../src/common/dsn");
+const wsClient_1 = require("../../src/client/wsClient");
+const wsConnectorPool_1 = require("../../src/client/wsConnectorPool");
+const constant_1 = require("../../src/common/constant");
+const wsEventCallback_1 = require("../../src/client/wsEventCallback");
+function resetPoolSingleton() {
+    const PoolClass = wsConnectorPool_1.WebSocketConnectionPool;
+    if (PoolClass._instance) {
+        PoolClass._instance.destroyed();
+        PoolClass._instance = undefined;
+    }
+}
+function resetEventCallbacks() {
+    wsEventCallback_1.WsEventCallback._msgActionRegister = new Map();
+}
+describe("WsClient reconnect integration", () => {
+    beforeEach(() => {
+        mockWebsocketState.reset();
+        resetPoolSingleton();
+        resetEventCallbacks();
+        jest.spyOn(Math, "random").mockReturnValue(0);
+    });
+    afterEach(async () => {
+        jest.restoreAllMocks();
+        mockWebsocketState.reset();
+        resetEventCallbacks();
+        resetPoolSingleton();
+    });
+    test("recovers conn/options context before replaying inflight insert", async () => {
+        mockWebsocketState.setBehaviors([
+            { disconnectOnActions: ["insert"] },
+            {},
+        ]);
+        const dsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041,host2:6042/mydb?timezone=UTC&retries=1&retry_backoff_ms=1");
+        const client = new wsClient_1.WsClient(dsn, 1000);
+        await client.connect("mydb");
+        await client.setOptionConnection(constant_1.TSDB_OPTION_CONNECTION.TSDB_OPTION_CONNECTION_TIMEZONE, "UTC");
+        const pending = client.exec(JSON.stringify({
+            action: "insert",
+            args: {
+                req_id: 999001,
+                data: "insert into t values(now, 1)",
+            },
+        }), false);
+        await expect(pending).resolves.toBeDefined();
+        const secondSocketActions = mockWebsocketState
+            .getSendLog()
+            .filter((entry) => entry.socketId === 2)
+            .map((entry) => entry.action);
+        expect(secondSocketActions[0]).toBe("conn");
+        expect(secondSocketActions[1]).toBe("options_connection");
+        expect(secondSocketActions[2]).toBe("insert");
+        expect(mockWebsocketState.getSocketCount()).toBe(2);
+        await client.close();
+    });
+    test("deduplicates reconnect when both onerror and onclose are raised", async () => {
+        mockWebsocketState.setBehaviors([
+            {
+                disconnectOnActions: ["insert"],
+                emitErrorBeforeClose: true,
+            },
+            {},
+        ]);
+        const dsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041,host2:6042/mydb?retries=1&retry_backoff_ms=1");
+        const client = new wsClient_1.WsClient(dsn, 1000);
+        await client.connect("mydb");
+        const pending = client.exec(JSON.stringify({
+            action: "insert",
+            args: {
+                req_id: 999002,
+                data: "insert into t values(now, 2)",
+            },
+        }), false);
+        await expect(pending).resolves.toBeDefined();
+        expect(mockWebsocketState.getSocketCount()).toBe(2);
+        await client.close();
+    });
+    test("rejects retriable inflight request when all reconnect attempts fail", async () => {
+        mockWebsocketState.setBehaviors([
+            { disconnectOnActions: ["insert"] },
+            { openFails: true },
+            { openFails: true },
+        ]);
+        const dsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041,host2:6042/mydb?retries=0&retry_backoff_ms=1");
+        const client = new wsClient_1.WsClient(dsn, 200);
+        await client.connect("mydb");
+        const pending = client.exec(JSON.stringify({
+            action: "insert",
+            args: {
+                req_id: 999003,
+                data: "insert into t values(now, 3)",
+            },
+        }), false);
+        await expect(pending).rejects.toThrow("Failed to reconnect to any available address");
+        await client.close();
+    });
+});

package/lib/test/bulkPulling/wsClient.recovery.test.d.ts

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

package/lib/test/bulkPulling/wsClient.recovery.test.d.ts.map

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