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

package/src/ipc/IPCServer.js

@@ -1,15 +1,19 @@
+const { uniqBy } = require('lodash');
 const { IPC } = require('node-ipc');
 
+const { serializeObjectWithError } = require('../utils/errorUtils');
+
 class IPCServer {
   /**
    * @param {object} options
-   * @param {import('./state').PrimarySessionState} options.sessionState
+   * @param {import('./SessionState')} options.sessionState
    * @param {Detox.Logger} options.logger
    */
   constructor({ sessionState, logger }) {
     this._sessionState = sessionState;
-    this._logger = logger.child({ __filename, cat: 'ipc' });
+    this._logger = logger.child({ cat: 'ipc,ipc-server' });
     this._ipc = null;
+    this._workers = new Set();
   }
 
   get id() {
@@ -26,12 +30,12 @@ class IPCServer {
     this._ipc.config.appspace = 'detox.';
     this._ipc.config.logger = (msg) => this._logger.trace(msg);
 
-      await new Promise((resolve) => {
+    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.on('reportTestResults', this.onReportTestResults.bind(this));
       this._ipc.server.start();
     });
   }
@@ -48,33 +52,46 @@ class IPCServer {
     });
   }
 
-  onRegisterContext({ id, logFile }, socket) {
+  onRegisterContext({ id }, socket) {
     this._sessionState.contexts.push(id);
 
-    if (logFile && !this._sessionState.logFiles.includes(logFile)) {
-      this._sessionState.logFiles.push(logFile);
-    }
-
-    this._ipc.server.emit(socket, 'registerContextDone', {});
+    this._ipc.server.emit(socket, 'registerContextDone', {
+      testResults: this._sessionState.testResults,
+      testSessionIndex: this._sessionState.testSessionIndex,
+    });
   }
 
-  onRegisterWorker({ workerId }, socket) {
+  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', {});
+      this._ipc.server.emit(socket, 'registerWorkerDone', { workersCount });
     }
 
-    if (workerId > this._sessionState.workersCount) {
-      const workersCount = this._sessionState.workersCount = workerId;
+    if (shouldBroadcast) {
       this._ipc.server.broadcast('sessionStateUpdate', { workersCount });
     }
   }
 
-  onFailedTests({ testFilePaths }, socket) {
-    this._sessionState.failedTestFiles.push(...testFilePaths);
+  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, 'failedTestsDone', {});
+      this._ipc.server.emit(socket, 'reportTestResultsDone', {
+        testResults: this._sessionState.testResults,
+      });
     }
+
+    this._ipc.server.broadcast('sessionStateUpdate', {
+      testResults: this._sessionState.testResults,
+    });
   }
 }
 

package/src/ipc/{state.js → SessionState.js}

@@ -1,8 +1,30 @@
+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 = '',
+    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);
   }
@@ -21,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;
     }
@@ -37,31 +59,4 @@ class SessionState {
   }
 }
 
-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,
-};
+module.exports = SessionState;

package/src/logger/DetoxLogger.js

@@ -1,201 +1,330 @@
 const path = require('path');
-const { PassThrough } = require('stream');
 
-const bunyan = require('bunyan');
-const bunyanDebugStream = require('bunyan-debug-stream');
 const _ = require('lodash');
 
-const temporaryPath = require('../artifacts/utils/temporaryPath');
-const { DetoxInternalError } = require('../errors');
+const { DetoxInternalError, DetoxError } = require('../errors');
 const { shortFormat } = require('../utils/dateUtils');
+const isPromise = require('../utils/isPromise');
 
