@playwright/test 1.31.2 → 1.32.0

package/lib/reporters/teleEmitter.js

@@ -0,0 +1,209 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TeleReporterEmitter = void 0;
+var _utils = require("playwright-core/lib/utils");
+var _teleReceiver = require("../isomorphic/teleReceiver");
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class TeleReporterEmitter {
+  constructor(messageSink) {
+    this._messageSink = void 0;
+    this._messageSink = messageSink;
+  }
+  onBegin(config, suite) {
+    const projects = [];
+    for (const projectSuite of suite.suites) {
+      const report = this._serializeProject(projectSuite);
+      projects.push(report);
+    }
+    this._messageSink({
+      method: 'onBegin',
+      params: {
+        config: this._serializeConfig(config),
+        projects
+      }
+    });
+  }
+  onTestBegin(test, result) {
+    result[idSymbol] = (0, _utils.createGuid)();
+    this._messageSink({
+      method: 'onTestBegin',
+      params: {
+        testId: test.id,
+        result: this._serializeResultStart(result)
+      }
+    });
+  }
+  onTestEnd(test, result) {
+    this._messageSink({
+      method: 'onTestEnd',
+      params: {
+        testId: test.id,
+        result: this._serializeResultEnd(result)
+      }
+    });
+  }
+  onStepBegin(test, result, step) {
+    step[idSymbol] = (0, _utils.createGuid)();
+    this._messageSink({
+      method: 'onStepBegin',
+      params: {
+        testId: test.id,
+        resultId: result[idSymbol],
+        step: this._serializeStepStart(step)
+      }
+    });
+  }
+  onStepEnd(test, result, step) {
+    this._messageSink({
+      method: 'onStepEnd',
+      params: {
+        testId: test.id,
+        resultId: result[idSymbol],
+        step: this._serializeStepEnd(step)
+      }
+    });
+  }
+  onError(error) {
+    this._messageSink({
+      method: 'onError',
+      params: {
+        error
+      }
+    });
+  }
+  onStdOut(chunk, test, result) {
+    this._onStdIO('stdio', chunk, test, result);
+  }
+  onStdErr(chunk, test, result) {
+    this._onStdIO('stderr', chunk, test, result);
+  }
+  _onStdIO(type, chunk, test, result) {
+    const isBase64 = typeof chunk !== 'string';
+    const data = isBase64 ? chunk.toString('base64') : chunk;
+    this._messageSink({
+      method: 'onStdIO',
+      params: {
+        testId: test === null || test === void 0 ? void 0 : test.id,
+        resultId: result ? result[idSymbol] : undefined,
+        type,
+        data,
+        isBase64
+      }
+    });
+  }
+  async onEnd(result) {
+    this._messageSink({
+      method: 'onEnd',
+      params: {
+        result
+      }
+    });
+  }
+  _serializeConfig(config) {
+    return {
+      rootDir: config.rootDir,
+      configFile: config.configFile,
+      listOnly: config._internal.listOnly
+    };
+  }
+  _serializeProject(suite) {
+    const project = suite.project();
+    const report = {
+      id: project._internal.id,
+      metadata: project.metadata,
+      name: project.name,
+      outputDir: project.outputDir,
+      repeatEach: project.repeatEach,
+      retries: project.retries,
+      testDir: project.testDir,
+      testIgnore: (0, _teleReceiver.serializeRegexPatterns)(project.testIgnore),
+      testMatch: (0, _teleReceiver.serializeRegexPatterns)(project.testMatch),
+      timeout: project.timeout,
+      suites: suite.suites.map(fileSuite => {
+        return this._serializeSuite(fileSuite);
+      }),
+      grep: (0, _teleReceiver.serializeRegexPatterns)(project.grep),
+      grepInvert: (0, _teleReceiver.serializeRegexPatterns)(project.grepInvert || []),
+      dependencies: project.dependencies,
+      snapshotDir: project.snapshotDir
+    };
+    return report;
+  }
+  _serializeSuite(suite) {
+    const result = {
+      type: suite._type,
+      title: suite.title,
+      fileId: suite._fileId,
+      parallelMode: suite._parallelMode,
+      location: suite.location,
+      suites: suite.suites.map(s => this._serializeSuite(s)),
+      tests: suite.tests.map(t => this._serializeTest(t))
+    };
+    return result;
+  }
+  _serializeTest(test) {
+    return {
+      testId: test.id,
+      title: test.title,
+      location: test.location,
+      expectedStatus: test.expectedStatus,
+      timeout: test.timeout,
+      annotations: test.annotations,
+      retries: test.retries
+    };
+  }
+  _serializeResultStart(result) {
+    return {
+      id: result[idSymbol],
+      retry: result.retry,
+      workerIndex: result.workerIndex,
+      parallelIndex: result.parallelIndex,
+      startTime: result.startTime.toISOString()
+    };
+  }
+  _serializeResultEnd(result) {
+    return {
+      id: result[idSymbol],
+      duration: result.duration,
+      status: result.status,
+      errors: result.errors,
+      attachments: result.attachments
+    };
+  }
+  _serializeStepStart(step) {
+    return {
+      id: step[idSymbol],
+      title: step.title,
+      category: step.category,
+      startTime: step.startTime.toISOString(),
+      location: step.location
+    };
+  }
+  _serializeStepEnd(step) {
+    return {
+      id: step[idSymbol],
+      duration: step.duration,
+      error: step.error
+    };
+  }
+}
+exports.TeleReporterEmitter = TeleReporterEmitter;
+const idSymbol = Symbol('id');

