webdriverio
diff --git a/‎.github/workflows/_ci-e2e-tauri-all-providers.reusable.yml‎
Lines changed: 1 addition & 1 deletion b/‎.github/workflows/_ci-e2e-tauri-all-providers.reusable.yml‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎.github/workflows/_ci-e2e.reusable.yml‎
Lines changed: 1 addition & 1 deletion b/‎.github/workflows/_ci-e2e.reusable.yml‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎.github/workflows/_ci-package.reusable.yml‎
Lines changed: 1 addition & 1 deletion b/‎.github/workflows/_ci-package.reusable.yml‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎.github/workflows/actions/download-archive/action.yml‎
Lines changed: 3 additions & 3 deletions b/‎.github/workflows/actions/download-archive/action.yml‎
Lines changed: 3 additions & 3 deletions
diff --git a/‎.github/workflows/actions/upload-archive/action.yml‎
Lines changed: 1 addition & 1 deletion b/‎.github/workflows/actions/upload-archive/action.yml‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎e2e/test/electron/mocking.spec.ts‎
Lines changed: 26 additions & 33 deletions b/‎e2e/test/electron/mocking.spec.ts‎
Lines changed: 26 additions & 33 deletions
diff --git a/‎e2e/test/electron/standalone/api.spec.ts‎
Lines changed: 1 addition & 1 deletion b/‎e2e/test/electron/standalone/api.spec.ts‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎e2e/test/electron/window.spec.ts‎
Lines changed: 1 addition & 3 deletions b/‎e2e/test/electron/window.spec.ts‎
Lines changed: 1 addition & 3 deletions
diff --git a/‎e2e/test/tauri/mocking.spec.ts‎
Lines changed: 66 additions & 20 deletions b/‎e2e/test/tauri/mocking.spec.ts‎
Lines changed: 66 additions & 20 deletions
@@ -539,6 +539,6 @@ jobs:
 
       - name: 🐛 Debug Build on Failure
         if: failure()
-        uses: goosewobbler/vscode-server-action@v1.3.0
+        uses: goosewobbler/vscode-server-action@v1.5.0
         with:
           timeout: '300000'
@@ -253,7 +253,7 @@ jobs:
       # Provide an interactive debugging session on failure
       # This allows manual investigation of the environment
       - name: 🐛 Debug Build on Failure
-        uses: goosewobbler/vscode-server-action@v1.3.0
+        uses: goosewobbler/vscode-server-action@v1.5.0
         if: failure()
         with:
           timeout: '300000'
@@ -241,7 +241,7 @@ jobs:
       # Provide an interactive debugging session on failure
       # This allows manual investigation of the environment
       - name: 🐛 Debug Build on Failure
-        uses: goosewobbler/vscode-server-action@v1.3.0
+        uses: goosewobbler/vscode-server-action@v1.5.0
         if: failure()
         with:
           timeout: '180000'
@@ -60,7 +60,7 @@ runs:
     - name: 🗄️ Restore Cache
       id: cache-restore
       if: inputs.use_cache != 'false-only'
-      uses: actions/cache/restore@v4
+      uses: actions/cache/restore@v5
       env:
         ACTIONS_CACHE_SERVICE_V2: 'true'
       with:
@@ -194,11 +194,11 @@ runs:
         WORKSPACE="${{ github.workspace }}"
         INPUT_PATH="${{ inputs.path }}"
         ARCHIVE_PATH="$INPUT_PATH/${{ inputs.filename }}"
-        
+
         if [ "${{ steps.cache-restore.outputs.cache-hit }}" == "true" ]; then
           # Cache hit: zip file was restored to inputs.path, need to extract it
           echo "Cache hit detected, extracting zip file..."
-          
+
           if [ -f "$ARCHIVE_PATH" ]; then
             echo "Found zip file at $ARCHIVE_PATH, extracting..."
             SOURCE_DIR="${RUNNER_TEMP}/artifact-extract-${{ github.run_id }}-${{ github.run_attempt }}"
 
@@ -236,7 +236,7 @@ runs:
     # Cross-platform archive enabled - works for TypeScript packages (wdio-desktop-build)
     # Tauri apps use 7zip for cross-platform compatible ZIPs
     - name: 🗄️ Cache Artifact (Platform-specific)
-      uses: actions/cache/save@v4
+      uses: actions/cache/save@v5
       env:
         ACTIONS_CACHE_SERVICE_V2: 'true'
       with:
 
