detox 19.13.0 → 20.0.0

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':
@@ -364,7 +409,7 @@ Please check your Detox config${this._atPath()}`,
       case 'gpuMode':
         return this._unsupportedPropertyByDeviceType('gpuMode', ['android.emulator'], deviceAlias);
       case 'headless':
-        return this._unsupportedPropertyByDeviceType('headless', ['android.emulator'], deviceAlias);
+        return this._unsupportedPropertyByDeviceType('headless', ['ios.simulator', 'android.emulator'], deviceAlias);
       case 'readonly':
         return this._unsupportedPropertyByDeviceType('readonly', ['android.emulator'], deviceAlias);
       case 'utilBinaryPaths':
@@ -456,7 +501,15 @@ 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 },
+    });
+  }
+
+  unsupportedReversePorts(appPath) {
+    return new DetoxConfigError({
+      message: `Non-Android app configs cannot have "reversePorts" property:`,
       debugInfo: this._focusOnAppConfig(appPath),
       inspectOptions: { depth: 4 },
     });
@@ -464,7 +517,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 +591,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 +663,27 @@ Examine your Detox config${this._atPath()}`,
     });
   }
 
+  invalidTestRunnerProperty(isGlobal) {
+    const testRunner = _.get(
+      isGlobal
+        ? this.contents
+        : this._getSelectedConfiguration(),
+      ['testRunner']
+    );
+
+    return new DetoxConfigError({
+      message: `testRunner should be an object, not a ${typeof testRunner}`,
+      hint: `Check that in your Detox config${this._atPath()}`,
+      inspectOptions: { depth: isGlobal ? 0 : 3 },
+      debugInfo: isGlobal ? {
+        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/ios/expectTwo.js

@@ -8,7 +8,8 @@ const tempfile = require('tempfile');
 
 const { assertEnum, assertNormalized } = require('../utils/assertArgument');
 const { actionDescription, expectDescription } = require('../utils/invocationTraceDescriptions');
-const { traceInvocationCall } = require('../utils/trace');
+const log = require('../utils/logger').child({ cat: 'ws-client, ws' });
+const traceInvocationCall = require('../utils/traceInvocationCall').bind(null, log);
 
 const assertDirection = assertEnum(['left', 'right', 'up', 'down']);
 const assertSpeed = assertEnum(['fast', 'slow']);

package/src/ipc/IPCClient.js

@@ -0,0 +1,117 @@
+const { IPC } = require('node-ipc');
+
+const { DetoxInternalError } = require('../errors');
+const { serializeObjectWithError } = require('../utils/errorUtils');
+
+class IPCClient {
+  constructor({ id, logger, state }) {
+    this._id = id;
+    /** @type {import('../logger/DetoxLogger')} logger */
+    this._logger = logger.child({ cat: 'ipc' });
+    /** @type {import('./SessionState')} */
+    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) {
+    const sessionState = await this._emit('registerWorker', { workerId });
+    this._state.patch(sessionState);
+  }
+
+  /**
+   * @param {DetoxInternals.DetoxTestFileReport[]} testResults
+   */
+  async reportTestResults(testResults) {
+    const sessionState = await this._emit('reportTestResults', {
+      testResults: testResults.map(r => serializeObjectWithError(r, 'testExecError')),
+    });
+    this._state.patch(sessionState);
+  }
+
+  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 });
+    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,98 @@
+const { uniqBy } = require('lodash');
+const { IPC } = require('node-ipc');
+
+const { serializeObjectWithError } = require('../utils/errorUtils');
+
+class IPCServer {
+  /**
+   * @param {object} options
+   * @param {import('./SessionState')} options.sessionState
+   * @param {Detox.Logger} options.logger
+   */
+  constructor({ sessionState, logger }) {
+    this._sessionState = sessionState;
+    this._logger = logger.child({ cat: 'ipc,ipc-server' });
+    this._ipc = null;
+    this._workers = new Set();
+  }
+
+  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('reportTestResults', this.onReportTestResults.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 }, socket) {
+    this._sessionState.contexts.push(id);
+
+    this._ipc.server.emit(socket, 'registerContextDone', {
+      testResults: this._sessionState.testResults,
+      testSessionIndex: this._sessionState.testSessionIndex,
+    });
+  }
+
+  onRegisterWorker({ workerId }, socket = null) {
+    const workersCount = this._workers.add(workerId).size;
+    const shouldBroadcast = workersCount > this._sessionState.workersCount;
+    this._sessionState.workersCount = workersCount;
+
+    if (socket) {
+      this._ipc.server.emit(socket, 'registerWorkerDone', { workersCount });
+    }
+
+    if (shouldBroadcast) {
+      this._ipc.server.broadcast('sessionStateUpdate', { workersCount });
+    }
+  }
+
+  onReportTestResults({ testResults }, socket = null) {
+    const merged = uniqBy([
+      ...testResults.map(r => serializeObjectWithError(r, 'testExecError')),
+      ...this._sessionState.testResults
+    ], 'testFilePath');
+
+    this._sessionState.testResults.splice(0, Infinity, ...merged);
+
+    if (socket) {
+      this._ipc.server.emit(socket, 'reportTestResultsDone', {
+        testResults: this._sessionState.testResults,
+      });
+    }
+
+    this._ipc.server.broadcast('sessionStateUpdate', {
+      testResults: this._sessionState.testResults,
+    });
+  }
+}
+
+module.exports = IPCServer;

package/src/ipc/SessionState.js

@@ -0,0 +1,62 @@
+const vm = require('vm');
+
+const cycle = require('json-cycle');
+
+const context = vm.createContext({ require }, {
+  name: 'VM User Context',
+});
+
+class SessionState {
+  constructor({
+    id = '',
+    contexts = [],
+    detoxConfig = null,
+    detoxIPCServer = '',
+    testResults = [],
+    testSessionIndex = 0,
+    workersCount = 0
+  }) {
+    this.id = id;
+    this.contexts = contexts;
+    this.detoxConfig = detoxConfig;
+    this.detoxIPCServer = detoxIPCServer;
+    this.testResults = testResults;
+    this.testSessionIndex = testSessionIndex;
+    this.workersCount = workersCount;
+  }
+
+  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' && val !== null && typeof val.$fn == 'string') {
+      return vm.runInContext(val.$fn, context);
+    } else {
+      return val;
+    }
+  }
+
+  static stringifier(key, val) {
+    if (typeof val === 'function') {
+      return { $fn: `(${val})` };
+    } else {
+      return val;
+    }
+  }
+}
+
+module.exports = SessionState;