-const customConsoleLogger = require('./customConsoleLogger');
+const BunyanLogger = require('./utils/BunyanLogger');
+const CategoryThreadDispatcher = require('./utils/CategoryThreadDispatcher');
+const MessageStack = require('./utils/MessageStack');
+const customConsoleLogger = require('./utils/customConsoleLogger');
+const sanitizeBunyanContext = require('./utils/sanitizeBunyanContext');
 
 /**
- * @typedef PrivateLoggerConfig
- * @property {string} [file]
+ * @typedef SharedLoggerConfig
+ * @property {string} file
+ * @property {Detox.DetoxLoggerConfig} [userConfig]
+ * @property {CategoryThreadDispatcher} [dispatcher]
+ * @property {BunyanLogger} [bunyan]
+ * @property {MessageStack} [messageStack]
  */
 
 class DetoxLogger {
   /**
-   * @param {Detox.DetoxLoggerConfig & PrivateLoggerConfig} [config]
+   * @param {Pick<SharedLoggerConfig, 'file' | 'userConfig'>} sharedConfig
    * @param {object} [context]
-   * @param {bunyan} [bunyanLogger]
    */
-  constructor(config, context, bunyanLogger) {
-    // IMPORTANT: all the loggers should share the same object instance of this._config
-    this._config = config || {
-      level: 'info',
-      overrideConsole: 'none',
-      options: {
-        showDate: true,
-        showLoggerName: true,
-        showPid: true,
-        showMetadata: false,
-      },
-    };
-
-    if (config && !context) {
-      this._config.file = temporaryPath.for.jsonl();
-    }
+  constructor(sharedConfig, context) {
+    /**
+     * @type {SharedLoggerConfig}
+     * IMPORTANT: all instances of {@link DetoxLogger} must share the same object instance of this._sharedConfig.
+     */
+    this._sharedConfig = sharedConfig;
 
     /** @type {object | undefined} */
     this._context = context;
-    /** @type {bunyan} */
-    this._bunyan = bunyanLogger || this._initBunyanLogger();
-
-    this.fatal = this._forward.bind(this, 'fatal');
-    this.error = this._forward.bind(this, 'error');
-    this.warn = this._forward.bind(this, 'warn');
-    this.info = this._forward.bind(this, 'info');
-    this.debug = this._forward.bind(this, 'debug');
-    this.trace = this._forward.bind(this, 'trace');
 
-    this.overrideConsole();
+    /** @public */
+    this.fatal = this._setupLogMethod('fatal');
+    /** @public */
+    this.error = this._setupLogMethod('error');
+    /** @public */
+    this.warn = this._setupLogMethod('warn');
+    /** @public */
+    this.info = this._setupLogMethod('info');
+    /** @public */
+    this.debug = this._setupLogMethod('debug');
+    /** @public */
+    this.trace = this._setupLogMethod('trace');
+
+    if (!context) {
+      // In this branch, `this` refers to the first (root) logger instance.
+
+      this._sharedConfig.userConfig = this._sharedConfig.userConfig || {
+        level: 'info',
+        overrideConsole: false,
+        options: {
+          showDate: false,
+          showLoggerName: false,
+          showProcess: false,
+          showPid: false,
+          showLevel: false,
+          showPrefixes: false,
+          showMetadata: false,
+        },
+      };
+
+      this._sharedConfig.bunyan = new BunyanLogger()
+        .installFileStream(this.file)
+        .installDebugStream(this.config);
+
+      this._sharedConfig.dispatcher = new CategoryThreadDispatcher();
+      this._sharedConfig.messageStack = new MessageStack();
+
+      this.overrideConsole();
+    }
   }
 
   /**
-   * @internal
+   * @public
+   * @returns {Detox.DetoxLogLevel}
    */
-  get config() {
-    return this._config;
-  }
-
-  /** @returns {Detox.DetoxLogLevel} */
   get level() {
-    return this._config.level;
+    return this.config.level;
   }
 
   /**
-   * @internal
+   * @public
+   * @param {object} [overrides]
+   * @returns {DetoxLogger}
    */
+  child(overrides) {
+    const merged = this._mergeContexts(this._context, sanitizeBunyanContext(overrides));
+    return new DetoxLogger(this._sharedConfig, merged);
+  }
+
+  /** @internal */
+  get config() {
+    return this._sharedConfig.userConfig;
+  }
+
+  /** @internal */
   get file() {
-    return this._config.file;
+    return this._sharedConfig.file;
   }
 
   /**
+   * @internal
    * @param config
    */
   async setConfig(config) {
-    if (this._context !== undefined) {
-      throw new DetoxInternalError('Trying to set a config for a non-root logger');
+    if (this._context) {
+      throw new DetoxInternalError('Trying to set a config in a non-root logger');
     }
 
-    if (this.file) {
-      throw new DetoxInternalError('Trying to set a config for a fully initialized logger');
-    }
-
-    _.merge(this._config, config);
-
-    // @ts-ignore
-    const [oldStream] = this._bunyan.streams.splice(0, 1);
-    oldStream.stream.end();
-    this._bunyan.addStream(this._createDebugStream());
+    _.merge(this.config, config);
+    this._sharedConfig.bunyan.installDebugStream(this.config);
+    this.overrideConsole();
+  }
 
-    this._config.file = temporaryPath.for.jsonl();
-    this._bunyan.addStream({
-      level: 'trace',
-      path: this._config.file,
-    });
+  /**
+   * @internal
+   */
+  overrideConsole(sandbox) {
+    const enabled = this.config.overrideConsole;
+    if (!enabled) {
+      return;
+    }
 
-    this.overrideConsole();
+    customConsoleLogger.overrideConsoleMethods((sandbox || global).console, this);
   }
 
   /**
-   * @param {object} [overrides]
-   * @returns {DetoxLogger}
+   * @private
    */
-  child(overrides) {
-    if (overrides && overrides.__filename) {
-      overrides.__filename = path.basename(overrides.__filename, '.js');
+  _mergeContexts(...contexts) {
+    const context = Object.assign({}, ...contexts);
+    const categories = _(contexts).flatMap((c) => {
+      if (c && c.cat) {
+        return _.isArray(c.cat) ? c.cat : c.cat.split(',');
+      }
+
+      return [];
+    }).uniq().join(',');
+
+    if (context.error || context.err) {
+      context.error = DetoxError.format(context.error || context.err);
+      delete context.err;
+    }
+
+    if (categories) {
+      context.cat = categories;
+    } else {
+      delete context.cat;
     }
 
-    return new DetoxLogger(this._config, {
-      ...this._context,
-      ...overrides,
-    }, this._bunyan);
+    if (context.__filename) {
+      context.__filename = path.basename(context.__filename);
+    }
+
+    context.ph = context.ph || 'i';
+    context.tid = this._sharedConfig.dispatcher.resolve(
+      context.ph,
+      context.cat,
+      context.id || 0
+    );
+
+    return context;
   }
 
   /**
-   * @param {bunyan.LogLevel} level
-   * @param {any[]} args
    * @private
+   * @param {Detox.DetoxLogLevel} level
+   * @returns {Detox._LogMethod}
    */
-  _forward(level, ...args) {
-    const msgContext = _.isError(args[0]) ? { err: args[0] } : _.isObject(args[0]) ? args[0] : undefined;
-    const msgArgs = msgContext !== undefined ? args.slice(1) : args;
-    const mergedContext = sanitizeBunyanContext({
-      ...this._context,
-      ...msgContext,
+  _setupLogMethod(level) {
+    const logMethod = this[level] = this._instant.bind(this, level);
+
+    return Object.assign(logMethod, {
+      begin: this._begin.bind(this, level),
+      complete: this._complete.bind(this, level),
+      end: this._end.bind(this, level),
     });
+  }
 
-    this._bunyan[level](mergedContext, ...msgArgs);
+  /** @private */
+  _begin(level, ...args) {
+    const { context, msg } = this._parseArgs({ ph: 'B' }, args);
+    this._beginInternal(level, context, msg);
   }
 
-  _initBunyanLogger() {
-    /** @type {bunyan.Stream[]} */
-    const streams = [this._createDebugStream()];
+  /** @private */
+  _beginInternal(level, context, msg) {
+    this._sharedConfig.messageStack.push(context.tid, msg);
+    this._sharedConfig.bunyan.logger[level](context, ...msg);
+  }
 
-    if (this._config.file) {
-      streams.push({
-        level: 'trace',
-        path: this._config.file,
-      });
+  /** @private */
+  _end(level, ...args) {
+    let { context, msg } = this._parseArgs({ ph: 'E' }, args);
+    this._endInternal(level, context, msg);
+  }
+
+  /** @private */
+  _endInternal(level, context, msg) {
+    const beginMsg = this._sharedConfig.messageStack.pop(context.tid);
+    if (msg.length === 0) {
+      msg = beginMsg;
     }
 
-    return bunyan.createLogger({ name: 'detox', streams });
+    this._sharedConfig.bunyan.logger[level](context, ...msg);
   }
 
-  _createDebugStream() {
-    const { out = process.stderr, ...streamOptions } = this._config.options;
-    const passthrough = new PassThrough().pipe(out);
-
-    return {
-      type: 'raw',
-      level: this._config.level,
-      stream: bunyanDebugStream.default({
-        ...streamOptions,
-        out: passthrough,
-      }),
-    };
+  /**
+   * @private
+   * @param {import('bunyan').LogLevel} level
+   * @param {any[]} args
+   */
+  _instant(level, ...args) {
+    const { context, msg } = this._parseArgs(null, args);
+    this._sharedConfig.bunyan.logger[level](context, ...msg);
   }
 
-  overrideConsole(sandbox) {
-    const option = this._config.overrideConsole;
-    if (option === 'none') {
-      return;
-    }
+  /**
+   * @param {import('bunyan').LogLevel} level
+   * @private
+   */
+  _complete(level, maybeContext, maybeMessage, maybeAction) {
+    const action = typeof maybeContext !== 'string' ? maybeAction : maybeMessage;
+    const args = maybeAction === action ? [maybeContext, maybeMessage] : [maybeContext];
+    const { context, msg } = this._parseArgs(null, args);
+    const end = (ctx) => this[level].end({
+      id: context.id,
+      cat: context.cat,
+      ...ctx,
+    });
 
-    if ((option === 'sandbox' && sandbox) || option === 'all') {
-      customConsoleLogger.overrideConsoleMethods((sandbox || global).console, this);
+    let result;
+    this._beginInternal(level, { ...context, ph: 'B' }, msg);
+    try {
+      result = typeof action === 'function'
+        ? action()
+        : action;
+
+      if (!isPromise(result)) {
+        end({ success: true });
+      } else {
+        result.then(
+          () => end({ success: true }),
+          (err) => end({ success: false, err }),
+        );
+      }
+
+      return result;
+    } catch (err) {
+      end({ success: false, err });
+      throw err;
     }
   }
 
-  /** @type {bunyanDebugStream.BunyanDebugStreamOptions} */
-  static defaultOptions = {
-    showDate: shortFormat,
-    showLoggerName: true,
-    showPid: true,
-    showMetadata: false,
-    basepath: path.join(__dirname, '..'),
-    prefixers: {
-      '__filename': (filename, { entry }) => {
-        if (entry.event === 'USER_LOG') {
-          return '';
-        }
-
-        if (entry.event === 'ERROR') {
-          return `${filename}/${entry.event}`;
-        }
-
-        return entry.event ? entry.event : filename;
-      },
-      'trackingId': id => ` #${id}`,
-      'cpid': pid => ` cpid=${pid}`,
-    },
-  };
+  /** @private */
+  _parseArgs(boundContext, args) {
+    const userContext = _.isError(args[0])
+      ? { err: args[0] }
+      : _.isObject(args[0])
+        ? args[0]
+        : undefined;
+
+    const msg = userContext !== undefined ? args.slice(1) : args;
+
+    const context = this._mergeContexts(
+      this._context,
+      boundContext,
+      sanitizeBunyanContext(userContext),
+    );
+
+    return { context, msg };
+  }
+
+  /** @internal */
+  static defaultOptions({ level }) {
+    const ph = level === 'trace' || level === 'debug'
+      ? value => require('chalk').grey(value) + ' '
+      : value => require('chalk').grey(value);
+
+    const id = level === 'trace'
+      ? value => require('chalk').yellow(`@${value}`)
+      : undefined;
+
+    const cat = level === 'trace' || level === 'debug'
+      ? (value) => require('chalk').yellow(`${value}`.split(',', 1)[0])
+      : undefined;
+
+    const event = level === 'trace' || level === 'debug'
+      ? (value) => require('chalk').grey(`:${value}`)
+      : undefined;
+
+    const identity = x => x;
+
+    return ({
+      showDate: shortFormat,
+      showLoggerName: true,
+      showPid: true,
+      showLevel: false,
+      showMetadata: false,
+      showPrefixes: (p) => p.join(''),
+      basepath: path.join(__dirname, '..'),
+      prefixers: _.omitBy({
+        ph,
+        cat,
+        event,
+        id,
+      }, _.isUndefined),
+      stringifiers: _.omitBy({
+        // eslint-disable-next-line unicorn/no-array-method-this-argument
+        'args': args => `(${require('lodash').map(args, a => JSON.stringify(a)).join(', ')})`,
+        'error': identity,
+        'data': json => typeof json === 'string' ? json : JSON.stringify(json, null, 2),
+        'stack': level === 'trace' || level === 'debug' ? identity : undefined,
+        'origin': level === 'trace' || level === 'debug' ? identity : undefined,
+      }, _.isUndefined),
+    });
+  }
 
   /**
+   * @internal
    * @param {string} level
    * @returns {Detox.DetoxLogLevel}
    */
@@ -216,29 +345,4 @@ class DetoxLogger {
   }
 }
 
-const RESERVED_PROPERTIES = [
-  'hostname',
-  'level',
-  'msg',
-  'name',
-  'pid',
-  'time',
-];
-
-function hasProperty(p) {
-  return _.has(this, p);
-}
-
-function hasReservedProperties(o) {
-  return RESERVED_PROPERTIES.some(hasProperty, o); // eslint-disable-line unicorn/no-array-method-this-argument
-}
-
-function escapeCallback(value, key) {
-  return RESERVED_PROPERTIES.includes(key) ? `${key}$` : key;
-}
-
-function sanitizeBunyanContext(context) {
-  return hasReservedProperties(context) ? _.mapKeys(context, escapeCallback) : context;
-}
-
 module.exports = DetoxLogger;

package/src/logger/index.js

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