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

package/README.md

@@ -13,7 +13,7 @@
 ```json
 {
   "scripts": {
-    "e2e:electron": "node ./node_modules/@lvce-editor/test-with-playwright/bin/test-with-playwright.js --runtime=electron --electron-version=v0.84.0 --test-path=./e2e"
+    "e2e:electron": "node ./node_modules/@lvce-editor/test-with-playwright/bin/test-with-playwright.js --electron --test-path=./e2e"
   }
 }
 ```
@@ -28,6 +28,7 @@ test('sample.hello-world', async () => {
 ## CLI Flags
 
 - `--runtime`: `browser` (default) or `electron`
+- `--electron`: shorthand for `--runtime=electron`; infers the Lvce release from the installed `@lvce-editor/server`
 - `--only-extension`: path to the extension under test
 - `--test-path`: path to the test root
 - `--server-path`: explicit server entry point
@@ -38,7 +39,7 @@ test('sample.hello-world', async () => {
 - `--browser`: browser engine to launch: `chromium`, `firefox`, or `webkit`
 - `--trace-focus`: add `traceFocus=true` to test URLs
 - `--electron-path`: path to an existing Electron app executable
-- `--electron-version`: Lvce release version to download, required for `--runtime=electron` when `--electron-path` is not provided
+- `--electron-version`: Lvce release version override; by default Electron uses the installed `@lvce-editor/server` version
 - `--electron-cache-dir`: directory for downloaded Electron apps, defaults to `.test-with-playwright/electron`
 - `--electron-arg`: extra Electron app argument, can be provided multiple times
 - `--electron-env`: Electron environment variable in `NAME=value` form, can be provided multiple times
@@ -47,7 +48,7 @@ test('sample.hello-world', async () => {
 
 - `browser` keeps the server-backed HTML test execution flow.
 - `--reuse-page` is browser-only. It loads `/tests/_all.html` once and reads JSON results from a hidden `.TestResults` element.
-- `electron` downloads or reuses a Lvce Electron app, launches it with Playwright, and runs each test module against the first window.
+- `electron` downloads or reuses the matching Lvce Electron app, launches it with Playwright and a temporary user data directory, and runs each test module against the first window.
 - `--electron-path` skips downloading and is useful for custom local builds.
 
 ## Reuse Page Results

package/dist/main.js

@@ -1,6 +1,7 @@
-import { dirname, join, resolve as resolve$1, basename } from 'node:path';
+import { resolve as resolve$1, join, dirname, parse, basename } from 'node:path';
+import { readFile, mkdir, readdir, stat, chmod, writeFile, rm, mkdtemp } from 'node:fs/promises';
+import { createRequire } from 'node:module';
 import { createWriteStream, existsSync } from 'node:fs';
-import { mkdir, readdir, stat, readFile, chmod, writeFile, rm, mkdtemp } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { pipeline } from 'node:stream/promises';
 import { execFile as execFile$1 } from 'node:child_process';
@@ -122,6 +123,7 @@ const getHelpMessage = () => {
 Options:
   --browser=<browser>       Browser to run tests in: chromium, firefox, or webkit
   --runtime=<runtime>       Runtime to run tests in: browser or electron
+  --electron                Run tests in Electron and infer the matching Lvce version
   --filter=<pattern>        Only run tests matching the filter
   --headless                Run the browser in headless mode
   --reuse-page              Run browser tests through /tests/_all.html on one page
@@ -131,7 +133,7 @@ Options:
   --timeout=<ms>            Test timeout in milliseconds
   --trace-focus             Log focus changes while tests run
   --electron-path=<path>    Path to an existing Electron app executable
-  --electron-version=<ver>  Lvce release version to download, for example v0.84.0
+  --electron-version=<ver>  Override the inferred Lvce release version
   --electron-cache-dir=<p>  Directory for downloaded Electron apps
   --electron-arg=<arg>      Extra Electron app argument, repeatable
   --electron-env=<env>      Electron environment variable as NAME=value, repeatable
@@ -409,14 +411,24 @@ const setOptionalPositiveNumber = (result, key, value, name) => {
     result[key] = toPositiveNumber(value, name);
   }
 };
+const getRuntime = parsed => {
+  if (parsed.electron) {
+    return 'electron';
+  }
+  if (parsed.runtime) {
+    return toCliString(parsed.runtime);
+  }
+  return undefined;
+};
 const parseCliArgs = argv => {
   const parsed = parseArgv(argv);
   const result = Object.create(null);
   if (parsed.browser) {
     result.browser = String(parsed.browser);
   }
-  if (parsed.runtime) {
-    result.runtime = String(parsed.runtime);
+  const runtime = getRuntime(parsed);
+  if (runtime) {
+    result.runtime = runtime;
   }
   if (parsed.filter) {
     result.filter = String(parsed.filter);
@@ -523,6 +535,64 @@ const getOptions = ({
   };
 };
 
+const serverPackageName = '@lvce-editor/server';
+const normalizeVersion = version => {
+  return version.startsWith('v') ? version : `v${version}`;
+};
+const readServerVersion = async path => {
+  try {
+    const content = await readFile(path, 'utf8');
+    const packageJson = JSON.parse(content);
+    if (packageJson.name === serverPackageName && typeof packageJson.version === 'string') {
+      return normalizeVersion(packageJson.version);
+    }
+  } catch {
+    // Try the next possible package location.
+  }
+  return undefined;
+};
+const findServerVersionFromPath = async path => {
+  let current = resolve$1(path);
+  if (!current.endsWith('package.json')) {
+    current = dirname(current);
+  }
+  const {
+    root
+  } = parse(current);
+  while (current !== root) {
+    const version = await readServerVersion(join(current, 'package.json'));
+    if (version) {
+      return version;
+    }
+    current = dirname(current);
+  }
+  return undefined;
+};
+const resolveServerEntryPoint = cwd => {
+  try {
+    const require = createRequire(join(cwd, 'package.json'));
+    return require.resolve(serverPackageName);
+  } catch {
+    return undefined;
+  }
+};
+const getPossibleServerPaths = (cwd, serverPath) => {
+  const resolvedServerEntryPoint = resolveServerEntryPoint(cwd);
+  return [...(serverPath ? [resolve$1(cwd, serverPath)] : []), ...(resolvedServerEntryPoint ? [resolvedServerEntryPoint] : []), join(cwd, 'node_modules', '@lvce-editor', 'server', 'package.json'), join(cwd, '..', 'server', 'node_modules', '@lvce-editor', 'server', 'package.json'), join(cwd, '..', 'build', 'node_modules', '@lvce-editor', 'server', 'package.json')];
+};
+const getElectronVersion = async ({
+  cwd,
+  serverPath
+}) => {
+  for (const possiblePath of getPossibleServerPaths(cwd, serverPath)) {
+    const version = possiblePath.endsWith('package.json') ? await readServerVersion(possiblePath) : await findServerVersionFromPath(possiblePath);
+    if (version) {
+      return version;
+    }
+  }
+  throw new Error('[test-with-playwright] Electron version could not be inferred from @lvce-editor/server; use --electron-version or --electron-path');
+};
+
 const downloadFile = async ({
   to,
   url
@@ -870,13 +940,19 @@ const getRuntimeOptions = async ({
     return getBrowserRuntimeOptions(serverPath);
   }
   const cacheDir = resolve$1(cwd, electronCacheDir || '.test-with-playwright/electron');
+  const version = electronVersion || electronPath ? electronVersion : await getElectronVersion({
+    cwd,
+    ...(serverPath && {
+      serverPath
+    })
+  });
   const executablePath = await prepareElectronApp({
     cacheDir,
     ...(electronPath && {
       electronPath: resolve$1(cwd, electronPath)
     }),
-    ...(electronVersion && {
-      version: electronVersion
+    ...(version && {
+      version
     })
   });
   return {
@@ -1035,7 +1111,6 @@ const walkValue = (value, transferrables, isTransferrable) => {
     for (const property of Object.values(value)) {
       walkValue(property, transferrables, isTransferrable);
     }
-    return;
   }
 };
 const getTransferrables = value => {
@@ -1189,7 +1264,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);
@@ -1426,8 +1508,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 || '';
@@ -1438,55 +1522,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}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/test-with-playwright",
-  "version": "22.5.0",
+  "version": "22.7.0",
   "description": "CLI tool for running Playwright tests",
   "repository": {
     "type": "git",
@@ -12,8 +12,8 @@
   "main": "dist/main.js",
   "bin": "bin/test-with-playwright.js",
   "dependencies": {
-    "@lvce-editor/test-with-playwright-worker": "22.5.0",
-    "@lvce-editor/test-worker": "^17.0.2"
+    "@lvce-editor/test-with-playwright-worker": "22.7.0",
+    "@lvce-editor/test-worker": "^17.2.0"
   },
   "engines": {
     "node": ">=24"