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

package/dist/workerMain.js

@@ -1,10 +1,13 @@
 import { join, dirname, basename } from 'node:path';
-import { readFile, writeFile, readdir, mkdtemp, rm } from 'node:fs/promises';
-import { pathToFileURL } from 'node:url';
+import { readFile, writeFile, readdir, mkdir, rm, access, mkdtemp } from 'node:fs/promises';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import IstanbulCoverage from 'istanbul-lib-coverage';
+import v8ToIstanbul from 'v8-to-istanbul';
+import IstanbulReport from 'istanbul-lib-report';
+import IstanbulReports from 'istanbul-reports';
 import net from 'node:net';
 import os, { tmpdir } from 'node:os';
-import { fork, spawn } from 'node:child_process';
-import { createInterface } from 'node:readline';
+import { fork } from 'node:child_process';
 import { createRequire } from 'node:module';
 
 const require$1 = createRequire(import.meta.url);
@@ -120,7 +123,7 @@ const Object$1 = 1;
 const Number$1 = 2;
 const Array$1 = 3;
 const String$1 = 4;
-const Boolean = 5;
+const Boolean$1 = 5;
 const Function = 6;
 const Null = 7;
 const Unknown = 8;
@@ -141,7 +144,7 @@ const getType = value => {
       }
       return Object$1;
     case 'boolean':
-      return Boolean;
+      return Boolean$1;
     default:
       return Unknown;
   }
