@lvce-editor/test-with-playwright-worker 22.7.1 → 22.8.1

package/dist/workerMain.js

@@ -1,6 +1,10 @@
 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 } from 'node:child_process';
@@ -119,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;
@@ -140,7 +144,7 @@ const getType = value => {
       }
       return Object$1;
     case 'boolean':
-      return Boolean;
+      return Boolean$1;
     default:
       return Unknown;
   }
@@ -165,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');
   }
 };
@@ -944,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);
 };
 
 /**
@@ -987,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;
@@ -1016,6 +1110,7 @@ const withTimeout = async (promise, timeout) => {
 const runElectronTest = async ({
   electronApp,
   page,
+  svgScreenshotOptions,
   test,
   testSrc,
   timeout
@@ -1042,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,
@@ -1097,6 +1199,7 @@ const runElectronTests = async ({
   onFinalResult,
   onResult,
   page,
+  svgScreenshotOptions,
   tests,
   testSrc,
   timeout
@@ -1112,7 +1215,10 @@ const runElectronTests = async ({
       page,
       test,
       testSrc,
-      timeout
+      timeout,
+      ...(svgScreenshotOptions && {
+        svgScreenshotOptions
+      })
     });
     await onResult(result);
     const resultCounts = getResultCounts$2(result.status);
@@ -1137,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
@@ -1176,6 +1279,7 @@ const getUrlFromTestFile = (absolutePath, port, traceFocus) => {
 const runTest = async ({
   page,
   port,
+  svgScreenshotOptions,
   test,
   testSrc,
   timeout,
@@ -1198,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
@@ -1260,6 +1371,7 @@ const runTests = async ({
   onResult,
   page,
   port,
+  svgScreenshotOptions,
   tests,
   testSrc,
   timeout,
@@ -1278,7 +1390,10 @@ const runTests = async ({
       test,
       testSrc,
       timeout,
-      traceFocus: traceFocus ?? false
+      traceFocus: traceFocus ?? false,
+      ...(svgScreenshotOptions && {
+        svgScreenshotOptions
+      })
     });
     await onResult(result);
     // @ts-ignore
@@ -1431,6 +1546,7 @@ const runTestsWithReusedPage = async ({
   try {
     const url = getAllTestsUrl(port, filter, traceFocus ?? false);
     await page.goto(url, {
+      timeout,
       waitUntil: 'networkidle'
     });
     const text = await readTestResultsText(page, timeout);
@@ -1458,6 +1574,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`);
@@ -1898,8 +2116,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);
@@ -1908,6 +2127,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 {
@@ -1929,15 +2152,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;
   }
@@ -1955,39 +2188,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.1",
+  "version": "22.8.1",
   "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"