playwright 1.54.1 → 1.56.1

package/lib/runner/testServer.js

@@ -29,30 +29,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var testServer_exports = {};
 __export(testServer_exports, {
   TestServerDispatcher: () => TestServerDispatcher,
-  resolveCtDirs: () => resolveCtDirs,
   runTestServer: () => runTestServer,
   runUIMode: () => runUIMode
 });
 module.exports = __toCommonJS(testServer_exports);
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
 var import_util = __toESM(require("util"));
 var import_server = require("playwright-core/lib/server");
 var import_utils = require("playwright-core/lib/utils");
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
-var import_reporters = require("./reporters");
-var import_sigIntWatcher = require("./sigIntWatcher");
-var import_tasks = require("./tasks");
 var import_configLoader = require("../common/configLoader");
-var import_fsWatcher = require("../fsWatcher");
-var import_teleReceiver = require("../isomorphic/teleReceiver");
-var import_gitCommitInfoPlugin = require("../plugins/gitCommitInfoPlugin");
-var import_webServerPlugin = require("../plugins/webServerPlugin");
-var import_base = require("../reporters/base");
-var import_internalReporter = require("../reporters/internalReporter");
 var import_list = __toESM(require("../reporters/list"));
-var import_compilationCache = require("../transform/compilationCache");
-var import_util2 = require("../util");
+var import_reporters = require("./reporters");
+var import_sigIntWatcher = require("./sigIntWatcher");
+var import_testRunner = require("./testRunner");
 const originalDebugLog = import_utilsBundle.debug.log;
 const originalStdoutWrite = process.stdout.write;
 const originalStderrWrite = process.stderr.write;
