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

package/dist/workerMain.js

@@ -1,11 +1,58 @@
-import { join, basename } from 'node:path';
-import { readdir } from 'node:fs/promises';
-import { expect, webkit, firefox, chromium } from '@playwright/test';
+import { join, dirname, basename } from 'node:path';
+import { readFile, writeFile, readdir } from 'node:fs/promises';
 import { pathToFileURL } from 'node:url';
 import net from 'node:net';
 import os from 'node:os';
 import { fork, spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
+import { createRequire } from 'node:module';
+
+const require$1 = createRequire(import.meta.url);
+const before = `      _onWebSocketOpened(event) {
+        const request2 = this._webSocketRequests.get(event.requestId);
+        assert(request2);
+        const response2 = this._webSocketResponses.get(event.requestId);
+        assert(response2);
+        this._webSocketRequests.delete(event.requestId);
+        this._webSocketResponses.delete(event.requestId);
+        this._page.frameManager.onWebSocketRequest(webSocketId(event.frameId, event.wsid), request2.headers);
+        this._page.frameManager.onWebSocketResponse(webSocketId(event.frameId, event.wsid), response2.status, response2.statusText, response2.headers);
+      }`;
+const after = `      _onWebSocketOpened(event) {
+        const request2 = this._webSocketRequests.get(event.requestId);
+        const response2 = this._webSocketResponses.get(event.requestId);
+        if (!request2 || !response2) {
+          this._webSocketRequests.delete(event.requestId);
+          this._webSocketResponses.delete(event.requestId);
+          return;
+        }
+        this._webSocketRequests.delete(event.requestId);
+        this._webSocketResponses.delete(event.requestId);
+        this._page.frameManager.onWebSocketRequest(webSocketId(event.frameId, event.wsid), request2.headers);
+        this._page.frameManager.onWebSocketResponse(webSocketId(event.frameId, event.wsid), response2.status, response2.statusText, response2.headers);
+      }`;
+const patchCoreBundleContent = content => {
+  if (content.includes(after)) {
+    return content;
+  }
+  if (!content.includes(before)) {
+    throw new Error('Could not patch Playwright Firefox worker WebSocket handler');
+  }
+  return content.split(before).join(after);
+};
+const getCoreBundlePath = () => {
+  const packageJsonPath = require$1.resolve('playwright-core/package.json');
+  return join(dirname(packageJsonPath), 'lib', 'coreBundle.js');
+};
+const patchPlaywrightFirefoxWorkerWebSocket = async () => {
+  const file = getCoreBundlePath();
+  const content = await readFile(file, 'utf8');
+  const patched = patchCoreBundleContent(content);
+  if (patched === content) {
+    return;
+  }
+  await writeFile(file, patched);
+};
 
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
@@ -70,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;
@@ -80,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':
@@ -107,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');
   }
 };
@@ -957,6 +1004,9 @@ const runElectronTest = async ({
         status: Skip$1
       };
     }
+    const {
+      expect
+    } = await import('@playwright/test');
     await withTimeout(testModule.test({
       electronApp,
       expect,
@@ -984,7 +1034,7 @@ const runElectronTest = async ({
   }
 };
 
-const getResultCounts$1 = status => {
+const getResultCounts$2 = status => {
   switch (status) {
     case Fail$1:
       return {
@@ -1036,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;
@@ -1104,6 +1154,9 @@ const runTest = async ({
 }) => {
   const start = performance.now();
   try {
+    const {
+      expect
+    } = await import('@playwright/test');
     const url = getUrlFromTestFile(test, port, traceFocus);
     await page.goto(url, {
       waitUntil: 'networkidle'
@@ -1138,7 +1191,7 @@ const runTest = async ({
   }
 };
 
-const getResultCounts = status => {
+const getResultCounts$1 = status => {
   switch (status) {
     case Fail$1:
       return {
@@ -1200,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;
@@ -1370,7 +1584,12 @@ const getServerPath = async serverPath => {
  * @param {{browser:'chromium'|'firefox'|'webkit', signal:AbortSignal, headless:boolean}} options
  * @returns
  */
-const getLauncher = browser => {
+const getLauncher = async browser => {
+  const {
+    chromium,
+    firefox,
+    webkit
+  } = await import('@playwright/test');
   switch (browser) {
     case 'chromium':
       return chromium;
@@ -1385,7 +1604,10 @@ const startBrowser = async ({
   headless,
   signal
 }) => {
-  const launcher = getLauncher(browser);
+  if (browser === 'firefox') {
+    await patchPlaywrightFirefoxWorkerWebSocket();
+  }
+  const launcher = await getLauncher(browser);
   const browserInstance = await launcher.launch({
     headless
   });
@@ -1629,6 +1851,9 @@ const startElectron = async ({
   let browser;
   try {
     const endpoint = await waitForDevtoolsEndpoint(child);
+    const {
+      chromium
+    } = await import('@playwright/test');
     browser = await chromium.connectOverCDP(endpoint);
     const page = await getFirstPage(browser);
     return createElectronLaunch({
@@ -1677,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);
@@ -1686,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);
   };
@@ -1703,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
@@ -1733,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,
@@ -1789,4 +2033,13 @@ const main = async () => {
   set(Cli, rpc);
 };
 
-main();
+const Main$1 = {
+  __proto__: null,
+  main
+};
+
+if (process.argv.includes('--browser=firefox')) {
+  await patchPlaywrightFirefoxWorkerWebSocket();
+}
+const Main = await Promise.resolve().then(function () { return Main$1; });
+await Main.main();

package/package.json

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