@tdengine/websocket 3.2.2 → 3.3.0

package/lib/test/bulkPulling/stmt1.func.test.js

@@ -5,12 +5,13 @@ const config_1 = require("../../src/common/config");
 const log_1 = require("../../src/common/log");
 const wsSql_1 = require("../../src/sql/wsSql");
 const wsStmt1_1 = require("../../src/stmt/wsStmt1");
+const utils_1 = require("../utils");
 let dns = "ws://localhost:6041";
 (0, log_1.setLevel)("debug");
 beforeAll(async () => {
     let conf = new config_1.WSConfig(dns);
-    conf.setUser("root");
-    conf.setPwd("taosdata");
+    conf.setUser((0, utils_1.testUsername)());
+    conf.setPwd((0, utils_1.testPassword)());
     let wsSql = await wsSql_1.WsSql.open(conf);
     await wsSql.exec("drop database if exists power_func_stmt1;");
     await wsSql.exec("create database if not exists power_func_stmt1 KEEP 3650 DURATION 10 BUFFER 16 WAL_LEVEL 1;");
@@ -32,8 +33,8 @@ describe("TDWebSocket.Stmt()", () => {
     ];
     test("normal connect", async () => {
         let conf = new config_1.WSConfig(dns, "100.100.100.100");
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
         conf.setDb("power_func_stmt1");
         let connector = await wsSql_1.WsSql.open(conf);
         let stmt = await connector.stmtInit();
@@ -48,8 +49,8 @@ describe("TDWebSocket.Stmt()", () => {
         let connector = null;
         try {
             let conf = new config_1.WSConfig(dns, "100.100.100.100");
-            conf.setUser("root");
-            conf.setPwd("taosdata");
+            conf.setUser((0, utils_1.testUsername)());
+            conf.setPwd((0, utils_1.testPassword)());
             conf.setDb("jest");
             connector = await wsSql_1.WsSql.open(conf);
             let stmt = await connector.stmtInit();
@@ -67,8 +68,8 @@ describe("TDWebSocket.Stmt()", () => {
     });
     test("normal Prepare", async () => {
         let conf = new config_1.WSConfig(dns, "100.100.100.100");
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
         conf.setDb("power_func_stmt1");
         let connector = await wsSql_1.WsSql.open(conf);
         let stmt = await connector.stmtInit();
@@ -86,8 +87,8 @@ describe("TDWebSocket.Stmt()", () => {
     });
     test("set tag error", async () => {
         let conf = new config_1.WSConfig(dns, "100.100.100.100");
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
         conf.setDb("power_func_stmt1");
         let connector = await wsSql_1.WsSql.open(conf);
         let stmt = await connector.stmtInit();
@@ -109,8 +110,8 @@ describe("TDWebSocket.Stmt()", () => {
     });
     test("error Prepare table", async () => {
         let conf = new config_1.WSConfig(dns, "100.100.100.100");
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
         conf.setDb("power_func_stmt1");
         let connector = await wsSql_1.WsSql.open(conf);
         let stmt = await connector.stmtInit();
@@ -130,8 +131,8 @@ describe("TDWebSocket.Stmt()", () => {
     });
     test("error Prepare tag", async () => {
         let conf = new config_1.WSConfig(dns, "100.100.100.100");
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
         conf.setDb("power_func_stmt1");
         let connector = await wsSql_1.WsSql.open(conf);
         let stmt = await connector.stmtInit();
@@ -151,8 +152,8 @@ describe("TDWebSocket.Stmt()", () => {
     });
     test("Bind a single table", async () => {
         let conf = new config_1.WSConfig(dns, "100.100.100.100");
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
         conf.setDb("power_func_stmt1");
         let connector = await wsSql_1.WsSql.open(conf);
         let stmt = await connector.stmtInit();
@@ -186,8 +187,8 @@ describe("TDWebSocket.Stmt()", () => {
     });
     test("error BindParam", async () => {
         let conf = new config_1.WSConfig(dns, "100.100.100.100");
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
         conf.setDb("power_func_stmt1");
         let connector = await wsSql_1.WsSql.open(conf);
         let stmt = await connector.stmtInit();
@@ -225,8 +226,8 @@ describe("TDWebSocket.Stmt()", () => {
     });
     test("no Batch", async () => {
         let conf = new config_1.WSConfig(dns, "100.100.100.100");
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
         conf.setDb("power_func_stmt1");
         let connector = await wsSql_1.WsSql.open(conf);
         let stmt = await connector.stmtInit();
@@ -263,8 +264,8 @@ describe("TDWebSocket.Stmt()", () => {
     });
     test("Batch after BindParam", async () => {
         let conf = new config_1.WSConfig(dns, "100.100.100.100");
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
         conf.setDb("power_func_stmt1");
         let connector = await wsSql_1.WsSql.open(conf);
         let stmt = await connector.stmtInit();
@@ -315,8 +316,8 @@ describe("TDWebSocket.Stmt()", () => {
     });
     test("no set tag", async () => {
         let conf = new config_1.WSConfig(dns, "100.100.100.100");
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
         conf.setDb("power_func_stmt1");
         let connector = await wsSql_1.WsSql.open(conf);
         let stmt = await connector.stmtInit();
@@ -345,8 +346,8 @@ describe("TDWebSocket.Stmt()", () => {
     });
     test("normal binary BindParam", async () => {
         let conf = new config_1.WSConfig(dns, "100.100.100.100");
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
         conf.setDb("power_func_stmt1");
         let connector = await wsSql_1.WsSql.open(conf);
         let stmt = await connector.stmtInit();
@@ -374,8 +375,8 @@ describe("TDWebSocket.Stmt()", () => {
     });
     test("normal json BindParam", async () => {
         let conf = new config_1.WSConfig(dns, "100.100.100.100");
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
         conf.setDb("power_func_stmt1");
         let connector = await wsSql_1.WsSql.open(conf);
         let stmt = await connector.stmtInit();
@@ -408,8 +409,8 @@ describe("TDWebSocket.Stmt()", () => {
 });
 afterAll(async () => {
     let conf = new config_1.WSConfig(dns);
-    conf.setUser("root");
-    conf.setPwd("taosdata");
+    conf.setUser((0, utils_1.testUsername)());
+    conf.setPwd((0, utils_1.testPassword)());
     let wsSql = await wsSql_1.WsSql.open(conf);
     await wsSql.exec("drop database power_func_stmt1");
     await wsSql.close();

package/lib/test/bulkPulling/stmt1.type.test.js

@@ -148,7 +148,7 @@ const selectTable = `select * from ${table}`;
 const selectTableCN = `select * from ${tableCN}`;
 const selectJsonTable = `select * from ${jsonTable}`;
 const selectJsonTableCN = `select * from ${jsonTableCN}`;
-let dsn = "ws://root:taosdata@localhost:6041";
+let dsn = `ws://${(0, utils_1.testUsername)()}:${(0, utils_1.testPassword)()}@localhost:6041`;
 (0, log_1.setLevel)("debug");
 beforeAll(async () => {
     let conf = new config_1.WSConfig(dsn);

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");
+    });
+});