@lvce-editor/test-with-playwright-worker 22.39.1 → 22.39.3

package/dist/coverageWorkerMain.js

@@ -1,8 +1,8 @@
+import IstanbulCoverage from 'istanbul-lib-coverage';
 import IstanbulReport from 'istanbul-lib-report';
 import IstanbulReports from 'istanbul-reports';
 import { rm, mkdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import IstanbulCoverage from 'istanbul-lib-coverage';
 import v8ToIstanbul from 'v8-to-istanbul';
 
 const normalizeLine = line => {
@@ -932,8 +932,29 @@ const executeReport = (coverageMap, directory, name) => {
   });
   IstanbulReports.create(name).execute(context);
 };
-const writeJavascriptCoverage = async (entries, directory) => {
-  const coverageMap = await createJavascriptCoverage(entries);
+const writeJavascriptCoverage = async (entries, directory, threshold, include) => {
+  let coverageMap = await createJavascriptCoverage(entries);
+  if (include) {
+    const includedCoverage = IstanbulCoverage.createCoverageMap();
+    for (const path of coverageMap.files()) {
+      if (path.includes(include)) {
+        includedCoverage.addFileCoverage(coverageMap.fileCoverageFor(path));
+      }
+    }
+    coverageMap = includedCoverage;
+    if (coverageMap.files().length === 0) {
+      throw new Error(`[test-with-playwright] worker coverage target produced no files matching ${include}`);
+    }
+  }
+  if (threshold !== undefined) {
+    if (coverageMap.files().length === 0) {
+      throw new Error('[test-with-playwright] worker coverage target produced no reportable JavaScript');
+    }
+    const {
+      lines
+    } = coverageMap.getCoverageSummary().toJSON();
+    console.info(`[test-with-playwright] worker line coverage: ${lines.pct}% (${lines.covered}/${lines.total})`);
+  }
   await rm(directory, {
     force: true,
     recursive: true
@@ -954,6 +975,14 @@ const writeJavascriptCoverage = async (entries, directory) => {
   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}`);
+  if (threshold !== undefined) {
+    const {
+      lines
+    } = coverageMap.getCoverageSummary().toJSON();
+    if (lines.total === 0 || lines.pct < threshold) {
+      throw new Error(`[test-with-playwright] worker line coverage ${lines.pct}% is below threshold ${threshold}%`);
+    }
+  }
 };
 
 const commandMap = {

package/dist/workerMain.js

@@ -2099,37 +2099,290 @@ const getCoverageWorkerUrl = (moduleUrl = import.meta.url) => {
   return new URL('../../../../test-with-playwright-coverage-worker/src/workerMain.ts', moduleUrl).href;
 };
 
-const writeJavascriptCoverage = async (entries, directory) => {
+const writeJavascriptCoverage = async (entries, directory, threshold, include) => {
   const rpc = create$1({
     commandMap: {},
     path: fileURLToPath(getCoverageWorkerUrl()),
     stdio: 'inherit'
   });
   try {
-    await rpc.invoke(WriteJavascriptCoverage, entries, directory);
+    await rpc.invoke(WriteJavascriptCoverage, entries, directory, threshold, include);
   } finally {
     await rpc.dispose();
   }
 };
 
+const trackPromise = (promises, promise, onError) => {
+  let trackedPromise = Promise.resolve();
+  trackedPromise = (async () => {
+    try {
+      await promise;
+    } catch (error) {
+      await onError(error);
+    } finally {
+      promises.delete(trackedPromise);
+    }
+  })();
+  promises.add(trackedPromise);
+};
+const startWorkerJavascriptCoverage = async (page, targetScript) => {
+  const session = await page.context().newCDPSession(page);
+  const sessions = new Set();
+  const tasks = new Set();
+  const entries = new Map();
+  const pendingEntries = new Set();
+  const timers = new Map();
+  const pendingCommands = new Map();
+  let commandId = 0;
+  let collectionError;
+  let stopped = false;
+  const recordCollectionError = error => {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!message.includes('No session with given id') && !message.includes('Target closed')) {
+      collectionError = error instanceof Error ? error : new Error(message);
+    }
+  };
+  const getCollectionError = () => collectionError;
+  const onReceivedMessage = ({
+    message
+  }) => {
+    const response = JSON.parse(message);
+    if (response.id === undefined) {
+      return;
+    }
+    const pending = pendingCommands.get(response.id);
+    if (!pending) {
+      return;
+    }
+    pendingCommands.delete(response.id);
+    if (response.error) {
+      pending.reject(new Error(response.error.message));
+    } else {
+      pending.resolve(response.result);
+    }
+  };
+  const sendToTarget = (sessionId, method, params = {}) => {
+    const id = ++commandId;
+    const command = new Promise((resolve, reject) => {
+      pendingCommands.set(id, {
+        reject,
+        resolve
+      });
+    });
+    void session.send('Target.sendMessageToTarget', {
+      message: JSON.stringify({
+        id,
+        method,
+        params
+      }),
+      sessionId
+    }).catch(error => {
+      const message = error instanceof Error ? error.message : String(error);
+      const pending = pendingCommands.get(id);
+      pendingCommands.delete(id);
+      pending?.reject(new Error(message));
+    });
+    return command;
+  };
+  const handleAttachedTarget = async ({
+    sessionId,
+    targetInfo
+  }) => {
+    const matches = targetInfo.type === 'worker' && targetInfo.url.includes(targetScript);
+    if (matches) {
+      sessions.add(sessionId);
+      await sendToTarget(sessionId, 'Debugger.enable');
+      await sendToTarget(sessionId, 'Profiler.enable');
+      await sendToTarget(sessionId, 'Profiler.startPreciseCoverage', {
+        callCount: true,
+        detailed: true
+      });
+      const timer = setInterval(() => {
+        trackPromise(pendingEntries, readTargetCoverage(sendToTarget, sessionId, entries), error => {
+          recordCollectionError(error);
+        });
+      }, 50);
+      timers.set(sessionId, timer);
+    }
+    await sendToTarget(sessionId, 'Runtime.runIfWaitingForDebugger');
+    if (matches) {
+      await readTargetCoverage(sendToTarget, sessionId, entries);
+    }
+  };
+  const onAttached = target => {
+    trackPromise(tasks, handleAttachedTarget(target), async error => {
+      recordCollectionError(error);
+      try {
+        await sendToTarget(target.sessionId, 'Runtime.runIfWaitingForDebugger');
+      } catch {
+        // The target may have closed before it could be resumed.
+      }
+    });
+  };
+  const onDetached = ({
+    sessionId
+  }) => {
+    if (!sessions.has(sessionId)) {
+      return;
+    }
+    sessions.delete(sessionId);
+    const timer = timers.get(sessionId);
+    if (timer) {
+      clearInterval(timer);
+      timers.delete(sessionId);
+    }
+  };
+  session.on('Target.attachedToTarget', onAttached);
+  session.on('Target.detachedFromTarget', onDetached);
+  session.on('Target.receivedMessageFromTarget', onReceivedMessage);
+  await session.send('Target.setAutoAttach', {
+    autoAttach: true,
+    flatten: false,
+    waitForDebuggerOnStart: true
+  });
+  return {
+    async stop() {
+      if (stopped) {
+        return entries.values().toArray();
+      }
+      stopped = true;
+      session.off('Target.attachedToTarget', onAttached);
+      session.off('Target.detachedFromTarget', onDetached);
+      try {
+        for (const timer of timers.values()) {
+          clearInterval(timer);
+        }
+        timers.clear();
+        await session.send('Target.setAutoAttach', {
+          autoAttach: false,
+          flatten: false,
+          waitForDebuggerOnStart: false
+        });
+        while (tasks.size > 0) {
+          await Promise.all(tasks);
+        }
+        await Promise.all(pendingEntries);
+        const firstCollectionError = getCollectionError();
+        if (firstCollectionError) {
+          throw new Error(firstCollectionError.message, {
+            cause: firstCollectionError
+          });
+        }
+        for (const sessionId of sessions) {
+          trackPromise(pendingEntries, readTargetCoverage(sendToTarget, sessionId, entries), error => {
+            recordCollectionError(error);
+          });
+        }
+        await Promise.all(pendingEntries);
+        const finalCollectionError = getCollectionError();
+        if (finalCollectionError) {
+          throw new Error(finalCollectionError.message, {
+            cause: finalCollectionError
+          });
+        }
+        for (const sessionId of sessions) {
+          try {
+            await sendToTarget(sessionId, 'Profiler.stopPreciseCoverage');
+          } catch {
+            // A target can exit after its last coverage snapshot.
+          }
+        }
+        const result = entries.values().toArray();
+        if (result.length === 0) {
+          throw new Error(`[test-with-playwright] no JavaScript coverage was collected for worker target ${targetScript}`);
+        }
+        return result;
+      } finally {
+        session.off('Target.receivedMessageFromTarget', onReceivedMessage);
+        await session.detach();
+      }
+    }
+  };
+};
+const readTargetCoverage = async (sendToTarget, sessionId, entries) => {
+  try {
+    const {
+      result
+    } = await sendToTarget(sessionId, 'Profiler.takePreciseCoverage');
+    for (const script of result) {
+      if (!script.url) {
+        continue;
+      }
+      const {
+        scriptSource
+      } = await sendToTarget(sessionId, 'Debugger.getScriptSource', {
+        scriptId: script.scriptId
+      });
+      const key = `${sessionId}:${script.scriptId}`;
+      const previous = entries.get(key);
+      const functions = script.functions.map((fn, index) => {
+        const previousFunction = previous?.functions[index];
+        return {
+          functionName: fn.functionName,
+          isBlockCoverage: fn.isBlockCoverage,
+          ranges: fn.ranges.map((range, rangeIndex) => {
+            const previousRange = previousFunction?.ranges[rangeIndex];
+            return {
+              count: range.count + (previousRange?.count ?? 0),
+              endOffset: range.endOffset,
+              startOffset: range.startOffset
+            };
+          })
+        };
+      });
+      entries.set(key, {
+        functions,
+        scriptId: script.scriptId,
+        source: previous?.source ?? scriptSource,
+        url: script.url
+      });
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!message.includes('No session with given id') && !message.includes('Target closed')) {
+      throw error;
+    }
+  }
+};
+
 const runWithJavascriptCoverage = async ({
   coverage,
+  coverageInclude,
+  coverageTarget,
+  coverageThreshold,
   cwd,
   page,
   run
 }) => {
-  if (!coverage) {
+  if (!coverage && !coverageTarget) {
     await run();
     return;
   }
-  await page.coverage.startJSCoverage({
-    resetOnNavigation: false
-  });
+  const workerCoverage = coverageTarget ? await startWorkerJavascriptCoverage(page, coverageTarget) : undefined;
+  let pageCoverageStarted = false;
   try {
+    if (coverage) {
+      await page.coverage.startJSCoverage({
+        resetOnNavigation: false
+      });
+      pageCoverageStarted = true;
+    }
     await run();
   } finally {
-    const entries = await page.coverage.stopJSCoverage();
-    await writeJavascriptCoverage(entries, join(cwd, 'coverage'));
+    let workerEntries;
+    if (pageCoverageStarted) {
+      try {
+        const entries = await page.coverage.stopJSCoverage();
+        await writeJavascriptCoverage(entries, join(cwd, 'coverage'));
+      } finally {
+        workerEntries = await workerCoverage?.stop();
+      }
+    } else if (workerCoverage) {
+      workerEntries = await workerCoverage.stop();
+    }
+    if (workerEntries) {
+      await writeJavascriptCoverage(workerEntries, join(cwd, 'coverage', 'worker'), coverageThreshold, coverageInclude);
+    }
   }
 };
 
@@ -2628,6 +2881,17 @@ const tearDownTests = async ({
   }
 };
 
+const assertCoverageOptions = (coverageTarget, coverageInclude, coverageThreshold) => {
+  if (coverageTarget !== undefined) {
+    string(coverageTarget);
+  }
+  if (coverageInclude !== undefined) {
+    string(coverageInclude);
+  }
+  if (coverageThreshold !== undefined) {
+    number(coverageThreshold);
+  }
+};
 /**
  * @param {string} extensionPath
  * @param {string} testPath
@@ -2642,7 +2906,7 @@ const tearDownTests = async ({
  * @param {boolean} coverage
  * @param {boolean} traceRendererWorker
  */
-const runAllTests = async (extensionPath, testPath, cwd, browser, headless, timeout, runtimeOptions, traceFocus, filter, reusePage, svgScreenshotOptions, coverage, traceRendererWorker) => {
+const runAllTests = async (extensionPath, testPath, cwd, browser, headless, timeout, runtimeOptions, traceFocus, filter, reusePage, svgScreenshotOptions, coverage, coverageInclude, coverageTarget, coverageThreshold, traceRendererWorker) => {
   string(extensionPath);
   string(testPath);
   string(cwd);
@@ -2652,6 +2916,7 @@ const runAllTests = async (extensionPath, testPath, cwd, browser, headless, time
   object(runtimeOptions);
   boolean(reusePage);
   boolean(coverage);
+  assertCoverageOptions(coverageTarget, coverageInclude, coverageThreshold);
   boolean(traceRendererWorker);
   if (svgScreenshotOptions !== undefined) {
     object(svgScreenshotOptions);
@@ -2683,6 +2948,15 @@ const runAllTests = async (extensionPath, testPath, cwd, browser, headless, time
     });
     await runWithJavascriptCoverage({
       coverage,
+      ...(coverageTarget !== undefined && {
+        coverageTarget
+      }),
+      ...(coverageInclude !== undefined && {
+        coverageInclude
+      }),
+      ...(coverageThreshold !== undefined && {
+        coverageThreshold
+      }),
       cwd,
       page: electron.page,
       run: async () => {
@@ -2728,6 +3002,15 @@ const runAllTests = async (extensionPath, testPath, cwd, browser, headless, time
     if (reusePage) {
       await runWithJavascriptCoverage({
         coverage,
+        ...(coverageTarget !== undefined && {
+          coverageTarget
+        }),
+        ...(coverageInclude !== undefined && {
+          coverageInclude
+        }),
+        ...(coverageThreshold !== undefined && {
+          coverageThreshold
+        }),
         cwd,
         page,
         run: async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/test-with-playwright-worker",
-  "version": "22.39.1",
+  "version": "22.39.3",
   "description": "Worker package for test-with-playwright",
   "repository": {
     "type": "git",