detox 20.0.14-next-is-hittable-check-2.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,6 @@ 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);
@@ -33,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} */
@@ -54,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,
@@ -72,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;
 
@@ -83,8 +108,7 @@ class DetoxWorker {
       }
     };
 
-    await this._client.connect();
-    if (this._isCleaningUp) return;
+    yield this._client.connect();
 
     const invocationManager = new InvocationManager(this._client);
 
@@ -101,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,
@@ -113,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,
@@ -125,7 +147,6 @@ class DetoxWorker {
         deviceConfig: this._deviceConfig,
         sessionConfig,
       });
-    if (this._isCleaningUp) return;
 
     const matchers = matchersFactory.createMatchers({
       invocationManager,
@@ -146,26 +167,22 @@ class DetoxWorker {
     }
 
     // @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];
@@ -198,38 +215,45 @@ class DetoxWorker {
     return this._context.log;
   }
 
-  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);
+  };
+
+  onTestFnFailure = function* (_signal, ...args) {
+    yield this._artifactsManager.onTestFnFailure(...args);
   };
-  onHookFailure = async (...args) => this._artifactsManager.onHookFailure(...args);
-  onTestFnFailure = async (...args) => this._artifactsManager.onTestFnFailure(...args);
-  onTestDone = async (testSummary) => {
-    if (this._isCleaningUp) return;
+
+  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);
 
-  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)
@@ -237,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();
     }
   }
 
@@ -279,6 +299,24 @@ 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;
+      };
+    }
+  }
+
 }
 
 /**

package/src/artifacts/ArtifactsManager.js

@@ -46,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 });
       }
     }
 

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/composeRunnerConfig.js

@@ -120,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;
@@ -42,7 +44,7 @@ class SessionState {
 
   static reviver(key, val) {
     if (typeof val === 'object' && val !== null && typeof val.$fn == 'string') {
-      return eval(val.$fn);
+      return vm.runInContext(val.$fn, context);
     } else {
       return val;
     }

package/src/logger/DetoxLogger.js

@@ -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();

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];
   }
 }
 

package/src/logger/utils/DetoxLogFinalizer.js

@@ -0,0 +1,134 @@
+const path = require('path');
+const { promisify } = require('util');
+
+const fs = require('fs-extra');
+const glob = require('glob');
+const pipe = require('multipipe');
+
+const temporary = require('../../artifacts/utils/temporaryPath');
+
+const globAsync = promisify(glob);
+const globSync = glob.sync;
+const streamUtils = () => require('../../logger/utils/streamUtils');
+
+/**
+ * @typedef DetoxLogFinalizerConfig
+ * @property {import('../../ipc/SessionState')} session
+ */
+
+class DetoxLogFinalizer {
+  /** @param {DetoxLogFinalizerConfig} config */
+  constructor(config) {
+    this._session = config.session;
+  }
+
+  createEventStream() {
+    const sessionId = this._session.id;
+    const logs = globSync(temporary.for.jsonl(`${sessionId}.*`));
+
+    return streamUtils()
+      .uniteSessionLogs(logs)
+      .pipe(streamUtils().chromeTraceStream());
+  }
+
+  async finalize() {
+    const sessionId = this._session.id;
+    const logs = await globAsync(temporary.for.jsonl(`${sessionId}.*`));
+    if (logs.length === 0) {
+      return;
+    }
+
+    if (this._areLogsEnabled()) {
+      const rootDir = this._config.artifacts.rootDir;
+
+      await fs.mkdirp(rootDir);
+      const [out1Stream, out2Stream] = ['detox.log', 'detox.trace.json']
+        .map((filename) => fs.createWriteStream(path.join(rootDir, filename)));
+
+      const tidHashMap = await this._scanForThreadIds(logs);
+      const mergedStream = streamUtils().uniteSessionLogs(logs);
+
+      await Promise.all([
+        pipe(mergedStream, streamUtils().debugStream(this._config.logger.options), out1Stream),
+        pipe(mergedStream, streamUtils().chromeTraceStream(tidHashMap), streamUtils().writeJSON(), out2Stream),
+      ]);
+    }
+
+    await Promise.all(logs.map(filepath => fs.remove(filepath)));
+  }
+
+  finalizeSync() {
+    const sessionId = this._session.id;
+    const rootDir = this._config.artifacts.rootDir;
+    const logsEnabled = this._areLogsEnabled();
+
+    if (logsEnabled) {
+      fs.mkdirpSync(rootDir);
+    }
+
+    const logs = globSync(temporary.for.jsonl(`${sessionId}.*`));
+
+    for (const log of logs) {
+      if (logsEnabled) {
+        fs.moveSync(log, path.join(rootDir, path.basename(log)));
+      } else {
+        fs.removeSync(log);
+      }
+    }
+  }
+
+  /** @private */
+  get _config() {
+    // The config appears later in the lifecycle, so we need to access it lazily
+    return this._session.detoxConfig;
+  }
+
+  /** @private */
+  _areLogsEnabled() {
+    const { rootDir, plugins } = this._config.artifacts;
+    if (!rootDir || !plugins) {
+      return false;
+    }
+
+    if (!plugins.log.enabled) {
+      return false;
+    }
+
+    if (!plugins.log.keepOnlyFailedTestsArtifacts) {
+      return true;
+    }
+
+    return this._session.testResults.some(r => !r.success);
+  }
+
+  /** @private */
+  async _scanForThreadIds(logs) {
+    const processes = await new Promise((resolve, reject) => {
+      const result = {};
+      streamUtils().uniteSessionLogs(logs)
+        .on('end', () => resolve(result))
+        .on('error', (err) => reject(err))
+        .on('data', (event) => {
+          const { ph, pid, tid, cat } = event;
+          if (ph === 'B' || ph === 'i') {
+            const categories = (result[pid] = result[pid] || {});
+            const mainCategory = String(cat).split(',')[0];
+            const tids = (categories[mainCategory] = categories[mainCategory] || []);
+            if (!tids.includes(tid)) {
+              tids.push(tid);
+            }
+          }
+        });
+    });
+
+    const tidArray = Object.entries(processes).flatMap(([pid, categories]) => {
+      return Object.entries(categories).flatMap(([category, tids]) => {
+        return tids.map(tid => `${pid}:${category}:${tid}`);
+      });
+    });
+
+    return new Map(tidArray.map((hash, index) => [hash, index]));
+  }
+}
+
+module.exports = DetoxLogFinalizer;

