Refactor test utilities and improve path handling in tests

- Introduced `useTempDir` utility for managing temporary directories in tests, replacing manual directory creation and cleanup.
- Updated path handling in `path-validation.test.ts` and `sessions.test.ts` to utilize the new `useTempDir` utility.
- Consolidated worker thread tests to use `writeWorkerScript` for creating worker scripts, improving readability and maintainability.
- Enhanced error handling in worker thread tests to ensure clear error messages when accessing databases across threads.
- Adjusted TypeScript configuration to set the root directory for better project structure.

Author: mceachen

test/backup-restoration.test.ts

@@ -1,29 +1,23 @@
 import { expect } from "@jest/globals";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
+import * as fs from "node:fs";
 import { DatabaseSync } from "../src/index";
+import { useTempDir } from "./test-utils";
 
 describe("Backup Restoration", () => {
-  let tmpDir: string;
+  const { getDbPath, closeDatabases } = useTempDir("sqlite-backup-test-");
+
   let sourceDb: InstanceType<typeof DatabaseSync>;
   let sourceFile: string;
   let backupFile: string;
 
   beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sqlite-backup-test-"));
-    sourceFile = path.join(tmpDir, "source.db");
-    backupFile = path.join(tmpDir, "backup.db");
+    sourceFile = getDbPath("source.db");
+    backupFile = getDbPath("backup.db");
     sourceDb = new DatabaseSync(sourceFile);
   });
 
   afterEach(() => {
-    try {
-      if (sourceDb) sourceDb.close();
-    } catch {
-      // Ignore errors when closing
-    }
-    fs.rmSync(tmpDir, { recursive: true, force: true });
+    closeDatabases(sourceDb);
   });
 
   it("should restore data correctly from backup", async () => {
@@ -232,7 +226,7 @@ describe("Backup Restoration", () => {
     `);
 
     // First backup
-    const backup1 = path.join(tmpDir, "backup1.db");
+    const backup1 = getDbPath("backup1.db");
     await sourceDb.backup(backup1);
 
     // Add more data
@@ -241,7 +235,7 @@ describe("Backup Restoration", () => {
     );
 
     // Second backup
-    const backup2 = path.join(tmpDir, "backup2.db");
+    const backup2 = getDbPath("backup2.db");
     await sourceDb.backup(backup2);
 
     // Add final data

test/backup.test.ts

@@ -1,25 +1,25 @@
-import { afterEach, beforeEach, describe, expect, it } from "@jest/globals";
+import { describe, expect, it } from "@jest/globals";
 import * as fs from "node:fs";
-import * as fsp from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
 import { DatabaseSync } from "../src";
+import { createTestDb, useTempDir } from "./test-utils";
 
 describe("Backup functionality", () => {
+  const { getDbPath, closeDatabases } = useTempDir("sqlite-backup-test-", {
+    waitForWindows: true,
+  });
+
   let sourceDb: InstanceType<typeof DatabaseSync>;
-  let tmpDir: string;
   let sourcePath: string;
   let destPath: string;
 
   beforeEach(() => {
-    // Create temporary directory for test databases
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sqlite-backup-test-"));
-    sourcePath = path.join(tmpDir, "source.db");
-    destPath = path.join(tmpDir, "destination.db");
+    sourcePath = getDbPath("source.db");
+    destPath = getDbPath("destination.db");
 
     // Create and populate source database
-    sourceDb = new DatabaseSync(sourcePath);
-    sourceDb.exec(`
+    sourceDb = createTestDb(
+      sourcePath,
+      `
       CREATE TABLE users (
         id INTEGER PRIMARY KEY,
         name TEXT NOT NULL,
@@ -39,30 +39,13 @@ describe("Backup functionality", () => {
         ('Widget', 9.99),
         ('Gadget', 19.99),
         ('Doohickey', 29.99);
-    `);
+    `,
+    );
   });
 
-  afterEach(async () => {
-    try {
-      sourceDb?.close();
-    } catch {
-      // Ignore close errors during cleanup
-    }
-
-    // Wait a bit for Windows file handles to be released
-    if (process.platform === "win32") {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-
-    if (fs.existsSync(tmpDir)) {
-      await fsp.rm(tmpDir, {
-        recursive: true,
-        force: true,
-        maxRetries: 3,
-        retryDelay: 500,
-      });
-    }
-  }, 10000); // Increase timeout to 10 seconds
+  afterEach(() => {
+    closeDatabases(sourceDb);
+  });
 
   it("should create a backup of the database", async () => {
     // Perform backup
@@ -163,7 +146,7 @@ describe("Backup functionality", () => {
 
   it("should handle backup with attached databases", async () => {
     // Attach another database
-    const attachedPath = path.join(tmpDir, "attached.db");
+    const attachedPath = getDbPath("attached.db");
     sourceDb.exec(`ATTACH DATABASE '${attachedPath}' AS attached`);
     sourceDb.exec(`
       CREATE TABLE attached.extra_data (
@@ -215,7 +198,7 @@ describe("Backup functionality", () => {
   });
 
   it("should handle concurrent backups", async () => {
-    const destPath2 = path.join(tmpDir, "destination2.db");
+    const destPath2 = getDbPath("destination2.db");
 
     // Start two backups concurrently
     const [pages1, pages2] = await Promise.all([
@@ -285,7 +268,7 @@ describe("Backup functionality", () => {
     `);
 
     // Perform backup
-    const backupPath = path.join(tmpDir, "full_backup.db");
+    const backupPath = getDbPath("full_backup.db");
     const totalPages = await sourceDb.backup(backupPath);
     expect(totalPages).toBeGreaterThan(0);
 
@@ -463,7 +446,7 @@ describe("Backup functionality", () => {
     };
 
     // Perform backup
-    const backupPath = path.join(tmpDir, "pragma_backup.db");
+    const backupPath = getDbPath("pragma_backup.db");
     await sourceDb.backup(backupPath);
     sourceDb.close();
 
@@ -536,7 +519,7 @@ describe("Backup functionality", () => {
       timestamp: number;
     }> = [];
 
-    const backupPath = path.join(tmpDir, "pages_test.db");
+    const backupPath = getDbPath("pages_test.db");
     const startTime = Date.now();
 
     // Use a small rate to ensure multiple iterations
@@ -614,7 +597,7 @@ describe("Backup functionality", () => {
 
   it("should handle incremental backup simulation", async () => {
     // Create initial backup
-    const backup1Path = path.join(tmpDir, "backup1.db");
+    const backup1Path = getDbPath("backup1.db");
     await sourceDb.backup(backup1Path);
 
     // Add more data
@@ -624,7 +607,7 @@ describe("Backup functionality", () => {
     `);
 
     // Create second backup
-    const backup2Path = path.join(tmpDir, "backup2.db");
+    const backup2Path = getDbPath("backup2.db");
     await sourceDb.backup(backup2Path);
 
     // Don't close sourceDb here - let afterEach handle it
@@ -679,7 +662,7 @@ describe("Backup functionality", () => {
     }
 
     // Test 1: Backup with rate = -1 (all at once)
-    const backup1Path = path.join(tmpDir, "all_at_once.db");
+    const backup1Path = getDbPath("all_at_once.db");
     let callbackCount1 = 0;
 
     await sourceDb.backup(backup1Path, {
@@ -690,7 +673,7 @@ describe("Backup functionality", () => {
     });
 
     // Test 2: Backup with rate = 1 (one page at a time)
-    const backup2Path = path.join(tmpDir, "one_page.db");
+    const backup2Path = getDbPath("one_page.db");
     let callbackCount2 = 0;
     const progressInfo2: Array<{ remaining: number }> = [];
 
@@ -703,7 +686,7 @@ describe("Backup functionality", () => {
     });
 
     // Test 3: Backup with rate = 5
-    const backup3Path = path.join(tmpDir, "five_pages.db");
+    const backup3Path = getDbPath("five_pages.db");
     let callbackCount3 = 0;
     const progressInfo3: Array<{ remaining: number }> = [];
 

test/concurrent-access.test.ts

@@ -1,24 +1,12 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
 import { DatabaseSync } from "../src";
+import { useTempDir } from "./test-utils";
 
 describe("Concurrent Access Patterns Tests", () => {
-  let tempDir: string;
+  const { getDbPath } = useTempDir("sqlite-concurrent-test-");
   let dbPath: string;
 
   beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "sqlite-concurrent-test-"));
-    dbPath = path.join(tempDir, "concurrent.db");
-  });
-
-  afterEach(() => {
-    try {
-      if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath);
-      fs.rmdirSync(tempDir);
-    } catch {
-      // Ignore cleanup errors
-    }
+    dbPath = getDbPath("concurrent.db");
   });
 
   describe("Multiple Reader Pattern", () => {

test/concurrent-simple.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it } from "@jest/globals";
+import { DatabaseSync } from "../src";
+import { useTempDir } from "./test-utils";
+
+describe("Simple Concurrent Access Tests", () => {
+  const { getDbPath } = useTempDir("sqlite-concurrent-simple-");
+  let dbPath: string;
+
+  beforeEach(() => {
+    dbPath = getDbPath("test.db");
+  });
+
+  it("should handle multiple database connections", () => {
+    // Create database with first connection
+    const db1 = new DatabaseSync(dbPath);
+    db1.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)");
+    db1.exec("INSERT INTO test (value) VALUES ('hello')");
+
+    // Open second connection for reading
+    const db2 = new DatabaseSync(dbPath, { readOnly: true });
+    const result = db2.prepare("SELECT * FROM test").get();
+    expect(result.value).toBe("hello");
+
+    // Clean up
+    db1.close();
+    db2.close();
+  });
+
+  it("should handle WAL mode for concurrent access", () => {
+    // Create database and enable WAL
+    const db1 = new DatabaseSync(dbPath);
+    db1.exec("PRAGMA journal_mode = WAL");
+    db1.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value INTEGER)");
+
+    // Insert data
+    for (let i = 0; i < 10; i++) {
+      db1.exec(`INSERT INTO test (value) VALUES (${i})`);
+    }
+
+    // Open multiple readers
+    const readers = [];
+    for (let i = 0; i < 3; i++) {
+      const reader = new DatabaseSync(dbPath, { readOnly: true });
+      readers.push(reader);
+    }
+
+    // All readers should see the same data
+    for (const reader of readers) {
+      const count = reader.prepare("SELECT COUNT(*) as count FROM test").get();
+      expect(count.count).toBe(10);
+    }
+
+    // Clean up
+    db1.close();
+    readers.forEach((r) => r.close());
+  });
+
+  it("should handle rapid open/close cycles", () => {
+    // Initialize database
+    const initDb = new DatabaseSync(dbPath);
+    initDb.exec("CREATE TABLE test (id INTEGER PRIMARY KEY)");
+    initDb.close();
+
+    // Rapid open/close cycles
+    for (let i = 0; i < 20; i++) {
+      const db = new DatabaseSync(dbPath);
+      const result = db.prepare("SELECT COUNT(*) as count FROM test").get();
+      expect(result.count).toBe(0);
+      db.close();
+    }
+  });
+
+  it("should handle concurrent prepared statements", () => {
+    const db = new DatabaseSync(":memory:");
+    db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)");
+
+    // Create multiple prepared statements
+    const insertStmt = db.prepare("INSERT INTO test (value) VALUES (?)");
+    const selectStmt = db.prepare("SELECT * FROM test WHERE value = ?");
+    const countStmt = db.prepare("SELECT COUNT(*) as count FROM test");
+
+    // Use them concurrently
+    insertStmt.run("test1");
+    insertStmt.run("test2");
+    insertStmt.run("test3");
+
+    const count = countStmt.get();
+    expect(count.count).toBe(3);
+
+    const result = selectStmt.get("test2");
+    expect(result.value).toBe("test2");
+
+    // Clean up
+    insertStmt.finalize();
+    selectStmt.finalize();
+    countStmt.finalize();
+    db.close();
+  });
+});

test/extension-loading.test.ts

@@ -2,13 +2,14 @@ import { execSync } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
 import { DatabaseSync } from "../src";
+import { getDirname } from "./test-utils";
 
 describe("Extension Loading Tests", () => {
   // Build the test extension before running tests
   let testExtensionPath: string;
 
   beforeAll(() => {
-    const extensionDir = path.join(__dirname, "fixtures", "test-extension");
+    const extensionDir = path.join(getDirname(), "fixtures", "test-extension");
 
     // Build the extension
     try {
@@ -360,7 +361,7 @@ describe("Extension Loading Tests", () => {
     });
 
     test("can load extension in file-based database", () => {
-      const dbPath = path.join(__dirname, "test-extension.db");
+      const dbPath = path.join(getDirname(), "test-extension.db");
 
       // Clean up any existing file
       if (fs.existsSync(dbPath)) {