detox 19.13.0 → 20.0.0

package/src/realms/DetoxPrimaryContext.js

@@ -0,0 +1,261 @@
+const { URL } = require('url');
+
+const fs = require('fs-extra');
+const onSignalExit = require('signal-exit');
+
+const temporary = require('../artifacts/utils/temporaryPath');
+const { DetoxRuntimeError } = require('../errors');
+const SessionState = require('../ipc/SessionState');
+const symbols = require('../symbols');
+const { getCurrentCommand } = require('../utils/argparse');
+const uuid = require('../utils/uuid');
+
+const DetoxContext = require('./DetoxContext');
+
+// Protected symbols
+const { $logFinalizer, $restoreSessionState, $sessionState, $worker } = DetoxContext.protected;
+
+//#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');
+//#endregion
+
+class DetoxPrimaryContext extends DetoxContext {
+  constructor() {
+    super();
+
+    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.reportTestResults](testResults) {
+    if (this[_ipcServer]) {
+      this[_ipcServer].onReportTestResults({ testResults });
+    }
+  }
+
+  async [symbols.resolveConfig](opts = {}) {
+    const session = this[$sessionState];
+    if (!session.detoxConfig) {
+      const configuration = require('../configuration');
+      session.detoxConfig = await configuration.composeDetoxConfig(opts);
+    }
+
+    return session.detoxConfig;
+  }
+
+  /**
+   * @override
+   * @param {Partial<DetoxInternals.DetoxInitOptions>} [opts]
+   */
+  async [symbols.init](opts = {}) {
+    if (this[_dirty]) {
+      throw new DetoxRuntimeError({
+        message: 'Cannot initialize primary Detox context more than once.',
+        hint: DetoxRuntimeError.reportIssueIfJest,
+      });
+    }
+
+    this[_dirty] = true;
+    onSignalExit(this[_emergencyTeardown]);
+
+    const detoxConfig = await this[symbols.resolveConfig](opts);
+
+    const {
+      behavior: behaviorConfig,
+      device: deviceConfig,
+      logger: loggerConfig,
+      session: sessionConfig
+    } = detoxConfig;
+    await this[symbols.logger].setConfig(loggerConfig);
+
+    this[_lifecycleLogger].trace.begin({
+      cwd: process.cwd(),
+      data: this[$sessionState],
+    }, getCurrentCommand());
+
+    const IPCServer = require('../ipc/IPCServer');
+    this[_ipcServer] = new IPCServer({
+      sessionState: this[$sessionState],
+      logger: this[symbols.logger],
+    });
+
+    await this[_ipcServer].init();
+
+    const environmentFactory = require('../environmentFactory');
+    this[_globalLifecycleHandler] = await environmentFactory.createGlobalLifecycleHandler(deviceConfig);
+
+    if (this[_globalLifecycleHandler]) {
+      await this[_globalLifecycleHandler].globalInit();
+    }
+
+    if (!behaviorConfig.init.keepLockFile) {
+      await this[_resetLockFile]();
+    }
+
+    const DetoxServer = require('../server/DetoxServer');
+    if (sessionConfig.autoStart) {
+      this[_wss] = new DetoxServer({
+        port: sessionConfig.server
+          ? new URL(sessionConfig.server).port
+          : 0,
+        standalone: false,
+      });
+
+      await this[_wss].open();
+    }
+
+    if (!sessionConfig.server && this[_wss]) {
+      // @ts-ignore
+      sessionConfig.server = `ws://localhost:${this[_wss].port}`;
+    }
+
+    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]}`);
+
+    if (opts.workerId !== null) {
+      await this[symbols.installWorker](opts);
+    }
+  }
+
+  /**
+   * @override
+   * @param {Partial<DetoxInternals.DetoxInstallWorkerOptions>} [opts]
+   */
+  async [symbols.installWorker](opts = {}) {
+    const workerId = opts.workerId || 'worker';
+
+    this[$sessionState].workerId = workerId;
+    this[_ipcServer].onRegisterWorker({ workerId });
+
+    await super[symbols.installWorker]({ ...opts, workerId });
+  }
+
+  /** @override */
+  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[$logFinalizer].finalize();
+        } catch (err) {
+          this[_lifecycleLogger].error({ err }, 'Encountered an error while merging the process logs:');
+        }
+      }
+    }
+  }
+
+  [_emergencyTeardown] = (_code, signal) => {
+    if (!signal) {
+      return;
+    }
+
+    if (this[_globalLifecycleHandler]) {
+      this[_globalLifecycleHandler].emergencyCleanup();
+      this[_globalLifecycleHandler] = null;
+    }
+
+    if (this[_wss]) {
+      this[_wss].close();
+    }
+
+    if (this[_ipcServer]) {
+      this[_ipcServer].dispose();
+    }
+
+    if (this[_sessionFile]) {
+      fs.removeSync(this[_sessionFile]);
+    }
+
+    try {
+      this[_lifecycleLogger].trace.end({ abortSignal: signal });
+      this[$logFinalizer].finalizeSync();
+    } catch (err) {
+      this[symbols.logger].error({ err }, 'Encountered an error while merging the process logs:');
+    }
+  };
+
+  //#endregion
+
+  //#region Protected members
+  /**
+   * @protected
+   * @override
+   * @return {SessionState}
+   */
+  [$restoreSessionState]() {
+    return new SessionState({
+      id: uuid.UUID(),
+      detoxIPCServer: `primary-${process.pid}`,
+    });
+  }
+  //#endregion
+
+  //#region Private members
+  async[_resetLockFile]() {
+    const DeviceRegistry = require('../devices/DeviceRegistry');
+
+    const deviceType = this[symbols.config].device.type;
+
+    switch (deviceType) {
+      case 'ios.none':
+      case 'ios.simulator':
+        await DeviceRegistry.forIOS().reset();
+        break;
+      case 'android.attached':
+      case 'android.emulator':
+      case 'android.genycloud':
+        await DeviceRegistry.forAndroid().reset();
+        break;
+    }
+
+    if (deviceType === 'android.genycloud') {
+      const GenyDeviceRegistryFactory = require('../devices/allocation/drivers/android/genycloud/GenyDeviceRegistryFactory');
+      await GenyDeviceRegistryFactory.forGlobalShutdown().reset();
+    }
+  }
+  //#endregion
+}
+
+module.exports = DetoxPrimaryContext;

package/src/realms/DetoxSecondaryContext.js

@@ -0,0 +1,91 @@
+const fs = require('fs');
+
+const { DetoxInternalError } = require('../errors');
+const SessionState = require('../ipc/SessionState');
+const symbols = require('../symbols');
+
+const DetoxContext = require('./DetoxContext');
+
+// Protected symbols
+const { $restoreSessionState, $sessionState, $worker } = DetoxContext.protected;
+
+//#region Private symbols
+const _ipcClient = Symbol('ipcClient');
+//#endregion
+
+class DetoxSecondaryContext extends DetoxContext {
+  constructor() {
+    super();
+
+    /**
+     * @private
+     * @type {import('../ipc/IPCClient')}
+     */
+    this[_ipcClient] = null;
+  }
+
+  //#region Internal members
+  async [symbols.reportTestResults](testResults) {
+    if (this[_ipcClient]) {
+      await this[_ipcClient].reportTestResults(testResults);
+    } else {
+      throw new DetoxInternalError('Detected an attempt to report failed tests using a non-initialized context.');
+    }
+  }
+
+  async [symbols.resolveConfig]() {
+    return this[symbols.config];
+  }
+
+  /** @override */
+  async [symbols.init](opts = {}) {
+    const IPCClient = require('../ipc/IPCClient');
+
+    this[_ipcClient] = new IPCClient({
+      id: `secondary-${process.pid}`,
+      state: this[$sessionState],
+      logger: this[symbols.logger],
+    });
+
+    await this[_ipcClient].init();
+
+    if (opts.workerId !== null) {
+      await this[symbols.installWorker](opts);
+    }
+  }
+
+  /** @override */
+  async [symbols.cleanup]() {
+    try {
+      if (this[$worker]) {
+        await this[symbols.uninstallWorker]();
+      }
+    } finally {
+      if (this[_ipcClient]) {
+        await this[_ipcClient].dispose();
+        this[_ipcClient] = null;
+      }
+    }
+  }
+
+  /** @override */
+  async [symbols.installWorker](opts = {}) {
+    const workerId = opts.workerId || 'worker';
+    await this[_ipcClient].registerWorker(workerId);
+    await super[symbols.installWorker]({ ...opts, workerId });
+  }
+  //#endregion
+
+  //#region Protected members
+  /**
+   * @protected
+   * @override
+   * @return {SessionState}
+   */
+  [$restoreSessionState]() {
+    return SessionState.parse(fs.readFileSync(process.env.DETOX_CONFIG_SNAPSHOT_PATH));
+  }
+  //#endregion
+}
+
+module.exports = DetoxSecondaryContext;

package/src/realms/index.js

@@ -0,0 +1,10 @@
+function current() {
+  if (process.env.DETOX_CONFIG_SNAPSHOT_PATH) {
+    return require('./secondary');
+  } else {
+    return require('./primary');
+  }
+}
+
+/** @type {DetoxInternals.Facade} */
+module.exports = global['__detox__'] || current();

package/src/realms/primary.js

@@ -0,0 +1,3 @@
+const DetoxPrimaryContext = require('./DetoxPrimaryContext');
+
+module.exports = new DetoxPrimaryContext();

package/src/realms/secondary.js

@@ -0,0 +1,3 @@
+const DetoxSecondaryContext = require('./DetoxSecondaryContext');
+
+module.exports = new DetoxSecondaryContext();

package/src/server/DetoxConnection.js

@@ -1,43 +1,37 @@
-// @ts-nocheck
 const _ = require('lodash');
-const { WebSocket } = require('ws'); // eslint-disable-line @typescript-eslint/no-unused-vars, no-unused-vars
 
 const DetoxRuntimeError = require('../errors/DetoxRuntimeError');
-const logger = require('../utils/logger').child({ __filename });
+const logger = require('../utils/logger').child({ cat: 'ws-server,ws' });
 
 const AnonymousConnectionHandler = require('./handlers/AnonymousConnectionHandler');
 
-const EVENTS = {
-  NEW: { event: 'WSS_CONNECTION' },
-  GET: { event: 'WSS_GET_FROM' },
-  SEND: { event: 'WSS_SEND_TO' },
-  ERROR: { event: 'ERROR' },
-  SOCKET_ERROR: { event: 'WSS_SOCKET_ERROR' },
-};
-
 class DetoxConnection {
   /**
-   * @param {DetoxSessionManager} sessionManager
-   * @param {WebSocket} webSocket
-   * @param {Socket} socket
+   * @param {{
+   *   sessionManager: import('./DetoxSessionManager');
+   *   webSocket: import('ws');
+   *   socket: import('net').Socket;
+   * }} config
    */
   constructor({ sessionManager, webSocket, socket }) {
     this._onMessage = this._onMessage.bind(this);
     this._onError = this._onError.bind(this);
     this._onClose = this._onClose.bind(this);
 
-    this._log = logger.child({ trackingId: socket.remotePort });
+    this._log = logger.child({ id: socket.remotePort });
+    this._log.debug.begin(`connection :${socket.localPort}<->:${socket.remotePort}`);
+
     this._sessionManager = sessionManager;
     this._webSocket = webSocket;
     this._webSocket.on('message', this._onMessage);
     this._webSocket.on('error', this._onError);
     this._webSocket.on('close', this._onClose);
-    this._log.debug(EVENTS.NEW, 'registered a new connection.');
 
-    const log = this._log;
+    // eslint-disable-next-line unicorn/no-this-assignment
+    const self = this;
     this._handler = new AnonymousConnectionHandler({
       api: {
-        get log() { return log; },
+        get log() { return self._log; },
         appendLogDetails: (details) => { this._log = this._log.child(details); },
 
         registerSession: (params) => this._sessionManager.registerSession(this, params),
@@ -49,13 +43,13 @@ class DetoxConnection {
 
   sendAction(action) {
     const messageAsString = JSON.stringify(action);
-    this._log.trace(EVENTS.SEND, messageAsString);
+    this._log.trace({ data: action }, 'send');
     this._webSocket.send(messageAsString + '\n ');
   }
 
   _onMessage(rawData) {
     const data = _.isString(rawData) ? rawData : rawData.toString('utf8');
-    this._log.trace(EVENTS.GET, data);
+    this._log.trace({ data }, 'get');
 
     try {
       let action;
@@ -84,16 +78,17 @@ class DetoxConnection {
         this._handler.onError(handlerError, action);
       }
     } catch (error) {
-      this._log.warn({ ...EVENTS.ERROR }, error instanceof DetoxRuntimeError ? error.message : `${error}`);
+      this._log.warn({ error }, 'Caught unhandled error:');
     }
   }
 
-  _onError(e) {
-    this._log.warn(EVENTS.SOCKET_ERROR, DetoxRuntimeError.format(e));
+  _onError(error) {
+    this._log.warn({ error }, 'Caught socket error:');
   }
 
   _onClose() {
     this._sessionManager.unregisterConnection(this._webSocket);
+    this._log.debug.end();
   }
 }
 

package/src/server/DetoxServer.js

@@ -4,7 +4,7 @@ const WebSocket = require('ws');
 
 const { DetoxInternalError, DetoxRuntimeError } = require('../errors');
 const Deferred = require('../utils/Deferred');
-const log = require('../utils/logger').child({ __filename });
+const log = require('../utils/logger').child({ cat: 'ws-server,ws' });
 
 const DetoxSessionManager = require('./DetoxSessionManager');
 
@@ -40,18 +40,16 @@ class DetoxServer {
     await this._startListening();
 
     const level = this._options.standalone ? 'info' : 'debug';
-    log[level]({ event: 'WSS_CREATE' }, `Detox server listening on localhost:${this.port}...`);
+    log[level](`Detox server listening on localhost:${this.port}...`);
   }
 
   async close() {
     try {
       await this._closeWithTimeout(10000);
-      log.debug({ event: 'WSS_CLOSE' }, 'Detox server has been closed gracefully');
-    } catch (e) {
-      log.warn({ event: 'ERROR' },
-        `Detox server has been closed abruptly! See the error details below:\n`
-        + DetoxRuntimeError.format(e) + '\n'
-        + DetoxRuntimeError.reportIssue
+      log.debug('Detox server has been closed gracefully');
+    } catch (err) {
+      log.warn({ err },
+        `Detox server has been closed abruptly! See the error details below:`
       );
     }
   }
@@ -90,8 +88,7 @@ class DetoxServer {
     } else if (this._closing) {
       this._closing.reject(err);
     } else {
-      const formattedError = DetoxRuntimeError.format(err);
-      log.error('Detox server has got an unhandled error:\n' + formattedError);
+      log.error({ err }, 'Detox server has got an unhandled error:');
     }
   }
 

package/src/server/DetoxSession.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 const DetoxInternalError = require('../errors/DetoxInternalError');
-const log = require('../utils/logger').child({ __filename });
+const log = require('../utils/logger').child({ cat: 'ws-server,ws-session' });
 
 class DetoxSession {
   /**
@@ -17,7 +17,7 @@ class DetoxSession {
     /** @type {boolean | null} */
     this._pendingTesterStatus = null;
 
-    log.trace({ event: 'SESSION_CREATED' }, `created session ${id}`);
+    log.trace(`created session ${id}`);
   }
 
   get id() {
@@ -120,7 +120,7 @@ class DetoxSession {
   }
 
   _notifyAboutAppConnect() {
-    log.trace({ event: 'SESSION_JOINED' }, `app joined session ${this.id}`);
+    log.trace(`app joined session ${this.id}`);
 
     if (!this._tester) {
       return;
@@ -132,7 +132,7 @@ class DetoxSession {
   }
 
   _notifyAboutAppDisconnect() {
-    log.trace({ event: 'SESSION_TORN' }, `app exited session ${this.id}`);
+    log.trace(`app exited session ${this.id}`);
 
     if (!this._tester) {
       return;
@@ -144,11 +144,11 @@ class DetoxSession {
   }
 
   _notifyAboutTesterConnect() {
-    log.trace({ event: 'SESSION_JOINED' }, `tester joined session ${this.id}`);
+    log.trace(`tester joined session ${this.id}`);
   }
 
   _notifyAboutTesterDisconnect() {
-    log.trace({ event: 'SESSION_TORN' }, `tester exited session ${this.id}`);
+    log.trace(`tester exited session ${this.id}`);
 
     if (!this._app) {
       return;

package/src/server/DetoxSessionManager.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 const DetoxInternalError = require('../errors/DetoxInternalError');
-const log = require('../utils/logger').child({ __filename });
+const log = require('../utils/logger').child({ cat: 'ws-server,ws' });
 
 const DetoxConnection = require('./DetoxConnection');
 const DetoxSession = require('./DetoxSession');

package/src/server/handlers/RegisteredConnectionHandler.js

@@ -1,7 +1,6 @@
 // @ts-nocheck
 const { serializeError } = require('serialize-error');
 
-const DetoxError = require('../../errors/DetoxError');
 const DetoxInternalError = require('../../errors/DetoxInternalError');
 
 class RegisteredConnectionHandler {
@@ -41,7 +40,7 @@ class RegisteredConnectionHandler {
         messageId: action && action.messageId,
       });
     } catch (err) {
-      this._api.log.error('Cannot forward the error details to the tester due to the error:\n' + DetoxError.format(err));
+      this._api.log.error({ err }, 'Cannot forward the error details to the tester due to the error:');
       throw error;
     }
   }

package/src/symbols.js

@@ -0,0 +1,50 @@
+/**
+ * @type {{
+ *   readonly cleanup: unique symbol;
+ *   readonly config: unique symbol;
+ *   readonly getStatus: unique symbol;
+ *   readonly init: unique symbol;
+ *   readonly installWorker: unique symbol;
+ *   readonly logger: unique symbol;
+ *   readonly onHookFailure: unique symbol;
+ *   readonly onRunDescribeFinish: unique symbol;
+ *   readonly onRunDescribeStart: unique symbol;
+ *   readonly onTestDone: unique symbol;
+ *   readonly onTestFnFailure: unique symbol;
+ *   readonly onTestStart: unique symbol;
+ *   readonly reportTestResults: unique symbol;
+ *   readonly resolveConfig: unique symbol;
+ *   readonly session: unique symbol;
+ *   readonly tracing: unique symbol;
+ *   readonly uninstallWorker: unique symbol;
+ *   readonly worker: unique symbol;
+ * }}
+ */
+module.exports = {
+  //#region Lifecycle
+  onRunDescribeStart: Symbol('run_describe_start'),
+  onTestStart: Symbol('test_start'),
+  onHookFailure: Symbol('hook_failure'),
+  onTestFnFailure: Symbol('test_fn_failure'),
+  onTestDone: Symbol('test_done'),
+  onRunDescribeFinish: Symbol('run_describe_finish'),
+  //#endregion
+
+  //#region IPC
+  reportTestResults: Symbol('reportTestResults'),
+  //#endregion
+
+  //#region Main
+  cleanup: Symbol('cleanup'),
+  config: Symbol('config'),
+  getStatus: Symbol('getStatus'),
+  init: Symbol('init'),
+  installWorker: Symbol('installWorker'),
+  logger: Symbol('logger'),
+  resolveConfig: Symbol('resolveConfig'),
+  session: Symbol('session'),
+  tracing: Symbol('tracing'),
+  uninstallWorker: Symbol('uninstallWorker'),
+  worker: Symbol('worker'),
+  //#endregion
+};