fix(tests): update database location assertions to use fs.realpathSync on macOS and rm with retry on windows

Author: mceachen

test/backup.test.ts

@@ -62,7 +62,7 @@ describe("Backup functionality", () => {
         retryDelay: 500,
       });
     }
-  });
+  }, 10000); // Increase timeout to 10 seconds
 
   it("should create a backup of the database", async () => {
     // Perform backup

test/database.test.ts

@@ -181,7 +181,7 @@ describe("File-based Database Tests", () => {
 
     expect(db).toBeInstanceOf(DatabaseSync);
     expect(db.isOpen).toBe(true);
-    expect(db.location()).toBe(dbPath);
+    expect(db.location()).toBe(fs.realpathSync(dbPath));
     expect(fs.existsSync(dbPath)).toBe(true);
 
     db.close();
@@ -292,7 +292,7 @@ describe("File-based Database Tests", () => {
   test("database location property reflects actual path", () => {
     const db = new DatabaseSync(dbPath);
 
-    expect(db.location()).toBe(dbPath);
+    expect(db.location()).toBe(fs.realpathSync(dbPath));
 
     db.close();
   });
@@ -348,7 +348,7 @@ describe("Database Configuration Tests", () => {
     });
 
     expect(db.isOpen).toBe(true);
-    expect(db.location()).toBe(dbPath);
+    expect(db.location()).toBe(fs.realpathSync(dbPath));
 
     // Test that we can create tables (not readonly)
     expect(() => {
@@ -426,7 +426,7 @@ describe("Database Configuration Tests", () => {
     const db = new DatabaseSync(dbPath);
 
     expect(db.isOpen).toBe(true);
-    expect(db.location()).toBe(dbPath);
+    expect(db.location()).toBe(fs.realpathSync(dbPath));
 
     // Should be able to create and modify data (not readonly by default)
     db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY)");
@@ -607,7 +607,7 @@ describe("Database Configuration Tests", () => {
     });
 
     expect(db.isOpen).toBe(true);
-    expect(db.location()).toBe(dbPath);
+    expect(db.location()).toBe(fs.realpathSync(dbPath));
 
     // Should be able to read data
     const stmt = db.prepare("SELECT * FROM child WHERE id = ?");
@@ -641,7 +641,7 @@ describe("Database Configuration Tests", () => {
     });
 
     expect(db.isOpen).toBe(true);
-    expect(db.location()).toBe(dbPath);
+    expect(db.location()).toBe(fs.realpathSync(dbPath));
 
     // Should be readonly
     expect(() => {

test/location-method.test.ts

@@ -31,8 +31,8 @@ describe("Enhanced location() method tests", () => {
 
   test("location() returns main database path by default", () => {
     const db = new DatabaseSync(dbPath);
-    expect(db.location()).toBe(dbPath);
-    expect(db.location("main")).toBe(dbPath);
+    expect(db.location()).toBe(fs.realpathSync(dbPath));
+    expect(db.location("main")).toBe(fs.realpathSync(dbPath));
     db.close();
   });
 
@@ -50,11 +50,11 @@ describe("Enhanced location() method tests", () => {
     db.exec(`ATTACH DATABASE '${attachedDbPath}' AS attached_db`);
 
     // Main database should still return the main path
-    expect(db.location()).toBe(dbPath);
-    expect(db.location("main")).toBe(dbPath);
+    expect(db.location()).toBe(fs.realpathSync(dbPath));
+    expect(db.location("main")).toBe(fs.realpathSync(dbPath));
 
     // Attached database should return its path
-    expect(db.location("attached_db")).toBe(attachedDbPath);
+    expect(db.location("attached_db")).toBe(fs.realpathSync(attachedDbPath));
 
     db.close();
   });
@@ -78,8 +78,8 @@ describe("Enhanced location() method tests", () => {
       db.exec(`ATTACH DATABASE '${secondAttachedPath}' AS second_attached`);
 
       // Test all database locations
-      expect(db.location()).toBe(dbPath);
-      expect(db.location("main")).toBe(dbPath);
+      expect(db.location()).toBe(fs.realpathSync(dbPath));
+      expect(db.location("main")).toBe(fs.realpathSync(dbPath));
       expect(db.location("first_attached")).toBe(attachedDbPath);
       expect(db.location("second_attached")).toBe(secondAttachedPath);
 
@@ -123,13 +123,13 @@ describe("Enhanced location() method tests", () => {
 
     // Attach and then detach a database
     db.exec(`ATTACH DATABASE '${attachedDbPath}' AS temp_db`);
-    expect(db.location("temp_db")).toBe(attachedDbPath);
+    expect(db.location("temp_db")).toBe(fs.realpathSync(attachedDbPath));
 
     db.exec("DETACH DATABASE temp_db");
     expect(db.location("temp_db")).toBeNull();
 
     // Main database should still work
-    expect(db.location()).toBe(dbPath);
+    expect(db.location()).toBe(fs.realpathSync(dbPath));
 
     db.close();
   });
@@ -157,7 +157,7 @@ describe("Enhanced location() method tests", () => {
     const specialPath = path.join(tempDir, "special-db_123.db");
     db.exec(`ATTACH DATABASE '${specialPath}' AS "special_db_123"`);
 
-    expect(db.location("special_db_123")).toBe(specialPath);
+    expect(db.location("special_db_123")).toBe(fs.realpathSync(specialPath));
 
     db.close();
 

test/path-validation.test.ts

@@ -12,8 +12,18 @@ describe("Path Validation", () => {
   });
 
   afterEach(async () => {
+    // Wait for Windows file handles to be released
+    if (process.platform === "win32") {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+
     if (tmpDir) {
-      await rm(tmpDir, { recursive: true, force: true });
+      await rm(tmpDir, {
+        recursive: true,
+        force: true,
+        maxRetries: 3,
+        retryDelay: 500,
+      });
     }
   });
 
@@ -138,17 +148,35 @@ describe("Path Validation", () => {
 
   describe("Backup path validation", () => {
     let sourceDb: DatabaseSyncInstance;
+    const openDbs: DatabaseSyncInstance[] = [];
 
     beforeEach(() => {
       sourceDb = new DatabaseSync(":memory:");
       sourceDb.exec("CREATE TABLE test (id INTEGER, value TEXT)");
       sourceDb.exec("INSERT INTO test VALUES (1, 'test')");
     });
 
-    afterEach(() => {
-      if (sourceDb.isOpen) {
+    afterEach(async () => {
+      // Close all databases opened during tests
+      for (const db of openDbs) {
+        try {
+          if (db.isOpen) {
+            db.close();
+          }
+        } catch {
+          // Ignore close errors
+        }
+      }
+      openDbs.length = 0;
+
+      if (sourceDb?.isOpen) {
         sourceDb.close();
       }
+
+      // Wait for Windows file handles to be released
+      if (process.platform === "win32") {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
     });
 
     it("should accept string destination paths", async () => {
@@ -157,6 +185,7 @@ describe("Path Validation", () => {
 
       // Verify backup was created
       const verifyDb = new DatabaseSync(destPath);
+      openDbs.push(verifyDb);
       const result = verifyDb.prepare("SELECT * FROM test").get();
       expect(result).toEqual({ id: 1, value: "test" });
       verifyDb.close();
@@ -169,6 +198,7 @@ describe("Path Validation", () => {
 
       // Verify backup was created
       const verifyDb = new DatabaseSync(destPath);
+      openDbs.push(verifyDb);
       const result = verifyDb.prepare("SELECT * FROM test").get();
       expect(result).toEqual({ id: 1, value: "test" });
       verifyDb.close();
@@ -181,6 +211,7 @@ describe("Path Validation", () => {
 
       // Verify backup was created
       const verifyDb = new DatabaseSync(destPath);
+      openDbs.push(verifyDb);
       const result = verifyDb.prepare("SELECT * FROM test").get();
       expect(result).toEqual({ id: 1, value: "test" });
       verifyDb.close();