detox 19.9.0 → 21.0.0-breaking.new-global-lifecycle.0

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,87 @@
+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', {
+      failedTestFiles: this._sessionState.failedTestFiles,
+    });
+  }
+
+  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', {});
+    }
+
+    this._ipc.server.broadcast('sessionStateUpdate', {
+      failedTestFiles: this._sessionState.failedTestFiles,
+    });
+  }
+}
+
+module.exports = IPCServer;

package/src/ipc/state.js

@@ -0,0 +1,76 @@
+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 = '',
+    failedTestFiles = [],
+    workerId = undefined,
+    workersCount = 0
+  }) {
+    super();
+
+    this.id = id;
+    this.detoxConfigSnapshotPath = detoxConfigSnapshotPath;
+    this.detoxConfig = detoxConfig;
+    this.detoxIPCServer = detoxIPCServer;
+    this.failedTestFiles = failedTestFiles;
+    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,
+};

package/src/logger/DetoxLogger.js

@@ -0,0 +1,244 @@
+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 { shortFormat } = require('../utils/dateUtils');
+
+const customConsoleLogger = require('./customConsoleLogger');
+
+/**
+ * @typedef PrivateLoggerConfig
+ * @property {string} [file]
+ */
+
+class DetoxLogger {
+  /**
+   * @param {Detox.DetoxLoggerConfig & PrivateLoggerConfig} [config]
+   * @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();
+    }
+
+    /** @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();
+  }
+
+  /**
+   * @internal
+   */
+  get config() {
+    return this._config;
+  }
+
+  /** @returns {Detox.DetoxLogLevel} */
+  get level() {
+    return this._config.level;
+  }
+
+  /**
+   * @internal
+   */
+  get file() {
+    return this._config.file;
+  }
+
+  /**
+   * @param config
+   */
+  async setConfig(config) {
+    if (this._context !== undefined) {
+      throw new DetoxInternalError('Trying to set a config for 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());
+
+    this._config.file = temporaryPath.for.jsonl();
+    this._bunyan.addStream({
+      level: 'trace',
+      path: this._config.file,
+    });
+
+    this.overrideConsole();
+  }
+
+  /**
+   * @param {object} [overrides]
+   * @returns {DetoxLogger}
+   */
+  child(overrides) {
+    if (overrides && overrides.__filename) {
+      overrides.__filename = path.basename(overrides.__filename, '.js');
+    }
+
+    return new DetoxLogger(this._config, {
+      ...this._context,
+      ...overrides,
+    }, this._bunyan);
+  }
+
+  /**
+   * @param {bunyan.LogLevel} level
+   * @param {any[]} args
+   * @private
+   */
+  _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,
+    });
+
+    this._bunyan[level](mergedContext, ...msgArgs);
+  }
+
+  _initBunyanLogger() {
+    /** @type {bunyan.Stream[]} */
+    const streams = [this._createDebugStream()];
+
+    if (this._config.file) {
+      streams.push({
+        level: 'trace',
+        path: this._config.file,
+      });
+    }
+
+    return bunyan.createLogger({ name: 'detox', streams });
+  }
+
+  _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,
+      }),
+    };
+  }
+
+  overrideConsole(sandbox) {
+    const option = this._config.overrideConsole;
+    if (option === 'none') {
+      return;
+    }
+
+    if ((option === 'sandbox' && sandbox) || option === 'all') {
+      customConsoleLogger.overrideConsoleMethods((sandbox || global).console, this);
+    }
+  }
+
+  /** @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}`,
+    },
+  };
+
+  /**
+   * @param {string} level
+   * @returns {Detox.DetoxLogLevel}
+   */
+  static castLevel(level) {
+    switch (level) {
+      case 'fatal':
+      case 'error':
+      case 'warn':
+      case 'info':
+      case 'debug':
+      case 'trace':
+        return level;
+      case 'verbose':
+        return 'debug';
+      default:
+        return 'info';
+    }
+  }
+}
+
+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/DetoxTraceEventBuilder.js

@@ -0,0 +1,21 @@
+const { AbstractEventBuilder } = require('trace-event-lib');
+
+class DetoxTraceEventBuilder extends AbstractEventBuilder {
+  constructor(forward) {
+    super();
+
+    this._forward = forward;
+  }
+
+  send(event) {
+    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+    const { pid, ts, name, args = {}, ...trace } = event;
+    if (trace.ph === 'E') {
+      this._forward({ ...args, trace }, `end`);
+    } else {
+      this._forward({ ...args, trace }, name);
+    }
+  }
+}
+
+module.exports = DetoxTraceEventBuilder;

