detox 19.7.0 → 20.0.0-breaking.new-global-lifecycle.0

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,

package/src/ipc/IPCClient.js

@@ -0,0 +1,117 @@
+const { IPC } = require('node-ipc');
+
+const { DetoxInternalError } = require('../errors');
+
+class IPCClient {
+  constructor({ id, logger, state }) {
+    this._id = id;
+    /** @type {import('../logger/DetoxLogger')} logger */
+    this._logger = logger.child({ __filename, cat: 'ipc' });
+    /** @type {import('./state').SecondarySessionState} */
+    this._state = state;
+
+    this._client = null;
+    this._serverConnection = null;
+  }
+
+  async init() {
+    this._client = new IPC();
+
+    Object.assign(this._client.config, {
+      id: this._id,
+      appspace: 'detox.',
+      logger: (msg) => this._logger.trace(msg),
+      stopRetrying: 0,
+      maxRetries: 0,
+    });
+
+    await this._connectToServer();
+    await this._registerContext();
+  }
+
+  async dispose() {
+    this._serverConnection = null;
+
+    if (this._client) {
+      this._client.disconnect(this.serverId);
+      this._client = null;
+    }
+  }
+
+  get sessionState() {
+    return this._state;
+  }
+
+  get serverId() {
+    return this.sessionState.detoxIPCServer;
+  }
+
+  async registerWorker(workerId) {
+    this._state.workerId = workerId;
+    await this._emit('registerWorker', { workerId });
+  }
+
+  /**
+   * @param {string[]} testFilePaths
+   */
+  async reportFailedTests(testFilePaths) {
+    await this._emit('failedTests', { testFilePaths });
+  }
+
+  async _connectToServer() {
+    const serverId = this.serverId;
+
+    this._serverConnection = await new Promise((resolve, reject) => {
+      this._client.connectTo(serverId, (client) => {
+        client.of[serverId]
+          .on('error', reject)
+          .on('disconnect', () => reject(new DetoxInternalError('IPC server has unexpectedly disconnected.')))
+          .on('connect', () => resolve(client.of[serverId]));
+      });
+    });
+
+    this._serverConnection.on('sessionStateUpdate', this._onSessionStateUpdate);
+  }
+
+  async _registerContext() {
+    const sessionState = await this._emit('registerContext', {
+      id: this._id,
+      logFile: this._logger.file,
+    });
+
+    this._state.patch(sessionState);
+  }
+
+  async _emit(event, payload) {
+    if (!this._serverConnection) {
+      throw new DetoxInternalError(`IPC server ${this.serverId} has unexpectedly disconnected.`);
+    }
+
+    return new Promise((resolve, reject) => {
+      const server = this._serverConnection;
+
+      function onError(err) {
+        server.off('error', onError);
+        server.off(`${event}Done`, onDone);
+        reject(err);
+      }
+
+      function onDone(response) {
+        server.off(`${event}Done`, onDone);
+        server.off('error', onError);
+        resolve(response);
+      }
+
+      server
+        .on('error', onError)
+        .on(`${event}Done`, onDone)
+        .emit(event, payload);
+    });
+  }
+
+  _onSessionStateUpdate = (payload) => {
+    this._state.patch(payload);
+  };
+}
+
+module.exports = IPCClient;

package/src/ipc/IPCServer.js

