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

package/src/realms/DetoxPrimaryContext.js

@@ -0,0 +1,229 @@
+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) {
+    const workerId = opts.workerId || 1;
+    this[$sessionState].workerId = workerId;
+    this[_ipcServer].onRegisterWorker({ 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,94 @@
+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],
+    });
+
+    const workerId = opts.workerId || 1;
+    await this[_ipcClient].init();
+    await this[_ipcClient].registerWorker(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/environment.js

@@ -78,7 +78,7 @@ function getAndroidEmulatorPath() {
     return legacyPath;
   }
 
-  throwSdkIntegrityError(sdkRoot, 'emulator/emulator');
+  throwSdkBinIntegrityError(sdkRoot, 'emulator/emulator');
 }
 
 async function getAaptPath() {
@@ -88,23 +88,33 @@ async function getAaptPath() {
   }
 
   const latestBuildTools = await getLatestBuildToolsPath(sdkRoot);
-  const defaultPath = latestBuildTools && which('aapt', latestBuildTools);
+  if (!latestBuildTools) {
+    throwSdkIntegrityError('Failed to find the "aapt" tool under the Android SDK: No build-tools are installed!');
+  }
+
+  const defaultPath = which('aapt', latestBuildTools);
   if (defaultPath) {
     return defaultPath;
   }
 
-  throwSdkIntegrityError(sdkRoot, `${latestBuildTools}/aapt`);
+  throwSdkToolPathError(`${latestBuildTools}/aapt`);
 }
 
 async function getLatestBuildToolsPath(sdkRoot) {
-  if (!sdkRoot) return '';
+  if (!sdkRoot) {
+    return '';
+  }
 
   const buildToolsDir = path.join(sdkRoot, 'build-tools');
-  if (!fs.existsSync(buildToolsDir)) return '';
+  if (!fs.existsSync(buildToolsDir)) {
+    return '';
+  }
 
   const buildToolsVersions = await fsext.getDirectories(buildToolsDir);
   const latestBuildToolsVersion = _.last(buildToolsVersions);
-  if (!latestBuildToolsVersion) return '';
+  if (!latestBuildToolsVersion) {
+    return '';
+  }
 
   return path.join(buildToolsDir, latestBuildToolsVersion);
 }
@@ -120,7 +130,7 @@ function getAdbPath() {
     return defaultPath;
   }
 
-  throwSdkIntegrityError(sdkRoot, 'platform-tools/adb');
+  throwSdkBinIntegrityError(sdkRoot, 'platform-tools/adb');
 }
 
 function getGmsaasPath() {
@@ -142,15 +152,20 @@ function throwMissingAvdError(avdName, avdPath, avdIniPath) {
   );
 }
 
-function throwSdkIntegrityError(sdkRoot, relativeExecutablePath) {
-  const executablePath = path.join(sdkRoot, relativeExecutablePath);
-  const name = path.basename(executablePath);
-  const dir = path.dirname(executablePath);
+function throwSdkBinIntegrityError(sdkRoot, relativeBinPath) {
+  const executablePath = path.join(sdkRoot, relativeBinPath);
+  throwSdkToolPathError(executablePath);
+}
 
-  throw new DetoxRuntimeError(
-    `There was no "${name}" executable file in directory: ${dir}.\n` +
-    `Check integrity of your Android SDK.`
-  );
+function throwSdkToolPathError(sdkToolPath) {
+  const name = path.basename(sdkToolPath);
+  const dir = path.dirname(sdkToolPath);
+
+  throwSdkIntegrityError(`There was no "${name}" executable file in directory: ${dir}`);
+}
+
+function throwSdkIntegrityError(errMessage) {
+  throw new DetoxRuntimeError(`${errMessage}\nCheck the integrity of your Android SDK.`);
 }
 
 function throwMissingGmsaasError() {