@@ -275,12 +275,6 @@ describe('Electron Mocking', () => {
         });
 
         it('should restore existing mocks', async () => {
-          // Ensure clipboard has expected initial state
-          await browser.electron.execute((electron) => {
-            electron.clipboard.clear();
-            electron.clipboard.writeText('some real clipboard text');
-          });
-
           const mockGetName = await browser.electron.mock('app', 'getName');
           const mockReadText = await browser.electron.mock('clipboard', 'readText');
           await mockGetName.mockReturnValue('mocked appName');
@@ -291,8 +285,6 @@ describe('Electron Mocking', () => {
           const appName = await browser.electron.execute((electron) => electron.app.getName());
           const clipboardText = await browser.electron.execute((electron) => electron.clipboard.readText());
           expect(appName).toBe(getExpectedAppName());
-
-          // Clipboard should be restored to original state
           expect(clipboardText).toBe('some real clipboard text');
         });
 
@@ -896,8 +888,8 @@ describe('Electron Mocking', () => {
 
             // Mock setName to store values and getName to return them
             let storedName = '';
-            await mockSetName.mockImplementation((name: string) => {
-              storedName = name;
+            await mockSetName.mockImplementation((name: unknown) => {
+              storedName = name as string;
             });
             await mockGetName.mockImplementation(() => storedName);
 
@@ -952,14 +944,12 @@ describe('Electron Mocking', () => {
           const mockNonExistentFunc = await browser.electron.mock('app', 'nonExistentMethod');
           expect(mockNonExistentFunc).toBeDefined();
 
-          // The mock exists but won't intercept actual calls
+          // The mock is installed on the API, so calls are intercepted
           await browser.electron.execute((electron) => {
-            // This should call the real app method, not our mock
-            const result = (electron.app as any).nonExistentMethod?.();
-            expect(result).toBeUndefined();
+            (electron.app as any).nonExistentMethod?.();
           });
 
-          expect(mockNonExistentFunc).toHaveBeenCalledTimes(0);
+          expect(mockNonExistentFunc).toHaveBeenCalledTimes(1);
         });
 
         it('should handle mocking non-existent class', async () => {
@@ -969,11 +959,10 @@ describe('Electron Mocking', () => {
           expect(mockNonExistentClass.__constructor).toBeDefined();
 
           // Constructor should exist but not intercept real instantiation
-          await browser.electron.execute((electron) => {
-            // This should not be intercepted by our mock
-            const instance = (electron as any).NonExistentClass ? new (electron as any).NonExistentClass() : null;
-            expect(instance).toBeNull();
+          const instance = await browser.electron.execute((electron) => {
+            return (electron as any).NonExistentClass ? new (electron as any).NonExistentClass() : null;
           });
+          expect(instance).toBeNull();
 
           expect(mockNonExistentClass.__constructor).toHaveBeenCalledTimes(0);
         });
@@ -1043,6 +1032,7 @@ describe('Electron Mocking', () => {
 
           await browser.electron.execute((electron) => {
             new electron.Tray('/path/to/icon1.png');
+            // @ts-expect-error — Tray constructor accepts extra args at runtime but types are narrow
             new electron.Tray('/path/to/icon2.png', { title: 'Test' });
           });
 
@@ -1059,7 +1049,8 @@ describe('Electron Mocking', () => {
 
           await browser.electron.execute((electron) => {
             const tray = new electron.Tray('/path/to/icon.png');
-            tray.setTitle('App').setToolTip('Menu'); // Should work if chaining works
+            // @ts-expect-error — mockReturnThis makes setTitle return `this`; types don't reflect it
+            tray.setTitle('App').setToolTip('Menu');
           });
 
           expect(mockTray.setToolTip).toHaveBeenCalledWith('Menu');
@@ -1069,8 +1060,8 @@ describe('Electron Mocking', () => {
       describe('Class Mock Methods', () => {
         describe('mockRestore', () => {
           it('should restore the original class implementation', async () => {
-            // Get original Tray constructor for comparison
-            const originalTray = await browser.electron.execute((electron) => electron.Tray);
+            // Get original Tray constructor name for comparison (functions serialize to {} via CDP)
+            const originalTrayName = await browser.electron.execute((electron) => electron.Tray.name);
 
             const mockTray = await browser.electron.mock('Tray');
 
@@ -1087,12 +1078,13 @@ describe('Electron Mocking', () => {
             // Restore original class
             await mockTray.mockRestore();
 
-            // Verify original class is restored
-            const restoredTray = await browser.electron.execute((electron) => electron.Tray);
-            expect(restoredTray).toBe(originalTray);
+            // Verify original class is restored (compare by name since functions can't be serialized via CDP)
+            const restoredTrayName = await browser.electron.execute((electron) => electron.Tray.name);
+            expect(restoredTrayName).toBe(originalTrayName);
 
-            // Constructor tracking should be gone
-            await browser.electron.execute((electron) => new electron.Tray('/path/to/icon.png'));
+            // Constructor tracking should be gone after restore
+            // Note: real Tray constructor throws with invalid path, so we ignore the error
+            await browser.electron.execute((electron) => new electron.Tray('/path/to/icon.png')).catch(() => {});
             expect(mockTray.__constructor.mock.calls).toStrictEqual([]);
           });
         });
@@ -1149,7 +1141,7 @@ describe('Electron Mocking', () => {
         });
 
         it('should work with restoreAllMocks', async () => {
-          const originalTray = await browser.electron.execute((electron) => electron.Tray);
+          const originalTrayName = await browser.electron.execute((electron) => electron.Tray.name);
 
           const mockTray = await browser.electron.mock('Tray');
           await mockTray.setTitle.mockReturnValue('mocked');
@@ -1164,9 +1156,9 @@ describe('Electron Mocking', () => {
           // Restore all mocks
           await browser.electron.restoreAllMocks();
 
-          // Verify original class is restored
-          const restoredTray = await browser.electron.execute((electron) => electron.Tray);
-          expect(restoredTray).toBe(originalTray);
+          // Verify original class is restored (compare by name since functions can't be serialized via CDP)
+          const restoredTrayName = await browser.electron.execute((electron) => electron.Tray.name);
+          expect(restoredTrayName).toBe(originalTrayName);
         });
       });
 
@@ -1177,6 +1169,7 @@ describe('Electron Mocking', () => {
 
             await browser.electron.execute((electron) => {
               new electron.Tray('/path/to/icon1.png');
+              // @ts-expect-error — Tray constructor accepts extra args at runtime but types are narrow
               new electron.Tray('/path/to/icon2.png', { title: 'Test' });
             });
 
@@ -1201,7 +1194,7 @@ describe('Electron Mocking', () => {
             const mockDialog = await browser.electron.mock('dialog', 'showOpenDialog');
 
             await browser.electron.execute((electron) => new electron.Tray('/path/to/icon.png'));
-            await browser.electron.execute((electron) => electron.dialog.showOpenDialog());
+            await browser.electron.execute((electron) => electron.dialog.showOpenDialog({}));
             await browser.electron.execute((electron) => new electron.Tray('/path/to/other.png'));
 
             const constructorOrder = mockTray.__constructor.mock.invocationCallOrder;
@@ -1285,7 +1278,7 @@ describe('Electron Mocking', () => {
         it('should support mockImplementation for instance methods', async () => {
           const mockTray = await browser.electron.mock('Tray');
 
-          await mockTray.setTitle.mockImplementation((title) => `Mocked: ${title}`);
+          await mockTray.setTitle.mockImplementation((title: unknown) => `Mocked: ${String(title)}`);
 
           const result = await browser.electron.execute((electron) => {
             const tray = new electron.Tray('/path/to/icon.png');
 
@@ -24,7 +24,7 @@ const isScript = appDirName.includes('script');
 const getExpectedAppName = (): string => {
   // In script mode, the app name will always be "Electron"
   // In binary mode, use the package name
-  return isScript ? 'Electron' : globalThis.packageJson?.name || packageJson.name;
+  return isScript ? 'Electron' : (globalThis.packageJson?.name ?? packageJson.name ?? '');
 };
 
 // Get app name and check against expected value
 
@@ -52,9 +52,7 @@ describe('application window tests', () => {
     } else {
       const elem = await browser.$('.switch-main-window');
       await elem.click();
-      // Verify the app switched to main window with an Electron E2E test app title
-      const title = await browser.getTitle();
-      expect(title).toMatch(/Electron.*E2E Test App/);
+      await expect(browser).toHaveTitle(/Electron.*E2E Test App/);
     }
   });
 });
@@ -123,12 +123,6 @@ describe('Tauri Mocking', () => {
   });
 
   describe('browser.tauri.restoreAllMocks', () => {
-    beforeEach(async () => {
-      await browser.tauri.execute(async ({ core }) => {
-        await core.invoke('write_clipboard', { content: 'real clipboard text' });
-      });
-    });
-
     it('should restore existing mocks', async () => {
       const mockReadClipboard = await browser.tauri.mock('read_clipboard');
       const mockGetPlatformInfo = await browser.tauri.mock('get_platform_info');
@@ -138,6 +132,11 @@ describe('Tauri Mocking', () => {
 
       await browser.tauri.restoreAllMocks();
 
+      // Write to clipboard AFTER restoring — any write_clipboard mock from prior tests is now gone
+      await browser.tauri.execute(async ({ core }) => {
+        await core.invoke('write_clipboard', { content: 'real clipboard text' });
+      });
+
       const clipboardContent = await browser.tauri.execute(async ({ core }) => await core.invoke('read_clipboard'));
       const platformInfo = await browser.tauri.execute(async ({ core }) => await core.invoke('get_platform_info'));
 
@@ -165,18 +164,12 @@ describe('Tauri Mocking', () => {
     describe('mockImplementation', () => {
       it('should use the specified implementation for an existing mock', async () => {
         const mockReadClipboard = await browser.tauri.mock('read_clipboard');
-        let callsCount = 0;
 
-        await mockReadClipboard.mockImplementation(() => {
-          if (typeof callsCount !== 'undefined') {
-            callsCount++;
-          }
-          return 'mocked clipboard value';
-        });
+        await mockReadClipboard.mockImplementation(() => 'mocked clipboard value');
 
         const result = await browser.tauri.execute(async ({ core }) => await core.invoke('read_clipboard'));
 
-        expect(callsCount).toBe(1);
+        expect(mockReadClipboard.mock.calls).toHaveLength(1);
         expect(result).toBe('mocked clipboard value');
       });
     });
@@ -296,6 +289,21 @@ describe('Tauri Mocking', () => {
 
         expect(error).toBe('This is a mock error');
       });
+
+      it('should reject with an Error object preserving message', async () => {
+        const mockGetPlatformInfo = await browser.tauri.mock('get_platform_info');
+        await mockGetPlatformInfo.mockRejectedValue(new Error('connection failed'));
+
+        const error = await browser.tauri.execute(async ({ core }) => {
+          try {
+            return await core.invoke('get_platform_info');
+          } catch (e) {
+            return e instanceof Error ? e.message : String(e);
+          }
+        });
+
+        expect(error).toBe('connection failed');
+      });
     });
 
     describe('mockRejectedValueOnce', () => {
@@ -331,6 +339,27 @@ describe('Tauri Mocking', () => {
         info = await getInfo();
         expect(info).toBe('default error');
       });
+
+      it('should reject with Error objects preserving message', async () => {
+        const mockGetPlatformInfo = await browser.tauri.mock('get_platform_info');
+
+        await mockGetPlatformInfo.mockRejectedValue(new Error('default error'));
+        await mockGetPlatformInfo.mockRejectedValueOnce(new Error('first error'));
+        await mockGetPlatformInfo.mockRejectedValueOnce(new Error('second error'));
+
+        const getMsg = async () =>
+          await browser.tauri.execute(async ({ core }) => {
+            try {
+              return await core.invoke('get_platform_info');
+            } catch (e) {
+              return e instanceof Error ? e.message : String(e);
+            }
+          });
+
+        expect(await getMsg()).toBe('first error');
+        expect(await getMsg()).toBe('second error');
+        expect(await getMsg()).toBe('default error');
+      });
     });
 
     describe('mockClear', () => {
@@ -558,21 +587,38 @@ describe('Tauri Mocking', () => {
       });
     });
 
-    describe('update() synchronization', () => {
+    describe('synchronization', () => {
       it('should synchronize mock calls after update', async () => {
         const mockReadClipboard = await browser.tauri.mock('read_clipboard');
 
-        await browser.tauri.execute(async ({ core }) => {
-          await core.invoke('read_clipboard');
-          await core.invoke('read_clipboard');
+        // Use browser.execute (raw WebDriver, no auto-sync) to invoke the inner mock directly
+        await browser.execute(() => {
+          // @ts-expect-error - window is available in browser context
+          const mockFn = window.__wdio_mocks__?.read_clipboard;
+          if (typeof mockFn === 'function') {
+            mockFn();
+            mockFn();
+          }
         });
 
-        // Before update, calls should be empty
+        // Before update(), outer mock has no calls (inner mock has 2)
         expect(mockReadClipboard.mock.calls).toStrictEqual([]);
 
         await mockReadClipboard.update();
 
-        // After update, calls should be synchronized
+        // After update(), calls are synchronized from inner mock
+        expect(mockReadClipboard.mock.calls).toHaveLength(2);
+      });
+
+      it('should auto-synchronize mock calls after execute', async () => {
+        const mockReadClipboard = await browser.tauri.mock('read_clipboard');
+
+        await browser.tauri.execute(async ({ core }) => {
+          await core.invoke('read_clipboard');
+          await core.invoke('read_clipboard');
+        });
+
+        // After tauri.execute (auto-synced), calls should be synchronized without calling update()
         expect(mockReadClipboard.mock.calls).toHaveLength(2);
       });