fix(tauri): improve error handling and response mapping (#198)

* fix(tauri): improve error handling and response mapping

- Enhanced the WebDriver server's error handling by adding logging for runtime creation and binding failures, ensuring better diagnostics.
- Introduced a mapping for known JavaScript error messages to their corresponding W3C error codes, specifically handling "stale element reference."
- Added unit tests to verify the correct mapping of JavaScript errors and the behavior of the new error response methods.

* fix(tauri): enhance error handling in port allocation and logging

- Improved error handling in the PortManager class to release the first port if the second allocation fails, ensuring resource management.
- Updated logging messages in TauriWorkerService to provide clearer error context during plugin initialization and command overriding.
- Adjusted mock implementation in tests to validate the new error handling behavior in port allocation.

Author: goosewobbler

packages/tauri-plugin-webdriver/src/server/mod.rs

@@ -51,7 +51,13 @@ impl<R: Runtime + 'static> AppState<R> {
 /// Start the `WebDriver` HTTP server on the specified port
 pub fn start<R: Runtime + 'static>(app: AppHandle<R>, port: u16) {
     std::thread::spawn(move || {
-        let rt = TokioRuntime::new().expect("Failed to create Tokio runtime");
+        let rt = match TokioRuntime::new() {
+            Ok(rt) => rt,
+            Err(e) => {
+                tracing::error!("Failed to create Tokio runtime for WebDriver server: {}", e);
+                return;
+            }
+        };
 
         rt.block_on(async {
             let state = Arc::new(AppState::new(app));
@@ -64,13 +70,22 @@ pub fn start<R: Runtime + 'static>(app: AppHandle<R>, port: u16) {
             #[cfg(not(target_os = "android"))]
             let addr = SocketAddr::from(([127, 0, 0, 1], port));
 
-            tracing::info!("WebDriver server listening on http://{}", addr);
+            let listener = match tokio::net::TcpListener::bind(addr).await {
+                Ok(l) => l,
+                Err(e) => {
+                    tracing::error!(
+                        "Failed to bind WebDriver server to {} — port may already be in use: {}",
+                        addr, e
+                    );
+                    return;
+                }
+            };
 
-            let listener = tokio::net::TcpListener::bind(addr)
-                .await
-                .expect("Failed to bind to address");
+            tracing::info!("WebDriver server listening on http://{}", addr);
 
-            axum::serve(listener, router).await.expect("Server error");
+            if let Err(e) = axum::serve(listener, router).await {
+                tracing::error!("WebDriver server error: {}", e);
+            }
         });
     });
 }

packages/tauri-plugin-webdriver/src/server/response.rs

