@lvce-editor/test-with-playwright-worker 22.5.0 → 22.7.0

package/dist/workerMain.js

@@ -1,8 +1,8 @@
 import { join, dirname, basename } from 'node:path';
-import { readFile, writeFile, readdir } from 'node:fs/promises';
+import { readFile, writeFile, readdir, mkdtemp, rm } from 'node:fs/promises';
 import { pathToFileURL } from 'node:url';
 import net from 'node:net';
-import os from 'node:os';
+import os, { tmpdir } from 'node:os';
 import { fork, spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { createRequire } from 'node:module';
@@ -213,7 +213,6 @@ const walkValue = (value, transferrables, isTransferrable) => {
     for (const property of Object.values(value)) {
       walkValue(property, transferrables, isTransferrable);
     }
-    return;
   }
 };
 const getTransferrables = value => {
@@ -367,7 +366,14 @@ class IpcError extends VError {
       const cause = new Error(message);
       // @ts-ignore
       cause.code = code;
-      cause.stack = stack;
+      if (stack) {
+        Object.defineProperty(cause, 'stack', {
+          configurable: true,
+          enumerable: false,
+          value: stack,
+          writable: true
+        });
+      }
       super(cause, betterMessage);
     } else {
       super(betterMessage);
@@ -522,8 +528,10 @@ const getCurrentStack = () => {
   const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
+const getNewLineIndex = (string, startIndex) => {
+  {
+    return string.indexOf(NewLine);
+  }
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
@@ -534,55 +542,77 @@ const getParentStack = error => {
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
+const restoreExistingError = (error, currentStack) => {
+  if (typeof error.stack === 'string') {
+    error.stack = error.stack + NewLine + currentStack;
+  }
+  return error;
+};
+const restoreMethodNotFoundError = (error, currentStack) => {
+  const restoredError = new JsonRpcError(error.message);
+  const parentStack = getParentStack(error);
+  restoredError.stack = parentStack + NewLine + currentStack;
+  return restoredError;
+};
+const restoreStackFromData = (restoredError, error, currentStack) => {
+  if (error.data.stack && error.data.type && error.message) {
+    restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
+    return;
+  }
+  if (error.data.stack) {
+    restoredError.stack = error.data.stack;
+  }
+};
+const applyDataProperties = (restoredError, error) => {
+  if (!error.data) {
+    return;
+  }
+  restoreStackFromData(restoredError, error, getCurrentStack());
+  if (error.data.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.data.codeFrame;
+  }
+  if (error.data.code) {
+    // @ts-ignore
+    restoredError.code = error.data.code;
+  }
+  if (error.data.type) {
+    // @ts-ignore
+    restoredError.name = error.data.type;
+  }
+};
+const applyDirectProperties = (restoredError, error) => {
+  if (error.stack) {
+    const lowerStack = restoredError.stack || '';
+    const indexNewLine = getNewLineIndex(lowerStack);
+    const parentStack = getParentStack(error);
+    // @ts-ignore
+    restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+  }
+  if (error.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.codeFrame;
+  }
+};
+const restoreMessageError = (error, _currentStack) => {
+  const restoredError = constructError(error.message, error.type, error.name);
+  if (error.data) {
+    applyDataProperties(restoredError, error);
+  } else {
+    applyDirectProperties(restoredError, error);
+  }
+  return restoredError;
+};
 const restoreJsonRpcError = error => {
   const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
-    if (typeof error.stack === 'string') {
-      error.stack = error.stack + NewLine + currentStack;
-    }
-    return error;
+    return restoreExistingError(error, currentStack);
   }
   if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine + currentStack;
-    return restoredError;
+    return restoreMethodNotFoundError(error, currentStack);
   }
   if (error && error.message) {
-    const restoredError = constructError(error.message, error.type, error.name);
-    if (error.data) {
-      if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        // @ts-ignore
-        restoredError.name = error.data.type;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
-    }
-    return restoredError;
+    return restoreMessageError(error);
   }
   if (typeof error === 'string') {
     return new Error(`JsonRpc Error: ${error}`);
@@ -1725,8 +1755,17 @@ const getElectronLaunchOptions = ({
   };
 };
 
+const getElectronProcessArgs = ({
+  args,
+  platform = process.platform,
+  userDataDir
+}) => {
+  return ['--remote-debugging-port=0', ...(platform === 'linux' ? ['--no-sandbox'] : []), ...args, `--user-data-dir=${userDataDir}`];
+};
+
 const SIGINT = 'SIGINT';
 
+const electronConnectionTimeout = 120_000;
 const devtoolsRegex = /^DevTools listening on (ws:\/\/.*)$/;
 const waitForDevtoolsEndpoint = async child => {
   const {
@@ -1743,10 +1782,13 @@ const waitForDevtoolsEndpoint = async child => {
     reject,
     resolve
   } = Promise.withResolvers();
+  const stderrLines = [];
   const onExit = () => {
-    reject(new Error('Electron exited before DevTools endpoint was available'));
+    const details = stderrLines.length > 0 ? `: ${stderrLines.join('\n')}` : '';
+    reject(new Error(`Electron exited before DevTools endpoint was available${details}`));
   };
   const onLine = line => {
+    stderrLines.push(line);
     const match = line.match(devtoolsRegex);
     if (match) {
       resolve(match[1]);
@@ -1772,24 +1814,50 @@ const getFirstPage = async browser => {
     timeout: 15_000
   });
 };
+const waitForChildExit = async child => {
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return;
+  }
+  await new Promise(resolve => {
+    const timeout = setTimeout(resolve, 5000);
+    child.once('exit', () => {
+      clearTimeout(timeout);
+      resolve();
+    });
+  });
+};
+const stopElectronProcess = async child => {
+  if (child.exitCode === null && child.signalCode === null) {
+    child.kill(SIGINT);
+    await waitForChildExit(child);
+  }
+  if (child.exitCode === null && child.signalCode === null) {
+    child.kill('SIGKILL');
+    await waitForChildExit(child);
+  }
+};
 const closeElectron = async ({
   browser,
-  child
+  child,
+  userDataDir
 }) => {
   try {
     await browser.close();
   } catch {
     // ignore close errors during cleanup
   }
-  if (!child.killed) {
-    child.kill(SIGINT);
-  }
+  await stopElectronProcess(child);
+  await rm(userDataDir, {
+    force: true,
+    recursive: true
+  });
 };
 const createElectronLaunch = ({
   browser,
   child,
   page,
-  signal
+  signal,
+  userDataDir
 }) => {
   let disposed = false;
   const dispose = async () => {
@@ -1802,7 +1870,8 @@ const createElectronLaunch = ({
     process.off('SIGTERM', handleSigterm);
     await closeElectron({
       browser,
-      child
+      child,
+      userDataDir
     });
   };
   const handleAbort = () => {
@@ -1844,7 +1913,12 @@ const startElectron = async ({
   signal
 }) => {
   const launchOptions = getElectronLaunchOptions(runtimeOptions);
-  const child = spawn(launchOptions.executablePath, ['--remote-debugging-port=0', ...launchOptions.args], {
+  const userDataDir = await mkdtemp(join(tmpdir(), 'test-with-playwright-electron-'));
+  const args = getElectronProcessArgs({
+    args: launchOptions.args,
+    userDataDir
+  });
+  const child = spawn(launchOptions.executablePath, args, {
     env: launchOptions.env,
     stdio: ['ignore', 'ignore', 'pipe']
   });
@@ -1854,13 +1928,16 @@ const startElectron = async ({
     const {
       chromium
     } = await import('@playwright/test');
-    browser = await chromium.connectOverCDP(endpoint);
+    browser = await chromium.connectOverCDP(endpoint, {
+      timeout: electronConnectionTimeout
+    });
     const page = await getFirstPage(browser);
     return createElectronLaunch({
       browser,
       child,
       page,
-      signal
+      signal,
+      userDataDir
     });
   } catch (error) {
     if (browser) {
@@ -1870,9 +1947,11 @@ const startElectron = async ({
         // ignore close errors during cleanup
       }
     }
-    if (!child.killed) {
-      child.kill(SIGINT);
-    }
+    await stopElectronProcess(child);
+    await rm(userDataDir, {
+      force: true,
+      recursive: true
+    });
     throw error;
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/test-with-playwright-worker",
-  "version": "22.5.0",
+  "version": "22.7.0",
   "description": "Worker package for test-with-playwright",
   "repository": {
     "type": "git",