@@ -166,7 +169,7 @@ const string = value => {
 };
 const boolean = value => {
   const type = getType(value);
-  if (type !== Boolean) {
+  if (type !== Boolean$1) {
     throw new AssertionError('expected value to be of type boolean');
   }
 };
@@ -945,7 +948,7 @@ const E_NO_TEST_FILES = 'E_NO_TEST_FILES';
  * @param {any} error
  */
 const isEnoentError = error => {
-  return error && error.code === ENOENT;
+  return Boolean(error && error.code === ENOENT);
 };
 
 /**
@@ -988,6 +991,96 @@ const getTests = async testSrc => {
 
 const Cli = 6001;
 
+const browserScriptCache = {};
+const fileExtensionRegex = /\.[^.]+$/;
+const tagBoundaryRegex = />\s*</g;
+const getBrowserScriptCandidates = () => {
+  return [fileURLToPath(new URL('svgScreenshot.js', import.meta.url)), fileURLToPath(new URL('../../../../../dist/test-with-playwright-worker/dist/svgScreenshot.js', import.meta.url))];
+};
+const readBrowserScript = async () => {
+  for (const candidate of getBrowserScriptCandidates()) {
+    try {
+      await access(candidate);
+      return await readFile(candidate, 'utf8');
+    } catch {
+      // Try the next development or distribution path.
+    }
+  }
+  throw new Error('[test-with-playwright] SVG screenshot browser script not found; run npm run build');
+};
+const getBrowserScript = () => {
+  browserScriptCache.promise ||= readBrowserScript();
+  return browserScriptCache.promise;
+};
+const capture = async (page, selector) => {
+  const browserScript = await getBrowserScript();
+  await page.evaluate(browserScript);
+  return page.evaluate(async selector => {
+    const api = globalThis.SvgScreenshot;
+    if (!api) {
+      throw new Error('SVG screenshot browser API was not initialized');
+    }
+    return api.capture(selector);
+  }, selector);
+};
+const formatSvg = svg => {
+  return `${svg.replaceAll(tagBoundaryRegex, '>\n<').trim()}\n`;
+};
+const getSnapshotName = (test, name) => {
+  const fileName = basename(test).replace(fileExtensionRegex, '');
+  return `${fileName}.${name}.svg`;
+};
+const captureSvgScreenshot = async ({
+  options,
+  page,
+  test
+}) => {
+  const svg = await capture(page, options.selector);
+  await compareSvgScreenshot({
+    options,
+    svg,
+    test
+  });
+};
+const compareSvgScreenshot = async ({
+  options,
+  svg,
+  test
+}) => {
+  const formattedSvg = formatSvg(svg);
+  const snapshotPath = join(options.directory, getSnapshotName(test, options.name));
+  const actualPath = `${snapshotPath}.actual`;
+  if (options.update) {
+    await mkdir(options.directory, {
+      recursive: true
+    });
+    await writeFile(snapshotPath, formattedSvg);
+    await rm(actualPath, {
+      force: true
+    });
+    return;
+  }
+  let expected;
+  try {
+    expected = await readFile(snapshotPath, 'utf8');
+  } catch (error) {
+    if (isEnoentError(error)) {
+      throw new Error(`[test-with-playwright] SVG screenshot is missing: ${snapshotPath}. Run with --update-svg-screenshots to create it.`);
+    }
+    throw error;
+  }
+  if (expected !== formattedSvg) {
+    await mkdir(options.directory, {
+      recursive: true
+    });
+    await writeFile(actualPath, formattedSvg);
+    throw new Error(`[test-with-playwright] SVG screenshot differs: ${snapshotPath}. Actual output: ${actualPath}`);
+  }
+  await rm(actualPath, {
+    force: true
+  });
+};
+
 const Pass$1 = 1;
 const Skip$1 = 2;
 const Fail$1 = 3;
@@ -1017,6 +1110,7 @@ const withTimeout = async (promise, timeout) => {
 const runElectronTest = async ({
   electronApp,
   page,
+  svgScreenshotOptions,
   test,
   testSrc,
   timeout
@@ -1043,6 +1137,13 @@ const runElectronTest = async ({
       Locator: page.locator.bind(page),
       page
     }), timeout);
+    if (svgScreenshotOptions) {
+      await captureSvgScreenshot({
+        options: svgScreenshotOptions,
+        page,
+        test
+      });
+    }
     const end = performance.now();
     return {
       end,
@@ -1098,6 +1199,7 @@ const runElectronTests = async ({
   onFinalResult,
   onResult,
   page,
+  svgScreenshotOptions,
   tests,
   testSrc,
   timeout
@@ -1113,7 +1215,10 @@ const runElectronTests = async ({
       page,
       test,
       testSrc,
-      timeout
+      timeout,
+      ...(svgScreenshotOptions && {
+        svgScreenshotOptions
+      })
     });
     await onResult(result);
     const resultCounts = getResultCounts$2(result.status);
@@ -1138,19 +1243,16 @@ const Fail = 'fail';
 const getTestState = (testOverlayState, text) => {
   switch (testOverlayState) {
     case Fail:
-      // @ts-ignore
       return {
         error: text,
         status: Fail$1
       };
     case Pass:
-      // @ts-ignore
       return {
         error: '',
         status: Pass$1
       };
     case Skip:
-      // @ts-ignore
       return {
         error: '',
         status: Skip$1
@@ -1177,6 +1279,7 @@ const getUrlFromTestFile = (absolutePath, port, traceFocus) => {
 const runTest = async ({
   page,
   port,
+  svgScreenshotOptions,
   test,
   testSrc,
   timeout,
@@ -1199,6 +1302,13 @@ const runTest = async ({
     const testOverlayState = await testOverlay.getAttribute('data-state');
     // @ts-ignore
     const testState = getTestState(testOverlayState, text || '');
+    if (testState.status === Pass$1 && svgScreenshotOptions) {
+      await captureSvgScreenshot({
+        options: svgScreenshotOptions,
+        page,
+        test
+      });
+    }
     const end = performance.now();
     return {
       // @ts-ignore
@@ -1261,6 +1371,7 @@ const runTests = async ({
   onResult,
   page,
   port,
+  svgScreenshotOptions,
   tests,
   testSrc,
   timeout,
@@ -1279,7 +1390,10 @@ const runTests = async ({
       test,
       testSrc,
       timeout,
-      traceFocus: traceFocus ?? false
+      traceFocus: traceFocus ?? false,
+      ...(svgScreenshotOptions && {
+        svgScreenshotOptions
+      })
     });
     await onResult(result);
     // @ts-ignore
@@ -1459,6 +1573,108 @@ const runTestsWithReusedPage = async ({
   });
 };
 
+const externalSourceMapCommentRegex = /(?:\/\/[#@]\s*sourceMappingURL=(?!data:).*?$|\/\*[#@]\s*sourceMappingURL=(?!data:).*?\*\/)/gm;
+const temporaryServerRootRegex = /^\/[a-f\d]{7,}(?=\/(?:js|packages)\/)/;
+const normalizeCoveragePath = path => {
+  return path.replace(temporaryServerRootRegex, '');
+};
+const normalizeCoverageData = coverageData => {
+  const normalized = Object.create(null);
+  for (const data of Object.values(coverageData)) {
+    const path = normalizeCoveragePath(data.path);
+    normalized[path] = {
+      ...data,
+      path
+    };
+  }
+  return normalized;
+};
+const getCoveragePath = url => {
+  try {
+    return decodeURIComponent(new URL(url).pathname);
+  } catch {
+    return url;
+  }
+};
+const isTestScript = url => {
+  try {
+    return new URL(url).pathname.startsWith('/tests/');
+  } catch {
+    return false;
+  }
+};
+const addEntryToCoverageMap = async (coverageMap, entry) => {
+  if (!entry.source || !entry.url || isTestScript(entry.url)) {
+    return;
+  }
+  const source = entry.source.replaceAll(externalSourceMapCommentRegex, '');
+  const converter = v8ToIstanbul(getCoveragePath(entry.url), 0, {
+    source
+  });
+  await converter.load();
+  converter.applyCoverage(entry.functions);
+  coverageMap.merge(normalizeCoverageData(converter.toIstanbul()));
+};
+const createJavascriptCoverage = async entries => {
+  const coverageMap = IstanbulCoverage.createCoverageMap();
+  for (const entry of entries) {
+    await addEntryToCoverageMap(coverageMap, entry);
+  }
+  return coverageMap;
+};
+
+const executeReport = (coverageMap, directory, name) => {
+  const context = IstanbulReport.createContext({
+    coverageMap,
+    dir: directory
+  });
+  IstanbulReports.create(name).execute(context);
+};
+const writeJavascriptCoverage = async (coverageMap, directory) => {
+  await rm(directory, {
+    force: true,
+    recursive: true
+  });
+  await mkdir(directory, {
+    recursive: true
+  });
+  executeReport(coverageMap, directory, 'json');
+  executeReport(coverageMap, directory, 'json-summary');
+  executeReport(coverageMap, directory, 'lcovonly');
+  const context = IstanbulReport.createContext({
+    coverageMap,
+    dir: directory
+  });
+  IstanbulReports.create('text', {
+    file: 'coverage.txt'
+  }).execute(context);
+  const summaryText = await readFile(join(directory, 'coverage.txt'), 'utf8');
+  const summary = summaryText.trimEnd();
+  console.info(`[test-with-playwright] JavaScript coverage written to ${directory}\n${summary}`);
+};
+
+const runWithJavascriptCoverage = async ({
+  coverage,
+  cwd,
+  page,
+  run
+}) => {
+  if (!coverage) {
+    await run();
+    return;
+  }
+  await page.coverage.startJSCoverage({
+    resetOnNavigation: false
+  });
+  try {
+    await run();
+  } finally {
+    const entries = await page.coverage.stopJSCoverage();
+    const coverageMap = await createJavascriptCoverage(entries);
+    await writeJavascriptCoverage(coverageMap, join(cwd, 'coverage'));
+  }
+};
+
 class Locked extends Error {
   constructor(port) {
     super(`${port} is locked`);
@@ -1760,101 +1976,26 @@ const getElectronProcessArgs = ({
   platform = process.platform,
   userDataDir
 }) => {
-  return ['--remote-debugging-port=0', ...(platform === 'linux' ? ['--no-sandbox'] : []), ...args, `--user-data-dir=${userDataDir}`];
+  return [...(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 {
-    stderr
-  } = child;
-  if (!stderr) {
-    throw new Error('Electron stderr is unavailable');
-  }
-  const lines = createInterface({
-    input: stderr
-  });
-  const {
-    promise,
-    reject,
-    resolve
-  } = Promise.withResolvers();
-  const stderrLines = [];
-  const onExit = () => {
-    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]);
-    }
-  };
-  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 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 electronLaunchTimeout = 120_000;
 const closeElectron = async ({
-  browser,
-  child,
+  electronApp,
   userDataDir
 }) => {
   try {
-    await browser.close();
+    await electronApp.close();
   } catch {
     // ignore close errors during cleanup
   }
-  await stopElectronProcess(child);
   await rm(userDataDir, {
     force: true,
     recursive: true
   });
 };
 const createElectronLaunch = ({
-  browser,
-  child,
+  electronApp,
   page,
   signal,
   userDataDir
@@ -1869,8 +2010,7 @@ const createElectronLaunch = ({
     process.off('SIGINT', handleSigint);
     process.off('SIGTERM', handleSigterm);
     await closeElectron({
-      browser,
-      child,
+      electronApp,
       userDataDir
     });
   };
@@ -1895,13 +2035,6 @@ const createElectronLaunch = ({
   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,
@@ -1918,44 +2051,44 @@ const startElectron = async ({
     args: launchOptions.args,
     userDataDir
   });
-  const child = spawn(launchOptions.executablePath, args, {
-    env: launchOptions.env,
-    stdio: ['ignore', 'ignore', 'pipe']
-  });
-  let browser;
+  let electronApp;
   try {
-    const endpoint = await waitForDevtoolsEndpoint(child);
     const {
-      chromium
+      _electron
     } = await import('@playwright/test');
-    browser = await chromium.connectOverCDP(endpoint, {
-      timeout: electronConnectionTimeout
+    electronApp = await _electron.launch({
+      args: [...args],
+      env: launchOptions.env,
+      executablePath: launchOptions.executablePath,
+      timeout: electronLaunchTimeout
+    });
+    const page = await electronApp.firstWindow({
+      timeout: electronLaunchTimeout
     });
-    const page = await getFirstPage(browser);
     return createElectronLaunch({
-      browser,
-      child,
+      electronApp,
       page,
       signal,
       userDataDir
     });
   } catch (error) {
-    if (browser) {
-      try {
-        await browser.close();
-      } catch {
-        // ignore close errors during cleanup
-      }
+    if (electronApp) {
+      await closeElectron({
+        electronApp,
+        userDataDir
+      });
+    } else {
+      await rm(userDataDir, {
+        force: true,
+        recursive: true
+      });
     }
-    await stopElectronProcess(child);
-    await rm(userDataDir, {
-      force: true,
-      recursive: true
-    });
     throw error;
   }
 };
 
+const SIGINT = 'SIGINT';
+
 const tearDownTests = async ({
   child,
   controller,
@@ -1982,8 +2115,9 @@ const tearDownTests = async ({
  * @param {boolean} traceFocus
  * @param {string} filter
  * @param {boolean} reusePage
+ * @param {boolean} coverage
  */
-const runAllTests = async (extensionPath, testPath, cwd, browser, headless, timeout, runtimeOptions, traceFocus, filter, reusePage) => {
+const runAllTests = async (extensionPath, testPath, cwd, browser, headless, timeout, runtimeOptions, traceFocus, filter, reusePage, svgScreenshotOptions, coverage) => {
   string(extensionPath);
   string(testPath);
   string(cwd);
@@ -1992,6 +2126,10 @@ const runAllTests = async (extensionPath, testPath, cwd, browser, headless, time
   number(timeout);
   object(runtimeOptions);
   boolean(reusePage);
+  boolean(coverage);
+  if (svgScreenshotOptions !== undefined) {
+    object(svgScreenshotOptions);
+  }
   const rpc = get(Cli);
   const controller = new AbortController();
   const {
@@ -2013,15 +2151,25 @@ const runAllTests = async (extensionPath, testPath, cwd, browser, headless, time
       runtimeOptions,
       signal
     });
-    await runElectronTests({
-      ...filterOption,
-      electronApp: electron.electronApp,
-      onFinalResult,
-      onResult,
+    await runWithJavascriptCoverage({
+      coverage,
+      cwd,
       page: electron.page,
-      tests,
-      testSrc,
-      timeout
+      run: async () => {
+        await runElectronTests({
+          ...filterOption,
+          electronApp: electron.electronApp,
+          onFinalResult,
+          onResult,
+          page: electron.page,
+          tests,
+          testSrc,
+          timeout,
+          ...(svgScreenshotOptions && {
+            svgScreenshotOptions
+          })
+        });
+      }
     });
     return;
   }
@@ -2039,39 +2187,55 @@ const runAllTests = async (extensionPath, testPath, cwd, browser, headless, time
     signal,
     testPath
   });
-  if (reusePage) {
-    await runTestsWithReusedPage({
-      ...filterOption,
-      onFinalResult,
-      onResult,
+  try {
+    if (reusePage) {
+      await runWithJavascriptCoverage({
+        coverage,
+        cwd,
+        page,
+        run: async () => {
+          await runTestsWithReusedPage({
+            ...filterOption,
+            onFinalResult,
+            onResult,
+            page,
+            port,
+            timeout,
+            traceFocus
+          });
+        }
+      });
+      return;
+    }
+    const tests = await getTests(testSrc);
+    await runWithJavascriptCoverage({
+      coverage,
+      cwd,
       page,
-      port,
-      timeout,
-      traceFocus
+      run: async () => {
+        await runTests({
+          ...filterOption,
+          headless,
+          onFinalResult,
+          onResult,
+          page,
+          port,
+          tests,
+          testSrc,
+          timeout,
+          traceFocus,
+          ...(svgScreenshotOptions && {
+            svgScreenshotOptions
+          })
+        });
+      }
     });
+  } finally {
     await tearDownTests({
       child,
       controller
     });
-    return;
   }
-  const tests = await getTests(testSrc);
-  await runTests({
-    ...filterOption,
-    headless,
-    onFinalResult,
-    onResult,
-    page,
-    port,
-    tests,
-    testSrc,
-    timeout,
-    traceFocus
-  });
-  await tearDownTests({
-    child,
-    controller
-  });
 };
 
 const RunAllTests = 'RunAllTests';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/test-with-playwright-worker",
-  "version": "22.7.0",
+  "version": "22.8.0",
   "description": "Worker package for test-with-playwright",
   "repository": {
     "type": "git",
@@ -13,7 +13,16 @@
   "main": "dist/workerMain.js",
   "dependencies": {
     "@playwright/test": "1.61.1",
-    "get-port": "^7.2.0"
+    "get-port": "^7.2.0",
+    "istanbul-lib-coverage": "^3.2.2",
+    "istanbul-lib-report": "^3.0.1",
+    "istanbul-reports": "^3.2.0",
+    "v8-to-istanbul": "^9.3.0"
+  },
+  "devDependencies": {
+    "@types/istanbul-lib-coverage": "^2.0.6",
+    "@types/istanbul-lib-report": "^3.0.3",
+    "@types/istanbul-reports": "^3.0.4"
   },
   "engines": {
     "node": ">=24"