@tdengine/websocket 3.2.3 → 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/stmt2.failover.test.d.ts

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

package/lib/test/bulkPulling/stmt2.failover.test.d.ts.map

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

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

@@ -0,0 +1,313 @@
+"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 wsStmt2_1 = require("../../src/stmt/wsStmt2");
+const wsProto = __importStar(require("../../src/stmt/wsProto"));
+const Step = {
+    INIT: 0,
+    PREPARE: 1,
+    BIND: 2,
+    EXEC: 3,
+    RESULT: 4,
+};
+function createMockWsClient() {
+    return {
+        getState: jest.fn(() => 1),
+        connect: jest.fn(async () => { }),
+        checkVersion: jest.fn(async () => { }),
+        exec: jest.fn(async () => ({
+            totalTime: 0,
+            msg: {
+                code: 0,
+                message: "",
+                timing: 0,
+                stmt_id: 1,
+                is_insert: false,
+                fields_count: 1,
+            },
+        })),
+        execNoResp: jest.fn(async () => { }),
+        sendBinaryMsg: jest.fn(async () => ({
+            totalTime: 0,
+            msg: {
+                code: 0,
+                message: "",
+                timing: 0,
+                stmt_id: 1,
+                affected: 0,
+            },
+        })),
+        waitForReady: jest.fn(async () => { }),
+        isNetworkError: jest.fn((_err) => false),
+    };
+}
+function createBareStmt() {
+    const wsClient = createMockWsClient();
+    const stmt = new wsStmt2_1.WsStmt2(wsClient);
+    stmt._stmt_id = 1n;
+    return {
+        stmt,
+        wsClient,
+    };
+}
+function makeExecReady(stmt) {
+    const tableInfo = {
+        getParams: () => ({ ok: true }),
+    };
+    stmt._currentTableInfo = tableInfo;
+    stmt._stmtTableInfoList = [tableInfo];
+    stmt._toBeBindTagCount = 0;
+    stmt._toBeBindColCount = 0;
+    stmt._toBeBindTableNameIndex = undefined;
+}
+function makeSavedBindBytes(reqId = 0n, stmtId = 1n) {
+    const bytes = new ArrayBuffer(16);
+    const view = new DataView(bytes);
+    view.setBigUint64(0, reqId, true);
+    view.setBigUint64(8, stmtId, true);
+    return bytes;
+}
+describe("WsStmt2 failover", () => {
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    test("prepare caches sql and rebuilds on network error", async () => {
+        const { stmt, wsClient } = createBareStmt();
+        const networkError = new Error("socket closed");
+        wsClient.isNetworkError.mockReturnValue(true);
+        jest.spyOn(stmt, "doPrepare").mockRejectedValueOnce(networkError);
+        const rebuildSpy = jest
+            .spyOn(stmt, "rebuildContext")
+            .mockResolvedValue(undefined);
+        const sql = "select * from meters where ts > ?";
+        await stmt.prepare(sql);
+        expect(stmt._savedSql).toBe(sql);
+        expect(rebuildSpy).toHaveBeenCalledWith(Step.PREPARE);
+    });
+    test("exec caches bind bytes and rebuilds on network error", async () => {
+        const { stmt, wsClient } = createBareStmt();
+        const networkError = new Error("cannot call send() while not connected");
+        const bindBytes = new Uint8Array([1, 2, 3]).buffer;
+        makeExecReady(stmt);
+        stmt._isInsert = false;
+        wsClient.isNetworkError.mockReturnValue(true);
+        jest.spyOn(wsProto, "stmt2BinaryBlockEncode").mockReturnValue(bindBytes);
+        jest.spyOn(stmt, "doSendBindBytes").mockRejectedValueOnce(networkError);
+        jest.spyOn(stmt, "rebuildContext").mockResolvedValue(undefined);
+        const cleanupSpy = jest.spyOn(stmt, "cleanup");
+        await stmt.exec();
+        expect(stmt._savedBindBytes).toBe(bindBytes);
+        expect(stmt.rebuildContext).toHaveBeenCalledWith(Step.BIND);
+        expect(cleanupSpy).not.toHaveBeenCalled();
+    });
+    test("exec only cleans up immediately for insert statements", async () => {
+        const bindBytes = new Uint8Array([7, 8, 9]).buffer;
+        const insertCtx = createBareStmt();
+        const insertStmt = insertCtx.stmt;
+        makeExecReady(insertStmt);
+        insertStmt._isInsert = true;
+        jest.spyOn(wsProto, "stmt2BinaryBlockEncode").mockReturnValue(bindBytes);
+        jest.spyOn(insertStmt, "doSendBindBytes").mockResolvedValue(undefined);
+        jest.spyOn(insertStmt, "doExec").mockResolvedValue(undefined);
+        const insertCleanupSpy = jest.spyOn(insertStmt, "cleanup");
+        await insertStmt.exec();
+        expect(insertCleanupSpy).toHaveBeenCalledTimes(1);
+        const queryCtx = createBareStmt();
+        const queryStmt = queryCtx.stmt;
+        makeExecReady(queryStmt);
+        queryStmt._isInsert = false;
+        jest.spyOn(wsProto, "stmt2BinaryBlockEncode").mockReturnValue(bindBytes);
+        jest.spyOn(queryStmt, "doSendBindBytes").mockResolvedValue(undefined);
+        jest.spyOn(queryStmt, "doExec").mockResolvedValue(undefined);
+        const queryCleanupSpy = jest.spyOn(queryStmt, "cleanup");
+        await queryStmt.exec();
+        expect(queryCleanupSpy).not.toHaveBeenCalled();
+    });
+    test("exec cleans up insert cache even when failover rebuild fails", async () => {
+        const { stmt, wsClient } = createBareStmt();
+        const networkError = new Error("cannot call send() while not connected");
+        const rebuildError = new Error("rebuild failed");
+        const bindBytes = new Uint8Array([1, 2, 3]).buffer;
+        makeExecReady(stmt);
+        stmt._isInsert = true;
+        wsClient.isNetworkError.mockReturnValue(true);
+        jest.spyOn(wsProto, "stmt2BinaryBlockEncode").mockReturnValue(bindBytes);
+        jest.spyOn(stmt, "doSendBindBytes").mockRejectedValueOnce(networkError);
+        jest.spyOn(stmt, "rebuildContext").mockRejectedValueOnce(rebuildError);
+        const cleanupSpy = jest.spyOn(stmt, "cleanup");
+        await expect(stmt.exec()).rejects.toThrow("rebuild failed");
+        expect(cleanupSpy).toHaveBeenCalledTimes(1);
+    });
+    test("resultSet rebuilds on network error and cleans up", async () => {
+        const { stmt, wsClient } = createBareStmt();
+        const networkError = new Error("connection reset");
+        const rebuiltRows = { id: "rebuilt" };
+        wsClient.isNetworkError.mockReturnValue(true);
+        jest.spyOn(stmt, "doResult").mockRejectedValueOnce(networkError);
+        const rebuildSpy = jest
+            .spyOn(stmt, "rebuildContext")
+            .mockResolvedValue(rebuiltRows);
+        const cleanupSpy = jest.spyOn(stmt, "cleanup");
+        const result = await stmt.resultSet();
+        expect(result).toBe(rebuiltRows);
+        expect(rebuildSpy).toHaveBeenCalledWith(Step.RESULT);
+        expect(cleanupSpy).toHaveBeenCalledTimes(1);
+    });
+    test("non-network errors are rethrown without rebuild in prepare", async () => {
+        const { stmt, wsClient } = createBareStmt();
+        const nonNetworkError = new Error("invalid sql");
+        wsClient.isNetworkError.mockReturnValue(false);
+        jest.spyOn(stmt, "doPrepare").mockRejectedValueOnce(nonNetworkError);
+        const rebuildSpy = jest
+            .spyOn(stmt, "rebuildContext")
+            .mockResolvedValue(undefined);
+        await expect(stmt.prepare("bad sql")).rejects.toThrow("invalid sql");
+        expect(rebuildSpy).not.toHaveBeenCalled();
+    });
+    test("non-network errors are rethrown without rebuild in exec", async () => {
+        const { stmt, wsClient } = createBareStmt();
+        const bindBytes = new Uint8Array([4, 5, 6]).buffer;
+        const nonNetworkError = new Error("invalid bind");
+        makeExecReady(stmt);
+        stmt._isInsert = false;
+        wsClient.isNetworkError.mockReturnValue(false);
+        jest.spyOn(wsProto, "stmt2BinaryBlockEncode").mockReturnValue(bindBytes);
+        jest.spyOn(stmt, "doSendBindBytes").mockRejectedValueOnce(nonNetworkError);
+        const rebuildSpy = jest
+            .spyOn(stmt, "rebuildContext")
+            .mockResolvedValue(undefined);
+        await expect(stmt.exec()).rejects.toThrow("invalid bind");
+        expect(rebuildSpy).not.toHaveBeenCalled();
+    });
+    test("non-network errors are rethrown without rebuild in resultSet", async () => {
+        const { stmt, wsClient } = createBareStmt();
+        const nonNetworkError = new Error("result failed");
+        wsClient.isNetworkError.mockReturnValue(false);
+        jest.spyOn(stmt, "doResult").mockRejectedValueOnce(nonNetworkError);
+        const rebuildSpy = jest
+            .spyOn(stmt, "rebuildContext")
+            .mockResolvedValue(undefined);
+        await expect(stmt.resultSet()).rejects.toThrow("result failed");
+        expect(rebuildSpy).not.toHaveBeenCalled();
+    });
+    test("rebuildContext replays steps in order to EXEC", async () => {
+        const { stmt } = createBareStmt();
+        const callOrder = [];
+        stmt._savedSql = "insert into t values(?, ?)";
+        stmt._savedBindBytes = makeSavedBindBytes();
+        jest.spyOn(stmt, "doInit").mockImplementation(async () => {
+            callOrder.push("init");
+        });
+        jest.spyOn(stmt, "doPrepare").mockImplementation(async () => {
+            callOrder.push("prepare");
+        });
+        jest.spyOn(stmt, "doSendBindBytes").mockImplementation(async () => {
+            callOrder.push("bind");
+        });
+        jest.spyOn(stmt, "doExec").mockImplementation(async () => {
+            callOrder.push("exec");
+        });
+        jest.spyOn(stmt, "doResult").mockImplementation(async () => {
+            callOrder.push("result");
+            return { rows: 1 };
+        });
+        await stmt.rebuildContext(Step.EXEC);
+        expect(callOrder).toEqual(["init", "prepare", "bind", "exec"]);
+    });
+    test("rebuildContext can rebuild to RESULT and return rows", async () => {
+        const { stmt } = createBareStmt();
+        const rows = { data: [1, 2, 3] };
+        stmt._savedSql = "select * from t where ts > ?";
+        stmt._savedBindBytes = makeSavedBindBytes();
+        jest.spyOn(stmt, "doInit").mockResolvedValue(undefined);
+        jest.spyOn(stmt, "doPrepare").mockResolvedValue(undefined);
+        jest.spyOn(stmt, "doSendBindBytes").mockResolvedValue(undefined);
+        jest.spyOn(stmt, "doExec").mockResolvedValue(undefined);
+        jest.spyOn(stmt, "doResult").mockResolvedValue(rows);
+        const result = await stmt.rebuildContext(Step.RESULT);
+        expect(result).toBe(rows);
+    });
+    test("buildReplayBindBytes rewrites req_id and stmt_id", () => {
+        const { stmt } = createBareStmt();
+        const originalBytes = makeSavedBindBytes(0n, 5n);
+        stmt._savedBindBytes = originalBytes;
+        stmt._stmt_id = 42n;
+        const replayBytes = stmt.buildReplayBindBytes();
+        const originalView = new DataView(originalBytes);
+        const replayView = new DataView(replayBytes);
+        expect(replayBytes).not.toBe(originalBytes);
+        expect(originalView.getBigUint64(8, true)).toBe(5n);
+        expect(replayView.getBigUint64(8, true)).toBe(42n);
+        expect(replayView.getBigUint64(0, true)).not.toBe(0n);
+    });
+    test("rebuildContext retries when rebuild gets another network error", async () => {
+        const { stmt, wsClient } = createBareStmt();
+        const networkError = new Error("connection reset");
+        stmt._savedSql = "select * from t";
+        stmt._savedBindBytes = new Uint8Array([2, 4, 6]).buffer;
+        wsClient.isNetworkError.mockImplementation((err) => err === networkError);
+        const initSpy = jest
+            .spyOn(stmt, "doInit")
+            .mockRejectedValueOnce(networkError)
+            .mockResolvedValue(undefined);
+        const prepareSpy = jest.spyOn(stmt, "doPrepare").mockResolvedValue(undefined);
+        await stmt.rebuildContext(Step.PREPARE);
+        expect(initSpy).toHaveBeenCalledTimes(2);
+        expect(prepareSpy).toHaveBeenCalledTimes(1);
+        expect(wsClient.waitForReady).toHaveBeenCalledTimes(2);
+    });
+    test("rebuildContext throws after max network retry attempts", async () => {
+        const { stmt, wsClient } = createBareStmt();
+        const networkError = new Error("connection reset");
+        stmt._savedSql = "select * from t";
+        stmt._savedBindBytes = makeSavedBindBytes();
+        wsClient.isNetworkError.mockReturnValue(true);
+        const initSpy = jest
+            .spyOn(stmt, "doInit")
+            .mockRejectedValue(networkError);
+        await expect(stmt.rebuildContext(Step.INIT)).rejects.toThrow("connection reset");
+        expect(initSpy).toHaveBeenCalledTimes(3);
+        expect(wsClient.waitForReady).toHaveBeenCalledTimes(3);
+    });
+    test("rebuildContext throws on non-network error", async () => {
+        const { stmt, wsClient } = createBareStmt();
+        const nonNetworkError = new Error("permission denied");
+        stmt._savedSql = "select * from t";
+        stmt._savedBindBytes = new Uint8Array([9, 9, 9]).buffer;
+        wsClient.isNetworkError.mockReturnValue(false);
+        jest.spyOn(stmt, "doInit").mockRejectedValueOnce(nonNetworkError);
+        await expect(stmt.rebuildContext(Step.INIT)).rejects.toThrow("permission denied");
+    });
+});

package/lib/test/bulkPulling/stmt2.init.failover.test.d.ts

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

package/lib/test/bulkPulling/stmt2.init.failover.test.d.ts.map

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