detox 19.13.0 → 20.0.0

package/src/{utils → logger/utils}/customConsoleLogger.js

@@ -1,6 +1,6 @@
 const util = require('util');
 
-const callsites = require('./callsites');
+const callsites = require('../../utils/callsites');
 
 const USER_STACK_FRAME_INDEX = 2;
 
@@ -25,20 +25,20 @@ function getStackDump() {
 
 function proxyLog(bunyanLoggerFn) {
   return (...args) => {
-    bunyanLoggerFn({ event: 'USER_LOG' }, getOrigin(), '\n', util.format(...args));
+    bunyanLoggerFn({ cat: 'user', origin: getOrigin() }, util.format(...args));
   };
 }
 
 function proxyTracing(bunyanLoggerFn) {
   return (...args) => {
-    bunyanLoggerFn({ event: 'USER_LOG' }, getOrigin(), '\n  Trace:', util.format(...args), '\n\r' + getStackDump());
+    bunyanLoggerFn({ cat: 'user', origin: getOrigin(), stack: getStackDump() }, util.format(...args));
   };
 }
 
 function proxyAssert(bunyanLoggerFn) {
   return (condition, ...args) => {
     if (!condition) {
-      bunyanLoggerFn({ event: 'USER_LOG' }, getOrigin(), '\n  AssertionError:', util.format(...args));
+      bunyanLoggerFn({ cat: 'user', origin: getOrigin() }, 'AssertionError:', util.format(...args));
     }
   };
 }
@@ -48,6 +48,7 @@ function overrideConsoleMethods(console, bunyanLogger) {
     const log = bunyanLogger;
 
     override(console, 'log', log.info.bind(log));
+    override(console, 'info', log.info.bind(log));
     override(console, 'warn', log.warn.bind(log));
     override(console, 'trace', log.info.bind(log));
     override(console, 'error', log.error.bind(log));

package/src/logger/utils/sanitizeBunyanContext.js

@@ -0,0 +1,30 @@
+const _ = require('lodash');
+
+const RESERVED_PROPERTIES = [
+  'hostname',
+  'level',
+  'msg',
+  'name',
+  'pid',
+  'tid',
+  'ph',
+  '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 context && hasReservedProperties(context) ? _.mapKeys(context, escapeCallback) : context;
+}
+
+module.exports = sanitizeBunyanContext;

package/src/logger/utils/streamUtils.js

@@ -0,0 +1,248 @@
+const { PassThrough, Transform } = require('stream');
+
+const bunyanDebugStream = require('bunyan-debug-stream');
+const duplexify = require('duplexify');
+const fs = require('fs-extra');
+const multiSort = require('multi-sort-stream');
+const pipe = require('multipipe');
+const JsonlParser = require('stream-json/jsonl/Parser');
+const stripAnsi = require('strip-ansi');
+const { AbstractEventBuilder } = require('trace-event-lib');
+
+const log = require('../../utils/logger').child({ cat: 'logger' });
+
+function compareTimestamps(a, b) {
+  return +(a.value.time > b.value.time) - +(a.value.time < b.value.time);
+}
+
+function mapTransform(fn) {
+  return new Transform({
+    objectMode: true,
+    transform(chunk, encoding, callback){
+      this.push(fn(chunk));
+      callback();
+    },
+  });
+}
+
+function flatMapTransform(fn) {
+  let index = 0;
+
+  return new Transform({
+    objectMode: true,
+    transform(chunk, encoding, callback){
+      const result = fn(chunk, index++);
+      if (Array.isArray(result)) {
+        // eslint-disable-next-line unicorn/no-array-method-this-argument
+        result.forEach(pushThis, this);
+      } else if (result) {
+        this.push(result);
+      }
+
+      callback();
+    },
+  });
+}
+
+function pushThis(x) {
+  return this.push(x);
+}
+
+function extractValue({ value }) {
+  value.msg = stripAnsi(value.msg);
+
+  if (typeof value.time === 'string') {
+    value.time = new Date(value.time);
+  }
+
+  return value;
+}
+
+function through() {
+  return new PassThrough({ objectMode: true });
+}
+
+function mergeSortedJSONL(jsonlStreams, comparator = compareTimestamps) {
+  const intermediate = mapTransform(extractValue);
+  const reemitError = (err) => intermediate.emit('error', err);
+  const addReemit = (stream) => stream.on('error', reemitError);
+  return pipe(multiSort(jsonlStreams.map(addReemit), comparator), intermediate, through());
+}
+
+function writeJSONL() {
+  return new JsonlStringer({
+    header: '',
+    delimiter: '\n',
+    footer: '',
+  });
+}
+
+function writeJSON() {
+  return new JsonlStringer({
+    header: '[\n\t',
+    delimiter: ',\n\t',
+    footer: '\n]\n',
+  });
+}
+
+function debugStream(options) {
+  const out = new PassThrough({ encoding: 'utf8' });
+  const writable = bunyanDebugStream.default({
+    ...options,
+    colors: false,
+    out,
+  });
+
+  return duplexify(writable, out, {
+    readableObjectMode: false,
+    writableObjectMode: true
+  });
+}
+
+class JsonlStringer extends Transform {
+  constructor({ replacer = undefined, header = '', delimiter = '\n', footer = '' } = {}) {
+    super({ writableObjectMode: true, readableObjectMode: false });
+
+    this._replacer = replacer;
+    this._header = header;
+    this._delimiter = delimiter;
+    this._footer = footer;
+  }
+
+  _transform(chunk, _, callback) {
+    if (this._header) {
+      this.push(this._header);
+    }
+
+    this.push(JSON.stringify(chunk, this._replacer));
+    this._transform = this._nextTransform;
+    callback(null);
+  }
+
+  _nextTransform(chunk, _, callback) {
+    this.push(this._delimiter + JSON.stringify(chunk, this._replacer));
+    callback(null);
+  }
+
+  _flush(callback) {
+    if (this._footer) {
+      this.push(this._footer);
+    }
+
+    callback();
+  }
+}
+
+class SimpleEventBuilder extends AbstractEventBuilder {
+  events = [];
+
+  send(event) {
+    this.events.push(event);
+  }
+}
+
+const ERROR_TID = 37707;
+
+function getTidHash({ pid, tid, cat }) {
+  const mainCategory = String(cat).split(',')[0];
+  return `${pid}:${mainCategory}:${tid}`;
+}
+
+function getFixedTID(tidHashMap, event) {
+  let tid = tidHashMap.get(getTidHash(event));
+  if (tid === undefined) {
+    tid = ERROR_TID;
+  }
+
+  return tid;
+}
+
+/**
+ * @param {Map<string, number>} [tidHashMap]
+ */
+function chromeTraceStream(tidHashMap) {
+  const knownPids = new Set();
+  const knownTids = new Set();
+  const fixTID = tidHashMap ? getFixedTID.bind(null, tidHashMap) : (x) => x.tid;
+
+  return flatMapTransform((data) => {
+    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+    const { cat: rawCat, msg: name, ph = 'i', pid, tid: _tid, time, name: _name, hostname: _hostname, ...args } = data;
+    const ts = new Date(time).getTime() * 1E3;
+    const cat = rawCat || 'undefined';
+    const tid = fixTID(data);
+
+    const builder = new SimpleEventBuilder();
+    if (!knownPids.has(pid)) {
+      builder.metadata({ pid, ts, name: 'process_name', args: { name: pid === process.pid ? 'primary' : 'secondary' } });
+      builder.metadata({ pid, ts, name: 'process_sort_index', args: { sort_index: knownPids.size } });
+      knownPids.add(pid);
+    }
+
+    if (!knownTids.has(tid)) {
+      const primaryCategory = cat.split(',', 1)[0];
+      builder.metadata({ pid, tid, ts, name: 'thread_name', args: { name: primaryCategory } });
+      builder.metadata({ pid, tid, ts, name: 'thread_sort_index', args: { sort_index: tid } });
+      knownTids.add(tid);
+    }
+
+    const event = { ph, name, pid, tid, cat, ts, args };
+    if (ph === 'E') {
+      delete event.name;
+    }
+
+    builder.events.push(event);
+    return builder.events;
+  });
+}
+
+// TODO: create PR to https://github.com/mafintosh/duplexify
+// should be able to pass { error: false } to end-of-stream
+function preventErrorSubscriptions(emitter) {
+  const originalOn = emitter.on.bind(emitter);
+  emitter.on = (event, ...args) => {
+    if (event === 'error') {
+      return emitter;
+    }
+
+    return originalOn(event, ...args);
+  };
+
+  return emitter;
+}
+
+function readJSONL() {
+  const readable = through();
+  const writable = JsonlParser.make({ checkErrors: true })
+    .on('error', (err) => {
+      if (err instanceof SyntaxError) {
+        log.debug({ err });
+        readable.end();
+      } else {
+        readable.emit('error', err);
+      }
+    });
+
+  return duplexify.obj(preventErrorSubscriptions(writable), writable.pipe(readable));
+}
+
+/**
+ * @param {string[]} logs
+ * @returns {NodeJS.ReadableStream}
+ */
+function uniteSessionLogs(logs) {
+  const readable = through();
+  const jsonlStreams = logs.map(filePath => fs.createReadStream(filePath).pipe(readJSONL()));
+  mergeSortedJSONL(jsonlStreams).pipe(readable);
+  return readable;
+}
+
+module.exports = {
+  readJSONL,
+  writeJSON,
+  writeJSONL,
+  mergeSortedJSONL,
+  debugStream,
+  chromeTraceStream,
+  uniteSessionLogs,
+};

package/src/logger/utils/tracerLegacy.js

@@ -0,0 +1,37 @@
+const methods = {
+  startSection(logger) {
+    return (msg, args) => {
+      if (args !== undefined) {
+        return logger.trace.begin(args, msg);
+      } else {
+        return logger.trace.begin(msg);
+      }
+    };
+  },
+
+  endSection(logger) {
+    return (_msg, args) => {
+      if (args !== undefined) {
+        return logger.trace.end(args);
+      } else {
+        return logger.trace.end();
+      }
+    };
+  },
+
+  traceCall(logger) {
+    return (name, action, args = {}) => logger.trace.complete(args, name, action);
+  },
+};
+
+function installLegacyTracerInterface(logger, target) {
+  target.traceCall = methods.traceCall(logger);
+  target.trace = Object.freeze({
+    startSection: methods.startSection(logger),
+    endSection: methods.endSection(logger),
+  });
+
+  return this;
+}
+
+module.exports = { install: installLegacyTracerInterface };

package/src/realms/DetoxConstants.js

@@ -0,0 +1,13 @@
+module.exports = Object.freeze({
+  userNotificationTriggers: {
+    push: 'push',
+    calendar: 'calendar',
+    timeInterval: 'timeInterval',
+    location: 'location'
+  },
+  userActivityTypes: {
+    searchableItem: 'com.apple.corespotlightitem',
+    browsingWeb: 'NSUserActivityTypeBrowsingWeb',
+  },
+  searchableItemActivityIdentifier: 'kCSSearchableItemActivityIdentifier'
+});

package/src/realms/DetoxContext.js

@@ -0,0 +1,183 @@
+const funpermaproxy = require('funpermaproxy');
+
+const temporary = require('../artifacts/utils/temporaryPath');
+const { DetoxRuntimeError } = require('../errors');
+const { DetoxLogger, DetoxLogFinalizer, installLegacyTracerInterface } = require('../logger');
+const symbols = require('../symbols');
+
+const DetoxConstants = require('./DetoxConstants');
+
+//#region Protected symbols
+const $cleanup = Symbol('cleanup');
+const $logFinalizer = Symbol('logFinalizer');
+const $restoreSessionState = Symbol('restoreSessionState');
+const $sessionState = Symbol('restoreSessionState');
+const $status = Symbol('status');
+const $worker = Symbol('worker');
+//#endregion
+
+class DetoxContext {
+  constructor() {
+    /** @type {DetoxInternals.DetoxStatus} */
+    this[$status] = 'inactive';
+
+    const _init = this[symbols.init].bind(this);
+    this[symbols.init] = async (opts) => {
+      this[$status] = 'init';
+      await _init(opts);
+      this[$status] = 'active';
+    };
+
+    const _cleanup = this[symbols.cleanup].bind(this);
+    this[symbols.cleanup] = async () => {
+      this[$status] = 'cleanup';
+      try {
+        await _cleanup();
+      } finally {
+        this[$status] = 'inactive';
+      }
+    };
+
+    this[symbols.getStatus] = this[symbols.getStatus].bind(this);
+    this[symbols.reportTestResults] = this[symbols.reportTestResults].bind(this);
+    this[symbols.resolveConfig] = this[symbols.resolveConfig].bind(this);
+    this[symbols.installWorker] = this[symbols.installWorker].bind(this);
+    this[symbols.uninstallWorker] = this[symbols.uninstallWorker].bind(this);
+
+    this[$sessionState] = this[$restoreSessionState]();
+
+    /**
+     * @type {DetoxLogger & Detox.Logger}
+     */
+    this[symbols.logger] = new DetoxLogger({
+      file: temporary.for.jsonl(`${this[$sessionState].id}.${process.pid}`),
+      userConfig: this[$sessionState].detoxConfig
+        ? this[$sessionState].detoxConfig.logger
+        : null,
+    });
+
+    this.log = this[symbols.logger].child({ cat: 'user' });
+    installLegacyTracerInterface(this.log, this);
+
+    this[$logFinalizer] = new DetoxLogFinalizer({
+      session: this[$sessionState]
+    });
+
+    /** @type {import('../DetoxWorker') | null} */
+    this[$worker] = null;
+  }
+
+  //#region Public members
+  device = funpermaproxy(() => this[symbols.worker].device);
+
+  element = funpermaproxy.callable(() => this[symbols.worker].element);
+
+  waitFor = funpermaproxy.callable(() => this[symbols.worker].waitFor);
+
+  expect = funpermaproxy.callable(() => this[symbols.worker].expect);
+
+  by = funpermaproxy(() => this[symbols.worker].by);
+
+  web = funpermaproxy.callable(() => this[symbols.worker].web);
+
+  get DetoxConstants() {
+    return DetoxConstants;
+  }
+
+  //#endregion
+
+  //#region Internal members
+  [symbols.onRunDescribeStart] = (...args) => this[symbols.worker].onRunDescribeStart(...args);
+  [symbols.onTestStart] = (...args) => this[symbols.worker].onTestStart(...args);
+  [symbols.onHookFailure] = (...args) => this[symbols.worker].onHookFailure(...args);
+  [symbols.onTestFnFailure] = (...args) => this[symbols.worker].onTestFnFailure(...args);
+  [symbols.onTestDone] = (...args) => this[symbols.worker].onTestDone(...args);
+  [symbols.onRunDescribeFinish] = (...args) => this[symbols.worker].onRunDescribeFinish(...args);
+  [symbols.config] = funpermaproxy(() => this[symbols.session].detoxConfig);
+  [symbols.session] = funpermaproxy(() => this[$sessionState]);
+  [symbols.tracing] = Object.freeze({
+    createEventStream: () => this[$logFinalizer].createEventStream(),
+  });
+  /** @abstract */
+  [symbols.reportTestResults](_testResults) {}
+  /**
+   * @abstract
+   * @param {Partial<DetoxInternals.DetoxInitOptions>} _opts
+   * @returns {Promise<DetoxInternals.RuntimeConfig>}
+   */
+  async [symbols.resolveConfig](_opts) { return null; }
+
+  [symbols.getStatus]() {
+    return this[$status];
+  }
+
+  get [symbols.worker]() {
+    if (!this[$worker]) {
+      throw new DetoxRuntimeError({
+        message: `Detox worker instance has not been installed in this context (${this.constructor.name}).`,
+        hint: DetoxRuntimeError.reportIssueIfJest + '\n' + 'Otherwise, make sure you call detox.installWorker() beforehand.',
+      });
+    }
+
+    return this[$worker];
+  }
+
+  /**
+   * @abstract
+   * @param {Partial<DetoxInternals.DetoxInitOptions>} [_opts]
+   * @returns {Promise<void>}
+   */
+  async [symbols.init](_opts = {}) {}
+
+  /**
+   * @param {Partial<DetoxInternals.DetoxInstallWorkerOptions>} [opts]
+   */
+  async [symbols.installWorker](opts) {
+    if (opts.global) {
+      opts.global['__detox__'] = this;
+      this.log.overrideConsole(opts.global);
+    }
+
+    const DetoxWorker = require('../DetoxWorker');
+    DetoxWorker.global = opts.global || global;
+    this[$worker] = new DetoxWorker(this);
+    this[$worker].id = opts.workerId;
+    await this[$worker].init();
+  }
+
+  async [symbols.uninstallWorker]() {
+    try {
+      if (this[$worker]) {
+        await this[$worker].cleanup();
+      }
+    } finally {
+      this[$worker] = null;
+    }
+  }
+
+  /**
+   * @abstract
+   */
+  async [symbols.cleanup]() {}
+  //#endregion
+
+  //#region Protected members
+  /**
+   * @abstract
+   * @protected
+   */
+  [$restoreSessionState]() {
+    return null;
+  }
+  //#endregion
+}
+
+module.exports = DetoxContext;
+module.exports.protected = {
+  $cleanup,
+  $logFinalizer,
+  $restoreSessionState,
+  $status,
+  $sessionState,
+  $worker,
+};

package/src/realms/DetoxInternalsFacade.js

@@ -0,0 +1,31 @@
+const funpermaproxy = require('funpermaproxy');
+
+const symbols = require('../symbols');
+
+class DetoxInternalsFacade {
+  /**
+   * @param context
+   */
+  constructor(context) {
+    this.config = context[symbols.config];
+    this.getStatus = context[symbols.getStatus];
+    this.init = context[symbols.init];
+    this.cleanup = context[symbols.cleanup];
+    this.log = context[symbols.logger];
+    this.installWorker = context[symbols.installWorker];
+    this.uninstallWorker = context[symbols.uninstallWorker];
+    this.onHookFailure = context[symbols.onHookFailure];
+    this.onRunDescribeFinish = context[symbols.onRunDescribeFinish];
+    this.onRunDescribeStart = context[symbols.onRunDescribeStart];
+    this.onTestDone = context[symbols.onTestDone];
+    this.onTestFnFailure = context[symbols.onTestFnFailure];
+    this.onTestStart = context[symbols.onTestStart];
+    this.reportTestResults = context[symbols.reportTestResults];
+    this.resolveConfig = context[symbols.resolveConfig];
+    this.session = context[symbols.session];
+    this.tracing = context[symbols.tracing];
+    this.worker = funpermaproxy(() => context[symbols.worker]);
+  }
+}
+
+module.exports = DetoxInternalsFacade;