package/src/logger/utils/ThreadDispatcher.js

@@ -2,17 +2,10 @@ const isUndefined = (x) => x === undefined;
 
 class ThreadDispatcher {
   /**
-   * @param {object} options
-   * @param {Detox.Logger} options.logger
-   * @param {string} options.name
-   * @param {number} options.min
-   * @param {number} [options.max]
+   * @param {string} name
    */
-  constructor({ logger, name, min, max = Infinity }) {
-    this.logger = logger;
+  constructor(name) {
     this.name = name;
-    this.min = min;
-    this.max = max;
     this.stacks = [];
     this.threads = [];
   }
@@ -25,7 +18,7 @@ class ThreadDispatcher {
     const tid = this._findTID(id);
     this.threads[tid] = id;
     this.stacks[tid] = (this.stacks[tid] || 0) + 1;
-    return this._transpose(tid);
+    return tid;
   }
 
   /**
@@ -33,8 +26,7 @@ class ThreadDispatcher {
    * @returns {number}
    */
   resolve(id) {
-    const tid = this._findTID(id);
-    return this._transpose(tid);
+    return this._findTID(id);
   }
 
   /**
@@ -46,7 +38,7 @@ class ThreadDispatcher {
     if (this.stacks[tid] && --this.stacks[tid] === 0) {
       delete this.threads[tid];
     }
-    return this._transpose(tid);
+    return tid;
   }
 
   /**
@@ -64,18 +56,6 @@ class ThreadDispatcher {
     }
     return tid === -1 ? this.threads.length : tid;
   }
-
-  _transpose(id) {
-    const result = this.min + id;
-    if (result > this.max) {
-      this.logger.warn(
-        { cat: ['logger', 'thread-dispatcher'] },
-        `${this.name} trace thread dispatcher has run out of available thread IDs: ${this.min}..${this.max}`
-      );
-    }
-
-    return Math.min(result, this.max);
-  }
 }
 
 module.exports = ThreadDispatcher;