detox 21.0.0-breaking.new-global-lifecycle.0 → 21.0.1-rc.0

package/src/logger/utils/streams/transformers.js

@@ -0,0 +1,39 @@
+const { PassThrough, Transform } = require('stream');
+
+function through() {
+  return new PassThrough({ objectMode: true });
+}
+
+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 results = fn(chunk, index++);
+      // eslint-disable-next-line unicorn/no-array-method-this-argument
+      results.forEach(pushThis, this);
+      callback();
+    },
+  });
+}
+
+function pushThis(x) {
+  return this.push(x);
+}
+
+module.exports = {
+  through,
+  mapTransform,
+  flatMapTransform,
+};

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

@@ -1,48 +1,71 @@
 const funpermaproxy = require('funpermaproxy');
 
+const temporary = require('../artifacts/utils/temporaryPath');
 const { DetoxRuntimeError } = require('../errors');
-const DetoxLogger = require('../logger/DetoxLogger');
-const DetoxTracer = require('../logger/DetoxTracer');
-const symbols = require('../symbols');
+const { DetoxLogger, DetoxLogFinalizer, installLegacyTracerInterface } = require('../logger');
 
 const DetoxConstants = require('./DetoxConstants');
+const symbols = require('./symbols');
 
+//#region Protected symbols
 const $cleanup = Symbol('cleanup');
-const $logger = Symbol('logger');
+const $logFinalizer = Symbol('logFinalizer');
 const $restoreSessionState = Symbol('restoreSessionState');
 const $sessionState = Symbol('restoreSessionState');