package/src/logger/DetoxTracer.js

@@ -0,0 +1,133 @@
+const _ = require('lodash');
+
+const isPromise = require('../utils/isPromise');
+
+const DetoxTraceEventBuilder = require('./DetoxTraceEventBuilder');
+const TraceThreadDispatcher = require('./TraceThreadDispatcher');
+
+class DetoxTracer {
+  /**
+   * @param {object} options
+   * @param {Detox.Logger} options.logger
+   */
+  constructor({ logger }) {
+    this.logger = logger;
+    this.builder = new DetoxTraceEventBuilder(this.logger.trace);
+    this.categories = {};
+    this.defaultEventDispatcher = new TraceThreadDispatcher({
+      logger,
+      name: 'Default',
+      min: 10000,
+    });
+    this.eventDispatchers = { '': this.defaultEventDispatcher };
+  }
+
+  /**
+   * @param {Detox.TraceEvent | string} eventOrName
+   * @param {Detox.TraceEvent['args']} [args]
+   * @returns {import('trace-event-lib').EndHandle<Detox.TraceEvent>}
+   */
+  begin(eventOrName, args) {
+    const event = typeof eventOrName === 'string' ? { name: eventOrName, args } : eventOrName;
+    const mainCategory = event.cat ? event.cat.split(',', 1)[0] : '';
+    const dispatcher = this.eventDispatchers[mainCategory] || this.defaultEventDispatcher;
+    const tid = dispatcher.begin(event.id);
+
+    return this.builder.begin({
+      args: event.args,
+      cat: event.cat || '',
+      cname: event.cname,
+      name: event.name,
+      tid,
+    });
+  }
+
+  end(eventOrName, args) {
+    const event = typeof eventOrName === 'string' ? { name: eventOrName, args } : eventOrName || {};
+    const mainCategory = event.cat ? event.cat.split(',', 1)[0] : '';
+    const dispatcher = this.eventDispatchers[mainCategory] || this.defaultEventDispatcher;
+    const tid = dispatcher.end(event.id);
+
+    this.builder.end({
+      args: event.args,
+      cname: event.cname,
+      tid,
+    });
+  }
+
+  section(sectionName, func) {
+    let result;
+
+    this.begin(sectionName);
+    try {
+      result = func();
+      if (!isPromise(result)) {
+        this.end(sectionName, { success: true });
+      } else {
+        result.then(
+          () => this.end(sectionName, { success: true }),
+          (err) => this.end(sectionName, { success: false, err }),
+        );
+      }
+    } catch (err) {
+      this.end(sectionName, { success: false, err });
+      throw err;
+    }
+
+    return result;
+  }
+
+  registerThreads(event, [min, max]) {
+    this.eventDispatchers[event] = new TraceThreadDispatcher({
+      logger: this.logger,
+      name: event,
+      min,
+      max,
+    });
+
+    return this;
+  }
+
+  static default(options) {
+    const tracer = new DetoxTracer(options);
+    for (const [key, range] of Object.entries(this.CATEGORIES)) {
+      tracer.registerThreads(key, range);
+    }
+
+    return Object.assign(
+      tracer.section.bind(tracer),
+      {
+        begin: tracer.begin.bind(tracer),
+        startSection: tracer.begin.bind(tracer),
+        end: tracer.end.bind(tracer),
+        endSection: tracer.end.bind(tracer),
+      });
+  }
+
+  static categorize(tid) {
+    return _.findKey(this.CATEGORIES, ([min, max]) => min <= tid && tid <= max) || 'user';
+  }
+
+  static threadize(cat) {
+    const [mainCategory] = cat ? cat.split(',', 1) : 'user';
+    const threads = _.find(this.CATEGORIES, (_, key) => key === mainCategory);
+    return threads ? threads[0] : 10000;
+  }
+
+  /**
+   * @type {Record<string, [number, number]>}
+   */
+  static CATEGORIES = {
+    'lifecycle': [0, 0],
+    'ipc': [29, 29],
+    'ws-server': [50, 99],
+    'ws-client': [100, 149],
+    'device': [150, 159],
+    'artifacts-manager': [300, 300],
+    'artifact-plugin': [310, 349],
+    'artifact': [350, 399],
+    'child-process': [400, 499],
+  };
+}
+
+module.exports = DetoxTracer;