detox 21.0.0-breaking.new-global-lifecycle.0 → 21.0.1-rc.0

package/local-cli/run-server.js

@@ -1,5 +1,8 @@
-const DetoxRuntimeError = require('../src/errors/DetoxRuntimeError');
+const collectCliConfig = require('../src/configuration/collectCliConfig');
+const composeLoggerConfig = require('../src/configuration/composeLoggerConfig');
+const { DetoxRuntimeError } = require('../src/errors');
 const DetoxServer = require('../src/server/DetoxServer');
+const logger = require('../src/utils/logger');
 
 module.exports.command = 'run-server';
 module.exports.desc = 'Start a standalone Detox server';
@@ -28,6 +31,14 @@ module.exports.handler = async function runServer(argv) {
     throw new DetoxRuntimeError(`The port should be between 1 and 65535, got ${argv.port}`);
   }
 
+  await logger.setConfig(composeLoggerConfig({
+    // @ts-ignore
+    globalConfig: {},
+    // @ts-ignore
+    localConfig: {},
+    cliConfig: collectCliConfig({ argv }),
+  }));
+
   await new DetoxServer({
     port: +argv.port,
     standalone: true,

package/local-cli/start.js

@@ -0,0 +1,49 @@
+const _ = require('lodash');
+
+const detox = require('../internals');
+
+const AppStartCommand = require('./startCommand/AppStartCommand');
+
+module.exports.command = 'start';
+module.exports.desc = 'Run app "start" scripts inside the selected configuration';
+module.exports.builder = {
+  C: {
+    alias: 'config-path',
+    describe: 'Specify Detox config file path. If not supplied, Detox searches for .detoxrc[.js] or "detox" section in package.json',
+  },
+  c: {
+    alias: ['configuration'],
+    describe:
+      'Select a local configuration from your defined configurations to extract the app "start" scripts from. If not supplied, and there\'s only one configuration, Detox will default to it',
+  },
+  f: {
+    alias: 'force',
+    describe: 'Ignore errors from the "start" scripts and proceed',
+    boolean: true,
+  }
+};
+
+module.exports.handler = async function start(argv) {
+  const { apps: appsConfig } = await detox.resolveConfig({ argv });
+  const startCommands = _(appsConfig)
+    .values()
+    .map(app => app.start)
+    .filter(Boolean)
+    .map(cmd => new AppStartCommand({
+      cmd,
+      passthrough: argv['--'],
+      forceSpawn: argv.force,
+    }))
+    .value();
+
+  if (startCommands.length) {
+    try {
+      await Promise.all(startCommands.map(c => c.execute()));
+    } catch (e) {
+      await Promise.allSettled(startCommands.map(c => c.stop()));
+      throw e;
+    }
+  } else {
+    detox.log.warn('No "start" commands were found in the app configs.');
+  }
+};

package/local-cli/startCommand/AppStartCommand.js

@@ -0,0 +1,65 @@
+const execa = require('execa');
+
+const detox = require('../../internals');
+const { DetoxRuntimeError } = require('../../src/errors');
+const Deferred = require('../../src/utils/Deferred');
+const log = detox.log.child({ cat: ['lifecycle', 'cli'] });
+
+class AppStartCommand {
+  constructor({ cmd, passthrough = [], forceSpawn = false }) {
+    this._id = Math.random();
+    this._cmd = cmd;
+    this._passthrough = passthrough;
+    this._forceSpawn = forceSpawn;
+
+    this._cpHandle = null;
+    this._cpDeferred = new Deferred();
+  }
+
+  execute() {
+    const cmd = [this._cmd, ...this._passthrough].join(' ');
+
+    log.info.begin({ id: this._id }, cmd);
+
+    const onEnd = (msg, code, signal) => {
+      log.trace.end({ id: this._id, code, signal }, msg);
+      this._cpDeferred.resolve();
+    };
+
+    const onError = (msg, code, signal) => {
+      const logLevel = this._forceSpawn ? 'warn' : 'error';
+      log[logLevel].end({ id: this._id, code, signal }, msg);
+      if (this._forceSpawn) {
+        this._cpDeferred.resolve();
+      } else {
+        this._cpDeferred.reject(new DetoxRuntimeError(msg));
+      }
+    };
+
+    this._cpHandle = execa.command(cmd, { stdio: 'inherit', shell: true });
+    this._cpHandle.on('error', onError);
+    this._cpHandle.on('exit', (code, signal) => {
+      const reason = code == null ? `signal ${signal}` : `code ${code}`;
+      const msg = `Command exited with ${reason}: ${cmd}`;
+      if (signal || code === 0) {
+        onEnd(msg, code, signal);
+      } else {
+        onError(msg, code, signal);
+      }
+
+      this._cpHandle = null;
+    });
+
+    return this._cpDeferred.promise;
+  }
+
+  async stop() {
+    if (this._cpHandle) {
+      this._cpHandle.kill();
+    }
+
+    return this._cpDeferred.promise;
+  }
+}
+
+module.exports = AppStartCommand;

package/local-cli/templates/jest.js

@@ -1,15 +1,18 @@
 const firstTestContent = require('./firstTestContent');
 
-const runnerConfig = `{
-  "globalSetup": "detox/runners/jest/globalSetup",
-  "globalTeardown": "detox/runners/jest/globalTeardown",
-  "maxWorkers": 1,
-  "reporters": ["detox/runners/jest/reporter"],
-  "testEnvironment": "detox/runners/jest/testEnvironment",
-  "testMatch": ["<rootDir>/e2e/**/*.test.js"],
-  "testTimeout": 120000,
-  "verbose": true
-}
+const runnerConfig = `\
+/** @type {import('@jest/types').Config.InitialOptions} */
+module.exports = {
+  rootDir: '..',
+  testMatch: ['<rootDir>/e2e/**/*.test.js'],
+  testTimeout: 120000,
+  maxWorkers: 1,
+  globalSetup: 'detox/runners/jest/globalSetup',
+  globalTeardown: 'detox/runners/jest/globalTeardown',
+  reporters: ['detox/runners/jest/reporter'],
+  testEnvironment: 'detox/runners/jest/testEnvironment',
+  verbose: true,
+};
 `;
 
 exports.starter = firstTestContent;

package/local-cli/test.js

@@ -3,24 +3,30 @@ const detox = require('../internals');
 const TestRunnerCommand = require('./testCommand/TestRunnerCommand');
 
 module.exports.command = 'test';
-module.exports.desc = 'Run your test suite with the test runner specified in package.json';
+module.exports.desc = 'Run your test suites with the test runner specified in the project\'s Detox config';
 module.exports.builder = require('./testCommand/builder');
 module.exports.middlewares = require('./testCommand/middlewares').default;
 
 module.exports.handler = async function test({ detoxArgs, runnerArgs }) {
   try {
-    await detox.globalSetup({
+    const opts = {
       argv: detoxArgs,
       testRunnerArgv: runnerArgs,
-    });
+      workerId: null,
+    };
+
+    const config = await detox.resolveConfig(opts);
+    if (!config.cli.inspectBrk) {
+      await detox.init(opts);
+    }
 
-    const runnerCommand = new TestRunnerCommand()
-      .setRunnerConfig(detox.config.runnerConfig)
-      .setDeviceConfig(detox.config.deviceConfig)
-      .replicateCLIConfig(detox.config.cliConfig);
+    const runnerCommand = new TestRunnerCommand({
+      config,
+      env: process.env,
+    });
 
     await runnerCommand.execute();
   } finally {
-    await detox.globalTeardown();
+    await detox.cleanup();
   }
 };

package/local-cli/testCommand/TestRunnerCommand.js

@@ -5,51 +5,116 @@ const parser = require('yargs-parser');
 const unparse = require('yargs-unparser');
 
 const detox = require('../../internals');
-const { DetoxRuntimeError } = require('../../src/errors');
+const log = detox.log.child({ cat: ['lifecycle', 'cli'] });
 const { printEnvironmentVariables, prependNodeModulesBinToPATH } = require('../../src/utils/envUtils');
-const { escapeSpaces } = require('../../src/utils/shellUtils');
+const { toSimplePath } = require('../../src/utils/pathUtils');
+const { escapeSpaces, useForwardSlashes } = require('../../src/utils/shellUtils');
+const sleep = require('../../src/utils/sleep');
+const AppStartCommand = require('../startCommand/AppStartCommand');
+const { markErrorAsLogged } = require('../utils/cliErrorHandling');
+
+const TestRunnerError = require('./TestRunnerError');
 
 class TestRunnerCommand {
-  constructor() {
-    this._argv = {};
-    this._env = {};
-    this._envHint = {};
-    this._retries = 0;
-    /** @type {Detox.DetoxDeviceConfig} */
-    this._deviceConfig = null;
+  /*
+    @param {object} opts
+    @param {DetoxInternals.RuntimeConfig} opts.config
+    @param {ProcessEnv} opts.env
+  */
+  constructor(opts) {
+    const cliConfig = opts.config.cli;
+    const deviceConfig = opts.config.device;
+    const runnerConfig = opts.config.testRunner;
+    const appsConfig = opts.config.apps;
+
+    this._argv = runnerConfig.args;
+    this._retries = runnerConfig.retries;
+    this._envHint = this._buildEnvHint(opts.env);
+    this._startCommands = this._prepareStartCommands(appsConfig, cliConfig);
+    this._envFwd = {};
+
+    if (runnerConfig.forwardEnv) {
+      this._envFwd = this._buildEnvOverride(cliConfig, deviceConfig);
+      Object.assign(this._envHint, this._envFwd);
+    }
   }
 
-  /**
-   * @param {Detox.DetoxDeviceConfig} config
-   * @returns {this}
-   */
-  setDeviceConfig(config) {
-    this._deviceConfig = config;
+  async execute() {
+    let runsLeft = 1 + this._retries;
+    let launchError = null;
+
+    if (this._startCommands.length > 0) {
+      try {
+        await Promise.race([sleep(1000), ...this._startCommands.map(cmd => cmd.execute())]);
+      } catch (e) {
+        await Promise.allSettled(this._startCommands.map(cmd => cmd.stop()));
+        throw e;
+      }
+    }
+
+    do {
+      try {
+        await this._spawnTestRunner();
+        launchError = null;
+      } catch (e) {
+        launchError = e;
+
+        const failedTestFiles = detox.session.testResults.filter(r => !r.success);
+
+        const { bail } = detox.config.testRunner;
+        if (bail && failedTestFiles.some(r => r.isPermanentFailure)) {
+          throw e;
+        }
 
-    return this;
+        const testFilesToRetry = failedTestFiles.filter(r => !r.isPermanentFailure).map(r => r.testFilePath);
+        if (_.isEmpty(testFilesToRetry)) {
+          throw e;
+        }
+
+        if (--runsLeft > 0) {
+          // @ts-ignore
+          detox.session.testSessionIndex++; // it is always the primary context, so we can update it
+
+          this._argv._ = testFilesToRetry.map(useForwardSlashes);
+          this._logRelaunchError(testFilesToRetry);
+        }
+      }
+    } while (launchError && runsLeft > 0);
+
+    await Promise.allSettled(this._startCommands.map(cmd => cmd.stop()));
+
+    if (launchError) {
+      throw launchError;
+    }
   }
 
-  /**
-   * @param {Detox.DetoxTestRunnerConfig} config
-   * @returns {this}
-   */
-  setRunnerConfig(config) {
-    this._argv = config.args;
-    this._retries = config.retries;
+  _buildEnvHint(env) {
+    return _(env)
+      .mapKeys((_value, key) => key.toUpperCase())
+      .pickBy((_value, key) => key.startsWith('DETOX_'))
+      .omit(['DETOX_CONFIG_SNAPSHOT_PATH'])
+      .value();
+  }
 
-    if (config.inspectBrk === true) {
-      this._env = this._envHint;
+  _prepareStartCommands(appsConfig, cliConfig) {
+    if (`${cliConfig.start}` === 'false') {
+      return [];
     }
 
-    return this;
+    return _.values(appsConfig)
+      .filter(app => app.start)
+      .map(app => new AppStartCommand({
+        cmd: app.start,
+        forceSpawn: cliConfig.start === 'force',
+      }));
   }
 
   /**
-   * @param {Partial<Readonly<DetoxInternals.DetoxCLIConfig>>} cliConfig
-   * @returns {this}
+   * @param {DetoxInternals.CLIConfig} cliConfig
+   * @param {Detox.DetoxDeviceConfig} deviceConfig
    */
-  replicateCLIConfig(cliConfig) {
-    this._envHint = _.omitBy({
+  _buildEnvOverride(cliConfig, deviceConfig) {
+    return _.omitBy({
       DETOX_APP_LAUNCH_ARGS: cliConfig.appLaunchArgs,
       DETOX_ARTIFACTS_LOCATION: cliConfig.artifactsLocation,
       DETOX_CAPTURE_VIEW_HIERARCHY: cliConfig.captureViewHierarchy,
@@ -59,7 +124,7 @@ class TestRunnerCommand {
       DETOX_DEBUG_SYNCHRONIZATION: cliConfig.debugSynchronization,
       DETOX_DEVICE_BOOT_ARGS: cliConfig.deviceBootArgs,
       DETOX_DEVICE_NAME: cliConfig.deviceName,
-      DETOX_FORCE_ADB_INSTALL: this._deviceConfig.type.startsWith('android.')
+      DETOX_FORCE_ADB_INSTALL: deviceConfig.type.startsWith('android.')
         ? cliConfig.forceAdbInstall
         : undefined,
       DETOX_GPU: cliConfig.gpu,
@@ -76,51 +141,13 @@ class TestRunnerCommand {
       DETOX_TAKE_SCREENSHOTS: cliConfig.takeScreenshots,
       DETOX_USE_CUSTOM_LOGGER: cliConfig.useCustomLogger,
     }, _.isUndefined);
-
-    return this;
-  }
-
-  async execute() {
-    let runsLeft = 1 + this._retries;
-    let launchError;
-
-    do {
-      try {
-        if (launchError) {
-          const list = this._argv._.map((file, index) => `  ${index + 1}. ${file}`).join('\n');
-          detox.log.error(
-            `There were failing tests in the following files:\n${list}\n\n` +
-            'Detox CLI is going to restart the test runner with those files...\n'
-          );
-        }
-
-        await this._doExecute();
-        launchError = null;
-      } catch (e) {
-        launchError = e;
-
-        // @ts-ignore
-        const { failedTestFiles } = detox.session;
-        if (_.isEmpty(failedTestFiles)) {
-          throw e;
-        }
-
-        this._argv._ = failedTestFiles.slice();
-        this._env.DETOX_RERUN_INDEX = 1 + (this._env.DETOX_RERUN_INDEX || 0);
-        failedTestFiles.splice(0, Infinity);
-      }
-    } while (launchError && --runsLeft > 0);
-
-    if (launchError) {
-      throw launchError;
-    }
   }
 
-  async _doExecute() {
+  async _spawnTestRunner() {
     const fullCommand = this._buildSpawnArguments().map(escapeSpaces);
     const fullCommandWithHint = printEnvironmentVariables(this._envHint) + fullCommand.join(' ');
 
-    detox.log.info({ event: 'RUN_START', env: this._envHint }, fullCommandWithHint);
+    log.info.begin({ env: this._envHint }, fullCommandWithHint);
 
     return new Promise((resolve, reject) => {
       cp.spawn(fullCommand[0], fullCommand.slice(1), {
@@ -128,20 +155,31 @@ class TestRunnerCommand {
         stdio: 'inherit',
         env: _({})
           .assign(process.env)
-          .assign(this._env)
+          .assign(this._envFwd)
           .omitBy(_.isUndefined)
           .tap(prependNodeModulesBinToPATH)
           .value()
       })
-        .on('error', (err) => reject(err))
-        .on('exit', (code) => code === 0
-          ? resolve()
-          : reject(new DetoxRuntimeError(`Command failed with exit code = ${code}:\n${fullCommandWithHint}`)
-        ));
+        .on('error', /* istanbul ignore next */ (err) => reject(err))
+        .on('exit', (code, signal) => {
+          if (code === 0) {
+            log.trace.end({ success: true });
+            resolve();
+          } else {
+            const error = new TestRunnerError({
+              command: fullCommandWithHint,
+              code,
+              signal,
+            });
+            log.error.end({ success: false, code, signal }, error.message);
+            reject(markErrorAsLogged(error));
+          }
+        });
     });
   }
 
   _buildSpawnArguments() {
+    /* istanbul ignore next */
     const { _: specs = [], '--': passthrough = [], $0, ...argv } = this._argv;
     const { _: $0_, ...$0argv } = parser($0);
 
@@ -152,6 +190,17 @@ class TestRunnerCommand {
       ...unparse({ _: [...passthrough, ...specs] }),
     ].map(String);
   }
+
+  _logRelaunchError(filePaths) {
+    const list = filePaths.map((file, index) => {
+      return `  ${index + 1}. ${toSimplePath(file)}`;
+    }).join('\n');
+
+    log.error(
+      `There were failing tests in the following files:\n${list}\n\n` +
+      'Detox CLI is going to restart the test runner with those files...\n'
+    );
+  }
 }
 
 module.exports = TestRunnerCommand;

package/local-cli/testCommand/TestRunnerError.js

@@ -0,0 +1,13 @@
+const { DetoxError } = require('../../src/errors');
+
+class TestRunnerError extends DetoxError {
+  constructor({ command, code, signal }) {
+    super(`Command failed with exit code = ${code}:\n${command}`);
+
+    this.code = code;
+    this.signal = signal;
+    this.name = 'TestRunnerError';
+  }
+}
+
+module.exports = TestRunnerError;

package/local-cli/testCommand/builder.js

@@ -28,6 +28,11 @@ module.exports = {
     describe: 'Reuse existing installed app (do not delete + reinstall) for a faster run.',
     boolean: true,
   },
+  start: {
+    group: 'Execution:',
+    describe: 'Run app "start" scripts before running the tests. Use --no-start to disable that, and --start=force to ignore errors.',
+    default: true,
+  },
   u: {
     alias: 'cleanup',
     group: 'Execution:',
@@ -109,7 +114,6 @@ module.exports = {
     describe: 'Override the device name specified in a configuration. Useful for running a single build configuration on multiple devices.',
   },
   'device-boot-args': {
-    alias: 'device-launch-args',
     group: 'Execution:',
     describe: 'Custom arguments to pass (through) onto the device (emulator/simulator) binary when booted.',
   },

package/local-cli/testCommand/middlewares.js

@@ -5,7 +5,7 @@ const { getJestBooleanArgs } = require('../utils/jestInternals');
 const { simpleUnquote, extractKnownKeys, disengageBooleanArgs } = require('../utils/yargsUtils');
 
 const testCommandArgs = require('./builder');
-const { DETOX_ARGV_OVERRIDE_NOTICE, DEVICE_LAUNCH_ARGS_DEPRECATION } = require('./warnings');
+const { DETOX_ARGV_OVERRIDE_NOTICE } = require('./warnings');
 
 function applyEnvironmentVariableAddendum(argv, yargs) {
   if (process.env.DETOX_ARGV_OVERRIDE) {
@@ -13,12 +13,13 @@ function applyEnvironmentVariableAddendum(argv, yargs) {
 
     const { _: positional, '--': passthrough, ...named } = yargs.parse(process.env.DETOX_ARGV_OVERRIDE);
 
-    if (positional) {
+    if (!_.isEmpty(positional)) {
+      /* istanbul ignore next */
       argv._ = argv._ || [];
       argv._.push(...positional.map(simpleUnquote));
     }
 
-    if (passthrough) {
+    if (!_.isEmpty(passthrough)) {
       argv['--'] = argv['--'] || [];
       argv['--'].push(...passthrough.map(simpleUnquote));
     }
@@ -29,14 +30,6 @@ function applyEnvironmentVariableAddendum(argv, yargs) {
   return argv;
 }
 
-function warnDeviceAppLaunchArgsDeprecation(argv) {
-  if (argv['device-boot-args'] && process.argv.some(a => a.startsWith('--device-launch-args'))) {
-    log.warn(DEVICE_LAUNCH_ARGS_DEPRECATION);
-  }
-
-  return argv;
-}
-
 /**
  * @param {Record<string, *>} argv
  * @returns {{
@@ -64,12 +57,10 @@ function splitArgv(argv) {
 // noinspection JSUnusedGlobalSymbols
 module.exports = {
   applyEnvironmentVariableAddendum,
-  warnDeviceAppLaunchArgsDeprecation,
   splitArgv,
 };
 
 module.exports.default = [
   applyEnvironmentVariableAddendum,
-  warnDeviceAppLaunchArgsDeprecation,
   splitArgv,
 ];

package/local-cli/testCommand/warnings.js

@@ -1,5 +1,3 @@
-const { DEVICE_LAUNCH_ARGS_DEPRECATION } = require('../../src/configuration/utils/warnings');
-
 const DETOX_ARGV_OVERRIDE_NOTICE = `
    _____ _____ ___________
   /  ___|_   _|  _  | ___ \\  $DETOX_ARGV_OVERRIDE is detected
@@ -22,5 +20,4 @@ const DETOX_ARGV_OVERRIDE_NOTICE = `
 
 module.exports = {
   DETOX_ARGV_OVERRIDE_NOTICE,
-  DEVICE_LAUNCH_ARGS_DEPRECATION,
 };

package/local-cli/utils/cliErrorHandling.js

@@ -0,0 +1,15 @@
+const loggedErrors = new WeakSet();
+
+function markErrorAsLogged(error) {
+  loggedErrors.add(error);
+  return error;
+}
+
+function isErrorAlreadyLogged(error) {
+  return loggedErrors.has(error);
+}
+
+module.exports = {
+  markErrorAsLogged,
+  isErrorAlreadyLogged,
+};

package/local-cli/utils/jestInternals.js

@@ -4,6 +4,7 @@ const path = require('path');
 
 const _ = require('lodash');
 const resolveFrom = require('resolve-from');
+const semver = require('semver');
 
 const { DetoxRuntimeError } = require('../../src/errors');
 
@@ -50,7 +51,9 @@ function resolveJestCliArgs() {
 
   try {
     const jestCliManifest = resolveJestDependency(jestLocation, 'jest-cli/package.json');
-    const argsJsFile = path.join(path.dirname(jestCliManifest), 'build/cli/args.js');
+    const jestCliVersion = require(jestCliManifest).version;
+    const argsJsFilePath = semver.gt(jestCliVersion, '29.1.2') ? 'build/args.js' : 'build/cli/args.js';
+    const argsJsFile = path.join(path.dirname(jestCliManifest), argsJsFilePath);
 
     return require(argsJsFile);
   } catch (e) {