@lvce-editor/test-with-playwright-worker 21.0.0 → 22.0.0

package/dist/workerMain.js

@@ -117,7 +117,7 @@ class AssertionError extends Error {
   }
 }
 const Object$1 = 1;
-const Number = 2;
+const Number$1 = 2;
 const Array$1 = 3;
 const String$1 = 4;
 const Boolean = 5;
@@ -127,7 +127,7 @@ const Unknown = 8;
 const getType = value => {
   switch (typeof value) {
     case 'number':
-      return Number;
+      return Number$1;
     case 'function':
       return Function;
     case 'string':
@@ -154,7 +154,7 @@ const object = value => {
 };
 const number = value => {
   const type = getType(value);
-  if (type !== Number) {
+  if (type !== Number$1) {
     throw new AssertionError('expected value to be of type number');
   }
 };
@@ -1034,7 +1034,7 @@ const runElectronTest = async ({
   }
 };
 
-const getResultCounts$1 = status => {
+const getResultCounts$2 = status => {
   switch (status) {
     case Fail$1:
       return {
@@ -1086,7 +1086,7 @@ const runElectronTests = async ({
       timeout
     });
     await onResult(result);
-    const resultCounts = getResultCounts$1(result.status);
+    const resultCounts = getResultCounts$2(result.status);
     failed += resultCounts.failed;
     passed += resultCounts.passed;
     skipped += resultCounts.skipped;
@@ -1191,7 +1191,7 @@ const runTest = async ({
   }
 };
 
-const getResultCounts = status => {
+const getResultCounts$1 = status => {
   switch (status) {
     case Fail$1:
       return {
@@ -1253,6 +1253,167 @@ const runTests = async ({
     });
     await onResult(result);
     // @ts-ignore
+    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 testResultsSelector = '.TestResults';
+const getResultCounts = 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 getAllTestsUrl = (port, filter, traceFocus) => {
+  const url = new URL(`http://localhost:${port}/tests/_all.html`);
+  if (traceFocus) {
+    url.searchParams.set('traceFocus', 'true');
+  }
+  if (filter) {
+    url.searchParams.set('filter', filter);
+  }
+  return url.href;
+};
+const isObject = value => {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+const parseStatus = value => {
+  switch (value) {
+    case 'fail':
+      return Fail$1;
+    case 'pass':
+      return Pass$1;
+    case 'skip':
+      return Skip$1;
+    default:
+      throw new Error(`expected status to be pass, skip, or fail`);
+  }
+};
+const parseString = (value, field) => {
+  if (typeof value !== 'string') {
+    throw new TypeError(`expected ${field} to be a string`);
+  }
+  return value;
+};
+const parseOptionalString = (value, field) => {
+  if (value === undefined) {
+    return '';
+  }
+  return parseString(value, field);
+};
+const parseNumber = (value, field) => {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    throw new TypeError(`expected ${field} to be a finite number`);
+  }
+  return value;
+};
+const parseTestResult = value => {
+  if (!isObject(value)) {
+    throw new TypeError(`expected test result to be an object`);
+  }
+  return {
+    end: parseNumber(value.end, 'end'),
+    error: parseOptionalString(value.error, 'error'),
+    name: parseString(value.name, 'name'),
+    start: parseNumber(value.start, 'start'),
+    status: parseStatus(value.status)
+  };
+};
+const parseTestResults = text => {
+  const parsed = JSON.parse(text);
+  if (!Array.isArray(parsed)) {
+    throw new TypeError(`expected TestResults JSON to be an array`);
+  }
+  return parsed.map(parseTestResult);
+};
+const getFailedAllTestsResult = (error, start) => {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    end: performance.now(),
+    error: message,
+    name: '_all.html',
+    start,
+    status: Fail$1
+  };
+};
+const readTestResultsText = async (page, timeout) => {
+  const testResults = page.locator(testResultsSelector);
+  await testResults.waitFor({
+    state: 'attached',
+    timeout
+  });
+  await page.waitForFunction(selector => {
+    const element = document.querySelector(selector);
+    const text = element?.textContent;
+    return typeof text === 'string' && text.trim().length > 0;
+  }, testResultsSelector, {
+    timeout
+  });
+  const text = await testResults.textContent();
+  if (!text || text.trim().length === 0) {
+    throw new Error(`TestResults is empty`);
+  }
+  return text;
+};
+const runTestsWithReusedPage = async ({
+  filter,
+  onFinalResult,
+  onResult,
+  page,
+  port,
+  timeout,
+  traceFocus
+}) => {
+  const start = performance.now();
+  let results;
+  try {
+    const url = getAllTestsUrl(port, filter, traceFocus ?? false);
+    await page.goto(url, {
+      waitUntil: 'networkidle'
+    });
+    const text = await readTestResultsText(page, timeout);
+    results = parseTestResults(text);
+  } catch (error) {
+    results = [getFailedAllTestsResult(error, start)];
+  }
+  let failed = 0;
+  let passed = 0;
+  let skipped = 0;
+  for (const result of results) {
+    await onResult(result);
     const resultCounts = getResultCounts(result.status);
     failed += resultCounts.failed;
     passed += resultCounts.passed;
@@ -1741,8 +1902,9 @@ const tearDownTests = async ({
  * @param {string} serverPath
  * @param {boolean} traceFocus
  * @param {string} filter
+ * @param {boolean} reusePage
  */
-const runAllTests = async (extensionPath, testPath, cwd, browser, headless, timeout, runtimeOptions, traceFocus, filter) => {
+const runAllTests = async (extensionPath, testPath, cwd, browser, headless, timeout, runtimeOptions, traceFocus, filter, reusePage) => {
   string(extensionPath);
   string(testPath);
   string(cwd);
@@ -1750,13 +1912,13 @@ const runAllTests = async (extensionPath, testPath, cwd, browser, headless, time
   boolean(headless);
   number(timeout);
   object(runtimeOptions);
+  boolean(reusePage);
   const rpc = get(Cli);
   const controller = new AbortController();
   const {
     signal
   } = controller;
   const testSrc = join(testPath, 'src');
-  const tests = await getTests(testSrc);
   const onResult = async result => {
     await rpc.invoke(HandleResult, result);
   };
@@ -1767,6 +1929,7 @@ const runAllTests = async (extensionPath, testPath, cwd, browser, headless, time
     filter
   };
   if (runtimeOptions.type === 'electron') {
+    const tests = await getTests(testSrc);
     await using electron = await startElectron({
       runtimeOptions,
       signal
@@ -1797,6 +1960,23 @@ const runAllTests = async (extensionPath, testPath, cwd, browser, headless, time
     signal,
     testPath
   });
+  if (reusePage) {
+    await runTestsWithReusedPage({
+      ...filterOption,
+      onFinalResult,
+      onResult,
+      page,
+      port,
+      timeout,
+      traceFocus
+    });
+    await tearDownTests({
+      child,
+      controller
+    });
+    return;
+  }
+  const tests = await getTests(testSrc);
   await runTests({
     ...filterOption,
     headless,

package/package.json

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