@lvce-editor/test-with-playwright 22.6.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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/test-with-playwright",
-  "version": "22.6.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.6.0",
-    "@lvce-editor/test-worker": "^17.1.0"
+    "@lvce-editor/test-with-playwright-worker": "22.7.0",
+    "@lvce-editor/test-worker": "^17.2.0"
   },
   "engines": {
     "node": ">=24"