@@ -66,22 +55,14 @@ 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();
   }
 }
 class TestServerDispatcher {
   constructor(configLocation, configCLIOverrides) {
-    this._watchedProjectDirs = /* @__PURE__ */ new Set();
-    this._ignoredProjectOutputs = /* @__PURE__ */ new Set();
-    this._watchedTestDependencies = /* @__PURE__ */ new Set();
-    this._queue = Promise.resolve();
     this._serializer = require.resolve("./uiModeReporter");
-    this._watchTestDirs = false;
     this._closeOnDisconnect = false;
-    this._populateDependenciesOnList = false;
-    this._configLocation = configLocation;
-    this._configCLIOverrides = configCLIOverrides;
+    this._testRunner = new import_testRunner.TestRunner(configLocation, configCLIOverrides);
     this.transport = {
       onconnect: () => {
       },
@@ -91,27 +72,26 @@ class TestServerDispatcher {
           (0, import_utils.gracefullyProcessExitDoNotHang)(0);
       }
     };
-    this._watcher = new import_fsWatcher.Watcher((events) => {
-      const collector = /* @__PURE__ */ new Set();
-      events.forEach((f) => (0, import_compilationCache.collectAffectedTestFiles)(f.file, collector));
-      this._dispatchEvent("testFilesChanged", { testFiles: [...collector] });
-    });
     this._dispatchEvent = (method, params) => this.transport.sendEvent?.(method, params);
+    this._testRunner.on(import_testRunner.TestRunnerEvent.TestFilesChanged, (testFiles) => this._dispatchEvent("testFilesChanged", { testFiles }));
   }
   async _wireReporter(messageSink) {
     return await (0, import_reporters.createReporterForTestServer)(this._serializer, messageSink);
   }
-  async _collectingInternalReporter(...extraReporters) {
+  async _collectingReporter() {
     const report = [];
-    const collectingReporter = await (0, import_reporters.createReporterForTestServer)(this._serializer, (e) => report.push(e));
-    return { reporter: new import_internalReporter.InternalReporter([collectingReporter, ...extraReporters]), report };
+    return {
+      reporter: await (0, import_reporters.createReporterForTestServer)(this._serializer, (e) => report.push(e)),
+      report
+    };
   }
   async initialize(params) {
     this._serializer = params.serializer || require.resolve("./uiModeReporter");
     this._closeOnDisconnect = !!params.closeOnDisconnect;
-    await this._setInterceptStdio(!!params.interceptStdio);
-    this._watchTestDirs = !!params.watchTestDirs;
-    this._populateDependenciesOnList = !!params.populateDependenciesOnList;
+    await this._testRunner.initialize({
+      ...params
+    });
+    this._setInterceptStdio(!!params.interceptStdio);
   }
   async ping() {
   }
@@ -121,271 +101,102 @@ class TestServerDispatcher {
     (0, import_utilsBundle.open)("vscode://file/" + params.location.file + ":" + params.location.line).catch((e) => console.error(e));
   }
   async resizeTerminal(params) {
-    process.stdout.columns = params.cols;
-    process.stdout.rows = params.rows;
-    process.stderr.columns = params.cols;
-    process.stderr.rows = params.rows;
+    this._testRunner.resizeTerminal(params);
   }
   async checkBrowsers() {
-    return { hasBrowsers: hasSomeBrowsers() };
+    return { hasBrowsers: this._testRunner.hasSomeBrowsers() };
   }
   async installBrowsers() {
-    await installBrowsers();
+    await this._testRunner.installBrowsers();
   }
   async runGlobalSetup(params) {
     await this.runGlobalTeardown();
-    const { reporter, report } = await this._collectingInternalReporter(new import_list.default());
-    const config = await this._loadConfigOrReportError(reporter, this._configCLIOverrides);
-    if (!config)
-      return { status: "failed", report };
-    const { status, cleanup } = await (0, import_tasks.runTasksDeferCleanup)(new import_tasks.TestRun(config, reporter), [
-      ...(0, import_tasks.createGlobalSetupTasks)(config)
-    ]);
-    if (status !== "passed")
-      await cleanup();
-    else
-      this._globalSetup = { cleanup, report };
+    const { reporter, report } = await this._collectingReporter();
+    this._globalSetupReport = report;
+    const { status } = await this._testRunner.runGlobalSetup([reporter, new import_list.default()]);
     return { report, status };
   }
   async runGlobalTeardown() {
-    const globalSetup = this._globalSetup;
-    const status = await globalSetup?.cleanup();
-    this._globalSetup = void 0;
-    return { status, report: globalSetup?.report || [] };
+    const { status } = await this._testRunner.runGlobalTeardown();
+    const report = this._globalSetupReport || [];
+    this._globalSetupReport = void 0;
+    return { status, report };
   }
   async startDevServer(params) {
     await this.stopDevServer({});
-    const { reporter, report } = await this._collectingInternalReporter();
-    const config = await this._loadConfigOrReportError(reporter);
-    if (!config)
-      return { report, status: "failed" };
-    const { status, cleanup } = await (0, import_tasks.runTasksDeferCleanup)(new import_tasks.TestRun(config, reporter), [
-      (0, import_tasks.createLoadTask)("out-of-process", { failOnLoadErrors: true, filterOnly: false }),
-      (0, import_tasks.createStartDevServerTask)()
-    ]);
-    if (status !== "passed")
-      await cleanup();
-    else
-      this._devServer = { cleanup, report };
+    const { reporter, report } = await this._collectingReporter();
+    const { status } = await this._testRunner.startDevServer(reporter, "out-of-process");
     return { report, status };
   }
   async stopDevServer(params) {
-    const devServer = this._devServer;
-    const status = await devServer?.cleanup();
-    this._devServer = void 0;
-    return { status, report: devServer?.report || [] };
+    const { status } = await this._testRunner.stopDevServer();
+    const report = this._devServerReport || [];
+    this._devServerReport = void 0;
+    return { status, report };
   }
   async clearCache(params) {
-    const reporter = new import_internalReporter.InternalReporter([]);
-    const config = await this._loadConfigOrReportError(reporter);
-    if (!config)
-      return;
-    await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), [
-      (0, import_tasks.createClearCacheTask)(config)
-    ]);
+    await this._testRunner.clearCache();
   }
   async listFiles(params) {
-    const { reporter, report } = await this._collectingInternalReporter();
-    const config = await this._loadConfigOrReportError(reporter);
-    if (!config)
-      return { status: "failed", report };
-    config.cliProjectFilter = params.projects?.length ? params.projects : void 0;
-    const status = await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), [
-      (0, import_tasks.createListFilesTask)(),
-      (0, import_tasks.createReportBeginTask)()
-    ]);
+    const { reporter, report } = await this._collectingReporter();
+    const { status } = await this._testRunner.listFiles(reporter, params.projects);
     return { report, status };
   }
   async listTests(params) {
-    let result;
-    this._queue = this._queue.then(async () => {
-      const { config, report, status } = await this._innerListTests(params);
-      if (config)
-        await this._updateWatchedDirs(config);
-      result = { report, status };
-    }).catch(printInternalError);
-    await this._queue;
-    return result;
-  }
-  async _innerListTests(params) {
-    const overrides = {
-      ...this._configCLIOverrides,
-      repeatEach: 1,
-      retries: 0
-    };
-    const { reporter, report } = await this._collectingInternalReporter();
-    const config = await this._loadConfigOrReportError(reporter, overrides);
-    if (!config)
-      return { report, reporter, status: "failed" };
-    config.cliArgs = params.locations || [];
-    config.cliGrep = params.grep;
-    config.cliGrepInvert = params.grepInvert;
-    config.cliProjectFilter = params.projects?.length ? params.projects : void 0;
-    config.cliListOnly = true;
-    const status = await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), [
-      (0, import_tasks.createLoadTask)("out-of-process", { failOnLoadErrors: false, filterOnly: false, populateDependencies: this._populateDependenciesOnList }),
-      (0, import_tasks.createReportBeginTask)()
-    ]);
-    return { config, report, reporter, status };
-  }
-  async _updateWatchedDirs(config) {
-    this._watchedProjectDirs = /* @__PURE__ */ new Set();
-    this._ignoredProjectOutputs = /* @__PURE__ */ new Set();
-    for (const p of config.projects) {
-      this._watchedProjectDirs.add(p.project.testDir);
-      this._ignoredProjectOutputs.add(p.project.outputDir);
-    }
-    const result = await resolveCtDirs(config);
-    if (result) {
-      this._watchedProjectDirs.add(result.templateDir);
-      this._ignoredProjectOutputs.add(result.outDir);
-    }
-    if (this._watchTestDirs)
-      await this._updateWatcher(false);
-  }
-  async _updateWatcher(reportPending) {
-    await this._watcher.update([...this._watchedProjectDirs, ...this._watchedTestDependencies], [...this._ignoredProjectOutputs], reportPending);
+    const { reporter, report } = await this._collectingReporter();
+    const { status } = await this._testRunner.listTests(reporter, params);
+    return { report, status };
   }
   async runTests(params) {
-    let result = { status: "passed" };
-    this._queue = this._queue.then(async () => {
-      result = await this._innerRunTests(params).catch((e) => {
-        printInternalError(e);
-        return { status: "failed" };
-      });
-    });
-    await this._queue;
-    return result;
-  }
-  async _innerRunTests(params) {
-    await this.stopTests();
-    const overrides = {
-      ...this._configCLIOverrides,
-      repeatEach: 1,
-      retries: 0,
-      preserveOutputDir: true,
-      reporter: params.reporters ? params.reporters.map((r) => [r]) : void 0,
-      use: {
-        ...this._configCLIOverrides.use,
-        ...params.trace === "on" ? { trace: { mode: "on", sources: false, _live: true } } : {},
-        ...params.trace === "off" ? { trace: "off" } : {},
-        ...params.video === "on" || params.video === "off" ? { video: params.video } : {},
-        ...params.headed !== void 0 ? { headless: !params.headed } : {},
-        _optionContextReuseMode: params.reuseContext ? "when-possible" : void 0,
-        _optionConnectOptions: params.connectWsEndpoint ? { wsEndpoint: params.connectWsEndpoint } : void 0
-      },
-      ...params.updateSnapshots ? { updateSnapshots: params.updateSnapshots } : {},
-      ...params.updateSourceMethod ? { updateSourceMethod: params.updateSourceMethod } : {},
-      ...params.workers ? { workers: params.workers } : {}
-    };
-    if (params.trace === "on")
-      process.env.PW_LIVE_TRACE_STACKS = "1";
-    else
-      process.env.PW_LIVE_TRACE_STACKS = void 0;
     const wireReporter = await this._wireReporter((e) => this._dispatchEvent("report", e));
-    const config = await this._loadConfigOrReportError(new import_internalReporter.InternalReporter([wireReporter]), overrides);
-    if (!config)
-      return { status: "failed" };
-    const testIdSet = params.testIds ? new Set(params.testIds) : null;
-    config.cliListOnly = false;
-    config.cliPassWithNoTests = true;
-    config.cliArgs = params.locations || [];
-    config.cliGrep = params.grep;
-    config.cliGrepInvert = params.grepInvert;
-    config.cliProjectFilter = params.projects?.length ? params.projects : void 0;
-    config.testIdMatcher = testIdSet ? (id) => testIdSet.has(id) : void 0;
-    const configReporters = await (0, import_reporters.createReporters)(config, "test", true);
-    const reporter = new import_internalReporter.InternalReporter([...configReporters, wireReporter]);
-    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.createRunTestsTasks)(config)
-    ];
-    const run = (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), tasks, 0, stop).then(async (status) => {
-      this._testRun = void 0;
-      return status;
+    const { status } = await this._testRunner.runTests(wireReporter, {
+      ...params,
+      doNotRunDepsOutsideProjectFilter: true
     });
-    this._testRun = { run, stop };
-    return { status: await run };
+    return { status };
   }
   async watch(params) {
-    this._watchedTestDependencies = /* @__PURE__ */ new Set();
-    for (const fileName of params.fileNames) {
-      this._watchedTestDependencies.add(fileName);
-      (0, import_compilationCache.dependenciesForTestFile)(fileName).forEach((file) => this._watchedTestDependencies.add(file));
-    }
-    await this._updateWatcher(true);
+    await this._testRunner.watch(params.fileNames);
   }
   async findRelatedTestFiles(params) {
-    const errorReporter = (0, import_reporters.createErrorCollectingReporter)(import_base.internalScreen);
-    const reporter = new import_internalReporter.InternalReporter([errorReporter]);
-    const config = await this._loadConfigOrReportError(reporter);
-    if (!config)
-      return { errors: errorReporter.errors(), testFiles: [] };
-    const status = await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), [
-      (0, import_tasks.createLoadTask)("out-of-process", { failOnLoadErrors: true, filterOnly: false, populateDependencies: true })
-    ]);
-    if (status !== "passed")
-      return { errors: errorReporter.errors(), testFiles: [] };
-    return { testFiles: (0, import_compilationCache.affectedTestFiles)(params.files) };
+    return this._testRunner.findRelatedTestFiles(params.files);
   }
   async stopTests() {
-    this._testRun?.stop?.resolve();
-    await this._testRun?.run;
+    await this._testRunner.stopTests();
+  }
+  async stop() {
+    this._setInterceptStdio(false);
+    await this._testRunner.stop();
   }
