@lvce-editor/test-with-playwright-worker 18.1.0 → 20.0.0

package/dist/workerMain.js

@@ -1,10 +1,11 @@
-import { basename, join } from 'node:path';
+import { join, basename } from 'node:path';
 import { readdir } from 'node:fs/promises';
 import { expect, firefox, chromium } from '@playwright/test';
+import { pathToFileURL } from 'node:url';
 import net from 'node:net';
 import os from 'node:os';
-import { pathToFileURL } from 'node:url';
-import { fork } from 'node:child_process';
+import { fork, spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
 
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
@@ -98,6 +99,12 @@ const getType = value => {
       return Unknown;
   }
 };
+const object = value => {
+  const type = getType(value);
+  if (type !== Object$1) {
+    throw new AssertionError('expected value to be of type object');
+  }
+};
 const number = value => {
   const type = getType(value);
   if (type !== Number) {
@@ -904,33 +911,169 @@ const getTests = async testSrc => {
 
 const Cli = 6001;
 
-const Pass$1 = 'pass';
-const Skip$1 = 'skip';
-const Fail$1 = 'fail';
+const Pass$1 = 1;
+const Skip$1 = 2;
+const Fail$1 = 3;
 
-const Pass = 1;
-const Skip = 2;
-const Fail = 3;
+const importTestModule = async (testSrc, test) => {
+  const testPath = join(testSrc, test);
+  const testModule = await import(pathToFileURL(testPath).toString());
+  return testModule;
+};
+const withTimeout = async (promise, timeout) => {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`Electron test timed out after ${timeout}ms`));
+    }, timeout);
+    void (async () => {
+      try {
+        const value = await promise;
+        resolve(value);
+      } catch (error) {
+        reject(error instanceof Error ? error : new Error(String(error)));
+      } finally {
+        clearTimeout(timer);
+      }
+    })();
+  });
+};
+const runElectronTest = async ({
+  electronApp,
+  page,
+  test,
+  testSrc,
+  timeout
+}) => {
+  const start = performance.now();
+  try {
+    const testModule = await importTestModule(testSrc, test);
+    if (testModule.skip) {
+      const end = performance.now();
+      return {
+        end,
+        error: '',
+        name: test,
+        start,
+        status: Skip$1
+      };
+    }
+    await withTimeout(testModule.test({
+      electronApp,
+      expect,
+      Locator: page.locator.bind(page),
+      page
+    }), timeout);
+    const end = performance.now();
+    return {
+      end,
+      error: '',
+      name: test,
+      start,
+      status: Pass$1
+    };
+  } catch (error) {
+    const end = performance.now();
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      end,
+      error: message,
+      name: test,
+      start,
+      status: Fail$1
+    };
+  }
+};
+
+const getResultCounts$1 = status => {
+  switch (status) {
+    case Fail$1:
+      return {
+        failed: 1,
+        passed: 0,
+        skipped: 0
+      };
+    case Pass$1:
+      return {
+        failed: 0,
+        passed: 1,
+        skipped: 0
+      };
+    case Skip$1:
+      return {
+        failed: 0,
+        passed: 0,
+        skipped: 1
+      };
+    default:
+      return {
+        failed: 0,
+        passed: 0,
+        skipped: 0
+      };
+  }
+};
+const runElectronTests = async ({
+  electronApp,
+  filter,
+  onFinalResult,
+  onResult,
+  page,
+  tests,
+  testSrc,
+  timeout
+}) => {
+  let failed = 0;
+  let skipped = 0;
+  let passed = 0;
+  const start = performance.now();
+  const filteredTests = filter ? tests.filter(test => test.includes(filter)) : tests;
+  for (const test of filteredTests) {
+    const result = await runElectronTest({
+      electronApp,
+      page,
+      test,
+      testSrc,
+      timeout
+    });
+    await onResult(result);
+    const resultCounts = getResultCounts$1(result.status);
+    failed += resultCounts.failed;
+    passed += resultCounts.passed;
+    skipped += resultCounts.skipped;
+  }
+  const end = performance.now();
+  await onFinalResult({
+    end,
+    failed,
+    passed,
+    skipped,
+    start
+  });
+};
+
+const Pass = 'pass';
+const Skip = 'skip';
+const Fail = 'fail';
 
 const getTestState = (testOverlayState, text) => {
   switch (testOverlayState) {
-    case Fail$1:
+    case Fail:
       // @ts-ignore
       return {
         error: text,
-        status: Fail
+        status: Fail$1
       };
-    case Pass$1:
+    case Pass:
       // @ts-ignore
       return {
         error: '',
-        status: Pass
+        status: Pass$1
       };
-    case Skip$1:
+    case Skip:
       // @ts-ignore
       return {
         error: '',
-        status: Skip
+        status: Skip$1
       };
     default:
       throw new Error(`unexpected test state: ${testOverlayState}`);
@@ -990,26 +1133,26 @@ const runTest = async ({
       error: message,
       name: test,
       start,
-      status: Fail
+      status: Fail$1
     };
   }
 };
 
 const getResultCounts = status => {
   switch (status) {
-    case Fail:
+    case Fail$1:
       return {
         failed: 1,
         passed: 0,
         skipped: 0
       };
-    case Pass:
+    case Pass$1:
       return {
         failed: 0,
         passed: 1,
         skipped: 0
       };
-    case Skip:
+    case Skip$1:
       return {
         failed: 0,
         passed: 0,
@@ -1195,7 +1338,6 @@ async function getPorts(options) {
 }
 
 const getPort = () => {
-  // @ts-ignore
   return getPorts();
 };
 
@@ -1325,14 +1467,194 @@ const setupTests = async ({
   };
 };
 
+const getProcessEnv = () => {
+  const env = Object.create(null);
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== undefined) {
+      env[key] = value;
+    }
+  }
+  return env;
+};
+const getElectronLaunchOptions = ({
+  args,
+  env,
+  executablePath
+}) => {
+  const launchEnv = {
+    ...getProcessEnv(),
+    ...env
+  };
+  delete launchEnv['ELECTRON_RUN_AS_NODE'];
+  return {
+    args,
+    env: launchEnv,
+    executablePath
+  };
+};
+
 const SIGINT = 'SIGINT';
 
+const devtoolsRegex = /^DevTools listening on (ws:\/\/.*)$/;
+const waitForDevtoolsEndpoint = async child => {
+  const {
+    stderr
+  } = child;
+  if (!stderr) {
+    throw new Error('Electron stderr is unavailable');
+  }
+  const lines = createInterface({
+    input: stderr
+  });
+  const {
+    promise,
+    reject,
+    resolve
+  } = Promise.withResolvers();
+  const onExit = () => {
+    reject(new Error('Electron exited before DevTools endpoint was available'));
+  };
+  const onLine = line => {
+    const match = line.match(devtoolsRegex);
+    if (match) {
+      resolve(match[1]);
+    }
+  };
+  child.once('exit', onExit);
+  lines.on('line', onLine);
+  try {
+    return await promise;
+  } finally {
+    child.off('exit', onExit);
+    lines.off('line', onLine);
+    lines.close();
+  }
+};
+const getFirstPage = async browser => {
+  const context = browser.contexts()[0];
+  const pages = context.pages();
+  if (pages.length > 0) {
+    return pages[0];
+  }
+  return context.waitForEvent('page', {
+    timeout: 15_000
+  });
+};
+const closeElectron = async ({
+  browser,
+  child
+}) => {
+  try {
+    await browser.close();
+  } catch {
+    // ignore close errors during cleanup
+  }
+  if (!child.killed) {
+    child.kill(SIGINT);
+  }
+};
+const createElectronLaunch = ({
+  browser,
+  child,
+  page,
+  signal
+}) => {
+  let disposed = false;
+  const dispose = async () => {
+    if (disposed) {
+      return;
+    }
+    disposed = true;
+    signal.removeEventListener('abort', handleAbort);
+    process.off('SIGINT', handleSigint);
+    process.off('SIGTERM', handleSigterm);
+    await closeElectron({
+      browser,
+      child
+    });
+  };
+  const handleAbort = () => {
+    void dispose();
+  };
+  const handleProcessSignal = processSignal => {
+    void (async () => {
+      try {
+        await dispose();
+      } finally {
+        process.kill(process.pid, processSignal);
+      }
+    })();
+  };
+  const handleSigint = () => {
+    handleProcessSignal('SIGINT');
+  };
+  const handleSigterm = () => {
+    handleProcessSignal('SIGTERM');
+  };
+  signal.addEventListener('abort', handleAbort);
+  process.once('SIGINT', handleSigint);
+  process.once('SIGTERM', handleSigterm);
+  const electronApp = {
+    close: dispose,
+    process: () => {
+      return child;
+    },
+    [Symbol.asyncDispose]: dispose
+  };
+  return {
+    electronApp,
+    page,
+    [Symbol.asyncDispose]: dispose
+  };
+};
+const startElectron = async ({
+  runtimeOptions,
+  signal
+}) => {
+  const launchOptions = getElectronLaunchOptions(runtimeOptions);
+  const child = spawn(launchOptions.executablePath, ['--remote-debugging-port=0', ...launchOptions.args], {
+    env: launchOptions.env,
+    stdio: ['ignore', 'ignore', 'pipe']
+  });
+  let browser;
+  try {
+    const endpoint = await waitForDevtoolsEndpoint(child);
+    browser = await chromium.connectOverCDP(endpoint);
+    const page = await getFirstPage(browser);
+    return createElectronLaunch({
+      browser,
+      child,
+      page,
+      signal
+    });
+  } catch (error) {
+    if (browser) {
+      try {
+        await browser.close();
+      } catch {
+        // ignore close errors during cleanup
+      }
+    }
+    if (!child.killed) {
+      child.kill(SIGINT);
+    }
+    throw error;
+  }
+};
+
 const tearDownTests = async ({
   child,
-  controller
+  controller,
+  kill
 }) => {
   controller.abort();
-  child.kill(SIGINT);
+  if (kill) {
+    await kill();
+    return;
+  }
+  if (child) {
+    child.kill(SIGINT);
+  }
 };
 
 /**
@@ -1346,31 +1668,19 @@ const tearDownTests = async ({
  * @param {boolean} traceFocus
  * @param {string} filter
  */
-const runAllTests = async (extensionPath, testPath, cwd, browser, headless, timeout, serverPath, traceFocus, filter) => {
+const runAllTests = async (extensionPath, testPath, cwd, browser, headless, timeout, runtimeOptions, traceFocus, filter) => {
   string(extensionPath);
   string(testPath);
   string(cwd);
   string(browser);
   boolean(headless);
   number(timeout);
+  object(runtimeOptions);
   const rpc = get(Cli);
   const controller = new AbortController();
   const {
     signal
   } = controller;
-  // @ts-ignore
-  const {
-    child,
-    page,
-    port
-  } = await setupTests({
-    browser,
-    headless,
-    onlyExtension: extensionPath,
-    serverPath,
-    signal,
-    testPath
-  });
   const testSrc = join(testPath, 'src');
   const tests = await getTests(testSrc);
   const onResult = async result => {
@@ -1382,6 +1692,37 @@ const runAllTests = async (extensionPath, testPath, cwd, browser, headless, time
   const filterOption = filter === undefined ? undefined : {
     filter
   };
+  if (runtimeOptions.type === 'electron') {
+    await using electron = await startElectron({
+      runtimeOptions,
+      signal
+    });
+    await runElectronTests({
+      ...filterOption,
+      electronApp: electron.electronApp,
+      onFinalResult,
+      onResult,
+      page: electron.page,
+      tests,
+      testSrc,
+      timeout
+    });
+    return;
+  }
+  const {
+    child,
+    page,
+    port
+  } = await setupTests({
+    browser,
+    headless,
+    onlyExtension: extensionPath,
+    ...(runtimeOptions.serverPath && {
+      serverPath: runtimeOptions.serverPath
+    }),
+    signal,
+    testPath
+  });
   await runTests({
     ...filterOption,
     headless,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/test-with-playwright-worker",
-  "version": "18.1.0",
+  "version": "20.0.0",
   "description": "Worker package for test-with-playwright",
   "repository": {
     "type": "git",
@@ -12,7 +12,8 @@
   "type": "module",
   "main": "dist/workerMain.js",
   "dependencies": {
-    "@playwright/test": "1.61.0"
+    "@playwright/test": "1.61.0",
+    "get-port": "^7.2.0"
   },
   "engines": {
     "node": ">=24"