test: consolidate error-path coverage from overlapping Jules PRs

Several Jules PRs added distinct error-path tests to the same test files,
making them mutually conflicting on GitHub. This consolidates the distinct
cases into one change (dropping overlaps):

- databaseModel: save/saveAs writeToFile -> serializeDatabase fallback (#409);
  undo/redo modification error handling (#378)
- sqlite-db: createDatabaseEngine file-read errors (#392); safeRollback
  warn-on-error (#389); executeQuery iteration error frees statement (#384)
- nativeWorker: export NativeWorkerProcess + handleData deserialization-error
  logging (#407); createNativeDatabaseConnection error context (#412)
- tableExporter: stream-write -> memory export fallback (#400); export error
  surfacing (#388)

Subsumes #404/#368 (covered by #409) and #393 (covered by #378).
Unit suite: 311 passing (was 299).

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: 3 people

src/nativeWorker.ts

@@ -157,7 +157,7 @@ function writeMessage(stream: NodeJS.WritableStream, msg: unknown): void {
  *
  * Manages the txiki-js child process and provides RPC-style communication.
  */
-class NativeWorkerProcess {
+export class NativeWorkerProcess {
   private process: ChildProcess | null = null;
   private messageId = 0;
   private pendingRequests = new Map<number, {

tests/unit/databaseModel.test.ts

@@ -1,5 +1,5 @@
 import './vscode_mock_setup';
-import { describe, it, before, after, beforeEach } from 'node:test';
+import { describe, it, before, after, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert';
 import { mockVscode } from './mocks/vscode';
 
@@ -118,3 +118,345 @@ describe('isAutoCommitEnabled', () => {
         await setupEnvironmentAndTest(undefined, 'ssh-remote', 2 /* Workspace */, false);
     });
 });
+
+
+
+
+describe('DatabaseDocument save/saveAs fallback', () => {
+    let DatabaseDocument: any;
+
+    beforeEach(() => {
+        // Clear module cache to ensure we get a fresh instance that uses our mocked workerFactory
+        const moduleCache = require('module')._cache;
+        Object.keys(moduleCache).forEach(key => {
+            if (key.includes('src/') && !key.includes('workerFactory') && !key.includes('mocks')) {
+                delete moduleCache[key];
+            }
+        });
+
+        const workerFactoryPath = require.resolve('../../src/workerFactory');
+        moduleCache[workerFactoryPath] = {
+            id: workerFactoryPath,
+            filename: workerFactoryPath,
+            loaded: true,
+            exports: {
+                createDatabaseConnection: async () => ({
+                    establishConnection: async () => ({
+                        databaseOps: {
+                            engineKind: Promise.resolve('wasm'),
+                            writeToFile: async () => { throw new Error('Simulated write failure'); },
+                            serializeDatabase: async () => new Uint8Array([1, 2, 3]),
+                            applyModifications: async () => {}
+                        },
+                        isReadOnly: false
+                    }),
+                    workerMethods: {
+                        [Symbol.dispose]: () => {}
+                    }
+                })
+            }
+        };
+
+        const dbModel = require('../../src/databaseModel');
+        DatabaseDocument = dbModel.DatabaseDocument;
+    });
+
+    const createFileUri = (path: string) => {
+        return {
+            scheme: 'file',
+            authority: '',
+            path: path,
+            query: '',
+            fragment: '',
+            fsPath: path,
+            with: () => ({}),
+            toJSON: () => ({})
+        };
+    };
+
+    const createDocBypassingFactory = (dbOps: any) => {
+        const mockViewerProvider = {
+            reporter: {},
+            isVerified: true,
+            context: { extensionUri: createFileUri('/ext') },
+            forceReadOnly: false,
+            outputChannel: undefined
+        };
+        const fileUri = createFileUri('/test/db.sqlite');
+
+        return new (DatabaseDocument as any)(
+            mockViewerProvider,
+            fileUri,
+            null, // tracker
+            false, // autoCommitEnabled
+            { databaseOps: dbOps, isReadOnly: false },
+            { [Symbol.dispose]: () => {} }, // workerMethods
+            async () => {}, // establishConnection
+            {} // reporter
+        );
+    };
+
+    it('saveAs: falls back to buffer transfer when writeToFile fails for file URI', async () => {
+        let serialized = false;
+        const dbOps = {
+            engineKind: Promise.resolve('wasm'),
+            writeToFile: async () => { throw new Error('Simulated write failure'); },
+            serializeDatabase: async () => {
+                serialized = true;
+                return new Uint8Array([1, 2, 3]);
+            }
+        };
+
+        const doc = createDocBypassingFactory(dbOps);
+
+        const targetUri = createFileUri('/test/target.sqlite');
+
+        let statCalled = false;
+        let writeFileCalled = false;
+
+        const originalFs = mockVscode.workspace.fs;
+        mockVscode.workspace.fs = {
+            ...originalFs,
+            stat: async () => {
+                statCalled = true;
+                return { size: 100 }; // Less than getFileSizeLimit()
+            },
+            writeFile: async (uri: any, content: any) => {
+                writeFileCalled = true;
+                assert.deepStrictEqual(content, new Uint8Array([1, 2, 3]));
+            },
+            readFile: async () => new Uint8Array([])
+        } as any;
+
+        const originalConsoleWarn = console.warn;
+        let consoleWarnCalled = false;
+        console.warn = (msg: string, err: any) => {
+            if (msg && msg.includes('Direct write failed')) {
+                consoleWarnCalled = true;
+            } else {
+                originalConsoleWarn(msg, err);
+            }
+        };
+
+        try {
+            await doc.saveAs(targetUri, undefined);
+
+            assert.strictEqual(consoleWarnCalled, true, 'console.warn should be called');
+            assert.strictEqual(statCalled, true, 'fs.stat should be called');
+            assert.strictEqual(serialized, true, 'serializeDatabase should be called');
+            assert.strictEqual(writeFileCalled, true, 'fs.writeFile should be called');
+        } finally {
+            mockVscode.workspace.fs = originalFs;
+            console.warn = originalConsoleWarn;
+        }
+    });
+
+    it('save: falls back to buffer transfer when writeToFile fails for file URI', async () => {
+        let serialized = false;
+        const dbOps = {
+            engineKind: Promise.resolve('wasm'),
+            writeToFile: async () => { throw new Error('Simulated write failure'); },
+            serializeDatabase: async () => {
+                serialized = true;
+                return new Uint8Array([1, 2, 3]);
+            }
+        };
+
+        const doc = createDocBypassingFactory(dbOps);
+
+        let writeFileCalled = false;
+
+        const originalFs = mockVscode.workspace.fs;
+        mockVscode.workspace.fs = {
+            ...originalFs,
+            stat: async () => {
+                return { size: 100 };
+            },
+            writeFile: async (uri: any, content: any) => {
+                writeFileCalled = true;
+                assert.deepStrictEqual(content, new Uint8Array([1, 2, 3]));
+            },
+            readFile: async () => new Uint8Array([])
+        } as any;
+
+        const originalConsoleWarn = console.warn;
+        let consoleWarnCalled = false;
+        console.warn = (msg: string, err: any) => {
+            if (msg && msg.includes('Direct write failed')) {
+                consoleWarnCalled = true;
+            } else {
+                originalConsoleWarn(msg, err);
+            }
+        };
+
+        try {
+            await doc.save();
+
+            assert.strictEqual(consoleWarnCalled, true, 'console.warn should be called');
+            assert.strictEqual(serialized, true, 'serializeDatabase should be called');
+            assert.strictEqual(writeFileCalled, true, 'fs.writeFile should be called');
+        } finally {
+            mockVscode.workspace.fs = originalFs;
+            console.warn = originalConsoleWarn;
+        }
+    });
+});
+
+
+describe('DatabaseDocument undo/redo error handling', () => {
+    let mockViewerProvider: any;
+    let mockOpenContext: any;
+    let originalShowErrorMessage: any;
+    let originalL10n: any;
+
+    beforeEach(() => {
+        originalShowErrorMessage = mockVscode.window.showErrorMessage;
+        originalL10n = mockVscode.l10n.t;
+
+        mockVscode.l10n.t = (key: string, ...args: any[]) => {
+            let res = key;
+            args.forEach((arg, i) => {
+                res = res.replace(`{${i}}`, String(arg));
+            });
+            return res;
+        };
+
+        mockViewerProvider = {
+            reporter: undefined,
+            isVerified: true,
+            context: { extensionUri: mockVscode.Uri.parse('file:///ext') },
+            forceReadOnly: false
+        };
+
+        mockOpenContext = {
+            backupId: undefined
+        };
+
+        const moduleCache = require('module')._cache;
+        const workerFactoryPath = require.resolve('../../src/workerFactory');
+        moduleCache[workerFactoryPath] = {
+            id: workerFactoryPath,
+            filename: workerFactoryPath,
+            loaded: true,
+            exports: {
+                createDatabaseConnection: () => {
+                    return Promise.resolve({
+                        workerMethods: {
+                            open: () => Promise.resolve({ isReadOnly: false, bufferInfo: {} }),
+                            exec: () => Promise.resolve(),
+                        },
+                        establishConnection: () => Promise.resolve({ isReadOnly: false }),
+                        databaseOps: {
+                            undoModification: () => Promise.resolve(),
+                            redoModification: () => Promise.resolve(),
+                            close: () => Promise.resolve(),
+                            getSchema: () => Promise.resolve([]),
+                            query: () => Promise.resolve([])
+                        }
+                    });
+                }
+            }
+        };
+
+    });
+
+    afterEach(() => {
+        mockVscode.window.showErrorMessage = originalShowErrorMessage;
+        mockVscode.l10n.t = originalL10n;
+    });
+
+    it('should show error message when undoModification fails', async () => {
+        let errorMessageShown = false;
+        mockVscode.window.showErrorMessage = async (msg?: string) => {
+            if (msg?.includes('Test Undo Error')) {
+                errorMessageShown = true;
+            }
+        };
+
+        // We clear module cache of databaseModel so it uses the mocked workerFactory
+        delete require('module')._cache[require.resolve('../../src/databaseModel')];
+        const { DatabaseDocument } = require('../../src/databaseModel');
+
+        const uri = mockVscode.Uri.parse('file:///test.db');
+        const doc = await DatabaseDocument.create(mockViewerProvider, uri, mockOpenContext);
+
+        // Mock database operations to throw error on undo
+        const dbOps = doc.databaseOperations;
+        if(dbOps) {
+            dbOps.undoModification = () => Promise.reject(new Error("Test Undo Error"));
+        } else {
+             // force override via any
+             (doc as any).connectionState = {
+                databaseOps: {
+                    undoModification: () => Promise.reject(new Error("Test Undo Error")),
+                    redoModification: () => Promise.resolve()
+                }
+             };
+        }
+
+        let undoAction: (() => Promise<void>) | undefined;
+        doc.onDidChange((modification: any) => {
+            undoAction = modification.undo;
+        });
+
+        doc.recordModification({
+            label: 'Test Mod',
+            action: 'Test Mod Action',
+            sql: [],
+            inverseSql: []
+        });
+
+        assert.ok(undoAction, 'Undo action should be emitted');
+
+        await undoAction();
+
+        assert.strictEqual(errorMessageShown, true, 'Error message should be shown for failed undo');
+    });
+
+    it('should show error message when redoModification fails', async () => {
+        let errorMessageShown = false;
+        mockVscode.window.showErrorMessage = async (msg?: string) => {
+            if (msg?.includes('Test Redo Error')) {
+                errorMessageShown = true;
+            }
+        };
+
+        const { DatabaseDocument } = require('../../src/databaseModel');
+        const uri = mockVscode.Uri.parse('file:///test.db');
+        const doc = await DatabaseDocument.create(mockViewerProvider, uri, mockOpenContext);
+
+        // Mock database operations to throw error on redo
+        const dbOps = doc.databaseOperations;
+        if(dbOps) {
+             dbOps.redoModification = () => Promise.reject(new Error("Test Redo Error"));
+        } else {
+            (doc as any).connectionState = {
+                databaseOps: {
+                    undoModification: () => Promise.resolve(),
+                    redoModification: () => Promise.reject(new Error("Test Redo Error"))
+                }
+             };
+        }
+
+        let redoAction: (() => Promise<void>) | undefined;
+        let undoAction: (() => Promise<void>) | undefined;
+        doc.onDidChange((modification: any) => {
+            undoAction = modification.undo;
+            redoAction = modification.redo;
+        });
+
+        doc.recordModification({
+            label: 'Test Mod',
+            action: 'Test Mod Action',
+            sql: [],
+            inverseSql: []
+        });
+
+        assert.ok(redoAction, 'Redo action should be emitted');
+
+        await undoAction!();
+        await redoAction();
+
+        assert.strictEqual(errorMessageShown, true, 'Error message should be shown for failed redo');
+    });
+});