@@ -91,6 +91,11 @@ impl WebDriverErrorResponse {
     }
 
     pub fn javascript_error(message: &str, stacktrace: Option<String>) -> Self {
+        // Map known JS error messages to their correct W3C error codes
+        if message.contains("stale element reference") {
+            return Self::stale_element_reference();
+        }
+
         Self::new(
             StatusCode::INTERNAL_SERVER_ERROR,
             "javascript error",
@@ -99,6 +104,15 @@ impl WebDriverErrorResponse {
         )
     }
 
+    pub fn stale_element_reference() -> Self {
+        Self::new(
+            StatusCode::NOT_FOUND,
+            "stale element reference",
+            "Element is no longer attached to the DOM",
+            None,
+        )
+    }
+
     pub fn unknown_error(message: &str) -> Self {
         Self::new(
             StatusCode::INTERNAL_SERVER_ERROR,
@@ -188,3 +202,40 @@ impl IntoResponse for WebDriverErrorResponse {
 
 /// Result type for `WebDriver` handlers
 pub type WebDriverResult = Result<WebDriverResponse, WebDriverErrorResponse>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn javascript_error_maps_stale_element_reference() {
+        let err = WebDriverErrorResponse::javascript_error("stale element reference", None);
+        assert_eq!(err.status, StatusCode::NOT_FOUND);
+        assert_eq!(err.error, "stale element reference");
+    }
+
+    #[test]
+    fn javascript_error_preserves_generic_errors() {
+        let err = WebDriverErrorResponse::javascript_error("TypeError: x is not a function", None);
+        assert_eq!(err.status, StatusCode::INTERNAL_SERVER_ERROR);
+        assert_eq!(err.error, "javascript error");
+        assert_eq!(err.message, "TypeError: x is not a function");
+    }
+
+    #[test]
+    fn javascript_error_preserves_stacktrace_for_generic_errors() {
+        let err = WebDriverErrorResponse::javascript_error(
+            "ReferenceError: foo is not defined",
+            Some("at eval:1:1".to_string()),
+        );
+        assert_eq!(err.error, "javascript error");
+        assert_eq!(err.stacktrace, Some("at eval:1:1".to_string()));
+    }
+
+    #[test]
+    fn stale_element_reference_returns_not_found() {
+        let err = WebDriverErrorResponse::stale_element_reference();
+        assert_eq!(err.status, StatusCode::NOT_FOUND);
+        assert_eq!(err.error, "stale element reference");
+    }
+}

packages/tauri-service/src/portManager.ts

@@ -37,11 +37,17 @@ export class PortManager {
     });
     this.usedPorts.add(port);
 
-    const nativePort = await getPort({
-      port: preferredNativePort ?? this.baseNativePort,
-      host: '127.0.0.1',
-      exclude: Array.from(this.usedPorts),
-    });
+    let nativePort: number;
+    try {
+      nativePort = await getPort({
+        port: preferredNativePort ?? this.baseNativePort,
+        host: '127.0.0.1',
+        exclude: Array.from(this.usedPorts),
+      });
+    } catch (error) {
+      this.usedPorts.delete(port);
+      throw error;
+    }
     this.usedPorts.add(nativePort);
 
     log.debug(`Allocated port pair: main=${port}, native=${nativePort}`);

packages/tauri-service/src/service.ts

@@ -108,7 +108,7 @@ export default class TauriWorkerService {
         });
         log.debug('Tauri plugin initialization complete');
       } catch (error) {
-        log.error('Failed to wait for plugin initialization:', error);
+        log.error('Failed to wait for plugin initialization — tauri.execute() and mocking may not work:', error);
       }
     }
 
@@ -292,8 +292,8 @@ export default class TauriWorkerService {
       } as Parameters<typeof browser.overwriteCommand>[1];
 
       browser.overwriteCommand(commandName, testOverride, true);
-    } catch {
-      // ignore
+    } catch (error) {
+      log.warn(`Failed to override element command '${commandName}':`, error);
     }
   }
 
@@ -370,6 +370,6 @@ async function updateAllMocks() {
     );
     log.debug('All mock updates completed successfully');
   } catch (error) {
-    log.debug('Mock update batch failed:', error);
+    log.warn('Mock update batch failed:', error);
   }
 }

packages/tauri-service/test/portManager.spec.ts

@@ -65,6 +65,32 @@ describe('PortManager', () => {
       expect(manager.getUsedPorts()).toContain(4444);
       expect(manager.getUsedPorts()).toContain(4445);
     });
+
+    it('should release first port if second allocation fails', async () => {
+      const getPort = await import('get-port');
+      const mockGetPort = vi.mocked(getPort.default);
+      let callCount = 0;
+      mockGetPort.mockImplementation(async ({ port }: { port: number }) => {
+        callCount++;
+        if (callCount === 2) {
+          throw new Error('no ports available');
+        }
+        return port;
+      });
+
+      await expect(manager.allocatePortPair(5000, 5001)).rejects.toThrow('no ports available');
+      expect(manager.getUsedPorts()).not.toContain(5000);
+      expect(manager.getUsedPorts()).toHaveLength(0);
+
+      // Restore default mock implementation
+      mockGetPort.mockImplementation(async ({ port, exclude = [] }: { port: number; exclude: number[] }) => {
+        let candidate = port;
+        while (exclude.includes(candidate) || usedPorts.has(candidate)) {
+          candidate++;
+        }
+        return candidate;
+      });
+    });
   });
 
   describe('allocatePorts', () => {