fix: identical tests in tauri and electron all 329 tests pass

Author: abose

README.md

@@ -25,6 +25,10 @@ Here's a closer look at the Phoenix VFS organization:
   - **Windows Example**: `/tauri/c/Program Files/` could represent the C drive's "Program Files" directory.
   - **Linux/macOS Example**: `/tauri/usr/bin/` might be an accessible directory, akin to native paths you'd expect on these platforms.
 
+- **Electron Support**:
+  - Electron is also supported using the same `/tauri/` paths for backward compatibility.
+  - The APIs work identically in both Electron and Tauri environments.
+
 - **Node Websocket Connector Integration**:
   - The `/tauri/` paths can be accessed via websockets. This integration is much more
     performant than Tauri's fs rust APIs(generally 4x faster and 10x faster for large files).

src-electron/main.js

@@ -131,6 +131,26 @@ ipcMain.handle('get-app-data-dir', () => {
     }
 });
 
+// Get Windows drive letters (returns null on non-Windows platforms)
+ipcMain.handle('get-windows-drives', async () => {
+    if (process.platform !== 'win32') {
+        return null;
+    }
+    // On Windows, check which drive letters exist by testing A-Z
+    const drives = [];
+    for (let i = 65; i <= 90; i++) { // A-Z
+        const letter = String.fromCharCode(i);
+        const drivePath = `${letter}:\\`;
+        try {
+            await fsp.access(drivePath);
+            drives.push(letter);
+        } catch {
+            // Drive doesn't exist
+        }
+    }
+    return drives.length > 0 ? drives : null;
+});
+
 // Dialogs
 ipcMain.handle('show-open-dialog', async (event, options) => {
     const result = await dialog.showOpenDialog(mainWindow, options);

src-electron/preload.js

@@ -22,6 +22,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
     getAppPath: () => ipcRenderer.invoke('get-app-path'),
     getDocumentsDir: () => ipcRenderer.invoke('get-documents-dir'),
     getAppDataDir: () => ipcRenderer.invoke('get-app-data-dir'),
+    getWindowsDrives: () => ipcRenderer.invoke('get-windows-drives'),
     showOpenDialog: (options) => ipcRenderer.invoke('show-open-dialog', options),
     showSaveDialog: (options) => ipcRenderer.invoke('show-save-dialog', options),
 

test/test-copy.browser.js

@@ -60,26 +60,41 @@ function _setupTests(testTypeSrc, testTypeDst) {
     }
 
     before(async function () {
+        this.timeout(15000);
+        if (window.__TAURI__ || window.__ELECTRON__) {
+            await window.waitForTrue(()=>{return window.isNodeSetup;}, 10000);
+        }
         srcTestPath = await _getPathForTestType(testTypeSrc) + '/src';
         destTestPath = await _getPathForTestType(testTypeDst)+ '/dest';
     });
 
     beforeEach(async function () {
+        this.timeout(15000);
         // setup test folders
         await _clean();
         console.log(`mkdir: `, srcTestPath);
         let makeSuccess = false;
-        fs.mkdirs(srcTestPath, 0o777 ,true, ()=>{
+        let makeError = null;
+        fs.mkdirs(srcTestPath, 0o777 ,true, (err)=>{
+            makeError = err;
             makeSuccess = true;
         });
         await waitForTrue(()=>{return makeSuccess;},10000);
+        if (makeError) {
+            console.error(`Failed to create srcTestPath: `, makeError);
+        }
 
         console.log(`mkdir: `, destTestPath);
         makeSuccess = false;
-        fs.mkdirs(destTestPath, 0o777 ,true, ()=>{
+        makeError = null;
+        fs.mkdirs(destTestPath, 0o777 ,true, (err)=>{
+            makeError = err;
             makeSuccess = true;
         });
         await waitForTrue(()=>{return makeSuccess;},10000);
+        if (makeError) {
+            console.error(`Failed to create destTestPath: `, makeError);
+        }
     });
 
     afterEach(async function () {

test/test-getPlatformPath-api.browser.js

@@ -84,22 +84,32 @@ describe(`test getTauriVirtualPath api`, function () {
     }
 });
 
-if(window.__TAURI__){
+if(window.__TAURI__ || window.__ELECTRON__){
     describe(`test _get_windows_drives api`, function () {
         function isLetter(str) {
             return !!(str.length === 1 && str.match(/[a-z]/i));
         }
+
+        async function getWindowsDrives() {
+            if (window.__TAURI__) {
+                return window.__TAURI__.invoke('_get_windows_drives');
+            } else if (window.electronAPI) {
+                return window.electronAPI.getWindowsDrives();
+            }
+            return null;
+        }
+
         if(IS_WINDOWS){
             it(`windows: should _get_windows_drives return all windows drives`, async function () {
-                let drives = await window.__TAURI__.invoke('_get_windows_drives');
+                let drives = await getWindowsDrives();
                 expect(drives.length > 1).to.be.true;
                 for(let drive of drives){
                     expect(isLetter(drive)).to.be.true;
                 }
             });
         } else {
             it(`should _get_windows_drives return null in other platforms`, async function () {
-                let drives = await window.__TAURI__.invoke('_get_windows_drives');
+                let drives = await getWindowsDrives();
                 expect(drives).to.be.null;
             });
         }

test/test-node.browser.js

@@ -1,7 +1,7 @@
 /* global expect, execNode, NODE_COMMANDS, fs */
 
 describe(`node ws fs tests`, function () {
-    if(!window.__TAURI__){
+    if(!window.__TAURI__ && !window.__ELECTRON__){
         return;
     }
 

test/test.worker.js

@@ -6,7 +6,11 @@ function _setupTests(testType) {
     let messageFromWorker = null;
 
     function consoleLogToShell(message) {
-        return window.__TAURI__.invoke("console_log", {message});
+        if (window.__TAURI__) {
+            return window.__TAURI__.invoke("console_log", {message});
+        } else if (window.electronAPI) {
+            return window.electronAPI.consoleLog(message);
+        }
     }
 
     async function _clean() {
@@ -28,8 +32,8 @@ function _setupTests(testType) {
     }
 
     async function _requestWritePerm() {
-        if(window.__TAURI__ || testPath !== window.mountTestPath){
-            // fs access apis not tested in tauri
+        if(window.__TAURI__ || window.__ELECTRON__ || testPath !== window.mountTestPath){
+            // fs access apis not tested in tauri/electron
             return;
         }
         return new Promise((resolve, reject)=>{
@@ -45,13 +49,19 @@ function _setupTests(testType) {
     }
 
     async function _setupTestPath() {
+        let appDataDir;
         switch (testType) {
         case TEST_TYPE_FS_ACCESS: testPath = window.mountTestPath;break;
         case TEST_TYPE_FILER: testPath = window.virtualTestPath;break;
         case TEST_TYPE_TAURI_WS:
             await window.waitForTrue(()=>{return window.isNodeSetup;}, 10000);
             fs.forceUseNodeWSEndpoint(true);
-            testPath = fs.getTauriVirtualPath(`${await window.__TAURI__.path.appLocalDataDir()}test-phoenix-fs`);
+            if (window.__TAURI__) {
+                appDataDir = await window.__TAURI__.path.appLocalDataDir();
+            } else if (window.electronAPI) {
+                appDataDir = await window.electronAPI.getAppDataDir();
+            }
+            testPath = fs.getTauriVirtualPath(`${appDataDir}test-phoenix-fs`);
             consoleLogToShell("using tauri websocket test path: "+ testPath);
             break;
         default: throw new Error("unknown file system impl");
@@ -171,16 +181,16 @@ describe(`web worker filer tests`, function () {
     _setupTests(TEST_TYPE_FILER);
 });
 
-if(window.__TAURI__){
+if(window.__TAURI__ || window.__ELECTRON__){
     describe(`web worker Tauri WS tests`, function () {
         _setupTests(TEST_TYPE_TAURI_WS);
     });
 }
 
 if(window.supportsFsAccessAPIs) {
     describe(`web worker fs access tests`, function () {
-        if(window.__TAURI__){
-            it(`fs access tests are disabled in tauri`, function () {});
+        if(window.__TAURI__ || window.__ELECTRON__){
+            it(`fs access tests are disabled in tauri/electron`, function () {});
             return;
         } else {
             _setupTests(TEST_TYPE_FS_ACCESS);