detox 20.0.14-is-hittable-over-master.0 → 20.0.14-prerelease.0

package/src/DetoxWorker.js

@@ -1,3 +1,4 @@
+const CAF = require('caf');
 const _ = require('lodash');
 
 const Client = require('./client/Client');
@@ -11,7 +12,7 @@ const uuid = require('./utils/uuid');
 class DetoxWorker {
   constructor(context) {
     this._context = context;
-    this._isCleaningUp = false;
+    this._injectedGlobalProperties = [];
     this._config = context[symbols.config];
     this._runtimeErrorComposer = new DetoxRuntimeErrorComposer(this._config);
     this._client = null;
@@ -32,6 +33,18 @@ class DetoxWorker {
       onError: this._onEmitError.bind(this),
     });
 
+
+    /** @type {DetoxInternals.RuntimeConfig['apps']} */
+    this._appsConfig = null;
+    /** @type {DetoxInternals.RuntimeConfig['artifacts']} */
+    this._artifactsConfig = null;
+    /** @type {DetoxInternals.RuntimeConfig['behavior']} */
+    this._behaviorConfig = null;
+    /** @type {DetoxInternals.RuntimeConfig['device']} */
+    this._deviceConfig = null;
+    /** @type {DetoxInternals.RuntimeConfig['session']} */
+    this._sessionConfig = null;
+
     /** @type {string} */
     this.id = 'worker';
     /** @type {Detox.Device} */
@@ -53,11 +66,23 @@ class DetoxWorker {
     this.trace = this._context.trace;
     /** @deprecated */
     this.traceCall = this._context.traceCall;
-  }
 
-  async init() {
-    if (this._isCleaningUp) return;
+    this._reinstallAppsOnDevice = CAF(this._reinstallAppsOnDevice.bind(this));
+    this._initToken = new CAF.cancelToken();
+
+    this._cafWrap([
+      'init',
+      'onRunDescribeStart',
+      'onTestStart',
+      'onHookFailure',
+      'onTestFnFailure',
+      'onTestDone',
+      'onRunDescribeFinish',
+    ]);
+  }
 
+  /** @this {DetoxWorker} */
+  init = function* (signal) {
     const {
       apps: appsConfig,
       artifacts: artifactsConfig,
@@ -71,6 +96,7 @@ class DetoxWorker {
     this._behaviorConfig = behaviorConfig;
     this._deviceConfig = deviceConfig;
     this._sessionConfig = sessionConfig;
+    // @ts-ignore
     this._sessionConfig.sessionId = sessionConfig.sessionId || uuid.UUID();
     this._runtimeErrorComposer.appsConfig = this._appsConfig;
 
@@ -82,8 +108,7 @@ class DetoxWorker {
       }
     };
 
-    await this._client.connect();
-    if (this._isCleaningUp) return;
+    yield this._client.connect();
 
     const invocationManager = new InvocationManager(this._client);
 
@@ -100,8 +125,7 @@ class DetoxWorker {
     } = environmentFactory.createFactories(this._deviceConfig);
 
     const envValidator = envValidatorFactory.createValidator();
-    await envValidator.validate();
-    if (this._isCleaningUp) return;
+    yield envValidator.validate();
 
     const commonDeps = {
       invocationManager,
@@ -112,8 +136,7 @@ class DetoxWorker {
 
     this._artifactsManager = artifactsManagerFactory.createArtifactsManager(this._artifactsConfig, commonDeps);
     this._deviceAllocator = deviceAllocatorFactory.createDeviceAllocator(commonDeps);
-    this._deviceCookie = await this._deviceAllocator.allocate(this._deviceConfig);
-    if (this._isCleaningUp) return;
+    this._deviceCookie = yield this._deviceAllocator.allocate(this._deviceConfig);
 
     this.device = runtimeDeviceFactory.createRuntimeDevice(
       this._deviceCookie,
@@ -124,7 +147,6 @@ class DetoxWorker {
         deviceConfig: this._deviceConfig,
         sessionConfig,
       });
-    if (this._isCleaningUp) return;
 
     const matchers = matchersFactory.createMatchers({
       invocationManager,
@@ -134,34 +156,37 @@ class DetoxWorker {
     Object.assign(this, matchers);
 
     if (behaviorConfig.init.exposeGlobals) {
-      Object.assign(DetoxWorker.global, {
+      const injectedGlobals = {
         ...matchers,
         device: this.device,
         detox: this,
-      });
+      };
+
+      this._injectedGlobalProperties = Object.keys(injectedGlobals);
+      Object.assign(DetoxWorker.global, injectedGlobals);
     }
 
     // @ts-ignore
-    await this.device.installUtilBinaries();
-    if (this._isCleaningUp) return;
+    yield this.device.installUtilBinaries();
 
     if (behaviorConfig.init.reinstallApp) {
-      await this._reinstallAppsOnDevice();
-      if (this._isCleaningUp) return;
+      yield this._reinstallAppsOnDevice(signal);
     }
 
     const appAliases = Object.keys(this._appsConfig);
     if (appAliases.length === 1) {
-      await this.device.selectApp(appAliases[0]);
+      yield this.device.selectApp(appAliases[0]);
     } else {
-      await this.device.selectApp(null);
+      yield this.device.selectApp(null);
     }
-
-    return this;
-  }
+  };
 
   async cleanup() {
-    this._isCleaningUp = true;
+    this._initToken.abort('CLEANUP');
+
+    for (const key of this._injectedGlobalProperties) {
+      delete DetoxWorker.global[key];
+    }
 
     if (this._artifactsManager) {
       await this._artifactsManager.onBeforeCleanup();
@@ -190,44 +215,45 @@ class DetoxWorker {
     return this._context.log;
   }
 
-  onRunStart = async (...args) => this._artifactsManager.onRunStart(...args);
-  onRunDescribeStart = async (...args) => this._artifactsManager.onRunDescribeStart(...args);
-  onTestStart = async (testSummary) => {
-    if (this._isCleaningUp) return;
+  onRunDescribeStart = function* (_signal, ...args) {
+    yield this._artifactsManager.onRunDescribeStart(...args);
+  };
+
+  onTestStart = function* (_signal, testSummary) {
     this._validateTestSummary('beforeEach', testSummary);
 
-    if (this._isCleaningUp) return;
-    await this._dumpUnhandledErrorsIfAny({
+    yield this._dumpUnhandledErrorsIfAny({
       pendingRequests: false,
       testName: testSummary.fullName,
     });
 
-    if (this._isCleaningUp) return;
-    await this._artifactsManager.onTestStart(testSummary);
+    yield this._artifactsManager.onTestStart(testSummary);
+  };
+
+  onHookFailure = function* (_signal, ...args) {
+    yield this._artifactsManager.onHookFailure(...args);
   };
-  onHookStart = async (...args) => this._artifactsManager.onHookStart(...args);
-  onHookFailure = async (...args) => this._artifactsManager.onHookFailure(...args);
-  onHookSuccess = async (...args) => this._artifactsManager.onHookSuccess(...args);
-  onTestFnStart = async (...args) => this._artifactsManager.onTestFnStart(...args);
-  onTestFnFailure = async (...args) => this._artifactsManager.onTestFnFailure(...args);
-  onTestFnSuccess = async (...args) => this._artifactsManager.onTestFnSuccess(...args);
-  onTestDone = async (testSummary) => {
-    if (this._isCleaningUp) return;
+
+  onTestFnFailure = function* (_signal, ...args) {
+    yield this._artifactsManager.onTestFnFailure(...args);
+  };
+
+  onTestDone = function* (_signal, testSummary) {
     this._validateTestSummary('afterEach', testSummary);
 
-    if (this._isCleaningUp) return;
-    await this._artifactsManager.onTestDone(testSummary);
+    yield this._artifactsManager.onTestDone(testSummary);
 
-    if (this._isCleaningUp) return;
-    await this._dumpUnhandledErrorsIfAny({
+    yield this._dumpUnhandledErrorsIfAny({
       pendingRequests: testSummary.timedOut,
       testName: testSummary.fullName,
     });
   };
-  onRunDescribeFinish = async (...args) => this._artifactsManager.onRunDescribeFinish(...args);
-  onRunFinish = async (...args) => this._artifactsManager.onRunFinish(...args);
 
-  async _reinstallAppsOnDevice() {
+  onRunDescribeFinish = function* (_signal, ...args) {
+    yield this._artifactsManager.onRunDescribeFinish(...args);
+  };
+
+  *_reinstallAppsOnDevice(_signal) {
     const appNames = _(this._appsConfig)
       .map((config, key) => [key, `${config.binaryPath}:${config.testBinaryPath}`])
       .uniqBy(1)
@@ -235,17 +261,13 @@ class DetoxWorker {
       .value();
 
     for (const appName of appNames) {
-      await this.device.selectApp(appName);
-      if (this._isCleaningUp) return;
-      await this.device.uninstallApp();
-      if (this._isCleaningUp) return;
+      yield this.device.selectApp(appName);
+      yield this.device.uninstallApp();
     }
 
     for (const appName of appNames) {
-      await this.device.selectApp(appName);
-      if (this._isCleaningUp) return;
-      await this.device.installApp();
-      if (this._isCleaningUp) return;
+      yield this.device.selectApp(appName);
+      yield this.device.installApp();
     }
   }
 
@@ -277,10 +299,28 @@ class DetoxWorker {
       error
     );
   }
+
+  _cafWrap(methodNames) {
+    for (const methodName of methodNames) {
+      const cafMethod = CAF(this[methodName].bind(this));
+      this[methodName] = async (...args) => {
+        try {
+          await cafMethod(this._initToken.signal, ...args);
+        } catch (e) {
+          if (e !== 'CLEANUP') {
+            throw e;
+          }
+        }
+
+        return this;
+      };
+    }
+  }
+
 }
 
 /**
- * @type {NodeJS.Global}
+ * @type {NodeJS.Global | {}}
  */
 DetoxWorker.global = global;
 

package/src/artifacts/ArtifactsManager.js

@@ -32,19 +32,13 @@ class ArtifactsManager extends EventEmitter {
       'onBootDevice',
       'onCreateExternalArtifact',
       'onHookFailure',
-      'onHookStart',
-      'onHookSuccess',
       'onLaunchApp',
       'onRunDescribeFinish',
       'onRunDescribeStart',
-      'onRunFinish',
-      'onRunStart',
       'onShutdownDevice',
       'onTerminateApp',
       'onTestDone',
       'onTestFnFailure',
-      'onTestFnStart',
-      'onTestFnSuccess',
       'onTestStart',
     ]);
   }
@@ -52,13 +46,13 @@ class ArtifactsManager extends EventEmitter {
   _resolveArtifactsPathBuilder(pathBuilder, rootDir) {
     if (typeof pathBuilder === 'string') {
       pathBuilder = resolveModuleFromPath(pathBuilder);
+    }
 
-      if (typeof pathBuilder === 'function') {
-        try {
-          pathBuilder = pathBuilder({ rootDir });
-        } catch (e) {
-          pathBuilder = new pathBuilder({ rootDir });
-        }
+    if (typeof pathBuilder === 'function') {
+      try {
+        pathBuilder = pathBuilder({ rootDir });
+      } catch (e) {
+        pathBuilder = new pathBuilder({ rootDir });
       }
     }
 
@@ -185,8 +179,6 @@ class ArtifactsManager extends EventEmitter {
     });
   }
 
-  async onRunStart() {}
-
   async onRunDescribeStart(suite) {
     await this._callPlugins('ascending', 'onRunDescribeStart', suite);
   }
@@ -195,22 +187,14 @@ class ArtifactsManager extends EventEmitter {
     await this._callPlugins('ascending', 'onTestStart', testSummary);
   }
 
-  async onHookStart() {}
-
   async onHookFailure(testSummary) {
     await this._callPlugins('plain', 'onHookFailure', testSummary);
   }
 
-  async onHookSuccess() {}
-
-  async onTestFnStart() {}
-
   async onTestFnFailure(testSummary) {
     await this._callPlugins('plain', 'onTestFnFailure', testSummary);
   }
 
-  async onTestFnSuccess() {}
-
   async onTestDone(testSummary) {
     await this._callPlugins('descending', 'onTestDone', testSummary);
   }
@@ -219,8 +203,6 @@ class ArtifactsManager extends EventEmitter {
     await this._callPlugins('descending', 'onRunDescribeFinish', suite);
   }
 
-  async onRunFinish() {}
-
   async onBeforeCleanup() {
     await this._callPlugins('descending', 'onBeforeCleanup');
     await this._idlePromise;

package/src/configuration/collectCliConfig.js

@@ -1,9 +1,6 @@
 const _ = require('lodash');
 
 const argparse = require('../utils/argparse');
-const log = require('../utils/logger').child({ cat: 'config' });
-
-const { DEVICE_LAUNCH_ARGS_GENERIC_DEPRECATION } = require('./utils/warnings');
 
 const asBoolean = (value) => {
   if (typeof value === 'boolean') {
@@ -25,14 +22,6 @@ const asNumber = (value) => {
     : undefined;
 };
 
-const deprecateDeviceLaunchArgs = (value) => {
-  if (value) {
-    log.warn(DEVICE_LAUNCH_ARGS_GENERIC_DEPRECATION);
-  }
-
-  return value;
-};
-
 function collectCliConfig({ argv }) {
   const env = (key) => argparse.getArgValue(key);
   const get = (key, fallback) => {
@@ -51,7 +40,7 @@ function collectCliConfig({ argv }) {
     configPath: get('config-path'),
     configuration: get('configuration'),
     debugSynchronization: asNumber(get('debug-synchronization')),
-    deviceBootArgs: get('device-boot-args', deprecateDeviceLaunchArgs(argparse.getEnvValue('device-launch-args'))),
+    deviceBootArgs: get('device-boot-args'),
     appLaunchArgs: get('app-launch-args'),
     deviceName: get('device-name'),
     forceAdbInstall: asBoolean(get('force-adb-install')),

package/src/configuration/composeLoggerConfig.js

@@ -14,7 +14,7 @@ function composeLoggerConfig(opts) {
   const items = [
     {
       level: 'info',
-      overrideConsole: 'sandbox',
+      overrideConsole: true,
       options: defaultOptions,
     },
     globalConfig.logger,
@@ -46,7 +46,7 @@ function adaptCLI(cliConfig) {
   }
 
   if (cliConfig.useCustomLogger !== undefined) {
-    result.overrideConsole = cliConfig.useCustomLogger ? 'all' : 'none';
+    result.overrideConsole = cliConfig.useCustomLogger;
   }
 
   if (cliConfig.noColor) {

package/src/configuration/composeRunnerConfig.js

@@ -56,11 +56,12 @@ function composeRunnerConfig(opts) {
 
   if (typeof merged.inspectBrk === 'function') {
     if (cliConfig.inspectBrk) {
+      merged.retries = 0;
+      merged.forwardEnv = true;
       merged.inspectBrk(merged);
-      merged.inspectBrk = true;
-    } else {
-      merged.inspectBrk = false;
     }
+
+    delete merged.inspectBrk;
   }
 
   return merged;
@@ -119,9 +120,10 @@ function hasEmptyPositionalArgs(value, key) {
  * @param {Detox.DetoxTestRunnerConfig} config
  */
 function inspectBrkHookDefault(config) {
-  config.args.$0 = /* istanbul ignore if */ os.platform() === 'win32'
-    ? `node --inspect-brk ./node_modules/jest/bin/jest.js`
-    : `node --inspect-brk ./node_modules/.bin/jest`;
+  /* istanbul ignore next */
+  config.args.$0 = os.platform() !== 'win32'
+    ? `node --inspect-brk ./node_modules/.bin/jest`
+    : `node --inspect-brk ./node_modules/jest/bin/jest.js`;
   config.args.runInBand = true;
   delete config.args.w;
   delete config.args.workers;

package/src/devices/common/drivers/ios/tools/AppleSimUtils.js

@@ -93,7 +93,7 @@ class AppleSimUtils {
       `(https://developer.apple.com/xcode/). In case you already have the latest Xcode version installed, ` +
       `try run the command: \`sudo xcode-select -s /Applications/Xcode.app\`. If you are running tests from CI, ` +
       `we recommend running them with "--headless" device configuration (see: ` +
-      `https://wix.github.io/Detox/docs/next/api/configuration/#device-configurations).`
+      `https://wix.github.io/Detox/docs/next/cli/test/#options).`
     );
   }
 

package/src/errors/DetoxConfigErrorComposer.js

@@ -664,7 +664,12 @@ Examine your Detox config${this._atPath()}`,
   }
 
   invalidTestRunnerProperty(isGlobal) {
-    const testRunner = _.get(this.contents, ['testRunner']);
+    const testRunner = _.get(
+      isGlobal
+        ? this.contents
+        : this._getSelectedConfiguration(),
+      ['testRunner']
+    );
 
     return new DetoxConfigError({
       message: `testRunner should be an object, not a ${typeof testRunner}`,

package/src/ipc/SessionState.js

@@ -1,12 +1,15 @@
+const vm = require('vm');
+
 const cycle = require('json-cycle');
 
-const uuid = require('../utils/uuid');
+const context = vm.createContext({ require }, {
+  name: 'VM User Context',
+});
 
 class SessionState {
   constructor({
-    id = uuid.UUID(),
+    id = '',
     contexts = [],
-    detoxConfigSnapshotPath = '',
     detoxConfig = null,
     detoxIPCServer = '',
     testResults = [],
@@ -15,7 +18,6 @@ class SessionState {
   }) {
     this.id = id;
     this.contexts = contexts;
-    this.detoxConfigSnapshotPath = detoxConfigSnapshotPath;
     this.detoxConfig = detoxConfig;
     this.detoxIPCServer = detoxIPCServer;
     this.testResults = testResults;
@@ -41,8 +43,8 @@ class SessionState {
   }
 
   static reviver(key, val) {
-    if (typeof val === 'object' && typeof val.$fn == 'string') {
-      return eval(val.$fn);
+    if (typeof val === 'object' && val !== null && typeof val.$fn == 'string') {
+      return vm.runInContext(val.$fn, context);
     } else {
       return val;
     }

package/src/logger/DetoxLogger.js

@@ -55,7 +55,7 @@ class DetoxLogger {
 
       this._sharedConfig.userConfig = this._sharedConfig.userConfig || {
         level: 'info',
-        overrideConsole: 'none',
+        overrideConsole: false,
         options: {
           showDate: false,
           showLoggerName: false,
@@ -71,25 +71,7 @@ class DetoxLogger {
         .installFileStream(this.file)
         .installDebugStream(this.config);
 
-      this._sharedConfig.dispatcher = new CategoryThreadDispatcher({
-        logger: this,
-        categories: {
-          'lifecycle': [0],
-          'cli': [1],
-          'logger': [2],
-          'ipc': [29],
-          'ws-server': [50, 99],
-          'ws-client': [100, 149],
-          'device': [150, 159],
-          'artifacts-manager': [300],
-          'artifacts-plugin': [310, 349],
-          'artifact': [350, 399],
-          'child-process': [400, 499],
-          'default': [999],
-          'user': [10000, 10999]
-        },
-      });
-
+      this._sharedConfig.dispatcher = new CategoryThreadDispatcher();
       this._sharedConfig.messageStack = new MessageStack();
 
       this.overrideConsole();
@@ -143,14 +125,12 @@ class DetoxLogger {
    * @internal
    */
   overrideConsole(sandbox) {
-    const option = this.config.overrideConsole;
-    if (option === 'none') {
+    const enabled = this.config.overrideConsole;
+    if (!enabled) {
       return;
     }
 
-    if ((option === 'sandbox' && sandbox) || option === 'all') {
-      customConsoleLogger.overrideConsoleMethods((sandbox || global).console, this);
-    }
+    customConsoleLogger.overrideConsoleMethods((sandbox || global).console, this);
   }
 
   /**

package/src/logger/index.js

@@ -1,4 +1,5 @@
 module.exports = {
   DetoxLogger: require('./DetoxLogger'),
+  DetoxLogFinalizer: require('./utils/DetoxLogFinalizer'),
   installLegacyTracerInterface: require('./utils/tracerLegacy').install,
 };

package/src/logger/utils/CategoryThreadDispatcher.js

@@ -1,23 +1,9 @@
-const _ = require('lodash');
-
 const ThreadDispatcher = require('./ThreadDispatcher');
 
 class CategoryThreadDispatcher {
-  /**
-   * @param {object} config
-   * @param {Record<string, [number, number?]>} config.categories
-   * @param {Detox.Logger} config.logger
-   */
-  constructor(config) {
-    this.categories = config.categories;
-    this.dispatchers = _.mapValues(this.categories, (range, name) => {
-      return new ThreadDispatcher({
-        name,
-        logger: config.logger,
-        min: range[0],
-        max: range[1] || range[0],
-      });
-    });
+  constructor() {
+    /** @type {Record<string, ThreadDispatcher>} */
+    this._dispatchers = {};
   }
 
   /**
@@ -38,20 +24,12 @@ class CategoryThreadDispatcher {
 
   /** @returns {ThreadDispatcher} */
   _resolveDispatcher(cat) {
-    const mainCategory = cat ? cat.split(',', 1)[0] : '';
-    return this.dispatchers[mainCategory] || this.dispatchers.default;
-  }
-
-  categorize(tid) {
-    return _.findKey(this.categories, ([min, max]) => min <= tid && tid <= max) || 'default';
-  }
-
-  threadize(cat) {
-    if (!cat) {
-      return this.categories.default[0];
+    const mainCategory = cat ? cat.split(',', 1)[0] : 'default';
+    if (!this._dispatchers[mainCategory]) {
+      this._dispatchers[mainCategory] = new ThreadDispatcher(mainCategory);
     }
 
-    return _.find(this.categories, (_, key) => key === cat[0]);
+    return this._dispatchers[mainCategory];
   }
 }