@stablyai/internal-playwright 0.1.0

package/lib/runner/tasks.js

@@ -0,0 +1,410 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tasks_exports = {};
+__export(tasks_exports, {
+  TestRun: () => TestRun,
+  createApplyRebaselinesTask: () => createApplyRebaselinesTask,
+  createClearCacheTask: () => createClearCacheTask,
+  createGlobalSetupTasks: () => createGlobalSetupTasks,
+  createListFilesTask: () => createListFilesTask,
+  createLoadTask: () => createLoadTask,
+  createPluginSetupTasks: () => createPluginSetupTasks,
+  createReportBeginTask: () => createReportBeginTask,
+  createRunTestsTasks: () => createRunTestsTasks,
+  createStartDevServerTask: () => createStartDevServerTask,
+  runTasks: () => runTasks,
+  runTasksDeferCleanup: () => runTasksDeferCleanup
+});
+module.exports = __toCommonJS(tasks_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_util = require("util");
+var import_utils = require("playwright-core/lib/utils");
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_dispatcher = require("./dispatcher");
+var import_failureTracker = require("./failureTracker");
+var import_loadUtils = require("./loadUtils");
+var import_projectUtils = require("./projectUtils");
+var import_rebase = require("./rebase");
+var import_taskRunner = require("./taskRunner");
+var import_vcs = require("./vcs");
+var import_test = require("../common/test");
+var import_testGroups = require("../runner/testGroups");
+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, 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, options);
+  }
+}
+async function runTasks(testRun, tasks, globalTimeout, cancelPromise) {
+  const deadline = globalTimeout ? (0, import_utils.monotonicTime)() + globalTimeout : 0;
+  const taskRunner = new import_taskRunner.TaskRunner(testRun.reporter, globalTimeout || 0);
+  for (const task of tasks)
+    taskRunner.addTask(task);
+  testRun.reporter.onConfigure(testRun.config.config);
+  const status = await taskRunner.run(testRun, deadline, cancelPromise);
+  return await finishTaskRun(testRun, status);
+}
+async function runTasksDeferCleanup(testRun, tasks) {
+  const taskRunner = new import_taskRunner.TaskRunner(testRun.reporter, 0);
+  for (const task of tasks)
+    taskRunner.addTask(task);
+  testRun.reporter.onConfigure(testRun.config.config);
+  const { status, cleanup } = await taskRunner.runDeferCleanup(testRun, 0);
+  return { status: await finishTaskRun(testRun, status), cleanup };
+}
+async function finishTaskRun(testRun, status) {
+  if (status === "passed")
+    status = testRun.failureTracker.result();
+  const modifiedResult = await testRun.reporter.onEnd({ status });
+  if (modifiedResult && modifiedResult.status)
+    status = modifiedResult.status;
+  await testRun.reporter.onExit();
+  return status;
+}
+function createGlobalSetupTasks(config) {
+  const tasks = [];
+  if (!config.configCLIOverrides.preserveOutputDir)
+    tasks.push(createRemoveOutputDirsTask());
+  tasks.push(
+    ...createPluginSetupTasks(config),
+    ...config.globalTeardowns.map((file) => createGlobalTeardownTask(file, config)).reverse(),
+    ...config.globalSetups.map((file) => createGlobalSetupTask(file, config))
+  );
+  return tasks;
+}
+function createRunTestsTasks(config) {
+  return [
+    createPhasesTask(),
+    createReportBeginTask(),
+    ...config.plugins.map((plugin) => createPluginBeginTask(plugin)),
+    createRunTestsTask()
+  ];
+}
+function createClearCacheTask(config) {
+  return {
+    title: "clear cache",
+    setup: async () => {
+      await (0, import_util2.removeDirAndLogToConsole)(import_compilationCache.cacheDir);
+      for (const plugin of config.plugins)
+        await plugin.instance?.clearCache?.();
+    }
+  };
+}
+function createReportBeginTask() {
+  return {
+    title: "report begin",
+    setup: async (testRun) => {
+      testRun.reporter.onBegin?.(testRun.rootSuite);
+    },
+    teardown: async ({}) => {
+    }
+  };
+}
+function createPluginSetupTasks(config) {
+  return config.plugins.map((plugin) => ({
+    title: "plugin setup",
+    setup: async ({ reporter }) => {
+      if (typeof plugin.factory === "function")
+        plugin.instance = await plugin.factory();
+      else
+        plugin.instance = plugin.factory;
+      await plugin.instance?.setup?.(config.config, config.configDir, reporter);
+    },
+    teardown: async () => {
+      await plugin.instance?.teardown?.();
+    }
+  }));
+}
+function createPluginBeginTask(plugin) {
+  return {
+    title: "plugin begin",
+    setup: async (testRun) => {
+      await plugin.instance?.begin?.(testRun.rootSuite);
+    },
+    teardown: async () => {
+      await plugin.instance?.end?.();
+    }
+  };
+}
+function createGlobalSetupTask(file, config) {
+  let title = "global setup";
+  if (config.globalSetups.length > 1)
+    title += ` (${file})`;
+  let globalSetupResult;
+  return {
+    title,
+    setup: async ({ config: config2 }) => {
+      const setupHook = await (0, import_loadUtils.loadGlobalHook)(config2, file);
+      globalSetupResult = await setupHook(config2.config);
+    },
+    teardown: async () => {
+      if (typeof globalSetupResult === "function")
+        await globalSetupResult();
+    }
+  };
+}
+function createGlobalTeardownTask(file, config) {
+  let title = "global teardown";
+  if (config.globalTeardowns.length > 1)
+    title += ` (${file})`;
+  return {
+    title,
+    teardown: async ({ config: config2 }) => {
+      const teardownHook = await (0, import_loadUtils.loadGlobalHook)(config2, file);
+      await teardownHook(config2.config);
+    }
+  };
+}
+function createRemoveOutputDirsTask() {
+  return {
+    title: "clear output",
+    setup: async ({ config }) => {
+      const outputDirs = /* @__PURE__ */ new Set();
+      const projects = (0, import_projectUtils.filterProjects)(config.projects, config.cliProjectFilter);
+      projects.forEach((p) => outputDirs.add(p.project.outputDir));
+      await Promise.all(Array.from(outputDirs).map((outputDir) => (0, import_utils.removeFolders)([outputDir]).then(async ([error]) => {
+        if (!error)
+          return;
+        if (error.code === "EBUSY") {
+          const entries = await readDirAsync(outputDir).catch((e) => []);
+          await Promise.all(entries.map((entry) => (0, import_utils.removeFolders)([import_path.default.join(outputDir, entry)])));
+        } else {
+          throw error;
+        }
+      })));
+    }
+  };
+}
+function createListFilesTask() {
+  return {
+    title: "load tests",
+    setup: async (testRun, errors) => {
+      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");
+        projectSuite._fullProject = project;
+        testRun.rootSuite._addSuite(projectSuite);
+        const suites = files.map((file) => {
+          const title = import_path.default.relative(testRun.config.config.rootDir, file);
+          const suite = new import_test.Suite(title, "file");
+          suite.location = { file, line: 0, column: 0 };
+          projectSuite._addSuite(suite);
+          return suite;
+        });
+        testRun.projectSuites.set(project, suites);
+      }
+    }
+  };
+}
+function createLoadTask(mode, options) {
+  return {
+    title: "load tests",
+    setup: async (testRun, errors, softErrors) => {
+      await (0, import_loadUtils.collectProjectsAndTestFiles)(testRun, !!options.doNotRunDepsOutsideProjectFilter);
+      await (0, import_loadUtils.loadFileSuites)(testRun, mode, options.failOnLoadErrors ? errors : softErrors);
+      if (testRun.config.cliOnlyChanged || options.populateDependencies) {
+        for (const plugin of testRun.config.plugins)
+          await plugin.instance?.populateDependencies?.();
+      }
+      if (testRun.config.cliOnlyChanged) {
+        const changedFiles = await (0, import_vcs.detectChangedTestFiles)(testRun.config.cliOnlyChanged, testRun.config.configDir);
+        testRun.config.preOnlyTestFilters.push((test) => changedFiles.has(test.location.file));
+      }
+      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.`,
+            `Make sure that arguments are regular expressions matching test files.`,
+            `You may need to escape symbols like "$" or "*" and quote the arguments.`
+          ].join("\n"));
+        }
+        throw new Error(`No tests found`);
+      }
+    }
+  };
+}
+function createApplyRebaselinesTask() {
+  return {
+    title: "apply rebaselines",
+    setup: async () => {
+      (0, import_rebase.clearSuggestedRebaselines)();
+    },
+    teardown: async ({ config, reporter }) => {
+      await (0, import_rebase.applySuggestedRebaselines)(config, reporter);
+    }
+  };
+}
+function createPhasesTask() {
+  return {
+    title: "create phases",
+    setup: async (testRun) => {
+      let maxConcurrentTestGroups = 0;
+      const processed = /* @__PURE__ */ new Set();
+      const projectToSuite = new Map(testRun.rootSuite.suites.map((suite) => [suite._fullProject, suite]));
+      const allProjects = [...projectToSuite.keys()];
+      const teardownToSetups = (0, import_projectUtils.buildTeardownToSetupsMap)(allProjects);
+      const teardownToSetupsDependents = /* @__PURE__ */ new Map();
+      for (const [teardown, setups] of teardownToSetups) {
+        const closure = (0, import_projectUtils.buildDependentProjects)(setups, allProjects);
+        closure.delete(teardown);
+        teardownToSetupsDependents.set(teardown, [...closure]);
+      }
+      for (let i = 0; i < projectToSuite.size; i++) {
+        const phaseProjects = [];
+        for (const project of projectToSuite.keys()) {
+          if (processed.has(project))
+            continue;
+          const projectsThatShouldFinishFirst = [...project.deps, ...teardownToSetupsDependents.get(project) || []];
+          if (projectsThatShouldFinishFirst.find((p) => !processed.has(p)))
+            continue;
+          phaseProjects.push(project);
+        }
+        for (const project of phaseProjects)
+          processed.add(project);
+        if (phaseProjects.length) {
+          let testGroupsInPhase = 0;
+          const phase = { dispatcher: new import_dispatcher.Dispatcher(testRun.config, testRun.reporter, testRun.failureTracker), projects: [] };
+          testRun.phases.push(phase);
+          for (const project of phaseProjects) {
+            const projectSuite = projectToSuite.get(project);
+            const testGroups = (0, import_testGroups.createTestGroups)(projectSuite, testRun.config.config.workers);
+            phase.projects.push({ project, projectSuite, testGroups });
+            testGroupsInPhase += Math.min(project.workers ?? Number.MAX_SAFE_INTEGER, testGroups.length);
+          }
+          (0, import_utilsBundle.debug)("pw:test:task")(`created phase #${testRun.phases.length} with ${phase.projects.map((p) => p.project.project.name).sort()} projects, ${testGroupsInPhase} testGroups`);
+          maxConcurrentTestGroups = Math.max(maxConcurrentTestGroups, testGroupsInPhase);
+        }
+      }
+      testRun.config.config.metadata.actualWorkers = Math.min(testRun.config.config.workers, maxConcurrentTestGroups);
+    }
+  };
+}
+function createRunTestsTask() {
+  return {
+    title: "test suite",
+    setup: async ({ phases, failureTracker }) => {
+      const successfulProjects = /* @__PURE__ */ new Set();
+      const extraEnvByProjectId = /* @__PURE__ */ new Map();
+      const teardownToSetups = (0, import_projectUtils.buildTeardownToSetupsMap)(phases.map((phase) => phase.projects.map((p) => p.project)).flat());
+      for (const { dispatcher, projects } of phases) {
+        const phaseTestGroups = [];
+        for (const { project, testGroups } of projects) {
+          let extraEnv = {};
+          for (const dep of project.deps)
+            extraEnv = { ...extraEnv, ...extraEnvByProjectId.get(dep.id) };
+          for (const setup of teardownToSetups.get(project) || [])
+            extraEnv = { ...extraEnv, ...extraEnvByProjectId.get(setup.id) };
+          extraEnvByProjectId.set(project.id, extraEnv);
+          const hasFailedDeps = project.deps.some((p) => !successfulProjects.has(p));
+          if (!hasFailedDeps)
+            phaseTestGroups.push(...testGroups);
+        }
+        if (phaseTestGroups.length) {
+          await dispatcher.run(phaseTestGroups, extraEnvByProjectId);
+          await dispatcher.stop();
+          for (const [projectId, envProduced] of dispatcher.producedEnvByProjectId()) {
+            const extraEnv = extraEnvByProjectId.get(projectId) || {};
+            extraEnvByProjectId.set(projectId, { ...extraEnv, ...envProduced });
+          }
+        }
+        if (!failureTracker.hasWorkerErrors()) {
+          for (const { project, projectSuite } of projects) {
+            const hasFailedDeps = project.deps.some((p) => !successfulProjects.has(p));
+            if (!hasFailedDeps && !projectSuite.allTests().some((test) => !test.ok()))
+              successfulProjects.add(project);
+          }
+        }
+      }
+    },
+    teardown: async ({ phases }) => {
+      for (const { dispatcher } of phases.reverse())
+        await dispatcher.stop();
+    }
+  };
+}
+function createStartDevServerTask() {
+  return {
+    title: "start dev server",
+    setup: async ({ config }, errors, softErrors) => {
+      if (config.plugins.some((plugin) => !!plugin.devServerCleanup)) {
+        errors.push({ message: `DevServer is already running` });
+        return;
+      }
+      for (const plugin of config.plugins)
+        plugin.devServerCleanup = await plugin.instance?.startDevServer?.();
+      if (!config.plugins.some((plugin) => !!plugin.devServerCleanup))
+        errors.push({ message: `DevServer is not available in the package you are using. Did you mean to use component testing?` });
+    },
+    teardown: async ({ config }) => {
+      for (const plugin of config.plugins) {
+        await plugin.devServerCleanup?.();
+        plugin.devServerCleanup = void 0;
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TestRun,
+  createApplyRebaselinesTask,
+  createClearCacheTask,
+  createGlobalSetupTasks,
+  createListFilesTask,
+  createLoadTask,
+  createPluginSetupTasks,
+  createReportBeginTask,
+  createRunTestsTasks,
+  createStartDevServerTask,
+  runTasks,
+  runTasksDeferCleanup
+});

package/lib/runner/tasks.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/runner/tasks.ts"],
+  "sourcesContent": ["/**\n * Copyright Microsoft Corporation. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport fs from 'fs';\nimport path from 'path';\nimport { promisify } from 'util';\n\nimport { monotonicTime, removeFolders } from 'playwright-core/lib/utils';\nimport { debug } from 'playwright-core/lib/utilsBundle';\n\nimport { Dispatcher  } from './dispatcher';\nimport { FailureTracker } from './failureTracker';\nimport { collectProjectsAndTestFiles, createRootSuite, loadFileSuites, loadGlobalHook } from './loadUtils';\nimport { buildDependentProjects, buildTeardownToSetupsMap, filterProjects } from './projectUtils';\nimport { applySuggestedRebaselines, clearSuggestedRebaselines } from './rebase';\nimport { TaskRunner } from './taskRunner';\nimport { detectChangedTestFiles } from './vcs';\nimport { Suite } from '../common/test';\nimport { createTestGroups } from '../runner/testGroups';\nimport { cacheDir } from '../transform/compilationCache';\nimport { removeDirAndLogToConsole } from '../util';\n\nimport type { TestGroup } from '../runner/testGroups';\nimport type { EnvByProjectId } from './dispatcher';\nimport type { TestRunnerPluginRegistration } from '../plugins';\nimport type { Task } from './taskRunner';\nimport type { FullResult } from '../../types/testReporter';\nimport type { FullConfigInternal, FullProjectInternal } from '../common/config';\nimport type { InternalReporter } from '../reporters/internalReporter';\nimport type { ManualPromise } from 'playwright-core/lib/utils';\n\nconst readDirAsync = promisify(fs.readdir);\n\ntype ProjectWithTestGroups = {\n  project: FullProjectInternal;\n  projectSuite: Suite;\n  testGroups: TestGroup[];\n};\n\ntype Phase = {\n  dispatcher: Dispatcher,\n  projects: ProjectWithTestGroups[]\n};\n\nexport class TestRun {\n  readonly config: FullConfigInternal;\n  readonly reporter: InternalReporter;\n  readonly failureTracker: FailureTracker;\n  rootSuite: Suite | undefined = undefined;\n  readonly phases: Phase[] = [];\n  projectFiles: Map<FullProjectInternal, string[]> = new Map();\n  projectSuites: Map<FullProjectInternal, Suite[]> = new Map();\n\n  constructor(config: FullConfigInternal, reporter: InternalReporter) {\n    this.config = config;\n    this.reporter = reporter;\n    this.failureTracker = new FailureTracker(config);\n  }\n}\n\nexport async function runTasks(testRun: TestRun, tasks: Task<TestRun>[], globalTimeout?: number, cancelPromise?: ManualPromise<void>) {\n  const deadline = globalTimeout ? monotonicTime() + globalTimeout : 0;\n  const taskRunner = new TaskRunner<TestRun>(testRun.reporter, globalTimeout || 0);\n  for (const task of tasks)\n    taskRunner.addTask(task);\n  testRun.reporter.onConfigure(testRun.config.config);\n  const status = await taskRunner.run(testRun, deadline, cancelPromise);\n  return await finishTaskRun(testRun, status);\n}\n\nexport async function runTasksDeferCleanup(testRun: TestRun, tasks: Task<TestRun>[]) {\n  const taskRunner = new TaskRunner<TestRun>(testRun.reporter, 0);\n  for (const task of tasks)\n    taskRunner.addTask(task);\n  testRun.reporter.onConfigure(testRun.config.config);\n  const { status, cleanup } = await taskRunner.runDeferCleanup(testRun, 0);\n  return { status: await finishTaskRun(testRun, status), cleanup };\n}\n\nasync function finishTaskRun(testRun: TestRun, status: FullResult['status']) {\n  if (status === 'passed')\n    status = testRun.failureTracker.result();\n  const modifiedResult = await testRun.reporter.onEnd({ status });\n  if (modifiedResult && modifiedResult.status)\n    status = modifiedResult.status;\n  await testRun.reporter.onExit();\n  return status;\n}\n\nexport function createGlobalSetupTasks(config: FullConfigInternal) {\n  const tasks: Task<TestRun>[] = [];\n  if (!config.configCLIOverrides.preserveOutputDir)\n    tasks.push(createRemoveOutputDirsTask());\n  tasks.push(\n      ...createPluginSetupTasks(config),\n      ...config.globalTeardowns.map(file => createGlobalTeardownTask(file, config)).reverse(),\n      ...config.globalSetups.map(file => createGlobalSetupTask(file, config)),\n  );\n  return tasks;\n}\n\nexport function createRunTestsTasks(config: FullConfigInternal) {\n  return [\n    createPhasesTask(),\n    createReportBeginTask(),\n    ...config.plugins.map(plugin => createPluginBeginTask(plugin)),\n    createRunTestsTask(),\n  ];\n}\n\nexport function createClearCacheTask(config: FullConfigInternal): Task<TestRun> {\n  return {\n    title: 'clear cache',\n    setup: async () => {\n      await removeDirAndLogToConsole(cacheDir);\n      for (const plugin of config.plugins)\n        await plugin.instance?.clearCache?.();\n    },\n  };\n}\n\nexport function createReportBeginTask(): Task<TestRun> {\n  return {\n    title: 'report begin',\n    setup: async testRun => {\n      testRun.reporter.onBegin?.(testRun.rootSuite!);\n    },\n    teardown: async ({}) => {},\n  };\n}\n\nexport function createPluginSetupTasks(config: FullConfigInternal): Task<TestRun>[] {\n  return config.plugins.map(plugin => ({\n    title: 'plugin setup',\n    setup: async ({ reporter }) => {\n      if (typeof plugin.factory === 'function')\n        plugin.instance = await plugin.factory();\n      else\n        plugin.instance = plugin.factory;\n      await plugin.instance?.setup?.(config.config, config.configDir, reporter);\n    },\n    teardown: async () => {\n      await plugin.instance?.teardown?.();\n    },\n  }));\n}\n\nfunction createPluginBeginTask(plugin: TestRunnerPluginRegistration): Task<TestRun> {\n  return {\n    title: 'plugin begin',\n    setup: async testRun => {\n      await plugin.instance?.begin?.(testRun.rootSuite!);\n    },\n    teardown: async () => {\n      await plugin.instance?.end?.();\n    },\n  };\n}\n\nfunction createGlobalSetupTask(file: string, config: FullConfigInternal): Task<TestRun> {\n  let title = 'global setup';\n  if (config.globalSetups.length > 1)\n    title += ` (${file})`;\n\n  let globalSetupResult: any;\n  return {\n    title,\n    setup: async ({ config }) => {\n      const setupHook = await loadGlobalHook(config, file);\n      globalSetupResult = await setupHook(config.config);\n    },\n    teardown: async () => {\n      if (typeof globalSetupResult === 'function')\n        await globalSetupResult();\n    },\n  };\n}\n\nfunction createGlobalTeardownTask(file: string, config: FullConfigInternal): Task<TestRun> {\n  let title = 'global teardown';\n  if (config.globalTeardowns.length > 1)\n    title += ` (${file})`;\n\n  return {\n    title,\n    teardown: async ({ config }) => {\n      const teardownHook = await loadGlobalHook(config, file);\n      await teardownHook(config.config);\n    },\n  };\n}\n\nfunction createRemoveOutputDirsTask(): Task<TestRun> {\n  return {\n    title: 'clear output',\n    setup: async ({ config }) => {\n      const outputDirs = new Set<string>();\n      const projects = filterProjects(config.projects, config.cliProjectFilter);\n      projects.forEach(p => outputDirs.add(p.project.outputDir));\n\n      await Promise.all(Array.from(outputDirs).map(outputDir => removeFolders([outputDir]).then(async ([error]) => {\n        if (!error)\n          return;\n        if ((error as any).code === 'EBUSY') {\n          // We failed to remove folder, might be due to the whole folder being mounted inside a container:\n          //   https://github.com/microsoft/playwright/issues/12106\n          // Do a best-effort to remove all files inside of it instead.\n          const entries = await readDirAsync(outputDir).catch(e => []);\n          await Promise.all(entries.map(entry => removeFolders([path.join(outputDir, entry)])));\n        } else {\n          throw error;\n        }\n      })));\n    },\n  };\n}\n\nexport function createListFilesTask(): Task<TestRun> {\n  return {\n    title: 'load tests',\n    setup: async (testRun, errors) => {\n      testRun.rootSuite = await createRootSuite(testRun, errors, false);\n      testRun.failureTracker.onRootSuite(testRun.rootSuite);\n      await collectProjectsAndTestFiles(testRun, false);\n      for (const [project, files] of testRun.projectFiles) {\n        const projectSuite = new Suite(project.project.name, 'project');\n        projectSuite._fullProject = project;\n        testRun.rootSuite._addSuite(projectSuite);\n        const suites = files.map(file => {\n          const title = path.relative(testRun.config.config.rootDir, file);\n          const suite =  new Suite(title, 'file');\n          suite.location = { file, line: 0, column: 0 };\n          projectSuite._addSuite(suite);\n          return suite;\n        });\n        testRun.projectSuites.set(project, suites);\n      }\n    },\n  };\n}\n\nexport function createLoadTask(mode: 'out-of-process' | 'in-process', options: { filterOnly: boolean, failOnLoadErrors: boolean, doNotRunDepsOutsideProjectFilter?: boolean, populateDependencies?: boolean }): Task<TestRun> {\n  return {\n    title: 'load tests',\n    setup: async (testRun, errors, softErrors) => {\n      await collectProjectsAndTestFiles(testRun, !!options.doNotRunDepsOutsideProjectFilter);\n      await loadFileSuites(testRun, mode, options.failOnLoadErrors ? errors : softErrors);\n\n      if (testRun.config.cliOnlyChanged || options.populateDependencies) {\n        for (const plugin of testRun.config.plugins)\n          await plugin.instance?.populateDependencies?.();\n      }\n\n      if (testRun.config.cliOnlyChanged) {\n        const changedFiles = await detectChangedTestFiles(testRun.config.cliOnlyChanged, testRun.config.configDir);\n        testRun.config.preOnlyTestFilters.push(test => changedFiles.has(test.location.file));\n      }\n\n      testRun.rootSuite = await createRootSuite(testRun, options.failOnLoadErrors ? errors : softErrors, !!options.filterOnly);\n      testRun.failureTracker.onRootSuite(testRun.rootSuite);\n      // Fail when no tests.\n      if (options.failOnLoadErrors && !testRun.rootSuite.allTests().length && !testRun.config.cliPassWithNoTests && !testRun.config.config.shard && !testRun.config.cliOnlyChanged) {\n        if (testRun.config.cliArgs.length) {\n          throw new Error([\n            `No tests found.`,\n            `Make sure that arguments are regular expressions matching test files.`,\n            `You may need to escape symbols like \"$\" or \"*\" and quote the arguments.`,\n          ].join('\\n'));\n        }\n        throw new Error(`No tests found`);\n      }\n    },\n  };\n}\n\nexport function createApplyRebaselinesTask(): Task<TestRun> {\n  return {\n    title: 'apply rebaselines',\n    setup: async () => {\n      clearSuggestedRebaselines();\n    },\n    teardown: async ({ config, reporter }) => {\n      await applySuggestedRebaselines(config, reporter);\n    },\n  };\n}\n\nfunction createPhasesTask(): Task<TestRun> {\n  return {\n    title: 'create phases',\n    setup: async testRun => {\n      let maxConcurrentTestGroups = 0;\n\n      const processed = new Set<FullProjectInternal>();\n      const projectToSuite = new Map(testRun.rootSuite!.suites.map(suite => [suite._fullProject!, suite]));\n      const allProjects = [...projectToSuite.keys()];\n      const teardownToSetups = buildTeardownToSetupsMap(allProjects);\n      const teardownToSetupsDependents = new Map<FullProjectInternal, FullProjectInternal[]>();\n      for (const [teardown, setups] of teardownToSetups) {\n        const closure = buildDependentProjects(setups, allProjects);\n        closure.delete(teardown);\n        teardownToSetupsDependents.set(teardown, [...closure]);\n      }\n\n      for (let i = 0; i < projectToSuite.size; i++) {\n        // Find all projects that have all their dependencies processed by previous phases.\n        const phaseProjects: FullProjectInternal[] = [];\n        for (const project of projectToSuite.keys()) {\n          if (processed.has(project))\n            continue;\n          const projectsThatShouldFinishFirst = [...project.deps, ...(teardownToSetupsDependents.get(project) || [])];\n          if (projectsThatShouldFinishFirst.find(p => !processed.has(p)))\n            continue;\n          phaseProjects.push(project);\n        }\n\n        // Create a new phase.\n        for (const project of phaseProjects)\n          processed.add(project);\n        if (phaseProjects.length) {\n          let testGroupsInPhase = 0;\n          const phase: Phase = { dispatcher: new Dispatcher(testRun.config, testRun.reporter, testRun.failureTracker), projects: [] };\n          testRun.phases.push(phase);\n          for (const project of phaseProjects) {\n            const projectSuite = projectToSuite.get(project)!;\n            const testGroups = createTestGroups(projectSuite, testRun.config.config.workers);\n            phase.projects.push({ project, projectSuite, testGroups });\n            testGroupsInPhase += Math.min(project.workers ?? Number.MAX_SAFE_INTEGER, testGroups.length);\n          }\n          debug('pw:test:task')(`created phase #${testRun.phases.length} with ${phase.projects.map(p => p.project.project.name).sort()} projects, ${testGroupsInPhase} testGroups`);\n          maxConcurrentTestGroups = Math.max(maxConcurrentTestGroups, testGroupsInPhase);\n        }\n      }\n\n      testRun.config.config.metadata.actualWorkers = Math.min(testRun.config.config.workers, maxConcurrentTestGroups);\n    },\n  };\n}\n\nfunction createRunTestsTask(): Task<TestRun> {\n  return {\n    title: 'test suite',\n    setup: async ({ phases, failureTracker }) => {\n      const successfulProjects = new Set<FullProjectInternal>();\n      const extraEnvByProjectId: EnvByProjectId = new Map();\n      const teardownToSetups = buildTeardownToSetupsMap(phases.map(phase => phase.projects.map(p => p.project)).flat());\n\n      for (const { dispatcher, projects } of phases) {\n        // Each phase contains dispatcher and a set of test groups.\n        // We don't want to run the test groups belonging to the projects\n        // that depend on the projects that failed previously.\n        const phaseTestGroups: TestGroup[] = [];\n        for (const { project, testGroups } of projects) {\n          // Inherit extra environment variables from dependencies.\n          let extraEnv: Record<string, string | undefined> = {};\n          for (const dep of project.deps)\n            extraEnv = { ...extraEnv, ...extraEnvByProjectId.get(dep.id) };\n          for (const setup of teardownToSetups.get(project) || [])\n            extraEnv = { ...extraEnv, ...extraEnvByProjectId.get(setup.id) };\n          extraEnvByProjectId.set(project.id, extraEnv);\n\n          const hasFailedDeps = project.deps.some(p => !successfulProjects.has(p));\n          if (!hasFailedDeps)\n            phaseTestGroups.push(...testGroups);\n        }\n\n        if (phaseTestGroups.length) {\n          await dispatcher!.run(phaseTestGroups, extraEnvByProjectId);\n          await dispatcher.stop();\n          for (const [projectId, envProduced] of dispatcher.producedEnvByProjectId()) {\n            const extraEnv = extraEnvByProjectId.get(projectId) || {};\n            extraEnvByProjectId.set(projectId, { ...extraEnv, ...envProduced });\n          }\n        }\n\n        // If the worker broke, fail everything, we have no way of knowing which\n        // projects failed.\n        if (!failureTracker.hasWorkerErrors()) {\n          for (const { project, projectSuite } of projects) {\n            const hasFailedDeps = project.deps.some(p => !successfulProjects.has(p));\n            if (!hasFailedDeps && !projectSuite.allTests().some(test => !test.ok()))\n              successfulProjects.add(project);\n          }\n        }\n      }\n    },\n    teardown: async ({ phases }) => {\n      for (const { dispatcher } of phases.reverse())\n        await dispatcher.stop();\n    },\n  };\n}\n\nexport function createStartDevServerTask(): Task<TestRun> {\n  return {\n    title: 'start dev server',\n    setup: async ({ config }, errors, softErrors) => {\n      if (config.plugins.some(plugin => !!plugin.devServerCleanup)) {\n        errors.push({ message: `DevServer is already running` });\n        return;\n      }\n      for (const plugin of config.plugins)\n        plugin.devServerCleanup = await plugin.instance?.startDevServer?.();\n      if (!config.plugins.some(plugin => !!plugin.devServerCleanup))\n        errors.push({ message: `DevServer is not available in the package you are using. Did you mean to use component testing?` });\n    },\n\n    teardown: async ({ config }) => {\n      for (const plugin of config.plugins) {\n        await plugin.devServerCleanup?.();\n        plugin.devServerCleanup = undefined;\n      }\n    },\n  };\n}\n"],
+  "mappings": "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",
+  "names": ["import_util", "fs", "config", "path"]
+}

package/lib/runner/testGroups.js

@@ -0,0 +1,117 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var testGroups_exports = {};
+__export(testGroups_exports, {
+  createTestGroups: () => createTestGroups,
+  filterForShard: () => filterForShard
+});
+module.exports = __toCommonJS(testGroups_exports);
+function createTestGroups(projectSuite, expectedParallelism) {
+  const groups = /* @__PURE__ */ new Map();
+  const createGroup = (test) => {
+    return {
+      workerHash: test._workerHash,
+      requireFile: test._requireFile,
+      repeatEachIndex: test.repeatEachIndex,
+      projectId: test._projectId,
+      tests: []
+    };
+  };
+  for (const test of projectSuite.allTests()) {
+    let withWorkerHash = groups.get(test._workerHash);
+    if (!withWorkerHash) {
+      withWorkerHash = /* @__PURE__ */ new Map();
+      groups.set(test._workerHash, withWorkerHash);
+    }
+    let withRequireFile = withWorkerHash.get(test._requireFile);
+    if (!withRequireFile) {
+      withRequireFile = {
+        general: createGroup(test),
+        parallel: /* @__PURE__ */ new Map(),
+        parallelWithHooks: createGroup(test)
+      };
+      withWorkerHash.set(test._requireFile, withRequireFile);
+    }
+    let insideParallel = false;
+    let outerMostSequentialSuite;
+    let hasAllHooks = false;
+    for (let parent = test.parent; parent; parent = parent.parent) {
+      if (parent._parallelMode === "serial" || parent._parallelMode === "default")
+        outerMostSequentialSuite = parent;
+      insideParallel = insideParallel || parent._parallelMode === "parallel";
+      hasAllHooks = hasAllHooks || parent._hooks.some((hook) => hook.type === "beforeAll" || hook.type === "afterAll");
+    }
+    if (insideParallel) {
+      if (hasAllHooks && !outerMostSequentialSuite) {
+        withRequireFile.parallelWithHooks.tests.push(test);
+      } else {
+        const key = outerMostSequentialSuite || test;
+        let group = withRequireFile.parallel.get(key);
+        if (!group) {
+          group = createGroup(test);
+          withRequireFile.parallel.set(key, group);
+        }
+        group.tests.push(test);
+      }
+    } else {
+      withRequireFile.general.tests.push(test);
+    }
+  }
+  const result = [];
+  for (const withWorkerHash of groups.values()) {
+    for (const withRequireFile of withWorkerHash.values()) {
+      if (withRequireFile.general.tests.length)
+        result.push(withRequireFile.general);
+      result.push(...withRequireFile.parallel.values());
+      const parallelWithHooksGroupSize = Math.ceil(withRequireFile.parallelWithHooks.tests.length / expectedParallelism);
+      let lastGroup;
+      for (const test of withRequireFile.parallelWithHooks.tests) {
+        if (!lastGroup || lastGroup.tests.length >= parallelWithHooksGroupSize) {
+          lastGroup = createGroup(test);
+          result.push(lastGroup);
+        }
+        lastGroup.tests.push(test);
+      }
+    }
+  }
+  return result;
+}
+function filterForShard(shard, testGroups) {
+  let shardableTotal = 0;
+  for (const group of testGroups)
+    shardableTotal += group.tests.length;
+  const shardSize = Math.floor(shardableTotal / shard.total);
+  const extraOne = shardableTotal - shardSize * shard.total;
+  const currentShard = shard.current - 1;
+  const from = shardSize * currentShard + Math.min(extraOne, currentShard);
+  const to = from + shardSize + (currentShard < extraOne ? 1 : 0);
+  let current = 0;
+  const result = /* @__PURE__ */ new Set();
+  for (const group of testGroups) {
+    if (current >= from && current < to)
+      result.add(group);
+    current += group.tests.length;
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTestGroups,
+  filterForShard
+});

package/lib/runner/testGroups.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/runner/testGroups.ts"],
+  "sourcesContent": ["/**\n * Copyright Microsoft Corporation. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { Suite, TestCase } from '../common/test';\n\nexport type TestGroup = {\n  workerHash: string;\n  requireFile: string;\n  repeatEachIndex: number;\n  projectId: string;\n  tests: TestCase[];\n};\n\nexport function createTestGroups(projectSuite: Suite, expectedParallelism: number): TestGroup[] {\n  // This function groups tests that can be run together.\n  // Tests cannot be run together when:\n  // - They belong to different projects - requires different workers.\n  // - They have a different repeatEachIndex - requires different workers.\n  // - They have a different set of worker fixtures in the pool - requires different workers.\n  // - They have a different requireFile - reuses the worker, but runs each requireFile separately.\n  // - They belong to a parallel suite.\n\n  // Using the map \"workerHash -> requireFile -> group\" makes us preserve the natural order\n  // of worker hashes and require files for the simple cases.\n  const groups = new Map<string, Map<string, {\n    // Tests that must be run in order are in the same group.\n    general: TestGroup,\n\n    // There are 3 kinds of parallel tests:\n    // - Tests belonging to parallel suites, without beforeAll/afterAll hooks.\n    //   These can be run independently, they are put into their own group, key === test.\n    // - Tests belonging to parallel suites, with beforeAll/afterAll hooks.\n    //   These should share the worker as much as possible, put into single parallelWithHooks group.\n    //   We'll divide them into equally-sized groups later.\n    // - Tests belonging to serial suites inside parallel suites.\n    //   These should run as a serial group, each group is independent, key === serial suite.\n    parallel: Map<Suite | TestCase, TestGroup>,\n    parallelWithHooks: TestGroup,\n  }>>();\n\n  const createGroup = (test: TestCase): TestGroup => {\n    return {\n      workerHash: test._workerHash,\n      requireFile: test._requireFile,\n      repeatEachIndex: test.repeatEachIndex,\n      projectId: test._projectId,\n      tests: [],\n    };\n  };\n\n  for (const test of projectSuite.allTests()) {\n    let withWorkerHash = groups.get(test._workerHash);\n    if (!withWorkerHash) {\n      withWorkerHash = new Map();\n      groups.set(test._workerHash, withWorkerHash);\n    }\n    let withRequireFile = withWorkerHash.get(test._requireFile);\n    if (!withRequireFile) {\n      withRequireFile = {\n        general: createGroup(test),\n        parallel: new Map(),\n        parallelWithHooks: createGroup(test),\n      };\n      withWorkerHash.set(test._requireFile, withRequireFile);\n    }\n\n    // Note that a parallel suite cannot be inside a serial suite. This is enforced in TestType.\n    let insideParallel = false;\n    let outerMostSequentialSuite: Suite | undefined;\n    let hasAllHooks = false;\n    for (let parent: Suite | undefined = test.parent; parent; parent = parent.parent) {\n      if (parent._parallelMode === 'serial' || parent._parallelMode === 'default')\n        outerMostSequentialSuite = parent;\n      insideParallel = insideParallel || parent._parallelMode === 'parallel';\n      hasAllHooks = hasAllHooks || parent._hooks.some(hook => hook.type === 'beforeAll' || hook.type === 'afterAll');\n    }\n\n    if (insideParallel) {\n      if (hasAllHooks && !outerMostSequentialSuite) {\n        withRequireFile.parallelWithHooks.tests.push(test);\n      } else {\n        const key = outerMostSequentialSuite || test;\n        let group = withRequireFile.parallel.get(key);\n        if (!group) {\n          group = createGroup(test);\n          withRequireFile.parallel.set(key, group);\n        }\n        group.tests.push(test);\n      }\n    } else {\n      withRequireFile.general.tests.push(test);\n    }\n  }\n\n  const result: TestGroup[] = [];\n  for (const withWorkerHash of groups.values()) {\n    for (const withRequireFile of withWorkerHash.values()) {\n      // Tests without parallel mode should run serially as a single group.\n      if (withRequireFile.general.tests.length)\n        result.push(withRequireFile.general);\n\n      // Parallel test groups without beforeAll/afterAll can be run independently.\n      result.push(...withRequireFile.parallel.values());\n\n      // Tests with beforeAll/afterAll should try to share workers as much as possible.\n      const parallelWithHooksGroupSize = Math.ceil(withRequireFile.parallelWithHooks.tests.length / expectedParallelism);\n      let lastGroup: TestGroup | undefined;\n      for (const test of withRequireFile.parallelWithHooks.tests) {\n        if (!lastGroup || lastGroup.tests.length >= parallelWithHooksGroupSize) {\n          lastGroup = createGroup(test);\n          result.push(lastGroup);\n        }\n        lastGroup.tests.push(test);\n      }\n    }\n  }\n  return result;\n}\n\nexport function filterForShard(shard: { total: number, current: number }, testGroups: TestGroup[]): Set<TestGroup> {\n  // Note that sharding works based on test groups.\n  // This means parallel files will be sharded by single tests,\n  // while non-parallel files will be sharded by the whole file.\n  //\n  // Shards are still balanced by the number of tests, not files,\n  // even in the case of non-paralleled files.\n\n  let shardableTotal = 0;\n  for (const group of testGroups)\n    shardableTotal += group.tests.length;\n\n  // Each shard gets some tests.\n  const shardSize = Math.floor(shardableTotal / shard.total);\n  // First few shards get one more test each.\n  const extraOne = shardableTotal - shardSize * shard.total;\n\n  const currentShard = shard.current - 1; // Make it zero-based for calculations.\n  const from = shardSize * currentShard + Math.min(extraOne, currentShard);\n  const to = from + shardSize + (currentShard < extraOne ? 1 : 0);\n\n  let current = 0;\n  const result = new Set<TestGroup>();\n  for (const group of testGroups) {\n    // Any test group goes to the shard that contains the first test of this group.\n    // So, this shard gets any group that starts at [from; to)\n    if (current >= from && current < to)\n      result.add(group);\n    current += group.tests.length;\n  }\n  return result;\n}\n"],
+  "mappings": "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",
+  "names": []
+}