detox 19.9.0 → 21.0.0-breaking.new-global-lifecycle.0

package/src/devices/runtime/RuntimeDevice.js

@@ -1,6 +1,6 @@
 const DetoxRuntimeError = require('../../errors/DetoxRuntimeError');
 const debug = require('../../utils/debug'); // debug utils, leave here even if unused
-const { traceCall } = require('../../utils/trace');
+const { traceCall, traceMethods } = require('../../utils/trace');
 const wrapWithStackTraceCutter = require('../../utils/wrapWithStackTraceCutter');
 
 const LaunchArgsEditor = require('./utils/LaunchArgsEditor');
@@ -14,7 +14,7 @@ class RuntimeDevice {
     sessionConfig,
     runtimeErrorComposer,
   }, deviceDriver) {
-    wrapWithStackTraceCutter(this, [
+    const methodNames = [
       'captureViewHierarchy',
       'clearKeychain',
       'disableSynchronization',
@@ -46,7 +46,10 @@ class RuntimeDevice {
       'unmatchFace',
       'unmatchFinger',
       'unreverseTcpPort',
-    ]);
+    ];
+
+    traceMethods(this, 'device', methodNames);
+    wrapWithStackTraceCutter(this, methodNames);
 
     this._appsConfig = appsConfig;
     this._behaviorConfig = behaviorConfig;
@@ -80,13 +83,6 @@ class RuntimeDevice {
     return this._currentAppLaunchArgs;
   }
 
-  async _prepare() {
-    const appAliases = Object.keys(this._appsConfig);
-    if (appAliases.length === 1) {
-      await this.selectApp(appAliases[0]);
-    }
-  }
-
   async selectApp(name) {
     if (name === undefined) {
       throw this._errorComposer.cantSelectEmptyApp();
@@ -113,12 +109,71 @@ class RuntimeDevice {
   }
 
   async launchApp(params = {}, bundleId = this._bundleId) {
-    return traceCall('launchApp', () => this._doLaunchApp(params, bundleId));
+    const payloadParams = ['url', 'userNotification', 'userActivity'];
+    const hasPayload = this._assertHasSingleParam(payloadParams, params);
+    const newInstance = params.newInstance !== undefined
+      ? params.newInstance
+      : this._processes[bundleId] == null;
+
+    if (params.delete) {
+      await this.terminateApp(bundleId);
+      await this.uninstallApp();
+      await this.installApp();
+    } else if (newInstance) {
+      await this.terminateApp(bundleId);
+    }
+
+    const baseLaunchArgs = {
+      ...this._currentAppLaunchArgs.get(),
+      ...params.launchArgs,
+    };
+
+    if (params.url) {
+      baseLaunchArgs['detoxURLOverride'] = params.url;
+      if (params.sourceApp) {
+        baseLaunchArgs['detoxSourceAppOverride'] = params.sourceApp;
+      }
+    } else if (params.userNotification) {
+      this._createPayloadFileAndUpdatesParamsObject('userNotification', 'detoxUserNotificationDataURL', params, baseLaunchArgs);
+    } else if (params.userActivity) {
+      this._createPayloadFileAndUpdatesParamsObject('userActivity', 'detoxUserActivityDataURL', params, baseLaunchArgs);
+    }
+
+    if (params.permissions) {
+      await this.deviceDriver.setPermissions(bundleId, params.permissions);
+    }
+
+    if (params.disableTouchIndicators) {
+      baseLaunchArgs['detoxDisableTouchIndicators'] = true;
+    }
+
+    if (this._isAppRunning(bundleId) && hasPayload) {
+      await this.deviceDriver.deliverPayload({ ...(params), delayPayload: true });
+    }
+
+    if (this._behaviorConfig.launchApp === 'manual') {
+      this._processes[bundleId] = await this.deviceDriver.waitForAppLaunch(bundleId, this._prepareLaunchArgs(baseLaunchArgs), params.languageAndLocale);
+    } else {
+      this._processes[bundleId] = await this.deviceDriver.launchApp(bundleId, this._prepareLaunchArgs(baseLaunchArgs), params.languageAndLocale);
+      await this.deviceDriver.waitUntilReady();
+      await this.deviceDriver.waitForActive();
+    }
+
+    await this._emitter.emit('appReady', {
+      deviceId: this.deviceDriver.getExternalId(),
+      bundleId,
+      pid: this._processes[bundleId],
+    });
+
+    if (params.detoxUserNotificationDataURL) {
+      await this.deviceDriver.cleanupRandomDirectory(params.detoxUserNotificationDataURL);
+    }
+
+    if (params.detoxUserActivityDataURL) {
+      await this.deviceDriver.cleanupRandomDirectory(params.detoxUserActivityDataURL);
+    }
   }
 
-  /**
-   * @deprecated
-   */
   async relaunchApp(params = {}, bundleId) {
     if (params.newInstance === undefined) {
       params['newInstance'] = true;
@@ -300,73 +355,6 @@ class RuntimeDevice {
     }
     return this._currentApp;
   }
-
-  async _doLaunchApp(params, bundleId) {
-    const payloadParams = ['url', 'userNotification', 'userActivity'];
-    const hasPayload = this._assertHasSingleParam(payloadParams, params);
-    const newInstance = params.newInstance !== undefined
-      ? params.newInstance
-      : this._processes[bundleId] == null;
-
-    if (params.delete) {
-      await this.terminateApp(bundleId);
-      await this.uninstallApp();
-      await this.installApp();
-    } else if (newInstance) {
-      await this.terminateApp(bundleId);
-    }
-
-    const baseLaunchArgs = {
-      ...this._currentAppLaunchArgs.get(),
-      ...params.launchArgs,
-    };
-
-    if (params.url) {
-      baseLaunchArgs['detoxURLOverride'] = params.url;
-      if (params.sourceApp) {
-        baseLaunchArgs['detoxSourceAppOverride'] = params.sourceApp;
-      }
-    } else if (params.userNotification) {
-      this._createPayloadFileAndUpdatesParamsObject('userNotification', 'detoxUserNotificationDataURL', params, baseLaunchArgs);
-    } else if (params.userActivity) {
-      this._createPayloadFileAndUpdatesParamsObject('userActivity', 'detoxUserActivityDataURL', params, baseLaunchArgs);
-    }
-
-    if (params.permissions) {
-      await this.deviceDriver.setPermissions(bundleId, params.permissions);
-    }
-
-    if (params.disableTouchIndicators) {
-      baseLaunchArgs['detoxDisableTouchIndicators'] = true;
-    }
-
-    if (this._isAppRunning(bundleId) && hasPayload) {
-      await this.deviceDriver.deliverPayload({ ...params, delayPayload: true });
-    }
-
-    if (this._behaviorConfig.launchApp === 'manual') {
-      this._processes[bundleId] = await this.deviceDriver.waitForAppLaunch(bundleId, this._prepareLaunchArgs(baseLaunchArgs), params.languageAndLocale);
-    } else {
-      this._processes[bundleId] = await this.deviceDriver.launchApp(bundleId, this._prepareLaunchArgs(baseLaunchArgs), params.languageAndLocale);
-      await this.deviceDriver.waitUntilReady();
-      await this.deviceDriver.waitForActive();
-    }
-
-    await this._emitter.emit('appReady', {
-      deviceId: this.deviceDriver.getExternalId(),
-      bundleId,
-      pid: this._processes[bundleId],
-    });
-
-    if(params.detoxUserNotificationDataURL) {
-      await this.deviceDriver.cleanupRandomDirectory(params.detoxUserNotificationDataURL);
-    }
-
-    if(params.detoxUserActivityDataURL) {
-      await this.deviceDriver.cleanupRandomDirectory(params.detoxUserActivityDataURL);
-    }
-  }
-
   async _sendPayload(key, params) {
     const payloadFilePath = this.deviceDriver.createPayloadFile(params);
     const payload = {

package/src/devices/runtime/drivers/index.js

@@ -2,6 +2,5 @@ module.exports = {
   AndroidEmulatorRuntimeDriver: require('./android/emulator/EmulatorDriver'),
   AttachedAndroidRuntimeDriver: require('./android/attached/AttachedAndroidDriver'),
   GenycloudRuntimeDriver: require('./android/genycloud/GenyCloudDriver'),
-  IosRuntimeDriver: require('./ios/IosDriver'),
   IosSimulatorRuntimeDriver: require('./ios/SimulatorDriver'),
 };

package/src/devices/runtime/drivers/ios/SimulatorDriver.js

@@ -30,12 +30,13 @@ class SimulatorDriver extends IosDriver {
    * @param deps { SimulatorDriverDeps }
    * @param props { SimulatorDriverProps }
    */
-  constructor(deps, { udid, type, bootArgs }) {
+  constructor(deps, { udid, type, bootArgs, headless }) {
     super(deps);
 
     this.udid = udid;
     this._type = type;
     this._bootArgs = bootArgs;
+    this._headless = headless;
     this._deviceName = `${udid} (${this._type})`;
     this._simulatorLauncher = deps.simulatorLauncher;
     this._applesimutils = deps.applesimutils;
@@ -151,7 +152,7 @@ class SimulatorDriver extends IosDriver {
   async resetContentAndSettings() {
     await this._simulatorLauncher.shutdown(this.udid);
     await this._applesimutils.resetContentAndSettings(this.udid);
-    await this._simulatorLauncher.launch(this.udid, this._type, this._bootArgs);
+    await this._simulatorLauncher.launch(this.udid, this._type, this._bootArgs, this._headless);
   }
 
   getLogsPaths() {

package/src/devices/runtime/factories/ios.js

@@ -15,19 +15,13 @@ class RuntimeDriverFactoryIos extends RuntimeDeviceFactory {
   }
 }
 
-class Ios extends RuntimeDriverFactoryIos {
-  _createDriver(deviceCookie, deps, configs) { // eslint-disable-line no-unused-vars
-    const { IosRuntimeDriver } = require('../drivers');
-    return new IosRuntimeDriver(deps);
-  }
-}
-
 class IosSimulator extends RuntimeDriverFactoryIos {
   _createDriver(deviceCookie, deps, { deviceConfig }) {
     const props = {
       udid: deviceCookie.udid,
       type: deviceConfig.device.type,
       bootArgs: deviceConfig.bootArgs,
+      headless: deviceConfig.headless
     };
 
     const { IosSimulatorRuntimeDriver } = require('../drivers');
@@ -36,6 +30,5 @@ class IosSimulator extends RuntimeDriverFactoryIos {
 }
 
 module.exports = {
-  Ios,
   IosSimulator,
 };

package/src/devices/runtime/utils/LaunchArgsEditor.js

@@ -1,14 +1,7 @@
 const _ = require('lodash');
 
-const log = require('../../../utils/logger');
-
 const ScopedLaunchArgsEditor = require('./ScopedLaunchArgsEditor');
 
-/**
- * @typedef {Object} LaunchArgsEditorOptions
- * @property {boolean} [permanent=false] - Indicates whether the operation should affect the permanent app launch args.
- */
-
 class LaunchArgsEditor {
   constructor() {
     this._local = new ScopedLaunchArgsEditor();
@@ -19,67 +12,19 @@ class LaunchArgsEditor {
     return this._shared;
   }
 
-  /**
-   * @param {LaunchArgsEditorOptions} [options] - deprecated
-   */
-  modify(launchArgs, options) {
-    this._assertNoDeprecatedOptions('modify', options);
-
-    if (!_.isEmpty(launchArgs)) {
-      if (options && options.permanent) {
-        this._shared.modify(launchArgs);
-      } else {
-        this._local.modify(launchArgs);
-      }
-    }
-
+  modify(launchArgs) {
+    this._local.modify(launchArgs);
     return this;
   }
 
-  /**
-   * @param {LaunchArgsEditorOptions} [options] - deprecated
-   */
-  reset(options) {
-    this._assertNoDeprecatedOptions('reset', options);
+  reset() {
     this._local.reset();
-
-    if (options && options.permanent) {
-      this._shared.reset();
-    }
-
     return this;
   }
 
-  /**
-   * @param {LaunchArgsEditorOptions} [options] - deprecated
-   */
-  get(options) {
-    this._assertNoDeprecatedOptions('get', options);
-    const permanent = options && options.permanent;
-
-    if (permanent === true) {
-      return this._shared.get();
-    }
-
-    if (permanent === false) {
-      return this._local.get();
-    }
-
+  get() {
     return _.merge(this._shared.get(), this._local.get());
   }
-
-  _assertNoDeprecatedOptions(methodName, options) {
-    if (!options) {
-      return;
-    }
-
-    const target = options.permanent ? 'appLaunchArgs.shared' : 'appLaunchArgs';
-    log.warn({ event: 'DEPRECATION' }, [
-      `Detected an attempt to use device.launchArgs.${methodName}(...) with a deprecated 'options' parameter.`,
-      `Please use device.${target}.${methodName}(...) instead.`,
-      `For more details, see the reference at: https://wix.github.io/Detox/docs/api/device-object-api#deviceapplaunchargs\n`,
-    ].join('\n'));
-  }
 }
 
 module.exports = LaunchArgsEditor;

package/src/devices/runtime/utils/Storage.js

@@ -14,6 +14,10 @@ class Storage {
   }
 
   assign(map) {
+    if (_.isEmpty(map)) {
+      return;
+    }
+
     for (const key of Object.keys(map)) {
       this.set(key, map[key]);
     }

package/src/environmentFactory.js

@@ -85,14 +85,6 @@ function _getFactoryClasses(deviceConfig) {
       runtimeDeviceFactoryClass = runtimeDeviceFactories.IosSimulator;
       break;
 
-    case 'ios.none':
-      envValidatorFactoryClass = envValidationFactories.Noop;
-      deviceAllocatorFactoryClass = deviceAllocationFactories.None;
-      artifactsManagerFactoryClass = artifactsManagerFactories.Ios;
-      matchersFactoryClass = matchersFactories.Ios;
-      runtimeDeviceFactoryClass = runtimeDeviceFactories.Ios;
-      break;
-
     default: {
       return null;
     }

package/src/errors/DetoxConfigErrorComposer.js

@@ -25,16 +25,6 @@ class DetoxConfigErrorComposer {
   _atPath() {
     return this.filepath ? ` at path:\n${this.filepath}` : '.';
   }
-
-  _inTheAppConfig() {
-    const { type } = this._getSelectedConfiguration();
-    if (type) {
-      return `in configuration ${J(this.configurationName)}`;
-    }
-
-    return `in the app config`;
-  }
-
   _getSelectedConfiguration() {
     return _.get(this.contents, ['configurations', this.configurationName]);
   }
@@ -64,9 +54,10 @@ class DetoxConfigErrorComposer {
   }
 
   _focusOnDeviceConfig(deviceAlias, postProcess = _.identity) {
-    const { type, device } = this._getSelectedConfiguration();
+    const { device } = this._getSelectedConfiguration();
     if (!deviceAlias) {
-      if (type || !device) {
+      // istanbul ignore next
+      if (!device) {
         return this._focusOnConfiguration(postProcess);
       } else {
         return this._focusOnConfiguration(c => {
@@ -92,8 +83,7 @@ class DetoxConfigErrorComposer {
     if (alias) {
       return this.contents.devices[alias];
     } else {
-      const config = this._getSelectedConfiguration();
-      return config.type ? config : config.device;
+      return this._getSelectedConfiguration().device;
     }
   }
 
@@ -225,6 +215,61 @@ Examine your Detox config${this._atPath()}`,
     });
   }
 
+  configurationShouldNotUseLegacyFormat() {
+    const name = this.configurationName;
+    const localConfig = this._getSelectedConfiguration();
+    /* istanbul ignore next */
+    const deviceType = localConfig.type || '';
+    const isAndroid = deviceType.startsWith('android.');
+    const isIOS = deviceType.startsWith('ios.');
+    const appName = 'myApp' + (isIOS ? '.ios' : '') + (isAndroid ? '.android' : '');
+    const deviceName = isIOS ? 'simulator' : isAndroid ? 'emulator' : 'myDevice';
+    const appType = isIOS ? 'ios.app' : isAndroid ? 'android.apk' : '<optional property>';
+    const binaryPath = isIOS || isAndroid ? localConfig.binaryPath : (localConfig.binaryPath || '<optional property>');
+    const deviceQuery = isIOS || isAndroid ? localConfig.device : (localConfig.device || '<optional property>');
+
+    return new DetoxConfigError({
+      message: `The ${J(name)} configuration utilizes a deprecated all-in-one schema, that is not supported ` +
+        `by the current version of Detox.`,
+      hint: `Remove the "type" property. A valid configuration is expected to have both the "device" and "app" aliases ` +
+        `pointing to the corresponding keys in the 'devices' and 'apps' config sections. For example:\n
+{
+  "apps": {
+*-->${J(appName)}: {
+|     "type": ${J(appType)},
+|     "binaryPath": ${J(binaryPath)},
+|   },
+| },
+| "devices": {
+|*->${J(deviceName)}: {
+||    "type": ${J(deviceType)},
+||    "device": ${J(deviceQuery)}
+||  },
+||},
+||"configurations": {
+||  ${J(name)}: {
+||    /* REMOVE (!) "type": ${J(deviceType)} */
+|*--- "device": ${J(deviceName)},
+*---- "app": ${J(appName)},
+      ...
+    }
+  }
+}
+Examine your Detox config${this._atPath()}`,
+      debugInfo: {
+        apps: this.contents.apps
+          ? _.mapValues(this.contents.apps, _.constant({}))
+          : undefined,
+        devices: this.contents.devices
+          ? _.mapValues(this.contents.devices, _.constant({}))
+          : undefined,
+
+        ...this._focusOnConfiguration(),
+      },
+      inspectOptions: { depth: 2 }
+    });
+  }
+
   // endregion
 
   // region composeDeviceConfig
@@ -345,7 +390,7 @@ Please check your Detox config${this._atPath()}`,
       case 'forceAdbInstall':
         return this._invalidPropertyType('forceAdbInstall', 'a boolean value', deviceAlias);
       case 'gpuMode':
-        return this._invalidPropertyType('gpuMode', "'auto' | 'host' | 'swiftshader_indirect' | 'angle_indirect' | 'guest'", deviceAlias);
+        return this._invalidPropertyType('gpuMode', "'auto' | 'host' | 'swiftshader_indirect' | 'angle_indirect' | 'guest' | 'off'", deviceAlias);
       case 'headless':
         return this._invalidPropertyType('headless', 'a boolean value', deviceAlias);
       case 'readonly':
@@ -456,7 +501,7 @@ Examine your Detox config${this._atPath()}`,
 
   malformedAppLaunchArgs(appPath) {
     return new DetoxConfigError({
-      message: `Invalid type of "launchArgs" property ${this._inTheAppConfig()}.\nExpected an object:`,
+      message: `Invalid type of "launchArgs" property in the app config.\nExpected an object:`,
       debugInfo: this._focusOnAppConfig(appPath),
       inspectOptions: { depth: 4 },
     });
@@ -464,7 +509,7 @@ Examine your Detox config${this._atPath()}`,
 
   missingAppBinaryPath(appPath) {
     return new DetoxConfigError({
-      message: `Missing "binaryPath" property ${this._inTheAppConfig()}.\nExpected a string:`,
+      message: `Missing "binaryPath" property in the app config.\nExpected a string:`,
       debugInfo: this._focusOnAppConfig(appPath, this._ensureProperty('binaryPath')),
       inspectOptions: { depth: 4 },
     });
@@ -538,18 +583,6 @@ Examine your Detox config${this._atPath()}`,
     });
   }
 
-  oldSchemaHasAppAndApps() {
-    return new DetoxConfigError({
-      message: `Your configuration ${J(this.configurationName)} appears to be in a legacy format, which can’t contain "app" or "apps".`,
-      hint: `Remove "type" property from configuration and use "device" property instead:\n` +
-        `a) "device": { "type": ${J(this._getSelectedConfiguration().type)}, ... }\n` +
-        `b) "device": "<alias-to-device>" // you should add that device configuration to "devices" with the same key` +
-        `\n\nCheck your Detox config${this._atPath()}`,
-      debugInfo: this._focusOnConfiguration(this._ensureProperty('type', 'device')),
-      inspectOptions: { depth: 2 },
-    });
-  }
-
   ambiguousAppAndApps() {
     return new DetoxConfigError({
       message: `You can't have both "app" and "apps" defined in the ${J(this.configurationName)} configuration.`,
@@ -622,6 +655,20 @@ Examine your Detox config${this._atPath()}`,
     });
   }
 
+  invalidTestRunnerProperty(isGlobal) {
+    return new DetoxConfigError({
+      message: `testRunner should be an object, not a string`,
+      hint: `Check that in your Detox config${this._atPath()}`,
+      inspectOptions: { depth: isGlobal ? 0 : 3 },
+      debugInfo: isGlobal ? {
+        testRunner: _.get(this.contents, ['testRunner']),
+        ...this.contents,
+      } : {
+        ...this._focusOnConfiguration(c => _.pick(c, ['testRunner'])),
+      },
+    });
+  }
+
   cannotSkipAutostartWithMissingServer() {
     return new DetoxConfigError({
       message: `Cannot have both an undefined session.server URL and session.autoStart set to false`,

package/src/errors/DetoxError.js

@@ -12,6 +12,10 @@ class DetoxError extends Error {
     return 'Please report this issue on our GitHub tracker:\nhttps://github.com/wix/Detox/issues';
   }
 
+  static get reportIssueIfJest() {
+    return `If you are using Detox with Jest according to the latest guide, ${_.lowerFirst(this.reportIssue)}`;
+  }
+
   static inspectObj(obj, options) {
     return util.inspect(obj, {
       colors: false,

package/src/errors/DetoxRuntimeError.js

@@ -4,23 +4,23 @@ const DetoxError = require('./DetoxError');
 
 /**
  * @typedef DetoxRuntimeErrorOptions
- * @property message { String }
+ * @property [message] { String }
  * @property [hint] { String }
- * @property [debugInfo] { String }
+ * @property [debugInfo] { * }
  * @property [noStack] { Boolean }
  * @property [inspectOptions] { Object }
  */
 
 class DetoxRuntimeError extends DetoxError {
   /**
-   * @param options { DetoxRuntimeErrorOptions }
+   * @param [options] { String | DetoxRuntimeErrorOptions }
    */
   constructor(options) {
     super(formatOptions(options));
     this.name = 'DetoxRuntimeError';
 
-    if (options && options.noStack) {
-      delete this.stack;
+    if (options && typeof options !== 'string' && options.noStack) {
+      this.stack = '';
     }
   }
 }

package/src/errors/index.js

@@ -1,4 +1,5 @@
 const DetoxConfigError = require('./DetoxConfigError');
+const DetoxConfigErrorComposer = require('./DetoxConfigErrorComposer');
 const DetoxError = require('./DetoxError');
 const DetoxInternalError = require('./DetoxInternalError');
 const DetoxRuntimeError = require('./DetoxRuntimeError');
@@ -7,6 +8,7 @@ const DetoxRuntimeErrorComposer = require('./DetoxRuntimeErrorComposer');
 module.exports = {
   DetoxError,
   DetoxConfigError,
+  DetoxConfigErrorComposer,
   DetoxInternalError,
   DetoxRuntimeError,
   DetoxRuntimeErrorComposer,