-  async _setInterceptStdio(intercept) {
+  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";
           return originalStderrWrite.apply(process.stderr, [string]);
         };
       }
-      process.stdout.write = (chunk) => {
+      const stdoutWrite = (chunk) => {
         this._dispatchEvent("stdio", chunkToPayload("stdout", chunk));
         return true;
       };
-      process.stderr.write = (chunk) => {
+      const stderrWrite = (chunk) => {
         this._dispatchEvent("stdio", chunkToPayload("stderr", chunk));
         return true;
       };
+      process.stdout.write = stdoutWrite;
+      process.stderr.write = stderrWrite;
     } else {
       import_utilsBundle.debug.log = originalDebugLog;
       process.stdout.write = originalStdoutWrite;
       process.stderr.write = originalStderrWrite;
     }
   }
-  async closeGracefully() {
-    (0, import_utils.gracefullyProcessExitDoNotHang)(0);
-  }
-  async _loadConfig(overrides) {
-    try {
-      const config = await (0, import_configLoader.loadConfig)(this._configLocation, overrides);
-      if (!this._plugins) {
-        (0, import_webServerPlugin.webServerPluginsForConfig)(config).forEach((p) => config.plugins.push({ factory: p }));
-        (0, import_gitCommitInfoPlugin.addGitCommitInfoPlugin)(config);
-        this._plugins = config.plugins || [];
-      } else {
-        config.plugins.splice(0, config.plugins.length, ...this._plugins);
-      }
-      return { config };
-    } catch (e) {
-      return { config: null, error: (0, import_util2.serializeError)(e) };
-    }
-  }
-  async _loadConfigOrReportError(reporter, overrides) {
-    const { config, error } = await this._loadConfig(overrides);
-    if (config)
-      return config;
-    reporter.onConfigure(import_teleReceiver.baseFullConfig);
-    reporter.onError(error);
-    await reporter.onEnd({ status: "failed" });
-    await reporter.onExit();
-    return null;
-  }
 }
 async function runUIMode(configFile, configCLIOverrides, options) {
   const configLocation = (0, import_configLoader.resolveConfigLocation)(configFile);
@@ -445,39 +256,9 @@ function chunkToPayload(type, chunk) {
     return { type, buffer: chunk.toString("base64") };
   return { type, text: chunk };
 }
-function hasSomeBrowsers() {
-  for (const browserName of ["chromium", "webkit", "firefox"]) {
-    try {
-      import_server.registry.findExecutable(browserName).executablePathOrDie("javascript");
-      return true;
-    } catch {
-    }
-  }
-  return false;
-}
-async function installBrowsers() {
-  const executables = import_server.registry.defaultExecutables();
-  await import_server.registry.install(executables, false);
-}
-function printInternalError(e) {
-  console.error("Internal error:", e);
-}
-async function resolveCtDirs(config) {
-  const use = config.config.projects[0].use;
-  const relativeTemplateDir = use.ctTemplateDir || "playwright";
-  const templateDir = await import_fs.default.promises.realpath(import_path.default.normalize(import_path.default.join(config.configDir, relativeTemplateDir))).catch(() => void 0);
-  if (!templateDir)
-    return null;
-  const outDir = use.ctCacheDir ? import_path.default.resolve(config.configDir, use.ctCacheDir) : import_path.default.resolve(templateDir, ".cache");
-  return {
-    outDir,
-    templateDir
-  };
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   TestServerDispatcher,
-  resolveCtDirs,
   runTestServer,
   runUIMode
 });

package/lib/runner/watchMode.js

@@ -113,7 +113,11 @@ async function runWatchModeLoop(configLocation, initialOptions) {
     });
   });
   testServerConnection.onReport((report2) => teleSuiteUpdater.processTestReportEvent(report2));
-  await testServerConnection.initialize({ interceptStdio: false, watchTestDirs: true, populateDependenciesOnList: true });
+  await testServerConnection.initialize({
+    interceptStdio: false,
+    watchTestDirs: true,
+    populateDependenciesOnList: true
+  });
   await testServerConnection.runGlobalSetup({});
   const { report } = await testServerConnection.listTests({});
   teleSuiteUpdater.processListReport(report);

package/lib/runner/workerHost.js

@@ -39,24 +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, 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))
+      config: options.config,
+      artifactsDir: import_path.default.join(options.outputDir, (0, import_folders.artifactsFolderName)(workerIndex)),
+      pauseOnError: options.pauseOnError,
+      pauseAtEnd: options.pauseAtEnd
     };
   }
   async start() {