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

package/src/realms/DetoxPrimaryContext.js

@@ -0,0 +1,228 @@
+const path = require('path');
+const { URL } = require('url');
+
+const fs = require('fs-extra');
+const pipe = require('multipipe');
+
+const temporary = require('../artifacts/utils/temporaryPath');
+const { DetoxRuntimeError } = require('../errors');
+const { PrimarySessionState } = require('../ipc/state');
+const symbols = require('../symbols');
+
+const DetoxContext = require('./DetoxContext');
+
+const { $logger, $restoreSessionState, $sessionState } = DetoxContext.protected;
+
+const _finalizeLogs = Symbol('finalizeLogs');
+const _globalLifecycleHandler = Symbol('globalLifecycleHandler');
+const _ipcServer = Symbol('ipcServer');
+const _resetLockFile = Symbol('resetLockFile');
+const _wss = Symbol('wss');
+const _dirty = Symbol('dirty');
+
+class DetoxPrimaryContext extends DetoxContext {
+  constructor() {
+    super();
+
+    this[_dirty] = false;
+    this[_wss] = null;
+    this[_globalLifecycleHandler] = null;
+    /**
+     * @type {import('../ipc/IPCServer') | null}
+     */
+    this[_ipcServer] = null;
+  }
+
+  //#region Internal members
+  async [symbols.reportFailedTests](testFilePaths) {
+    if (this[_ipcServer]) {
+      this[_ipcServer].onFailedTests({ testFilePaths });
+    }
+  }
+
+  async [symbols.resolveConfig](opts = {}) {
+    const session = this[symbols.session];
+    if (!session.detoxConfig) {
+      const configuration = require('../configuration');
+      session.detoxConfig = await configuration.composeDetoxConfig(opts);
+    }
+
+    return session.detoxConfig;
+  }
+
+  /**
+   * @override
+   * @param {Partial<DetoxInternals.DetoxGlobalSetupOptions>} [opts]
+   */
+  async [symbols.globalSetup](opts) {
+    if (this[_dirty]) {
+      throw new DetoxRuntimeError({
+        message: 'Cannot initialize primary Detox context more than once.',
+        hint: DetoxRuntimeError.reportIssueIfJest,
+      });
+    }
+
+    this[_dirty] = true;
+    const detoxConfig = await this[symbols.resolveConfig](opts);
+
+    const { behaviorConfig, deviceConfig, loggerConfig, sessionConfig } = detoxConfig;
+    await this[$logger].setConfig(loggerConfig);
+
+    this.trace.begin({
+      cat: 'lifecycle',
+      args: this[$sessionState],
+      name: process.argv.slice(1).join(' '),
+    });
+
+    const IPCServer = require('../ipc/IPCServer');
+    this[_ipcServer] = new IPCServer({
+      sessionState: this[$sessionState],
+      logger: this[$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]) {
+      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;
+
+    // TODO: think about signal-exit and cleaning up the logs
+  }
+
+  /**
+   * @override
+   * @param {Partial<DetoxInternals.DetoxConfigurationSetupOptions>} [opts]
+   */
+  async [symbols.setup](opts) {
+    this[$sessionState].workerId = opts.workerId;
+    this[_ipcServer].onRegisterWorker({ workerId: opts.workerId });
+    await super[symbols.setup](opts);
+  }
+
+  /** @override */
+  async [symbols.globalTeardown]() {
+    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;
+    }
+
+    await fs.remove(this[$sessionState].detoxConfigSnapshotPath);
+    delete process.env.DETOX_CONFIG_SNAPSHOT_PATH;
+
+    try {
+      this.trace.end({ cat: 'lifecycle' });
+      await this[_finalizeLogs]();
+    } catch (err) {
+      this[$logger].error({ err }, 'Encountered an error while merging the process logs:');
+    }
+  }
+  //#endregion
+
+  //#region Protected members
+  /**
+   * @protected
+   * @override
+   * @return {PrimarySessionState}
+   */
+  [$restoreSessionState]() {
+    return new PrimarySessionState({
+      detoxConfigSnapshotPath: temporary.for.json(),
+      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;
+
+    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,93 @@
+const fs = require('fs');
+
+const { DetoxInternalError } = require('../errors');
+const { SecondarySessionState } = require('../ipc/state');
+const symbols = require('../symbols');
+
+const DetoxContext = require('./DetoxContext');
+
+const { $logger, $restoreSessionState, $sessionState } = DetoxContext.protected;
+const _ipcClient = Symbol('ipcClient');
+
+class DetoxSecondaryContext extends DetoxContext {
+  constructor() {
+    super();
+
+    /**
+     * @protected
+     * @type {*}
+     */
+    this[_ipcClient] = null;
+  }
+
+  //#region Internal members
+  async [symbols.reportFailedTests](testFilePaths) {
+    if (this[_ipcClient]) {
+      await this[_ipcClient].reportFailedTests(testFilePaths);
+    } 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.globalSetup](_opts = {}) {
+    // This is a no-op function.
+    // It is forbidden to add any logic to `globalSetup` of the secondary context.
+    // Violating this principle will almost definitely break some flows, where it is
+    // not guaranteed that `globalSetup` will ever get called. See UML diagrams.
+  }
+
+  /** @override */
+  async [symbols.globalTeardown]() {
+    // This is a no-op function.
+    // It is forbidden to add any logic to `globalTeardown` of the secondary context.
+    // Violating this principle will almost definitely break some flows, where it is
+    // not guaranteed that `globalTeardown` will ever get called. See UML diagrams.
+  }
+
+  /** @override */
+  async [symbols.setup](opts) {
+    const IPCClient = require('../ipc/IPCClient');
+
+    this[_ipcClient] = new IPCClient({
+      id: `secondary-${process.pid}`,
+      state: this[$sessionState],
+      logger: this[$logger],
+    });
+
+    await this[_ipcClient].init();
+    await this[_ipcClient].registerWorker(opts.workerId);
+    await super[symbols.setup](opts);
+  }
+
+  /** @override */
+  async [symbols.teardown]() {
+    try {
+      await super[symbols.teardown]();
+    } finally {
+      if (this[_ipcClient]) {
+        await this[_ipcClient].dispose();
+        this[_ipcClient] = null;
+      }
+    }
+  }
+  //#endregion
+
+  //#region Protected members
+
+  /**
+   * @protected
+   * @override
+   * @return {SecondarySessionState}
+   */
+  [$restoreSessionState]() {
+    return SecondarySessionState.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

@@ -3,7 +3,7 @@ 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({ __filename, cat: 'ws-server,ws' });
 
 const AnonymousConnectionHandler = require('./handlers/AnonymousConnectionHandler');
 

package/src/symbols.js

@@ -0,0 +1,56 @@
+/**
+ * @type {{
+ *   readonly config: unique symbol;
+ *   readonly globalSetup: unique symbol;
+ *   readonly globalTeardown: unique symbol;
+ *   readonly onHookFailure: unique symbol;
+ *   readonly onHookStart: unique symbol;
+ *   readonly onHookSuccess: unique symbol;
+ *   readonly onRunDescribeFinish: unique symbol;
+ *   readonly onRunDescribeStart: unique symbol;
+ *   readonly onRunFinish: unique symbol;
+ *   readonly onRunStart: unique symbol;
+ *   readonly onTestDone: unique symbol;
+ *   readonly onTestFnFailure: unique symbol;
+ *   readonly onTestFnStart: unique symbol;
+ *   readonly onTestFnSuccess: unique symbol;
+ *   readonly onTestStart: unique symbol;
+ *   readonly reportFailedTests: unique symbol;
+ *   readonly resolveConfig: unique symbol;
+ *   readonly session: unique symbol;
+ *   readonly setup: unique symbol;
+ *   readonly teardown: unique symbol;
+ *   readonly worker: unique symbol;
+ * }}
+ */
+module.exports = {
+  //#region Lifecycle
+  onRunStart: Symbol('run_start'),
+  onRunDescribeStart: Symbol('run_describe_start'),
+  onTestStart: Symbol('test_start'),
+  onHookStart: Symbol('hook_start'),
+  onHookFailure: Symbol('hook_failure'),
+  onHookSuccess: Symbol('hook_success'),
+  onTestFnStart: Symbol('test_fn_start'),
+  onTestFnFailure: Symbol('test_fn_failure'),
+  onTestFnSuccess: Symbol('test_fn_success'),
+  onTestDone: Symbol('test_done'),
+  onRunDescribeFinish: Symbol('run_describe_finish'),
+  onRunFinish: Symbol('run_finish'),
+  //#endregion
+
+  //#region IPC
+  reportFailedTests: Symbol('reportFailedTests'),
+  //#endregion
+
+  //#region Main
+  config: Symbol('config'),
+  globalSetup: Symbol('globalSetup'),
+  globalTeardown: Symbol('globalTeardown'),
+  resolveConfig: Symbol('resolveConfig'),
+  session: Symbol('session'),
+  setup: Symbol('setup'),
+  teardown: Symbol('teardown'),
+  worker: Symbol('worker'),
+  //#endregion
+};

package/src/utils/Timer.js

@@ -26,14 +26,13 @@ class Timer {
   }
 
   async run(action) {
-    const error = new DetoxRuntimeError();
-    delete error.stack;
+    const error = new DetoxRuntimeError({
+      message: `Exceeded timeout of ${this._timeout}ms while ${this.description}`,
+      noStack: true,
+    });
 
     return Promise.race([
-      this._timeoutDeferred.promise.then(() => {
-        error.message = `Exceeded timeout of ${this._timeout}ms while ${this.description}`;
-        throw error;
-      }),
+      this._timeoutDeferred.promise.then(() => { throw error; }),
       Promise.resolve().then(action),
     ]);
   }
@@ -52,6 +51,15 @@ class Timer {
       this._timeoutHandle = setTimeout(() => this._timeoutDeferred.resolve(), extraDelayMs);
     }
   }
+
+  static async run({ description, timeout, fn }) {
+    const timer = new Timer({ description, timeout });
+    try {
+      await timer.run(fn);
+    } finally {
+      timer.dispose();
+    }
+  }
 }
 
 module.exports = Timer;

package/{local-cli/utils/misc.js → src/utils/envUtils.js}

@@ -1,13 +1,5 @@
 const path = require('path');
 
-function getPlatformSpecificString(platform) {
-  switch (platform) {
-    case 'ios': return ':android:';
-    case 'android': return ':ios:';
-    default: return undefined;
-  }
-}
-
 function printEnvironmentVariables(envObject) {
   return Object.entries(envObject).reduce((cli, [key, value]) => {
     if (value == null || value === '') {
@@ -33,7 +25,6 @@ function prependNodeModulesBinToPATH(env) {
 }
 
 module.exports = {
-  getPlatformSpecificString,
   printEnvironmentVariables,
   prependNodeModulesBinToPATH,
 };

package/src/utils/logger.js

@@ -1,164 +1,4 @@
-// @ts-nocheck
-
-const path = require('path');
-
-const bunyan = require('bunyan');
-const bunyanDebugStream = require('bunyan-debug-stream');
-const fs = require('fs-extra');
-const onExit = require('signal-exit');
-
-const temporaryPath = require('../artifacts/utils/temporaryPath');
-
-const argparse = require('./argparse');
-const customConsoleLogger = require('./customConsoleLogger');
-const { shortFormat: shortDateFormat } = require('./dateUtils');
-
-function adaptLogLevelName(level) {
-  switch (level) {
-    case 'fatal':
-    case 'error':
-    case 'warn':
-    case 'info':
-    case 'debug':
-    case 'trace':
-      return level;
-
-    case 'verbose':
-      return 'debug';
-
-    default:
-      return 'info';
-  }
-}
-
-function tryOverrideConsole(logger, global) {
-  if (argparse.getArgValue('use-custom-logger') === 'true') {
-    const userLogger = logger.child({ component: 'USER_LOG' });
-    customConsoleLogger.overrideConsoleMethods(global.console, userLogger);
-  }
-}
-
-function createPlainBunyanStream({ logPath, level, showDate = true }) {
-  const options = {
-    showDate: showDate,
-    showLoggerName: true,
-    showPid: true,
-    showMetadata: false,
-    basepath: __dirname,
-    out: process.stderr,
-    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}`,
-    },
-  };
-
-  if (logPath) {
-    options.colors = false;
-    options.out = fs.createWriteStream(logPath, {
-      flags: 'a',
-    });
-  }
-
-  if (argparse.getFlag('--no-color')) {
-    options.colors = false;
-  }
-
-  return {
-    level,
-    type: 'raw',
-    stream: bunyanDebugStream(options),
-    serializers: bunyanDebugStream.serializers,
-  };
-}
-
 /**
- * @returns {Logger}
+ * @type {Detox.Logger}
  */
-function init() {
-  const levelFromArg = argparse.getArgValue('loglevel', 'l');
-  const level = adaptLogLevelName(levelFromArg);
-  const debugStream = createPlainBunyanStream({ level, showDate: shortDateFormat });
-  const bunyanStreams = [debugStream];
-
-  let jsonFileStreamPath, plainFileStreamPath;
-  if (!global.DETOX_CLI && !global.IS_RUNNING_DETOX_UNIT_TESTS) {
-    {
-      jsonFileStreamPath = temporaryPath.for.log();
-      fs.ensureFileSync(jsonFileStreamPath);
-      bunyanStreams.push({
-        level: 'trace',
-        path: jsonFileStreamPath,
-      });
-    }
-    {
-      plainFileStreamPath = temporaryPath.for.log();
-      fs.ensureFileSync(plainFileStreamPath);
-      bunyanStreams.push(createPlainBunyanStream({
-        level: 'trace',
-        logPath: plainFileStreamPath,
-      }));
-    }
-
-    onExit(() => {
-      try { fs.unlinkSync(jsonFileStreamPath); } catch (e) {}
-      try { fs.unlinkSync(plainFileStreamPath); } catch (e) {}
-    });
-  }
-
-  const logger = bunyan.createLogger({
-    name: 'detox',
-    streams: bunyanStreams,
-  });
-
-  if (jsonFileStreamPath) {
-    logger.jsonFileStreamPath = jsonFileStreamPath;
-  }
-
-  if (plainFileStreamPath) {
-    logger.plainFileStreamPath = plainFileStreamPath;
-  }
-
-  tryOverrideConsole(logger, global);
-
-  logger.getDetoxLevel = () => level;
-
-  logger.reinitialize = (global) => {
-    if (jsonFileStreamPath) {
-      fs.ensureFileSync(jsonFileStreamPath);
-    }
-
-    if (plainFileStreamPath) {
-      fs.ensureFileSync(plainFileStreamPath);
-    }
-
-    tryOverrideConsole(logger, global);
-  };
-
-  const originalChild = logger.child.bind(logger);
-
-  logger.child = (options) => {
-    if (options && options.__filename) {
-      return originalChild({
-        ...options,
-        __filename: path.basename(options.__filename)
-      });
-    }
-
-    return originalChild(options);
-  };
-
-  return logger;
-}
-
-module.exports = init();
+module.exports = require('../..').log;

package/src/utils/shellUtils.js

@@ -1,7 +1,17 @@
+const SPACE = ' ';
 const BACK_SLASH = '\\';
 const SINGLE_QUOTE = "'";
 const DOUBLE_QUOTE = '"';
 
+function escapeSpacesCMD(str) {
+  return str.includes(' ') ? `"${str}"` : str;
+}
+
+const BACK_SLASH_SPACE = BACK_SLASH + SPACE;
+function escapeSpacesShell(str) {
+  return str.replace(/ /g, BACK_SLASH_SPACE);
+}
+
 const ESCAPED_DOUBLE_QUOTE = BACK_SLASH + DOUBLE_QUOTE;
 function escapeInDoubleQuotedString(fragment) {
   return fragment.replace(/"/g, ESCAPED_DOUBLE_QUOTE);
@@ -62,12 +72,20 @@ const autoEscape = isRunningInCMDEXE()
   /* istanbul ignore next */ ? autoEscapeCmd
   /* istanbul ignore next */ : autoEscapeShell;
 
+const escapeSpaces = isRunningInCMDEXE()
+  /* istanbul ignore next */ ? escapeSpacesCMD
+  /* istanbul ignore next */ : escapeSpacesShell;
+
 module.exports = {
   escapeInDoubleQuotedString,
   escapeInDoubleQuotedRegexp,
   escapeWithSingleQuotedString,
   escapeWithDoubleQuotedString,
   isRunningInCMDEXE,
+  escapeSpaces: Object.assign(escapeSpaces, {
+    cmd: escapeSpacesCMD,
+    shell: escapeSpacesShell,
+  }),
   hasUnsafeChars: Object.assign(hasUnsafeChars, {
     cmd: hasUnsafeCMDChars,
     shell: hasUnsafeShellChars,