playwright 1.55.1 → 1.56.1

package/lib/runner/tasks.js

@@ -60,14 +60,15 @@ var import_compilationCache = require("../transform/compilationCache");
 var import_util2 = require("../util");
 const readDirAsync = (0, import_util.promisify)(import_fs.default.readdir);
 class TestRun {
-  constructor(config, reporter) {
+  constructor(config, reporter, options) {
     this.rootSuite = void 0;
     this.phases = [];
     this.projectFiles = /* @__PURE__ */ new Map();
     this.projectSuites = /* @__PURE__ */ new Map();
+    this.topLevelProjects = [];
     this.config = config;
     this.reporter = reporter;
-    this.failureTracker = new import_failureTracker.FailureTracker(config);
+    this.failureTracker = new import_failureTracker.FailureTracker(config, options);
   }
 }
 async function runTasks(testRun, tasks, globalTimeout, cancelPromise) {
@@ -214,8 +215,9 @@ function createListFilesTask() {
   return {
     title: "load tests",
     setup: async (testRun, errors) => {
-      testRun.rootSuite = await (0, import_loadUtils.createRootSuite)(testRun, errors, false);
-      testRun.failureTracker.onRootSuite(testRun.rootSuite);
+      const { rootSuite, topLevelProjects } = await (0, import_loadUtils.createRootSuite)(testRun, errors, false);
+      testRun.rootSuite = rootSuite;
+      testRun.failureTracker.onRootSuite(rootSuite, topLevelProjects);
       await (0, import_loadUtils.collectProjectsAndTestFiles)(testRun, false);
       for (const [project, files] of testRun.projectFiles) {
         const projectSuite = new import_test.Suite(project.project.name, "project");
@@ -247,9 +249,18 @@ function createLoadTask(mode, options) {
         const changedFiles = await (0, import_vcs.detectChangedTestFiles)(testRun.config.cliOnlyChanged, testRun.config.configDir);
         testRun.config.preOnlyTestFilters.push((test) => changedFiles.has(test.location.file));
       }
-      testRun.rootSuite = await (0, import_loadUtils.createRootSuite)(testRun, options.failOnLoadErrors ? errors : softErrors, !!options.filterOnly);
-      testRun.failureTracker.onRootSuite(testRun.rootSuite);
-      if (options.failOnLoadErrors && !testRun.rootSuite.allTests().length && !testRun.config.cliPassWithNoTests && !testRun.config.config.shard && !testRun.config.cliOnlyChanged) {
+      if (testRun.config.cliTestList) {
+        const testListFilter = await (0, import_loadUtils.loadTestList)(testRun.config, testRun.config.cliTestList);
+        testRun.config.preOnlyTestFilters.push(testListFilter);
+      }
+      if (testRun.config.cliTestListInvert) {
+        const testListInvertFilter = await (0, import_loadUtils.loadTestList)(testRun.config, testRun.config.cliTestListInvert);
+        testRun.config.preOnlyTestFilters.push((test) => !testListInvertFilter(test));
+      }
+      const { rootSuite, topLevelProjects } = await (0, import_loadUtils.createRootSuite)(testRun, options.failOnLoadErrors ? errors : softErrors, !!options.filterOnly);
+      testRun.rootSuite = rootSuite;
+      testRun.failureTracker.onRootSuite(rootSuite, topLevelProjects);
+      if (options.failOnLoadErrors && !testRun.rootSuite.allTests().length && !testRun.config.cliPassWithNoTests && !testRun.config.config.shard && !testRun.config.cliOnlyChanged && !testRun.config.cliTestList && !testRun.config.cliTestListInvert) {
         if (testRun.config.cliArgs.length) {
           throw new Error([
             `No tests found.`,

package/lib/runner/testRunner.js

@@ -51,8 +51,7 @@ var import_reporters = require("./reporters");
 var import_tasks = require("./tasks");
 var import_lastRun = require("./lastRun");
 const TestRunnerEvent = {
-  TestFilesChanged: "testFilesChanged",
-  RecoverFromStepError: "recoverFromStepError"
+  TestFilesChanged: "testFilesChanged"
 };
 class TestRunner extends import_events.default {
   constructor(configLocation, configCLIOverrides) {
@@ -63,8 +62,6 @@ class TestRunner extends import_events.default {
     this._queue = Promise.resolve();
     this._watchTestDirs = false;
     this._populateDependenciesOnList = false;
-    this._recoverFromStepErrors = false;
-    this._resumeAfterStepErrors = /* @__PURE__ */ new Map();
     this.configLocation = configLocation;
     this._configCLIOverrides = configCLIOverrides;
     this._watcher = new import_fsWatcher.Watcher((events) => {
@@ -74,9 +71,9 @@ class TestRunner extends import_events.default {
     });
   }
   async initialize(params) {
+    (0, import_utils.setPlaywrightTestProcessEnv)();
     this._watchTestDirs = !!params.watchTestDirs;
     this._populateDependenciesOnList = !!params.populateDependenciesOnList;
-    this._recoverFromStepErrors = !!params.recoverFromStepErrors;
   }
   resizeTerminal(params) {
     process.stdout.columns = params.cols;
@@ -98,6 +95,12 @@ class TestRunner extends import_events.default {
     const executables = import_server.registry.defaultExecutables();
     await import_server.registry.install(executables, false);
   }
+  async loadConfig() {
+    const { config, error } = await this._loadConfig(this._configCLIOverrides);
+    if (config)
+      return config;
+    throw new Error("Failed to load config: " + (error ? error.message : "Unknown error"));
+  }
   async runGlobalSetup(userReporters) {
     await this.runGlobalTeardown();
     const reporter = new import_internalReporter.InternalReporter(userReporters);
@@ -232,6 +235,7 @@ class TestRunner extends import_events.default {
       ...this._configCLIOverrides,
       repeatEach: 1,
       retries: 0,
+      timeout: params.timeout,
       preserveOutputDir: true,
       reporter: params.reporters ? params.reporters.map((r) => [r]) : void 0,
       use: {
@@ -265,16 +269,15 @@ class TestRunner extends import_events.default {
       const testIdSet = new Set(params.testIds);
       config.preOnlyTestFilters.push((test) => testIdSet.has(test.id));
     }
-    const configReporters = await (0, import_reporters.createReporters)(config, "test", true);
+    const configReporters = params.disableConfigReporters ? [] : await (0, import_reporters.createReporters)(config, "test", true);
     const reporter = new import_internalReporter.InternalReporter([...configReporters, userReporter]);
     const stop = new import_utils.ManualPromise();
     const tasks = [
       (0, import_tasks.createApplyRebaselinesTask)(),
-      (0, import_tasks.createLoadTask)("out-of-process", { filterOnly: true, failOnLoadErrors: false, doNotRunDepsOutsideProjectFilter: true }),
+      (0, import_tasks.createLoadTask)("out-of-process", { filterOnly: true, failOnLoadErrors: !!params.failOnLoadErrors, doNotRunDepsOutsideProjectFilter: params.doNotRunDepsOutsideProjectFilter }),
       ...(0, import_tasks.createRunTestsTasks)(config)
     ];
-    const testRun = new import_tasks.TestRun(config, reporter);
-    testRun.failureTracker.setRecoverFromStepErrorHandler(this._recoverFromStepError.bind(this));
+    const testRun = new import_tasks.TestRun(config, reporter, { pauseOnError: params.pauseOnError, pauseAtEnd: params.pauseAtEnd });
     const run = (0, import_tasks.runTasks)(testRun, tasks, 0, stop).then(async (status) => {
       this._testRun = void 0;
       return status;
@@ -282,24 +285,6 @@ class TestRunner extends import_events.default {
     this._testRun = { run, stop };
     return { status: await run };
   }
-  async _recoverFromStepError(stepId, error) {
-    if (!this._recoverFromStepErrors)
-      return { stepId, status: "failed" };
-    const recoveryPromise = new import_utils.ManualPromise();
-    this._resumeAfterStepErrors.set(stepId, recoveryPromise);
-    if (!error?.message || !error?.location)
-      return { stepId, status: "failed" };
-    this.emit(TestRunnerEvent.RecoverFromStepError, stepId, error.message, error.location);
-    const recoveredResult = await recoveryPromise;
-    if (recoveredResult.stepId !== stepId)
-      return { stepId, status: "failed" };
-    return recoveredResult;
-  }
-  async resumeAfterStepError(params) {
-    const recoveryPromise = this._resumeAfterStepErrors.get(params.stepId);
-    if (recoveryPromise)
-      recoveryPromise.resolve(params);
-  }
   async watch(fileNames) {
     this._watchedTestDependencies = /* @__PURE__ */ new Set();
     for (const fileName of fileNames) {
@@ -325,11 +310,13 @@ class TestRunner extends import_events.default {
   async stopTests() {
     this._testRun?.stop?.resolve();
     await this._testRun?.run;
-    this._resumeAfterStepErrors.clear();
   }
   async closeGracefully() {
     (0, import_utils.gracefullyProcessExitDoNotHang)(0);
   }
+  async stop() {
+    await this.runGlobalTeardown();
+  }
   async _loadConfig(overrides) {
     try {
       const config = await (0, import_configLoader.loadConfig)(this.configLocation, overrides);
@@ -372,6 +359,7 @@ async function resolveCtDirs(config) {
   };
 }
 async function runAllTestsWithConfig(config) {
+  (0, import_utils.setPlaywrightTestProcessEnv)();
   const listOnly = config.cliListOnly;
   (0, import_gitCommitInfoPlugin.addGitCommitInfoPlugin)(config);
   (0, import_webServerPlugin.webServerPluginsForConfig)(config).forEach((p) => config.plugins.push({ factory: p }));

package/lib/runner/testServer.js

@@ -28,7 +28,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var testServer_exports = {};
 __export(testServer_exports, {
-  TestRunnerEvent: () => TestRunnerEvent,
   TestServerDispatcher: () => TestServerDispatcher,
   runTestServer: () => runTestServer,
   runUIMode: () => runUIMode
@@ -56,14 +55,9 @@ class TestServer {
     return await (0, import_server.startTraceViewerServer)({ ...options, transport: this._dispatcher.transport });
   }
   async stop() {
-    await this._dispatcher?._setInterceptStdio(false);
-    await this._dispatcher?.runGlobalTeardown();
+    await this._dispatcher?.stop();
   }
 }
-const TestRunnerEvent = {
-  TestFilesChanged: "testFilesChanged",
-  RecoverFromStepError: "recoverFromStepError"
-};
 class TestServerDispatcher {
   constructor(configLocation, configCLIOverrides) {
     this._serializer = require.resolve("./uiModeReporter");
@@ -79,8 +73,7 @@ class TestServerDispatcher {
       }
     };
     this._dispatchEvent = (method, params) => this.transport.sendEvent?.(method, params);
-    this._testRunner.on(TestRunnerEvent.TestFilesChanged, (testFiles) => this._dispatchEvent("testFilesChanged", { testFiles }));
-    this._testRunner.on(TestRunnerEvent.RecoverFromStepError, (stepId, message, location) => this._dispatchEvent("recoverFromStepError", { stepId, message, location }));
+    this._testRunner.on(import_testRunner.TestRunnerEvent.TestFilesChanged, (testFiles) => this._dispatchEvent("testFilesChanged", { testFiles }));
   }
   async _wireReporter(messageSink) {
     return await (0, import_reporters.createReporterForTestServer)(this._serializer, messageSink);
@@ -95,12 +88,10 @@ class TestServerDispatcher {
   async initialize(params) {
     this._serializer = params.serializer || require.resolve("./uiModeReporter");
     this._closeOnDisconnect = !!params.closeOnDisconnect;
-    await this._setInterceptStdio(!!params.interceptStdio);
     await this._testRunner.initialize({
-      watchTestDirs: !!params.watchTestDirs,
-      populateDependenciesOnList: !!params.populateDependenciesOnList,
-      recoverFromStepErrors: !!params.recoverFromStepErrors
+      ...params
     });
+    this._setInterceptStdio(!!params.interceptStdio);
   }
   async ping() {
   }
@@ -158,12 +149,12 @@ class TestServerDispatcher {
   }
   async runTests(params) {
     const wireReporter = await this._wireReporter((e) => this._dispatchEvent("report", e));
-    const { status } = await this._testRunner.runTests(wireReporter, params);
+    const { status } = await this._testRunner.runTests(wireReporter, {
+      ...params,
+      doNotRunDepsOutsideProjectFilter: true
+    });
     return { status };
   }
-  async resumeAfterStepError(params) {
-    await this._testRunner.resumeAfterStepError(params);
-  }
   async watch(params) {
     await this._testRunner.watch(params.fileNames);
   }
@@ -173,10 +164,17 @@ class TestServerDispatcher {
   async stopTests() {
     await this._testRunner.stopTests();
   }
-  async _setInterceptStdio(intercept) {
+  async stop() {
+    this._setInterceptStdio(false);
+    await this._testRunner.stop();
+  }
+  async closeGracefully() {
+    await this._testRunner.closeGracefully();
+  }
+  _setInterceptStdio(interceptStdio) {
     if (process.env.PWTEST_DEBUG)
       return;
-    if (intercept) {
+    if (interceptStdio) {
       if (import_utilsBundle.debug.log === originalDebugLog) {
         import_utilsBundle.debug.log = (...args) => {
           const string = import_util.default.format(...args) + "\n";
@@ -199,9 +197,6 @@ class TestServerDispatcher {
       process.stderr.write = originalStderrWrite;
     }
   }
-  async closeGracefully() {
-    await this._testRunner.closeGracefully();
-  }
 }
 async function runUIMode(configFile, configCLIOverrides, options) {
   const configLocation = (0, import_configLoader.resolveConfigLocation)(configFile);
@@ -263,7 +258,6 @@ function chunkToPayload(type, chunk) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  TestRunnerEvent,
   TestServerDispatcher,
   runTestServer,
   runUIMode

package/lib/runner/watchMode.js

@@ -31,7 +31,6 @@ __export(watchMode_exports, {
   runWatchModeLoop: () => runWatchModeLoop
 });
 module.exports = __toCommonJS(watchMode_exports);
-var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_readline = __toESM(require("readline"));
 var import_stream = require("stream");
@@ -43,8 +42,6 @@ var import_utilsBundle = require("../utilsBundle");
 var import_testServer = require("./testServer");
 var import_teleSuiteUpdater = require("../isomorphic/teleSuiteUpdater");
 var import_testServerConnection = require("../isomorphic/testServerConnection");
-var import_util = require("../util");
-var import_babelBundle = require("../transform/babelBundle");
 class InMemoryTransport extends import_stream.EventEmitter {
   constructor(send) {
     super();
@@ -116,36 +113,10 @@ async function runWatchModeLoop(configLocation, initialOptions) {
     });
   });
   testServerConnection.onReport((report2) => teleSuiteUpdater.processTestReportEvent(report2));
-  testServerConnection.onRecoverFromStepError(({ stepId, message, location }) => {
-    process.stdout.write(`
-Test error occurred.
-`);
-    process.stdout.write("\n" + createErrorCodeframe(message, location) + "\n");
-    process.stdout.write(`
-${import_utils2.colors.dim("Try recovering from the error. Press")} ${import_utils2.colors.bold("c")} ${import_utils2.colors.dim("to continue or")} ${import_utils2.colors.bold("t")} ${import_utils2.colors.dim("to throw the error")}
-`);
-    readKeyPress((text) => {
-      if (text === "c") {
-        process.stdout.write(`
-${import_utils2.colors.dim("Continuing after recovery...")}
-`);
-        testServerConnection.resumeAfterStepError({ stepId, status: "recovered", value: void 0 }).catch(() => {
-        });
-      } else if (text === "t") {
-        process.stdout.write(`
-${import_utils2.colors.dim("Throwing error...")}
-`);
-        testServerConnection.resumeAfterStepError({ stepId, status: "failed" }).catch(() => {
-        });
-      }
-      return text;
-    });
-  });
   await testServerConnection.initialize({
     interceptStdio: false,
     watchTestDirs: true,
-    populateDependenciesOnList: true,
-    recoverFromStepErrors: !process.env.PWTEST_RECOVERY_DISABLED
+    populateDependenciesOnList: true
   });
   await testServerConnection.runGlobalSetup({});
   const { report } = await testServerConnection.listTests({});
@@ -418,29 +389,6 @@ async function toggleShowBrowser() {
 `);
   }
 }
-function createErrorCodeframe(message, location) {
-  let source;
-  try {
-    source = import_fs.default.readFileSync(location.file, "utf-8") + "\n//";
-  } catch (e) {
-    return;
-  }
-  return (0, import_babelBundle.codeFrameColumns)(
-    source,
-    {
-      start: {
-        line: location.line,
-        column: location.column
-      }
-    },
-    {
-      highlightCode: true,
-      linesAbove: 5,
-      linesBelow: 5,
-      message: (0, import_util.stripAnsiEscapes)(message).split("\n")[0] || void 0
-    }
-  );
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   runWatchModeLoop

package/lib/runner/workerHost.js

@@ -39,25 +39,26 @@ var import_ipc = require("../common/ipc");
 var import_folders = require("../isomorphic/folders");
 let lastWorkerIndex = 0;
 class WorkerHost extends import_processHost.ProcessHost {
-  constructor(testGroup, parallelIndex, config, recoverFromStepErrors, extraEnv, outputDir) {
+  constructor(testGroup, options) {
     const workerIndex = lastWorkerIndex++;
     super(require.resolve("../worker/workerMain.js"), `worker-${workerIndex}`, {
-      ...extraEnv,
+      ...options.extraEnv,
       FORCE_COLOR: "1",
       DEBUG_COLORS: process.env.DEBUG_COLORS === void 0 ? "1" : process.env.DEBUG_COLORS
     });
     this._didFail = false;
     this.workerIndex = workerIndex;
-    this.parallelIndex = parallelIndex;
+    this.parallelIndex = options.parallelIndex;
     this._hash = testGroup.workerHash;
     this._params = {
       workerIndex: this.workerIndex,
-      parallelIndex,
+      parallelIndex: options.parallelIndex,
       repeatEachIndex: testGroup.repeatEachIndex,
       projectId: testGroup.projectId,
-      config,
-      artifactsDir: import_path.default.join(outputDir, (0, import_folders.artifactsFolderName)(workerIndex)),
-      recoverFromStepErrors
+      config: options.config,
+      artifactsDir: import_path.default.join(options.outputDir, (0, import_folders.artifactsFolderName)(workerIndex)),
+      pauseOnError: options.pauseOnError,
+      pauseAtEnd: options.pauseAtEnd
     };
   }
   async start() {
@@ -78,9 +79,6 @@ class WorkerHost extends import_processHost.ProcessHost {
   runTestGroup(runPayload) {
     this.sendMessageNoReply({ method: "runTestGroup", params: runPayload });
   }
-  resumeAfterStepError(result) {
-    this.sendMessageNoReply({ method: "resumeAfterStepError", params: result });
-  }
   hash() {
     return this._hash;
   }