feat(config): skipLegacyWorkersInjection

detox/index.d.ts

@@ -46,6 +46,12 @@ declare global {
              * @example testRunner: 'mocha'
              */
             testRunner?: string;
+            /**
+             * Stops passing default `--maxWorkers 1` to the test runner,
+             * presuming that from now on you have that already configured
+             * in your test runner config as a default.
+             */
+            skipLegacyWorkersInjection?: boolean;
             /**
              * @example runnerConfig: 'e2e/config.js'
              */

detox/local-cli/init.js

@@ -102,6 +102,7 @@ function createJestFolderE2E() {
   createFile('.detoxrc.json', JSON.stringify({
     testRunner: 'jest',
     runnerConfig: 'e2e/config.json',
+    skipLegacyWorkersInjection: true,
     ...createDefaultConfigurations(),
   }, null, 2));
 }

detox/local-cli/templates/jest.js

@@ -1,6 +1,7 @@
 const firstTestContent = require('./firstTestContent');
 
 const runnerConfig = `{
+    "maxWorkers": 1,
     "testEnvironment": "./environment",
     "testRunner": "jest-circus/runner",
     "testTimeout": 120000,

detox/local-cli/test.js

@@ -13,6 +13,7 @@ const { loadLastFailedTests, resetLastFailedTests } = require('../src/utils/last
 const log = require('../src/utils/logger').child({ __filename });
 const { parse, quote } = require('../src/utils/shellQuote');
 
+const { readJestConfig } = require('./utils/jestInternals');
 const { getPlatformSpecificString, printEnvironmentVariables } = require('./utils/misc');
 const { prependNodeModulesBinToPATH } = require('./utils/misc');
 const splitArgv = require('./utils/splitArgv');
@@ -33,7 +34,7 @@ module.exports.handler = async function test(argv) {
     detoxArgs,
   });
 
-  const forwardedArgs = prepareArgs({
+  const forwardedArgs = await prepareArgs({
     cliConfig,
     runnerConfig,
     runnerArgs,
@@ -75,7 +76,7 @@ module.exports.middlewares = [
 
 function choosePrepareArgs({ cliConfig, detoxArgs, runner }) {
   if (runner === 'mocha') {
-    if (hasMultipleWorkers(cliConfig)) {
+    if (cliConfig.workers) {
       log.warn('Cannot use -w, --workers. Parallel test execution is only supported with Jest');
     }
 
@@ -155,19 +156,25 @@ function prepareMochaArgs({ cliConfig, runnerArgs, runnerConfig, platform }) {
   };
 }
 
-function prepareJestArgs({ cliConfig, runnerArgs, runnerConfig, platform }) {
+async function prepareJestArgs({ cliConfig, runnerArgs, runnerConfig, platform }) {
   const { specs, passthrough } = splitArgv.jest(runnerArgs);
   const platformFilter = getPlatformSpecificString(platform);
 
-  return {
-    argv: {
-      color: !cliConfig.noColor && undefined,
-      config: runnerConfig.runnerConfig /* istanbul ignore next */ || undefined,
-      testNamePattern: platformFilter ? `^((?!${platformFilter}).)*$` : undefined,
-      maxWorkers: cliConfig.workers,
+  const argv = _.omitBy({
+    color: !cliConfig.noColor && undefined,
+    config: runnerConfig.runnerConfig /* istanbul ignore next */ || undefined,
+    testNamePattern: platformFilter ? `^((?!${platformFilter}).)*$` : undefined,
+    maxWorkers: cliConfig.workers || (runnerConfig.skipLegacyWorkersInjection ? undefined : 1),
 
-      ...passthrough,
-    },
+    ...passthrough,
+  }, _.isUndefined);
+
+  const hasMultipleWorkers = runnerConfig.skipLegacyWorkersInjection
+    ? (await readJestConfig(argv)).globalConfig.maxWorkers > 1
+    : cliConfig.workers > 1;
+
+  return {
+    argv,
 
     env: _.omitBy({
       DETOX_APP_LAUNCH_ARGS: cliConfig.appLaunchArgs,
@@ -183,13 +190,13 @@ function prepareJestArgs({ cliConfig, runnerArgs, runnerConfig, platform }) {
       DETOX_GPU: cliConfig.gpu,
       DETOX_HEADLESS: cliConfig.headless,
       DETOX_LOGLEVEL: cliConfig.loglevel,
-      DETOX_READ_ONLY_EMU: platform === 'android' ? hasMultipleWorkers(cliConfig) : undefined,
+      DETOX_READ_ONLY_EMU: platform === 'android' ? hasMultipleWorkers : undefined,
       DETOX_RECORD_LOGS: cliConfig.recordLogs,
       DETOX_RECORD_PERFORMANCE: cliConfig.recordPerformance,
       DETOX_RECORD_TIMELINE: cliConfig.recordTimeline,
       DETOX_RECORD_VIDEOS: cliConfig.recordVideos,
       DETOX_REPORT_SPECS: _.isUndefined(cliConfig.jestReportSpecs)
-        ? !hasMultipleWorkers(cliConfig)
+        ? !hasMultipleWorkers
         : `${cliConfig.jestReportSpecs}` === 'true',
       DETOX_REUSE: cliConfig.reuse,
       DETOX_START_TIMESTAMP: Date.now(),
@@ -233,10 +240,6 @@ function launchTestRunner({ argv, env, specs }) {
   });
 }
 
-function hasMultipleWorkers(cliConfig) {
-  return cliConfig.workers != 1;
-}
-
 async function runTestRunnerWithRetries(forwardedArgs, { keepLockFile, platform, retries }) {
   let runsLeft = 1 + retries;
   let launchError;

detox/local-cli/test.test.js

@@ -306,6 +306,23 @@ describe('CLI', () => {
       });
     });
 
+    describe('given skipLegacyWorkersInjection: true', () => {
+      describe.each([
+        ['ios.simulator'],
+        ['android.emulator'],
+      ])('for %s', (configurationType) => {
+        it('should omit --maxWorkers CLI arg', async () => {
+          singleConfig().type = configurationType;
+          detoxConfig.skipLegacyWorkersInjection = true;
+          detoxConfig.runnerConfig = 'package.json';
+
+          await run();
+
+          expect(cliCall().command).not.toMatch(/--maxWorkers/);
+        });
+      });
+    });
+
     test.each([['-c'], ['--configuration']])(
       '%s <configuration> should provide inverted --testNamePattern that configuration (jest)',
       async (__configuration) => {
@@ -447,49 +464,63 @@ describe('CLI', () => {
       expect(cliCall().env).toEqual(expect.objectContaining({ DETOX_CAPTURE_VIEW_HIERARCHY: 'enabled' }));
     });
 
-    test.each([['-w'], ['--workers']])('%s <value> should be passed as CLI argument', async (__workers) => {
-      await run(`${__workers} 2`);
-      expect(cliCall().command).toContain('--maxWorkers 2');
-    });
+    describe.each([
+      [false],
+      [true],
+    ])('when skipLegacyWorkersInjection is %j', (skipLegacyWorkersInjection) => {
+      beforeEach(() => {
+        Object.assign(detoxConfig, {
+          skipLegacyWorkersInjection,
+          runnerConfig: tempfile('.json', JSON.stringify({
+            maxWorkers: 1,
+          })),
+        });
+      });
 
-    test.each([['-w'], ['--workers']])('%s <value> should be replaced with --maxWorkers <value>', async (__workers) => {
-      await run(`${__workers} 2 --maxWorkers 3`);
+      test.each([['-w'], ['--workers']])('%s <value> should be passed as CLI argument', async (__workers) => {
+        await run(`${__workers} 2`);
+        expect(cliCall().command).toContain('--maxWorkers 2');
+      });
 
-      const { command } = cliCall();
-      expect(command).toContain('--maxWorkers 3');
-      expect(command).not.toContain('--maxWorkers 2');
-    });
+      test.each([['-w'], ['--workers']])('%s <value> should be replaced with --maxWorkers <value>', async (__workers) => {
+        await run(`${__workers} 2 --maxWorkers 3`);
 
-    test.each([['-w'], ['--workers']])('%s <value> can be overriden by a later value', async (__workers) => {
-      await run(`${__workers} 2 ${__workers} 3`);
+        const { command } = cliCall();
+        expect(command).toContain('--maxWorkers 3');
+        expect(command).not.toContain('--maxWorkers 2');
+      });
 
-      const { command } = cliCall();
-      expect(command).toContain('--maxWorkers 3');
-      expect(command).not.toContain('--maxWorkers 2');
-    });
+      test.each([['-w'], ['--workers']])('%s <value> can be overriden by a later value', async (__workers) => {
+        await run(`${__workers} 2 ${__workers} 3`);
 
-    test.each([['-w'], ['--workers']])('%s <value> should not warn anything for iOS', async (__workers) => {
-      singleConfig().type = 'ios.simulator';
-      await run(`${__workers} 2`);
-      expect(logger.warn).not.toHaveBeenCalled();
-    });
+        const { command } = cliCall();
+        expect(command).toContain('--maxWorkers 3');
+        expect(command).not.toContain('--maxWorkers 2');
+      });
 
-    test.each([['-w'], ['--workers']])('%s <value> should not put readOnlyEmu environment variable for iOS', async (__workers) => {
-      singleConfig().type = 'ios.simulator';
-      await run(`${__workers} 2`);
-      expect(cliCall().env).not.toHaveProperty('DETOX_READ_ONLY_EMU');
-    });
+      test.each([['-w'], ['--workers']])('%s <value> should not warn anything for iOS', async (__workers) => {
+        singleConfig().type = 'ios.simulator';
+        await run(`${__workers} 2`);
+        expect(logger.warn).not.toHaveBeenCalled();
+      });
 
-    test.each([['-w'], ['--workers']])('%s <value> should put readOnlyEmu environment variable for Android if there is a single worker', async (__workers) => {
-      singleConfig().type = 'android.emulator';
-      await run(`${__workers} 1`);
-      expect(cliCall().env).toEqual(expect.objectContaining({ DETOX_READ_ONLY_EMU: false }));
-    });
+      test.each([['-w'], ['--workers']])('%s <value> should not put readOnlyEmu environment variable for iOS', async (__workers) => {
+        singleConfig().type = 'ios.simulator';
+        await run(`${__workers} 2`);
+        expect(cliCall().env).not.toHaveProperty('DETOX_READ_ONLY_EMU');
+      });
 
-    test.each([['-w'], ['--workers']])('%s <value> should put readOnlyEmu environment variable for Android if there are multiple workers', async (__workers) => {
-      singleConfig().type = 'android.emulator';
-      await run(`${__workers} 2`);
-      expect(cliCall().env).toEqual(expect.objectContaining({ DETOX_READ_ONLY_EMU: true }));
+      test.each([['-w'], ['--workers']])('%s <value> should put readOnlyEmu environment variable for Android if there is a single worker', async (__workers) => {
+        singleConfig().type = 'android.emulator';
+        await run(`${__workers} 1`);
+        expect(cliCall().env).toEqual(expect.objectContaining({ DETOX_READ_ONLY_EMU: false }));
+      });
+
+      test.each([['-w'], ['--workers']])('%s <value> should put readOnlyEmu environment variable for Android if there are multiple workers', async (__workers) => {
+        singleConfig().type = 'android.emulator';
+        await run(`${__workers} 2`);
+        expect(cliCall().env).toEqual(expect.objectContaining({ DETOX_READ_ONLY_EMU: true }));
+      });
     });
 
     test('should omit --testNamePattern for custom platforms', async () => {

detox/local-cli/utils/jestInternals.js

@@ -0,0 +1,70 @@
+const Module = require('module');
+const path = require('path');
+
+const resolveFrom = require('resolve-from');
+
+const DetoxRuntimeError = require('../../src/errors/DetoxRuntimeError');
+
+const getNodeModulePaths = (dir) => Module._nodeModulePaths(dir);
+
+function getJestLocation() {
+  const cwd = process.cwd();
+
+  if (!resolveFrom.silent(cwd, 'jest')) {
+    throw new DetoxRuntimeError({
+      message: 'Could not resolve "jest" package from the current working directory.\n\n' +
+        'This means that Detox could not find it in any of the following locations:\n' +
+        getNodeModulePaths(cwd).map(p => `* ${p}`).join('\n'),
+      hint: `Try installing "jest": npm install jest --save-dev`,
+    });
+  }
+
+  return path.dirname(resolveFrom(cwd, 'jest/package.json'));
+}
+
+function resolveJestDependency(jestLocation, dependencyName) {
+  const result = resolveFrom.silent(jestLocation, dependencyName);
+  if (!result) {
+    throw new DetoxRuntimeError({
+      message: `Could not resolve "${dependencyName}" package from the "jest" npm package directory.\n\n` +
+        'This means that Detox could not find it in any of the following locations:\n' +
+        getNodeModulePaths(jestLocation).map(p => `* ${p}`).join('\n'),
+      hint: 'Consider reporting this as an issue at: https://github.com/wix/Detox/issues'
+    });
+  }
+
+  return result;
+}
+
+function requireJestDependency(jestLocation, dependencyName) {
+  return require(resolveJestDependency(jestLocation, dependencyName));
+}
+
+function resolveJestCliArgs() {
+  const jestLocation = getJestLocation();
+  resolveJestDependency(jestLocation, 'jest-cli');
+
+  try {
+    const jestCliManifest = resolveJestDependency(jestLocation, 'jest-cli/package.json');
+    const argsJsFile = path.join(path.dirname(jestCliManifest), 'build/cli/args.js');
+
+    return require(argsJsFile);
+  } catch (e) {
+    throw new DetoxRuntimeError({
+      message: 'Could not parse CLI arguments supported by "jest-cli" package, see the error below.',
+      hint: 'Consider reporting this as an issue at: https://github.com/wix/Detox/issues',
+      debugInfo: e,
+    });
+  }
+}
+
+async function readJestConfig(argv) {
+  const jestLocation = getJestLocation();
+  const { readConfig } = requireJestDependency(jestLocation, 'jest-config');
+  return readConfig(argv, process.cwd(), false);
+}
+
+module.exports = {
+  resolveJestCliArgs,
+  readJestConfig,
+};

detox/local-cli/utils/splitArgv.js

@@ -1,11 +1,6 @@
-const Module = require('module');
-const path = require('path');
-
 const _ = require('lodash');
-const resolveFrom = require('resolve-from');
-
-const DetoxRuntimeError = require('../../src/errors/DetoxRuntimeError');
 
+const { resolveJestCliArgs } = require('./jestInternals');
 const testCommandArgs = require('./testCommandArgs');
 
 function extractKnownKeys(yargsBuilder) {
@@ -72,44 +67,6 @@ function getMochaBooleanArgs() {
     .value();
 }
 
-function resolveJestCliArgs() {
-  const cwd = process.cwd();
-  const getNodeModulePaths = (dir) => Module._nodeModulePaths(dir);
-
-  if (!resolveFrom.silent(cwd, 'jest')) {
-    throw new DetoxRuntimeError({
-      message: 'Could not resolve "jest" package from the current working directory.\n\n' +
-        'This means that Detox could not find it in any of the following locations:\n' +
-        getNodeModulePaths(cwd).map(p => `* ${p}`).join('\n'),
-      hint: `Try installing "jest": npm install jest --save-dev`,
-    });
-  }
-
-  const jestLocation = path.dirname(resolveFrom(cwd, 'jest/package.json'));
-
-  if (!resolveFrom.silent(jestLocation, 'jest-cli')) {
-    throw new DetoxRuntimeError({
-      message: 'Could not resolve "jest-cli" package from the "jest" npm package directory.\n\n' +
-        'This means that Detox could not find it in any of the following locations:\n' +
-        getNodeModulePaths(jestLocation).map(p => `* ${p}`).join('\n'),
-      hint: 'Consider reporting this as an issue at: https://github.com/wix/Detox/issues'
-    });
-  }
-
-  try {
-    const jestCliManifest = resolveFrom(jestLocation, 'jest-cli/package.json');
-    const argsJsFile = path.join(path.dirname(jestCliManifest), 'build/cli/args.js');
-
-    return require(argsJsFile);
-  } catch (e) {
-    throw new DetoxRuntimeError({
-      message: 'Could not parse CLI arguments supported by "jest-cli" package, see the error below.',
-      hint: 'Consider reporting this as an issue at: https://github.com/wix/Detox/issues',
-      debugInfo: e,
-    });
-  }
-}
-
 function splitDetoxArgv(argv) {
   const aliases = extractKnownKeys(testCommandArgs);
   const isDetoxArg = (_value, key) => aliases.has(key);

detox/local-cli/utils/testCommandArgs.js

@@ -106,7 +106,6 @@ module.exports = {
     group: 'Execution:',
     describe: 'Specifies the number of workers the test runner should spawn. Requires a test runner with parallel execution support (e.g. Jest)',
     number: true,
-    default: 1,
   },
   'jest-report-specs': {
     group: 'Execution:',

detox/package.json

@@ -1,7 +1,7 @@
 {
   "name": "detox",
   "description": "E2E tests and automation for mobile",
-  "version": "18.18.2-smoke.0",
+  "version": "18.19.0-smoke.0",
   "bin": {
     "detox": "local-cli/cli.js"
   },

detox/src/configuration/composeRunnerConfig.js

@@ -11,6 +11,7 @@ function composeRunnerConfig({ globalConfig, cliConfig }) {
     testRunner,
     runnerConfig: customRunnerConfig || defaultRunnerConfig,
     specs: globalConfig.specs || 'e2e',
+    skipLegacyWorkersInjection: Boolean(globalConfig.skipLegacyWorkersInjection),
   };
 }