@playwright/test 1.31.2 → 1.32.0

package/lib/runner/reporters.js

@@ -34,7 +34,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * limitations under the License.
  */
 
-async function createReporter(config, mode) {
+async function createReporter(config, mode, additionalReporters = []) {
   const defaultReporters = {
     dot: mode === 'list' ? ListModeReporter : _dot.default,
     line: mode === 'list' ? ListModeReporter : _line.default,
@@ -43,7 +43,7 @@ async function createReporter(config, mode) {
     json: _json.default,
     junit: _junit.default,
     null: _empty.default,
-    html: _html.default
+    html: mode === 'ui' ? _line.default : _html.default
   };
   const reporters = [];
   if (mode === 'watch') {
@@ -58,6 +58,7 @@ async function createReporter(config, mode) {
         reporters.push(new reporterConstructor(arg));
       }
     }
+    reporters.push(...additionalReporters);
     if (process.env.PW_TEST_REPORTER) {
       const reporterConstructor = await (0, _loadUtils.loadReporter)(config, process.env.PW_TEST_REPORTER);
       reporters.push(new reporterConstructor());

package/lib/runner/runner.js

@@ -11,6 +11,7 @@ var _reporters = require("./reporters");
 var _tasks = require("./tasks");
 var _utilsBundle = require("playwright-core/lib/utilsBundle");
 var _watchMode = require("./watchMode");
+var _uiMode = require("./uiMode");
 /**
  * Copyright 2019 Google Inc. All rights reserved.
  * Modifications copyright (c) Microsoft Corporation.
@@ -57,7 +58,7 @@ class Runner {
       factory: p
     }));
     const reporter = await (0, _reporters.createReporter)(config, listOnly ? 'list' : 'run');
-    const taskRunner = listOnly ? (0, _tasks.createTaskRunnerForList)(config, reporter) : (0, _tasks.createTaskRunner)(config, reporter);
+    const taskRunner = listOnly ? (0, _tasks.createTaskRunnerForList)(config, reporter, 'in-process') : (0, _tasks.createTaskRunner)(config, reporter);
     const context = {
       config,
       reporter,
@@ -89,6 +90,13 @@ class Runner {
     }));
     return await (0, _watchMode.runWatchModeLoop)(config);
   }
+  async uiAllTests() {
+    const config = this._config;
+    (0, _webServerPlugin.webServerPluginsForConfig)(config).forEach(p => config._internal.plugins.push({
+      factory: p
+    }));
+    return await (0, _uiMode.runUIMode)(config);
+  }
 }
 exports.Runner = Runner;
 function sanitizeConfigForJSON(object, visited) {

package/lib/runner/taskRunner.js

@@ -41,18 +41,15 @@ class TaskRunner {
       task
     });
   }
-  stop() {
-    this._interrupted = true;
-  }
-  async run(context, deadline) {
+  async run(context, deadline, cancelPromise) {
     const {
       status,
       cleanup
-    } = await this.runDeferCleanup(context, deadline);
+    } = await this.runDeferCleanup(context, deadline, cancelPromise);
     const teardownStatus = await cleanup();
     return status === 'passed' ? teardownStatus : status;
   }
-  async runDeferCleanup(context, deadline) {
+  async runDeferCleanup(context, deadline, cancelPromise = new _utils.ManualPromise()) {
     const sigintWatcher = new _sigIntWatcher.SigIntWatcher();
     const timeoutWatcher = new TimeoutWatcher(deadline);
     const teardownRunner = new TaskRunner(this._reporter, this._globalTimeoutForError);
@@ -89,14 +86,14 @@ class TaskRunner {
         (0, _utilsBundle.debug)('pw:test:task')(`"${name}" finished`);
       }
     };
-    await Promise.race([taskLoop(), sigintWatcher.promise(), timeoutWatcher.promise]);
+    await Promise.race([taskLoop(), cancelPromise, sigintWatcher.promise(), timeoutWatcher.promise]);
     sigintWatcher.disarm();
     timeoutWatcher.disarm();
 
     // Prevent subsequent tasks from running.
     this._interrupted = true;
     let status = 'passed';
-    if (sigintWatcher.hadSignal()) {
+    if (sigintWatcher.hadSignal() || cancelPromise !== null && cancelPromise !== void 0 && cancelPromise.isDone()) {
       status = 'interrupted';
     } else if (timeoutWatcher.timedOut()) {
       var _this$_reporter$onErr2, _this$_reporter2;
@@ -107,6 +104,7 @@ class TaskRunner {
     } else if (this._hasErrors) {
       status = 'failed';
     }
+    cancelPromise === null || cancelPromise === void 0 ? void 0 : cancelPromise.resolve();
     const cleanup = () => teardownRunner.runDeferCleanup(context, deadline).then(r => r.status);
     return {
       status,

package/lib/runner/tasks.js

@@ -15,7 +15,6 @@ var _dispatcher = require("./dispatcher");
 var _testGroups = require("../runner/testGroups");
 var _taskRunner = require("./taskRunner");
 var _loadUtils = require("./loadUtils");
-var _util2 = require("../util");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
  * Copyright Microsoft Corporation. All rights reserved.
@@ -59,7 +58,7 @@ function addGlobalSetupTasks(taskRunner, config) {
   taskRunner.addTask('clear output', createRemoveOutputDirsTask());
 }
 function addRunTasks(taskRunner, config) {
-  taskRunner.addTask('create tasks', createTestGroupsTask());
+  taskRunner.addTask('create phases', createPhasesTask());
   taskRunner.addTask('report begin', async ({
     reporter,
     rootSuite
@@ -73,9 +72,9 @@ function addRunTasks(taskRunner, config) {
   taskRunner.addTask('test suite', createRunTestsTask());
   return taskRunner;
 }
-function createTaskRunnerForList(config, reporter) {
+function createTaskRunnerForList(config, reporter, mode) {
   const taskRunner = new _taskRunner.TaskRunner(reporter, config.globalTimeout);
-  taskRunner.addTask('load tests', createLoadTask('in-process', false));
+  taskRunner.addTask('load tests', createLoadTask(mode, false));
   taskRunner.addTask('report begin', async ({
     reporter,
     rootSuite
@@ -151,39 +150,49 @@ function createLoadTask(mode, shouldFilterOnly, projectsToIgnore = new Set(), ad
     const {
       config
     } = context;
-    const cliMatcher = config._internal.cliArgs.length ? (0, _util2.createFileMatcherFromArguments)(config._internal.cliArgs) : () => true;
-    const fileMatcher = value => cliMatcher(value) && (additionalFileMatcher ? additionalFileMatcher(value) : true);
-    context.rootSuite = await (0, _loadUtils.loadAllTests)(mode, config, projectsToIgnore, fileMatcher, errors, shouldFilterOnly);
+    const filesToRunByProject = await (0, _loadUtils.collectProjectsAndTestFiles)(config, projectsToIgnore, additionalFileMatcher);
+    const fileSuitesByProject = await (0, _loadUtils.loadFileSuites)(mode, config, filesToRunByProject, errors);
+    context.rootSuite = await (0, _loadUtils.createRootSuite)(config, fileSuitesByProject, errors, shouldFilterOnly);
     // Fail when no tests.
     if (!context.rootSuite.allTests().length && !config._internal.passWithNoTests && !config.shard) throw new Error(`No tests found`);
   };
 }
-function createTestGroupsTask() {
+function createPhasesTask() {
   return async context => {
-    const {
-      config,
-      rootSuite,
-      reporter
-    } = context;
     context.config._internal.maxConcurrentTestGroups = 0;
-    for (const phase of buildPhases(rootSuite.suites)) {
-      // Go over the phases, for each phase create list of task groups.
-      const projects = [];
-      for (const projectSuite of phase) {
-        const testGroups = (0, _testGroups.createTestGroups)(projectSuite, config.workers);
-        projects.push({
-          project: projectSuite._projectConfig,
-          projectSuite,
-          testGroups
-        });
+    const processed = new Set();
+    const projectToSuite = new Map(context.rootSuite.suites.map(suite => [suite.project(), suite]));
+    for (let i = 0; i < projectToSuite.size; i++) {
+      // Find all projects that have all their dependencies processed by previous phases.
+      const phaseProjects = [];
+      for (const project of projectToSuite.keys()) {
+        if (processed.has(project)) continue;
+        if (project._internal.deps.find(p => !processed.has(p))) continue;
+        phaseProjects.push(project);
+      }
+
+      // Create a new phase.
+      for (const project of phaseProjects) processed.add(project);
+      if (phaseProjects.length) {
+        let testGroupsInPhase = 0;
+        const phase = {
+          dispatcher: new _dispatcher.Dispatcher(context.config, context.reporter),
+          projects: []
+        };
+        context.phases.push(phase);
+        for (const project of phaseProjects) {
+          const projectSuite = projectToSuite.get(project);
+          const testGroups = (0, _testGroups.createTestGroups)(projectSuite, context.config.workers);
+          phase.projects.push({
+            project,
+            projectSuite,
+            testGroups
+          });
+          testGroupsInPhase += testGroups.length;
+        }
+        (0, _utilsBundle.debug)('pw:test:task')(`created phase #${context.phases.length} with ${phase.projects.map(p => p.project.name).sort()} projects, ${testGroupsInPhase} testGroups`);
+        context.config._internal.maxConcurrentTestGroups = Math.max(context.config._internal.maxConcurrentTestGroups, testGroupsInPhase);
       }
-      const testGroupsInPhase = projects.reduce((acc, project) => acc + project.testGroups.length, 0);
-      (0, _utilsBundle.debug)('pw:test:task')(`running phase with ${projects.map(p => p.project.name).sort()} projects, ${testGroupsInPhase} testGroups`);
-      context.phases.push({
-        dispatcher: new _dispatcher.Dispatcher(config, reporter),
-        projects
-      });
-      context.config._internal.maxConcurrentTestGroups = Math.max(context.config._internal.maxConcurrentTestGroups, testGroupsInPhase);
     }
   };
 }
@@ -204,6 +213,7 @@ function createRunTestsTask() {
       phases
     } = context;
     const successfulProjects = new Set();
+    const extraEnvByProjectId = new Map();
     for (const {
       dispatcher,
       projects
@@ -216,6 +226,13 @@ function createRunTestsTask() {
         project,
         testGroups
       } of projects) {
+        // Inherit extra enviroment variables from dependencies.
+        let extraEnv = {};
+        for (const dep of project._internal.deps) extraEnv = {
+          ...extraEnv,
+          ...extraEnvByProjectId.get(dep._internal.id)
+        };
+        extraEnvByProjectId.set(project._internal.id, extraEnv);
         const hasFailedDeps = project._internal.deps.some(p => !successfulProjects.has(p));
         if (!hasFailedDeps) {
           phaseTestGroups.push(...testGroups);
@@ -226,8 +243,15 @@ function createRunTestsTask() {
         }
       }
       if (phaseTestGroups.length) {
-        await dispatcher.run(phaseTestGroups);
+        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 the worker broke, fail everything, we have no way of knowing which
@@ -243,19 +267,4 @@ function createRunTestsTask() {
       }
     }
   };
-}
-function buildPhases(projectSuites) {
-  const phases = [];
-  const processed = new Set();
-  for (let i = 0; i < projectSuites.length; i++) {
-    const phase = [];
-    for (const projectSuite of projectSuites) {
-      if (processed.has(projectSuite._projectConfig)) continue;
-      if (projectSuite._projectConfig._internal.deps.find(p => !processed.has(p))) continue;
-      phase.push(projectSuite);
-    }
-    for (const projectSuite of phase) processed.add(projectSuite._projectConfig);
-    if (phase.length) phases.push(phase);
-  }
-  return phases;
 }

package/lib/runner/testGroups.js

@@ -106,9 +106,16 @@ function createTestGroups(projectSuite, workers) {
   }
   return result;
 }
-function filterForShard(shard, filesByProject) {
+function filterForShard(shard, testGroups) {
+  // Note that sharding works based on test groups.
+  // This means parallel files will be sharded by single tests,
+  // while non-parallel files will be sharded by the whole file.
+  //
+  // Shards are still balanced by the number of tests, not files,
+  // even in the case of non-paralleled files.
+
   let shardableTotal = 0;
-  for (const files of filesByProject.values()) shardableTotal += files.length;
+  for (const group of testGroups) shardableTotal += group.tests.length;
 
   // Each shard gets some tests.
   const shardSize = Math.floor(shardableTotal / shard.total);
@@ -118,14 +125,12 @@ function filterForShard(shard, filesByProject) {
   const from = shardSize * currentShard + Math.min(extraOne, currentShard);
   const to = from + shardSize + (currentShard < extraOne ? 1 : 0);
   let current = 0;
-  const result = new Map();
-  for (const [project, files] of filesByProject) {
-    const shardFiles = [];
-    for (const file of files) {
-      if (current >= from && current < to) shardFiles.push(file);
-      ++current;
-    }
-    if (shardFiles.length) result.set(project, shardFiles);
+  const result = new Set();
+  for (const group of testGroups) {
+    // Any test group goes to the shard that contains the first test of this group.
+    // So, this shard gets any group that starts at [from; to)
+    if (current >= from && current < to) result.add(group);
+    current += group.tests.length;
   }
   return result;
 }

package/lib/runner/uiMode.js

@@ -0,0 +1,279 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runUIMode = runUIMode;
+var _server = require("playwright-core/lib/server");
+var _utils = require("playwright-core/lib/utils");
+var _compilationCache = require("../common/compilationCache");
+var _multiplexer = require("../reporters/multiplexer");
+var _teleEmitter = require("../reporters/teleEmitter");
+var _reporters = require("./reporters");
+var _tasks = require("./tasks");
+var _utilsBundle = require("../utilsBundle");
+/**
+ * Copyright Microsoft Corporation. All rights reserved.
+ *
+ * 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 UIMode {
+  constructor(config) {
+    this._config = void 0;
+    this._page = void 0;
+    this._testRun = void 0;
+    this.globalCleanup = void 0;
+    this._testWatcher = void 0;
+    this._originalStderr = void 0;
+    this._config = config;
+    process.env.PW_LIVE_TRACE_STACKS = '1';
+    config._internal.configCLIOverrides.forbidOnly = false;
+    config._internal.configCLIOverrides.globalTimeout = 0;
+    config._internal.configCLIOverrides.repeatEach = 0;
+    config._internal.configCLIOverrides.shard = undefined;
+    config._internal.configCLIOverrides.updateSnapshots = undefined;
+    config._internal.listOnly = false;
+    config._internal.passWithNoTests = true;
+    for (const project of config.projects) project._internal.deps = [];
+    for (const p of config.projects) p.retries = 0;
+    config._internal.configCLIOverrides.use = config._internal.configCLIOverrides.use || {};
+    config._internal.configCLIOverrides.use.trace = {
+      mode: 'on',
+      sources: false
+    };
+    this._originalStderr = process.stderr.write.bind(process.stderr);
+    this._installGlobalWatcher();
+  }
+  _installGlobalWatcher() {
+    const projectDirs = new Set();
+    for (const p of this._config.projects) projectDirs.add(p.testDir);
+    let coalescingTimer;
+    const watcher = _utilsBundle.chokidar.watch([...projectDirs], {
+      ignoreInitial: true,
+      persistent: true
+    }).on('all', async event => {
+      if (event !== 'add' && event !== 'change' && event !== 'unlink') return;
+      if (coalescingTimer) clearTimeout(coalescingTimer);
+      coalescingTimer = setTimeout(() => {
+        this._dispatchEvent({
+          method: 'listChanged'
+        });
+      }, 200);
+    });
+    return watcher;
+  }
+  async runGlobalSetup() {
+    const reporter = await (0, _reporters.createReporter)(this._config, 'watch');
+    const taskRunner = (0, _tasks.createTaskRunnerForWatchSetup)(this._config, reporter);
+    reporter.onConfigure(this._config);
+    const context = {
+      config: this._config,
+      reporter,
+      phases: []
+    };
+    const {
+      status,
+      cleanup: globalCleanup
+    } = await taskRunner.runDeferCleanup(context, 0);
+    if (status !== 'passed') {
+      await globalCleanup();
+      return status;
+    }
+    this.globalCleanup = globalCleanup;
+    return status;
+  }
+  async showUI() {
+    this._page = await (0, _server.showTraceViewer)([], 'chromium', {
+      app: 'watch.html',
+      headless: (0, _utils.isUnderTest)() && process.env.PWTEST_HEADED_FOR_TEST !== '1'
+    });
+    if (!process.env.PWTEST_DEBUG) {
+      process.stdout.write = chunk => {
+        this._dispatchEvent({
+          method: 'stdio',
+          params: chunkToPayload('stdout', chunk)
+        });
+        return true;
+      };
+      process.stderr.write = chunk => {
+        this._dispatchEvent({
+          method: 'stdio',
+          params: chunkToPayload('stderr', chunk)
+        });
+        return true;
+      };
+    }
+    const exitPromise = new _utils.ManualPromise();
+    this._page.on('close', () => exitPromise.resolve());
+    let queue = Promise.resolve();
+    this._page.exposeBinding('sendMessage', false, async (source, data) => {
+      const {
+        method,
+        params
+      } = data;
+      if (method === 'exit') {
+        exitPromise.resolve();
+        return;
+      }
+      if (method === 'watch') {
+        this._watchFiles(params.fileNames);
+        return;
+      }
+      if (method === 'open' && params.location) {
+        (0, _utilsBundle.open)('vscode://file/' + params.location).catch(e => this._originalStderr(String(e)));
+        return;
+      }
+      if (method === 'resizeTerminal') {
+        process.stdout.columns = params.cols;
+        process.stdout.rows = params.rows;
+        process.stderr.columns = params.cols;
+        process.stderr.columns = params.rows;
+        return;
+      }
+      if (method === 'stop') {
+        this._stopTests();
+        return;
+      }
+      queue = queue.then(() => this._queueListOrRun(method, params));
+      await queue;
+    });
+    await exitPromise;
+  }
+  async _queueListOrRun(method, params) {
+    if (method === 'list') await this._listTests();
+    if (method === 'run') await this._runTests(params.testIds);
+  }
+  _dispatchEvent(message) {
+    // eslint-disable-next-line no-console
+    this._page.mainFrame().evaluateExpression(dispatchFuncSource, true, message).catch(e => this._originalStderr(String(e)));
+  }
+  async _listTests() {
+    const listReporter = new _teleEmitter.TeleReporterEmitter(e => this._dispatchEvent(e));
+    const reporter = new _multiplexer.Multiplexer([listReporter]);
+    this._config._internal.listOnly = true;
+    this._config._internal.testIdMatcher = undefined;
+    const taskRunner = (0, _tasks.createTaskRunnerForList)(this._config, reporter, 'out-of-process');
+    const context = {
+      config: this._config,
+      reporter,
+      phases: []
+    };
+    (0, _compilationCache.clearCompilationCache)();
+    reporter.onConfigure(this._config);
+    const status = await taskRunner.run(context, 0);
+    reporter.onExit({
+      status
+    });
+  }
+  async _runTests(testIds) {
+    await this._stopTests();
+    const testIdSet = testIds ? new Set(testIds) : null;
+    this._config._internal.listOnly = false;
+    this._config._internal.testIdMatcher = id => !testIdSet || testIdSet.has(id);
+    const runReporter = new _teleEmitter.TeleReporterEmitter(e => this._dispatchEvent(e));
+    const reporter = await (0, _reporters.createReporter)(this._config, 'ui', [runReporter]);
+    const taskRunner = (0, _tasks.createTaskRunnerForWatch)(this._config, reporter);
+    const context = {
+      config: this._config,
+      reporter,
+      phases: []
+    };
+    (0, _compilationCache.clearCompilationCache)();
+    reporter.onConfigure(this._config);
+    const stop = new _utils.ManualPromise();
+    const run = taskRunner.run(context, 0, stop).then(async status => {
+      await reporter.onExit({
+        status
+      });
+      this._testRun = undefined;
+      this._config._internal.testIdMatcher = undefined;
+      return status;
+    });
+    this._testRun = {
+      run,
+      stop
+    };
+    await run;
+  }
+  async _watchFiles(fileNames) {
+    const files = new Set();
+    for (const fileName of fileNames) {
+      files.add(fileName);
+      (0, _compilationCache.dependenciesForTestFile)(fileName).forEach(file => files.add(file));
+    }
+    const watchedFiles = [...files].sort();
+    if (this._testWatcher && JSON.stringify(this._testWatcher.watchedFiles) === JSON.stringify(watchedFiles)) return;
+    if (this._testWatcher) {
+      if (this._testWatcher.collector.size) this._dispatchEvent({
+        method: 'filesChanged',
+        params: {
+          fileNames: [...this._testWatcher.collector]
+        }
+      });
+      clearTimeout(this._testWatcher.timer);
+      this._testWatcher.watcher.close().then(() => {});
+      this._testWatcher = undefined;
+    }
+    if (!watchedFiles.length) return;
+    const collector = new Set();
+    const watcher = _utilsBundle.chokidar.watch(watchedFiles, {
+      ignoreInitial: true
+    }).on('all', async (event, file) => {
+      if (event !== 'add' && event !== 'change') return;
+      (0, _compilationCache.collectAffectedTestFiles)(file, collector);
+      if (this._testWatcher.timer) clearTimeout(this._testWatcher.timer);
+      this._testWatcher.timer = setTimeout(() => {
+        const fileNames = [...collector];
+        collector.clear();
+        this._dispatchEvent({
+          method: 'filesChanged',
+          params: {
+            fileNames
+          }
+        });
+      }, 250);
+    });
+    this._testWatcher = {
+      watcher,
+      watchedFiles,
+      collector
+    };
+  }
+  async _stopTests() {
+    var _this$_testRun, _this$_testRun$stop, _this$_testRun2;
+    (_this$_testRun = this._testRun) === null || _this$_testRun === void 0 ? void 0 : (_this$_testRun$stop = _this$_testRun.stop) === null || _this$_testRun$stop === void 0 ? void 0 : _this$_testRun$stop.resolve();
+    await ((_this$_testRun2 = this._testRun) === null || _this$_testRun2 === void 0 ? void 0 : _this$_testRun2.run);
+  }
+}
+const dispatchFuncSource = String(message => {
+  window.dispatch(message);
+});
+async function runUIMode(config) {
+  var _uiMode$globalCleanup;
+  const uiMode = new UIMode(config);
+  const status = await uiMode.runGlobalSetup();
+  if (status !== 'passed') return status;
+  await uiMode.showUI();
+  return (await ((_uiMode$globalCleanup = uiMode.globalCleanup) === null || _uiMode$globalCleanup === void 0 ? void 0 : _uiMode$globalCleanup.call(uiMode))) || 'passed';
+}
+function chunkToPayload(type, chunk) {
+  if (chunk instanceof Buffer) return {
+    type,
+    buffer: chunk.toString('base64')
+  };
+  return {
+    type,
+    text: chunk
+  };
+}

package/lib/runner/workerHost.js

@@ -23,9 +23,13 @@ var _processHost = require("./processHost");
 
 let lastWorkerIndex = 0;
 class WorkerHost extends _processHost.ProcessHost {
-  constructor(testGroup, parallelIndex, config) {
+  constructor(testGroup, parallelIndex, config, extraEnv) {
     const workerIndex = lastWorkerIndex++;
-    super(require.resolve('../worker/workerMain.js'), `worker-${workerIndex}`);
+    super(require.resolve('../worker/workerMain.js'), `worker-${workerIndex}`, {
+      ...extraEnv,
+      FORCE_COLOR: '1',
+      DEBUG_COLORS: '1'
+    });
     this.parallelIndex = void 0;
     this.workerIndex = void 0;
     this._hash = void 0;
@@ -43,10 +47,7 @@ class WorkerHost extends _processHost.ProcessHost {
     };
   }
   async start() {
-    await this.startRunner(this._params, false, {
-      FORCE_COLOR: '1',
-      DEBUG_COLORS: '1'
-    });
+    await this.startRunner(this._params, false);
   }
   runTestGroup(runPayload) {
     this.sendMessageNoReply({