-const $tracer = Symbol('tracer');
-
-const _worker = Symbol('worker');
+const $status = Symbol('status');
+const $worker = Symbol('worker');
+//#endregion
 
 class DetoxContext {
   constructor() {
-    this[symbols.globalSetup] = this[symbols.globalSetup].bind(this);
-    this[symbols.globalTeardown] = this[symbols.globalTeardown].bind(this);
-    this[symbols.reportFailedTests] = this[symbols.reportFailedTests].bind(this);
+    /** @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.setup] = this[symbols.setup].bind(this);
-    this[symbols.teardown] = this[symbols.teardown].bind(this);
+    this[symbols.installWorker] = this[symbols.installWorker].bind(this);
+    this[symbols.uninstallWorker] = this[symbols.uninstallWorker].bind(this);
 
     this[$sessionState] = this[$restoreSessionState]();
 
-    const loggerConfig = this[$sessionState].detoxConfig
-      ? this[$sessionState].detoxConfig.loggerConfig
-      : undefined;
-
     /**
-     * @protected
      * @type {DetoxLogger & Detox.Logger}
      */
-    this[$logger] = new DetoxLogger(loggerConfig);
-    /** @protected */
-    this[$tracer] = DetoxTracer.default({
-      logger: this[$logger],
+    this[symbols.logger] = new DetoxLogger({
+      file: temporary.for.jsonl(`${this[$sessionState].id}.${process.pid}`),
+      userConfig: this[$sessionState].detoxConfig
+        ? this[$sessionState].detoxConfig.logger
+        : null,
     });
-    /** @deprecated */
-    this.traceCall = this[$tracer].bind(this[$tracer]);
+
+    this.log = this[symbols.logger].child({ cat: 'user' });
+    installLegacyTracerInterface(this.log, this);
+
+    this[$logFinalizer] = new DetoxLogFinalizer({
+      session: this[$sessionState],
+      logger: this[symbols.logger],
+    });
+
     /** @type {import('../DetoxWorker') | null} */
-    this[_worker] = null;
+    this[$worker] = null;
   }
 
   //#region Public members
@@ -62,91 +85,84 @@ class DetoxContext {
     return DetoxConstants;
   }
 
-  /**
-   * @returns {Detox.Logger}
-   */
-  get log() {
-    return this[$logger];
-  }
-
-  /**
-   * @returns {Detox.Tracer}
-   */
-  get trace() {
-    return this[$tracer];
-  }
   //#endregion
 
   //#region Internal members
-  [symbols.onRunStart] = (...args) => this[symbols.worker].onRunStart(...args);
   [symbols.onRunDescribeStart] = (...args) => this[symbols.worker].onRunDescribeStart(...args);
   [symbols.onTestStart] = (...args) => this[symbols.worker].onTestStart(...args);
-  [symbols.onHookStart] = (...args) => this[symbols.worker].onHookStart(...args);
   [symbols.onHookFailure] = (...args) => this[symbols.worker].onHookFailure(...args);
-  [symbols.onHookSuccess] = (...args) => this[symbols.worker].onHookSuccess(...args);
-  [symbols.onTestFnStart] = (...args) => this[symbols.worker].onTestFnStart(...args);
   [symbols.onTestFnFailure] = (...args) => this[symbols.worker].onTestFnFailure(...args);
-  [symbols.onTestFnSuccess] = (...args) => this[symbols.worker].onTestFnSuccess(...args);
   [symbols.onTestDone] = (...args) => this[symbols.worker].onTestDone(...args);
   [symbols.onRunDescribeFinish] = (...args) => this[symbols.worker].onRunDescribeFinish(...args);
-  [symbols.onRunFinish] = (...args) => this[symbols.worker].onRunFinish(...args);
   [symbols.config] = funpermaproxy(() => this[symbols.session].detoxConfig);
   [symbols.session] = funpermaproxy(() => this[$sessionState]);
+  [symbols.tracing] = Object.freeze({
+    createEventStream: () => this[$logFinalizer].createEventStream(),
+  });
   /** @abstract */
-  [symbols.reportFailedTests](_testFilePaths) {}
+  [symbols.reportTestResults](_testResults) {}
   /**
    * @abstract
-   * @param {Partial<DetoxInternals.DetoxGlobalSetupOptions>} _opts
+   * @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]) {
+    if (!this[$worker]) {
       throw new DetoxRuntimeError({
-        message: `Detox worker instance has not been initialized in this context (${this.constructor.name}).`,
-        hint: DetoxRuntimeError.reportIssueIfJest + '\n' + 'Otherwise, make sure you call detox.setup() beforehand.',
+        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];
+    return this[$worker];
   }
 
   /**
    * @abstract
-   * @param {Partial<DetoxInternals.DetoxGlobalSetupOptions>} [_opts]
+   * @param {Partial<DetoxInternals.DetoxInitOptions>} [_opts]
    * @returns {Promise<void>}
    */
-  async [symbols.globalSetup](_opts = {}) {}
+  async [symbols.init](_opts = {}) {}
 
   /**
-   * @param {Partial<DetoxInternals.DetoxConfigurationSetupOptions>} [opts]
+   * @param {Partial<DetoxInternals.DetoxInstallWorkerOptions>} [opts]
    */
-  async [symbols.setup](opts) {
-    const theGlobal = opts.global || global;
-    theGlobal['__detox__'] = this;
-    this[$logger].overrideConsole(theGlobal);
+  async [symbols.installWorker](opts) {
+    if (opts.global) {
+      opts.global['__detox__'] = {
+        clientApi: require('../../index'),
+        internalsApi: require('../../internals'),
+      };
+      this.log.overrideConsole(opts.global);
+    }
 
     const DetoxWorker = require('../DetoxWorker');
-    DetoxWorker.global = theGlobal;
-    this[_worker] = new DetoxWorker(this);
-    await this[_worker].init();
+    DetoxWorker.global = opts.global || global;
+    this[$worker] = new DetoxWorker(this);
+    this[$worker].id = opts.workerId;
+    await this[$worker].init();
   }
 
-  async [symbols.teardown]() {
+  async [symbols.uninstallWorker]() {
     try {
-      if (this[_worker]) {
-        await this[_worker].cleanup();
+      if (this[$worker]) {
+        await this[$worker].cleanup();
       }
     } finally {
-      this[_worker] = null;
+      this[$worker] = null;
     }
   }
 
   /**
    * @abstract
    */
-  async [symbols.globalTeardown]() {}
+  async [symbols.cleanup]() {}
   //#endregion
 
   //#region Protected members
@@ -163,8 +179,9 @@ class DetoxContext {
 module.exports = DetoxContext;
 module.exports.protected = {
   $cleanup,
-  $logger,
+  $logFinalizer,
   $restoreSessionState,
+  $status,
   $sessionState,
-  $tracer,
+  $worker,
 };

package/src/realms/DetoxInternalsFacade.js

@@ -1,6 +1,6 @@
 const funpermaproxy = require('funpermaproxy');
 
-const symbols = require('../symbols');
+const symbols = require('./symbols');
 
 class DetoxInternalsFacade {
   /**
@@ -8,26 +8,22 @@ class DetoxInternalsFacade {
    */
   constructor(context) {
     this.config = context[symbols.config];
-    this.globalSetup = context[symbols.globalSetup];
-    this.globalTeardown = context[symbols.globalTeardown];
-    this.log = context.log;
-    this.setup = context[symbols.setup];
-    this.teardown = context[symbols.teardown];
+    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.onHookStart = context[symbols.onHookStart];
-    this.onHookSuccess = context[symbols.onHookSuccess];
     this.onRunDescribeFinish = context[symbols.onRunDescribeFinish];
     this.onRunDescribeStart = context[symbols.onRunDescribeStart];
-    this.onRunFinish = context[symbols.onRunFinish];
-    this.onRunStart = context[symbols.onRunStart];
     this.onTestDone = context[symbols.onTestDone];
     this.onTestFnFailure = context[symbols.onTestFnFailure];
-    this.onTestFnStart = context[symbols.onTestFnStart];
-    this.onTestFnSuccess = context[symbols.onTestFnSuccess];
     this.onTestStart = context[symbols.onTestStart];
-    this.reportFailedTests = context[symbols.reportFailedTests];
+    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]);
   }
 }

package/src/realms/DetoxPrimaryContext.js

@@ -1,24 +1,31 @@
-const path = require('path');
 const { URL } = require('url');
 
 const fs = require('fs-extra');
-const pipe = require('multipipe');
+const onSignalExit = require('signal-exit');
 
 const temporary = require('../artifacts/utils/temporaryPath');
 const { DetoxRuntimeError } = require('../errors');
-const { PrimarySessionState } = require('../ipc/state');
-const symbols = require('../symbols');
+const SessionState = require('../ipc/SessionState');
+const { getCurrentCommand } = require('../utils/argparse');
+const uuid = require('../utils/uuid');
 
 const DetoxContext = require('./DetoxContext');
+const symbols = require('./symbols');
 
-const { $logger, $restoreSessionState, $sessionState } = DetoxContext.protected;
+// Protected symbols
+const { $logFinalizer, $restoreSessionState, $sessionState, $worker } = DetoxContext.protected;
 
-const _finalizeLogs = Symbol('finalizeLogs');
+//#region Private symbols
 const _globalLifecycleHandler = Symbol('globalLifecycleHandler');
 const _ipcServer = Symbol('ipcServer');
 const _resetLockFile = Symbol('resetLockFile');
 const _wss = Symbol('wss');
 const _dirty = Symbol('dirty');
+const _emergencyTeardown = Symbol('emergencyTeardown');
+const _lifecycleLogger = Symbol('lifecycleLogger');
+const _sessionFile = Symbol('sessionFile');
+const _logFinalError = Symbol('logFinalError');
+//#endregion
 
 class DetoxPrimaryContext extends DetoxContext {
   constructor() {
@@ -27,21 +34,26 @@ class DetoxPrimaryContext extends DetoxContext {
     this[_dirty] = false;
     this[_wss] = null;
     this[_globalLifecycleHandler] = null;
+    /** Path to file where the initial session object is serialized */
+    this[_sessionFile] = '';
     /**
      * @type {import('../ipc/IPCServer') | null}
      */
     this[_ipcServer] = null;
+    /** @type {Detox.Logger} */
+    this[_lifecycleLogger] = this[symbols.logger].child({ cat: 'lifecycle' });
   }
 
   //#region Internal members
-  async [symbols.reportFailedTests](testFilePaths) {
+  async [symbols.reportTestResults](testResults) {
     if (this[_ipcServer]) {
-      this[_ipcServer].onFailedTests({ testFilePaths });
+      this[_ipcServer].onReportTestResults({ testResults });
     }
   }
 
-  async [symbols.resolveConfig](opts = {}) {
-    const session = this[symbols.session];
+  async [symbols.resolveConfig](opts = { argv: { configuration: process.env.DETOX_DBG_SELECTED_CFG } })
+  {
+    const session = this[$sessionState];
     if (!session.detoxConfig) {
       const configuration = require('../configuration');
       session.detoxConfig = await configuration.composeDetoxConfig(opts);
@@ -52,9 +64,9 @@ class DetoxPrimaryContext extends DetoxContext {
 
   /**
    * @override
-   * @param {Partial<DetoxInternals.DetoxGlobalSetupOptions>} [opts]
+   * @param {Partial<DetoxInternals.DetoxInitOptions>} [opts]
    */
-  async [symbols.globalSetup](opts) {
+  async [symbols.init](opts = {}) {
     if (this[_dirty]) {
       throw new DetoxRuntimeError({
         message: 'Cannot initialize primary Detox context more than once.',
@@ -63,21 +75,28 @@ class DetoxPrimaryContext extends DetoxContext {
     }
 
     this[_dirty] = true;
+    onSignalExit(this[_emergencyTeardown]);
+
     const detoxConfig = await this[symbols.resolveConfig](opts);
 
-    const { behaviorConfig, deviceConfig, loggerConfig, sessionConfig } = detoxConfig;
-    await this[$logger].setConfig(loggerConfig);
+    const {
+      behavior: behaviorConfig,
+      device: deviceConfig,
+      logger: loggerConfig,
+      session: sessionConfig
+    } = detoxConfig;
+    await this[symbols.logger].setConfig(loggerConfig);
 
-    this.trace.begin({
-      cat: 'lifecycle',
-      args: this[$sessionState],
-      name: process.argv.slice(1).join(' '),
-    });
+    this[_lifecycleLogger].trace.begin({
+      cwd: process.cwd(),
+      data: this[$sessionState],
+    }, getCurrentCommand());
 
+    // TODO: IPC Server creation ought to be delegated to a generator/factory.
     const IPCServer = require('../ipc/IPCServer');
     this[_ipcServer] = new IPCServer({
       sessionState: this[$sessionState],
-      logger: this[$logger],
+      logger: this[symbols.logger],
     });
 
     await this[_ipcServer].init();
@@ -93,6 +112,7 @@ class DetoxPrimaryContext extends DetoxContext {
       await this[_resetLockFile]();
     }
 
+    // TODO: Detox-server creation ought to be delegated to a generator/factory.
     const DetoxServer = require('../server/DetoxServer');
     if (sessionConfig.autoStart) {
       this[_wss] = new DetoxServer({
@@ -105,106 +125,129 @@ class DetoxPrimaryContext extends DetoxContext {
       await this[_wss].open();
     }
 
+    // TODO: double check that this config is indeed propogated onto the client create at the detox-worker side
     if (!sessionConfig.server && this[_wss]) {
+      // @ts-ignore
       sessionConfig.server = `ws://localhost:${this[_wss].port}`;
     }
 
-    await fs.writeFile(this[$sessionState].detoxConfigSnapshotPath, this[$sessionState].stringify());
-    process.env.DETOX_CONFIG_SNAPSHOT_PATH = this[$sessionState].detoxConfigSnapshotPath;
+    this[_sessionFile] = temporary.for.json(this[$sessionState].id);
+    await fs.writeFile(this[_sessionFile], this[$sessionState].stringify());
+    process.env.DETOX_CONFIG_SNAPSHOT_PATH = this[_sessionFile];
+    this[_lifecycleLogger].trace(`Serialized the session state at: ${this[_sessionFile]}`);
 
-    // TODO: think about signal-exit and cleaning up the logs
+    if (opts.workerId !== null) {
+      await this[symbols.installWorker](opts);
+    }
   }
 
   /**
    * @override
-   * @param {Partial<DetoxInternals.DetoxConfigurationSetupOptions>} [opts]
+   * @param {Partial<DetoxInternals.DetoxInstallWorkerOptions>} [opts]
    */
-  async [symbols.setup](opts) {
-    const workerId = opts.workerId || 1;
+  async [symbols.installWorker](opts = {}) {
+    const workerId = opts.workerId || 'worker';
+
     this[$sessionState].workerId = workerId;
     this[_ipcServer].onRegisterWorker({ workerId });
-    await super[symbols.setup](opts);
+
+    await super[symbols.installWorker]({ ...opts, workerId });
   }
 
   /** @override */
-  async [symbols.globalTeardown]() {
+  async [symbols.cleanup]() {
+    try {
+      if (this[$worker]) {
+        await this[symbols.uninstallWorker]();
+      }
+    } finally {
+      if (this[_globalLifecycleHandler]) {
+        await this[_globalLifecycleHandler].globalCleanup();
+        this[_globalLifecycleHandler] = null;
+      }
+
+      if (this[_wss]) {
+        await this[_wss].close();
+        this[_wss] = null;
+      }
+
+      if (this[_ipcServer]) {
+        await this[_ipcServer].dispose();
+        this[_ipcServer] = null;
+      }
+
+      if (this[_sessionFile]) {
+        await fs.remove(this[_sessionFile]);
+      }
+
+      if (this[_dirty]) {
+        try {
+          this[_lifecycleLogger].trace.end();
+          await this[symbols.logger].close();
+          await this[$logFinalizer].finalize();
+        } catch (err) {
+          this[_logFinalError](err);
+        }
+      }
+    }
+  }
+
+  [_emergencyTeardown] = (_code, signal) => {
+    if (!signal) {
+      return;
+    }
+
     if (this[_globalLifecycleHandler]) {
-      await this[_globalLifecycleHandler].globalCleanup();
+      this[_globalLifecycleHandler].emergencyCleanup();
       this[_globalLifecycleHandler] = null;
     }
 
     if (this[_wss]) {
-      await this[_wss].close();
-      this[_wss] = null;
+      this[_wss].close();
     }
 
     if (this[_ipcServer]) {
-      await this[_ipcServer].dispose();
-      this[_ipcServer] = null;
+      this[_ipcServer].dispose();
     }
 
-    await fs.remove(this[$sessionState].detoxConfigSnapshotPath);
-    delete process.env.DETOX_CONFIG_SNAPSHOT_PATH;
+    if (this[_sessionFile]) {
+      fs.removeSync(this[_sessionFile]);
+    }
 
     try {
-      this.trace.end({ cat: 'lifecycle' });
-      await this[_finalizeLogs]();
+      this[_lifecycleLogger].trace.end({ abortSignal: signal });
+      this[symbols.logger].close().catch(this[_logFinalError]);
+      this[$logFinalizer].finalizeSync();
     } catch (err) {
-      this[$logger].error({ err }, 'Encountered an error while merging the process logs:');
+      this[_logFinalError](err);
     }
-  }
+  };
+
+  [_logFinalError] = (err) => {
+    this[_lifecycleLogger].error(err, 'Encountered an error while merging the process logs:');
+  };
+
   //#endregion
 
   //#region Protected members
   /**
    * @protected
    * @override
-   * @return {PrimarySessionState}
+   * @return {SessionState}
    */
   [$restoreSessionState]() {
-    return new PrimarySessionState({
-      detoxConfigSnapshotPath: temporary.for.json(),
+    return new SessionState({
+      id: uuid.UUID(),
       detoxIPCServer: `primary-${process.pid}`,
     });
   }
   //#endregion
 
   //#region Private members
-  async[_finalizeLogs]() {
-    const logs = [this[$logger].file, ...this[$sessionState].logFiles].filter(f => f && fs.existsSync(f));
-    if (logs.length === 0) {
-      return;
-    }
-
-    const streamUtils = require('../utils/streamUtils');
-    const { rootDir, plugins } = this[symbols.config].artifactsConfig || {};
-    const logConfig = plugins && plugins.log || 'none';
-    const enabled = rootDir && (typeof logConfig === 'string' ? logConfig !== 'none' : logConfig.enabled);
-
-    if (enabled) {
-      await fs.mkdirp(rootDir);
-      const [out1Stream, out2Stream, out3Stream] = ['detox.log.jsonl', 'detox.log', 'detox.trace.json']
-        .map((filename) => fs.createWriteStream(path.join(rootDir, filename)));
-
-      const mergedStream = streamUtils
-        .mergeSortedJSONL(
-          logs.map(filePath => fs.createReadStream(filePath).pipe(streamUtils.readJSONL()))
-        );
-
-      await Promise.all([
-        pipe(mergedStream, streamUtils.writeJSONL(), out1Stream),
-        pipe(mergedStream, streamUtils.debugStream(this[$logger].config.options), out2Stream),
-        pipe(mergedStream, streamUtils.chromeTraceStream(), streamUtils.writeJSON(), out3Stream),
-      ]);
-    }
-
-    await Promise.all(logs.map(filepath => fs.remove(filepath)));
-  }
-
   async[_resetLockFile]() {
     const DeviceRegistry = require('../devices/DeviceRegistry');
 
-    const deviceType = this[symbols.config].deviceConfig.type;
+    const deviceType = this[symbols.config].device.type;
 
     switch (deviceType) {
       case 'ios.none':