package/lib/runner/dispatcher.js

@@ -35,6 +35,8 @@ class Dispatcher {
     this._reporter = void 0;
     this._hasWorkerErrors = false;
     this._failureCount = 0;
+    this._extraEnvByProjectId = new Map();
+    this._producedEnvByProjectId = new Map();
     this._config = config;
     this._reporter = reporter;
   }
@@ -138,7 +140,8 @@ class Dispatcher {
     }
     return workersWithSameHash > this._queuedOrRunningHashCount.get(worker.hash());
   }
-  async run(testGroups) {
+  async run(testGroups, extraEnvByProjectId) {
+    this._extraEnvByProjectId = extraEnvByProjectId;
     this._queue = testGroups;
     for (const group of testGroups) {
       this._queuedOrRunningHashCount.set(group.workerHash, 1 + (this._queuedOrRunningHashCount.get(group.workerHash) || 0));
@@ -431,7 +434,7 @@ class Dispatcher {
     return result;
   }
   _createWorker(testGroup, parallelIndex, loaderData) {
-    const worker = new _workerHost.WorkerHost(testGroup, parallelIndex, loaderData);
+    const worker = new _workerHost.WorkerHost(testGroup, parallelIndex, loaderData, this._extraEnvByProjectId.get(testGroup.projectId) || {});
     const handleOutput = params => {
       var _data$resultByWorkerI;
       const chunk = chunkFromParams(params);
@@ -480,8 +483,18 @@ class Dispatcher {
         (_this$_reporter$onErr2 = (_this$_reporter11 = this._reporter).onError) === null || _this$_reporter$onErr2 === void 0 ? void 0 : _this$_reporter$onErr2.call(_this$_reporter11, error);
       }
     });
+    worker.on('exit', () => {
+      const producedEnv = this._producedEnvByProjectId.get(testGroup.projectId) || {};
+      this._producedEnvByProjectId.set(testGroup.projectId, {
+        ...producedEnv,
+        ...worker.producedEnv()
+      });
+    });
     return worker;
   }
+  producedEnvByProjectId() {
+    return this._producedEnvByProjectId;
+  }
   async stop() {
     if (this._isStopped) return;
     this._isStopped = true;

package/lib/runner/loadUtils.js

@@ -3,10 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.loadAllTests = loadAllTests;
+exports.collectProjectsAndTestFiles = collectProjectsAndTestFiles;
+exports.createRootSuite = createRootSuite;
+exports.loadFileSuites = loadFileSuites;
 exports.loadGlobalHook = loadGlobalHook;
 exports.loadReporter = loadReporter;
+var _fs = _interopRequireDefault(require("fs"));
 var _path = _interopRequireDefault(require("path"));
+var _readline = _interopRequireDefault(require("readline"));
 var _loaderHost = require("./loaderHost");
 var _test = require("../common/test");
 var _util = require("../util");
@@ -14,6 +18,7 @@ var _projectUtils = require("./projectUtils");
 var _transform = require("../common/transform");
 var _suiteUtils = require("../common/suiteUtils");
 var _testGroups = require("./testGroups");
+var _compilationCache = require("../common/compilationCache");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
  * Copyright Microsoft Corporation. All rights reserved.
@@ -31,82 +36,106 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * limitations under the License.
  */
 
-async function loadAllTests(mode, config, projectsToIgnore, fileMatcher, errors, shouldFilterOnly) {
-  const projects = (0, _projectUtils.filterProjects)(config.projects, config._internal.cliProjectFilter);
-  let filesToRunByProject = new Map();
-  let topLevelProjects;
-  let dependencyProjects;
-  // Collect files, categorize top level and dependency projects.
-  {
-    const fsCache = new Map();
-
-    // First collect all files for the projects in the command line, don't apply any file filters.
-    const allFilesForProject = new Map();
-    for (const project of projects) {
-      if (projectsToIgnore.has(project)) continue;
-      const files = await (0, _projectUtils.collectFilesForProject)(project, fsCache);
-      allFilesForProject.set(project, files);
-    }
+async function collectProjectsAndTestFiles(config, projectsToIgnore, additionalFileMatcher) {
+  const fsCache = new Map();
+  const sourceMapCache = new Map();
+  const cliFileMatcher = config._internal.cliArgs.length ? (0, _util.createFileMatcherFromArguments)(config._internal.cliArgs) : null;
 
-    // Filter files based on the file filters, eliminate the empty projects.
-    for (const [project, files] of allFilesForProject) {
-      const filteredFiles = files.filter(fileMatcher);
-      if (filteredFiles.length) filesToRunByProject.set(project, filteredFiles);
-    }
-    const projectClosure = (0, _projectUtils.buildProjectsClosure)([...filesToRunByProject.keys()]);
-    // Remove files for dependency projects, they'll be added back later.
-    for (const project of projectClosure.filter(p => p._internal.type === 'dependency')) filesToRunByProject.delete(project);
-
-    // Shard only the top-level projects.
-    if (config.shard) filesToRunByProject = (0, _testGroups.filterForShard)(config.shard, filesToRunByProject);
-
-    // Re-build the closure, project set might have changed.
-    const filteredProjectClosure = (0, _projectUtils.buildProjectsClosure)([...filesToRunByProject.keys()]);
-    topLevelProjects = filteredProjectClosure.filter(p => p._internal.type === 'top-level');
-    dependencyProjects = filteredProjectClosure.filter(p => p._internal.type === 'dependency');
-    topLevelProjects = topLevelProjects.filter(p => !projectsToIgnore.has(p));
-    dependencyProjects = dependencyProjects.filter(p => !projectsToIgnore.has(p));
-
-    // (Re-)add all files for dependent projects, disregard filters.
-    for (const project of dependencyProjects) {
+  // First collect all files for the projects in the command line, don't apply any file filters.
+  const allFilesForProject = new Map();
+  for (const project of (0, _projectUtils.filterProjects)(config.projects, config._internal.cliProjectFilter)) {
+    if (projectsToIgnore.has(project)) continue;
+    const files = await (0, _projectUtils.collectFilesForProject)(project, fsCache);
+    allFilesForProject.set(project, files);
+  }
+
+  // Filter files based on the file filters, eliminate the empty projects.
+  const filesToRunByProject = new Map();
+  for (const [project, files] of allFilesForProject) {
+    const matchedFiles = await Promise.all(files.map(async file => {
+      if (additionalFileMatcher && !additionalFileMatcher(file)) return;
+      if (cliFileMatcher) {
+        if (!cliFileMatcher(file) && !(await isPotentiallyJavaScriptFileWithSourceMap(file, sourceMapCache))) return;
+      }
+      return file;
+    }));
+    const filteredFiles = matchedFiles.filter(Boolean);
+    if (filteredFiles.length) filesToRunByProject.set(project, filteredFiles);
+  }
+
+  // (Re-)add all files for dependent projects, disregard filters.
+  const projectClosure = (0, _projectUtils.buildProjectsClosure)([...filesToRunByProject.keys()]).filter(p => !projectsToIgnore.has(p));
+  for (const project of projectClosure) {
+    if (project._internal.type === 'dependency') {
+      filesToRunByProject.delete(project);
       const files = allFilesForProject.get(project) || (await (0, _projectUtils.collectFilesForProject)(project, fsCache));
       filesToRunByProject.set(project, files);
     }
   }
+  return filesToRunByProject;
+}
+async function loadFileSuites(mode, config, filesToRunByProject, errors) {
+  // Determine all files to load.
+  const allTestFiles = new Set();
+  for (const files of filesToRunByProject.values()) files.forEach(file => allTestFiles.add(file));
 
-  // Load all test files and create a preprocessed root. Child suites are files there.
-  const fileSuits = [];
-  {
-    const loaderHost = mode === 'out-of-process' ? new _loaderHost.OutOfProcessLoaderHost(config) : new _loaderHost.InProcessLoaderHost(config);
-    const allTestFiles = new Set();
-    for (const files of filesToRunByProject.values()) files.forEach(file => allTestFiles.add(file));
-    for (const file of allTestFiles) {
-      const fileSuite = await loaderHost.loadTestFile(file, errors);
-      fileSuits.push(fileSuite);
-    }
-    await loaderHost.stop();
+  // Load test files.
+  const fileSuiteByFile = new Map();
+  const loaderHost = mode === 'out-of-process' ? new _loaderHost.OutOfProcessLoaderHost(config) : new _loaderHost.InProcessLoaderHost(config);
+  for (const file of allTestFiles) {
+    const fileSuite = await loaderHost.loadTestFile(file, errors);
+    fileSuiteByFile.set(file, fileSuite);
+    errors.push(...createDuplicateTitlesErrors(config, fileSuite));
   }
+  await loaderHost.stop();
 
-  // Complain about duplicate titles.
-  errors.push(...createDuplicateTitlesErrors(config, fileSuits));
+  // Check that no test file imports another test file.
+  // Loader must be stopped first, since it popuplates the dependency tree.
+  for (const file of allTestFiles) {
+    for (const dependency of (0, _compilationCache.dependenciesForTestFile)(file)) {
+      if (allTestFiles.has(dependency)) {
+        const importer = _path.default.relative(config.rootDir, file);
+        const importee = _path.default.relative(config.rootDir, dependency);
+        errors.push({
+          message: `Error: test file "${importer}" should not import test file "${importee}"`,
+          location: {
+            file,
+            line: 1,
+            column: 1
+          }
+        });
+      }
+    }
+  }
 
-  // Create root suites with clones for the projects.
+  // Collect file suites for each project.
+  const fileSuitesByProject = new Map();
+  for (const [project, files] of filesToRunByProject) {
+    const suites = files.map(file => fileSuiteByFile.get(file)).filter(Boolean);
+    fileSuitesByProject.set(project, suites);
+  }
+  return fileSuitesByProject;
+}
+async function createRootSuite(config, fileSuitesByProject, errors, shouldFilterOnly) {
+  // Create root suite, where each child will be a project suite with cloned file suites inside it.
   const rootSuite = new _test.Suite('', 'root');
 
-  // Interpret cli parameters.
-  const cliFileFilters = (0, _util.createFileFiltersFromArguments)(config._internal.cliArgs);
-  const grepMatcher = config._internal.cliGrep ? (0, _util.createTitleMatcher)((0, _util.forceRegExp)(config._internal.cliGrep)) : () => true;
-  const grepInvertMatcher = config._internal.cliGrepInvert ? (0, _util.createTitleMatcher)((0, _util.forceRegExp)(config._internal.cliGrepInvert)) : () => false;
-  const cliTitleMatcher = title => !grepInvertMatcher(title) && grepMatcher(title);
-
-  // First iterate leaf projects to focus only, then add all other projects.
-  for (const project of topLevelProjects) {
-    const projectSuite = await createProjectSuite(fileSuits, project, {
-      cliFileFilters,
-      cliTitleMatcher,
-      testIdMatcher: config._internal.testIdMatcher
-    }, filesToRunByProject.get(project));
-    if (projectSuite) rootSuite._addSuite(projectSuite);
+  // First add top-level projects, so that we can filterOnly and shard just top-level.
+  {
+    // Interpret cli parameters.
+    const cliFileFilters = (0, _util.createFileFiltersFromArguments)(config._internal.cliArgs);
+    const grepMatcher = config._internal.cliGrep ? (0, _util.createTitleMatcher)((0, _util.forceRegExp)(config._internal.cliGrep)) : () => true;
+    const grepInvertMatcher = config._internal.cliGrepInvert ? (0, _util.createTitleMatcher)((0, _util.forceRegExp)(config._internal.cliGrepInvert)) : () => false;
+    const cliTitleMatcher = title => !grepInvertMatcher(title) && grepMatcher(title);
+
+    // Clone file suites for top-level projects.
+    for (const [project, fileSuites] of fileSuitesByProject) {
+      if (project._internal.type === 'top-level') rootSuite._addSuite(await createProjectSuite(fileSuites, project, {
+        cliFileFilters,
+        cliTitleMatcher,
+        testIdMatcher: config._internal.testIdMatcher
+      }));
+    }
   }
 
   // Complain about only.
@@ -115,28 +144,47 @@ async function loadAllTests(mode, config, projectsToIgnore, fileMatcher, errors,
     if (onlyTestsAndSuites.length > 0) errors.push(...createForbidOnlyErrors(onlyTestsAndSuites));
   }
 
-  // Filter only for leaf projects.
+  // Filter only for top-level projects.
   if (shouldFilterOnly) (0, _suiteUtils.filterOnly)(rootSuite);
 
-  // Prepend the projects that are dependencies.
-  for (const project of dependencyProjects) {
-    const projectSuite = await createProjectSuite(fileSuits, project, {
-      cliFileFilters: [],
-      cliTitleMatcher: undefined
-    }, filesToRunByProject.get(project));
-    if (projectSuite) rootSuite._prependSuite(projectSuite);
+  // Shard only the top-level projects.
+  if (config.shard) {
+    // Create test groups for top-level projects.
+    const testGroups = [];
+    for (const projectSuite of rootSuite.suites) testGroups.push(...(0, _testGroups.createTestGroups)(projectSuite, config.workers));
+
+    // Shard test groups.
+    const testGroupsInThisShard = (0, _testGroups.filterForShard)(config.shard, testGroups);
+    const testsInThisShard = new Set();
+    for (const group of testGroupsInThisShard) {
+      for (const test of group.tests) testsInThisShard.add(test);
+    }
+
+    // Update project suites, removing empty ones.
+    (0, _suiteUtils.filterTestsRemoveEmptySuites)(rootSuite, test => testsInThisShard.has(test));
+  }
+
+  // Now prepend dependency projects.
+  {
+    // Filtering only and sharding might have reduced the number of top-level projects.
+    // Build the project closure to only include dependencies that are still needed.
+    const projectClosure = new Set((0, _projectUtils.buildProjectsClosure)(rootSuite.suites.map(suite => suite.project())));
+
+    // Clone file suites for dependency projects.
+    for (const [project, fileSuites] of fileSuitesByProject) {
+      if (project._internal.type === 'dependency' && projectClosure.has(project)) rootSuite._prependSuite(await createProjectSuite(fileSuites, project, {
+        cliFileFilters: [],
+        cliTitleMatcher: undefined
+      }));
+    }
   }
   return rootSuite;
 }
-async function createProjectSuite(fileSuits, project, options, files) {
-  const fileSuitesMap = new Map();
-  for (const fileSuite of fileSuits) fileSuitesMap.set(fileSuite._requireFile, fileSuite);
+async function createProjectSuite(fileSuites, project, options) {
   const projectSuite = new _test.Suite(project.name, 'project');
   projectSuite._projectConfig = project;
   if (project._internal.fullyParallel) projectSuite._parallelMode = 'parallel';
-  for (const file of files) {
-    const fileSuite = fileSuitesMap.get(file);
-    if (!fileSuite) continue;
+  for (const fileSuite of fileSuites) {
     for (let repeatEachIndex = 0; repeatEachIndex < project.repeatEach; repeatEachIndex++) {
       const builtSuite = (0, _suiteUtils.buildFileSuiteForProject)(project, fileSuite, repeatEachIndex);
       projectSuite._addSuite(builtSuite);
@@ -151,8 +199,8 @@ async function createProjectSuite(fileSuits, project, options, files) {
     if (grepInvertMatcher !== null && grepInvertMatcher !== void 0 && grepInvertMatcher(grepTitle)) return false;
     return grepMatcher(grepTitle) && (!options.cliTitleMatcher || options.cliTitleMatcher(grepTitle));
   };
-  if ((0, _suiteUtils.filterTestsRemoveEmptySuites)(projectSuite, titleMatcher)) return projectSuite;
-  return null;
+  (0, _suiteUtils.filterTestsRemoveEmptySuites)(projectSuite, titleMatcher);
+  return projectSuite;
 }
 function createForbidOnlyErrors(onlyTestsAndSuites) {
   const errors = [];
@@ -167,22 +215,20 @@ function createForbidOnlyErrors(onlyTestsAndSuites) {
   }
   return errors;
 }
-function createDuplicateTitlesErrors(config, fileSuites) {
+function createDuplicateTitlesErrors(config, fileSuite) {
   const errors = [];
-  for (const fileSuite of fileSuites) {
-    const testsByFullTitle = new Map();
-    for (const test of fileSuite.allTests()) {
-      const fullTitle = test.titlePath().slice(1).join(' › ');
-      const existingTest = testsByFullTitle.get(fullTitle);
-      if (existingTest) {
-        const error = {
-          message: `Error: duplicate test title "${fullTitle}", first declared in ${buildItemLocation(config.rootDir, existingTest)}`,
-          location: test.location
-        };
-        errors.push(error);
-      }
-      testsByFullTitle.set(fullTitle, test);
+  const testsByFullTitle = new Map();
+  for (const test of fileSuite.allTests()) {
+    const fullTitle = test.titlePath().slice(1).join(' › ');
+    const existingTest = testsByFullTitle.get(fullTitle);
+    if (existingTest) {
+      const error = {
+        message: `Error: duplicate test title "${fullTitle}", first declared in ${buildItemLocation(config.rootDir, existingTest)}`,
+        location: test.location
+      };
+      errors.push(error);
     }
+    testsByFullTitle.set(fullTitle, test);
   }
   return errors;
 }
@@ -201,4 +247,30 @@ function loadGlobalHook(config, file) {
 }
 function loadReporter(config, file) {
   return requireOrImportDefaultFunction(_path.default.resolve(config.rootDir, file), true);
+}
+async function isPotentiallyJavaScriptFileWithSourceMap(file, cache) {
+  if (!file.endsWith('.js')) return false;
+  if (cache.has(file)) return cache.get(file);
+  try {
+    const stream = _fs.default.createReadStream(file);
+    const rl = _readline.default.createInterface({
+      input: stream,
+      crlfDelay: Infinity
+    });
+    let lastLine;
+    rl.on('line', line => {
+      lastLine = line;
+    });
+    await new Promise((fulfill, reject) => {
+      rl.on('close', fulfill);
+      rl.on('error', reject);
+      stream.on('error', reject);
+    });
+    const hasSourceMap = !!lastLine && lastLine.startsWith('//# sourceMappingURL=');
+    cache.set(file, hasSourceMap);
+    return hasSourceMap;
+  } catch (e) {
+    cache.set(file, true);
+    return true;
+  }
 }

package/lib/runner/loaderHost.js

@@ -45,8 +45,8 @@ class OutOfProcessLoaderHost {
   constructor(config) {
     this._startPromise = void 0;
     this._processHost = void 0;
-    this._processHost = new _processHost.ProcessHost(require.resolve('../loader/loaderMain.js'), 'loader');
-    this._startPromise = this._processHost.startRunner((0, _ipc.serializeConfig)(config), true, {});
+    this._processHost = new _processHost.ProcessHost(require.resolve('../loader/loaderMain.js'), 'loader', {});
+    this._startPromise = this._processHost.startRunner((0, _ipc.serializeConfig)(config), true);
   }
   async loadTestFile(file, testErrors) {
     await this._startPromise;

package/lib/runner/processHost.js

@@ -25,7 +25,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  */
 
 class ProcessHost extends _events.EventEmitter {
-  constructor(runnerScript, processName) {
+  constructor(runnerScript, processName, env) {
     super();
     this.process = void 0;
     this._didSendStop = false;
@@ -35,16 +35,19 @@ class ProcessHost extends _events.EventEmitter {
     this._lastMessageId = 0;
     this._callbacks = new Map();
     this._processName = void 0;
+    this._producedEnv = {};
+    this._extraEnv = void 0;
     this._runnerScript = runnerScript;
     this._processName = processName;
+    this._extraEnv = env;
   }
-  async startRunner(runnerParams, inheritStdio, env) {
+  async startRunner(runnerParams, inheritStdio) {
     var _process$stdout$getCo, _process$stdout, _process$stderr$getCo, _process$stderr;
     this.process = _child_process.default.fork(require.resolve('../common/process'), {
       detached: false,
       env: {
         ...process.env,
-        ...env
+        ...this._extraEnv
       },
       stdio: inheritStdio ? ['ignore', 'inherit', 'inherit', 'ipc'] : ['ignore', 'ignore', process.env.PW_RUNNER_DEBUG ? 'inherit' : 'ignore', 'ipc']
     });
@@ -59,7 +62,13 @@ class ProcessHost extends _events.EventEmitter {
     this.process.on('error', e => {}); // do not yell at a send to dead process.
     this.process.on('message', message => {
       if (_utilsBundle.debug.enabled('pw:test:protocol')) (0, _utilsBundle.debug)('pw:test:protocol')('◀ RECV ' + JSON.stringify(message));
-      if (message.method === '__dispatch__') {
+      if (message.method === '__env_produced__') {
+        const producedEnv = message.params;
+        this._producedEnv = Object.fromEntries(producedEnv.map(e => {
+          var _e$;
+          return [e[0], (_e$ = e[1]) !== null && _e$ !== void 0 ? _e$ : undefined];
+        }));
+      } else if (message.method === '__dispatch__') {
         const {
           id,
           error,
@@ -149,6 +158,9 @@ class ProcessHost extends _events.EventEmitter {
   didSendStop() {
     return this._didSendStop;
   }
+  producedEnv() {
+    return this._producedEnv;
+  }
   send(message) {
     if (_utilsBundle.debug.enabled('pw:test:protocol')) (0, _utilsBundle.debug)('pw:test:protocol')('SEND ► ' + JSON.stringify(message));
     this.process.send(message);