@@ -0,0 +1,81 @@
+const { IPC } = require('node-ipc');
+
+class IPCServer {
+  /**
+   * @param {object} options
+   * @param {import('./state').PrimarySessionState} options.sessionState
+   * @param {Detox.Logger} options.logger
+   */
+  constructor({ sessionState, logger }) {
+    this._sessionState = sessionState;
+    this._logger = logger.child({ __filename, cat: 'ipc' });
+    this._ipc = null;
+  }
+
+  get id() {
+    return this._sessionState.detoxIPCServer;
+  }
+
+  get sessionState() {
+    return this._sessionState;
+  }
+
+  async init() {
+    this._ipc = new IPC();
+    this._ipc.config.id = this.id;
+    this._ipc.config.appspace = 'detox.';
+    this._ipc.config.logger = (msg) => this._logger.trace(msg);
+
+      await new Promise((resolve) => {
+      // TODO: handle reject
+      this._ipc.serve(() => resolve());
+      this._ipc.server.on('registerContext', this.onRegisterContext.bind(this));
+      this._ipc.server.on('registerWorker', this.onRegisterWorker.bind(this));
+      this._ipc.server.on('failedTests', this.onFailedTests.bind(this));
+      this._ipc.server.start();
+    });
+  }
+
+  async dispose() {
+    if (!this._ipc) {
+      return;
+    }
+
+    return new Promise((resolve, reject) =>{
+      // @ts-ignore
+      this._ipc.server.server.close(e => e ? reject(e) : resolve());
+      this._ipc.server.stop();
+    });
+  }
+
+  onRegisterContext({ id, logFile }, socket) {
+    this._sessionState.contexts.push(id);
+
+    if (logFile && !this._sessionState.logFiles.includes(logFile)) {
+      this._sessionState.logFiles.push(logFile);
+    }
+
+    this._ipc.server.emit(socket, 'registerContextDone', {});
+  }
+
+  onRegisterWorker({ workerId }, socket) {
+    if (socket) {
+      this._ipc.server.emit(socket, 'registerWorkerDone', {});
+    }
+
+    if (workerId > this._sessionState.workersCount) {
+      const workersCount = this._sessionState.workersCount = workerId;
+      this._ipc.server.broadcast('sessionStateUpdate', { workersCount });
+    }
+  }
+
+  onFailedTests({ testFilePaths }, socket) {
+    this._sessionState.failedTestFiles.push(...testFilePaths);
+
+    if (socket) {
+      this._ipc.server.emit(socket, 'failedTestsDone', {});
+    }
+  }
+}
+
+module.exports = IPCServer;

package/src/ipc/state.js

@@ -0,0 +1,67 @@
+const cycle = require('json-cycle');
+
+const uuid = require('../utils/uuid');
+
+class SessionState {
+  patch(state) {
+    Object.assign(this, state);
+  }
+
+  stringify() {
+    return cycle.stringify(this, SessionState.stringifier);
+  }
+
+  /**
+   * @return {*}
+   */
+  static parse(stringified) {
+    const Class = this; // eslint-disable-line unicorn/no-this-assignment
+    // @ts-ignore
+    return new Class(cycle.parse(stringified, SessionState.reviver));
+  }
+
+  static reviver(key, val) {
+    if (typeof val === 'object' && typeof val.$fn == 'string') {
+      return eval(val.$fn);
+    } else {
+      return val;
+    }
+  }
+
+  static stringifier(key, val) {
+    if (typeof val === 'function') {
+      return { $fn: `(${val})` };
+    } else {
+      return val;
+    }
+  }
+}
+
+class SecondarySessionState extends SessionState {
+  constructor({ id = uuid.UUID(), detoxConfigSnapshotPath = '', detoxConfig = null, detoxIPCServer = '', workerId = undefined, workersCount = 0 }) {
+    super();
+
+    this.id = id;
+    this.detoxConfigSnapshotPath = detoxConfigSnapshotPath;
+    this.detoxConfig = detoxConfig;
+    this.detoxIPCServer = detoxIPCServer;
+    this.workerId = workerId;
+    this.workersCount = workersCount;
+  }
+}
+
+class PrimarySessionState extends SecondarySessionState {
+  constructor({ contexts = [], failedTestFiles = [], logFiles = [], ...baseOpts }) {
+    super(baseOpts);
+
+    this.contexts = contexts;
+    this.failedTestFiles = failedTestFiles;
+    this.logFiles = logFiles;
+  }
+}
+
+module.exports = {
+  SessionState,
+  PrimarySessionState,
+  SecondarySessionState,
+};