detox 20.0.11-prerelease.0 → 20.0.13-prerelease.0

package/runners/jest/testEnvironment/index.js

@@ -1,6 +1,6 @@
 const resolveFrom = require('resolve-from');
 const maybeNodeEnvironment = require(resolveFrom(process.cwd(), 'jest-environment-node'));
-// @ts-ignore
+/** @type {typeof import('@jest/environment').JestEnvironment} */
 const NodeEnvironment = maybeNodeEnvironment.default || maybeNodeEnvironment;
 
 const detox = require('../../../internals');
@@ -33,110 +33,98 @@ class DetoxCircusEnvironment extends NodeEnvironment {
   constructor(config, context) {
     super(assertJestCircus27(config), assertExistingContext(context));
 
-    /** @private */
-    this._timer = null;
-    /** @private */
-    this._listenerFactories = {
-      DetoxInitErrorListener,
-      DetoxPlatformFilterListener,
-      DetoxCoreListener,
-      SpecReporter,
-      WorkerAssignReporter,
-    };
     /** @private */
     this._shouldManageDetox = detox.getStatus() === 'inactive';
     /** @private */
-    this._setupFailed = false;
+    this._timer = new Timer();
+
     /** @internal */
     this.testPath = context.testPath;
     /** @protected */
     this.testEventListeners = [];
     /** @protected */
-    this.initTimeout = detox.config.testRunner.jest.initTimeout;
-    /** @internal */
+    this.setupTimeout = detox.config.testRunner.jest.setupTimeout;
+    /** @protected */
+    this.teardownTimeout = detox.config.testRunner.jest.teardownTimeout;
+
     log.trace.begin(this.testPath);
 
-    this.setup = log.trace.complete.bind(null, 'set up environment', this.setup.bind(this));
+    const _setup = this.setup.bind(this);
+    this.setup = async () => {
+      await log.trace.complete('set up environment', async () => {
+        try {
+          this._timer.schedule(this.setupTimeout);
+          await this._handleTestEventAsync({ name: 'environment_setup_start' });
+          await this._timer.run(`setting up Detox environment`, _setup);
+          await this._handleTestEventAsync({ name: 'environment_setup_success' });
+        } catch (error) {
+          this._timer.schedule(this.teardownTimeout);
+          await this._handleTestEventAsync({ name: 'environment_setup_failure', error });
+          throw error;
+        } finally {
+          this._timer.clear();
+        }
+      });
+    };
+
     const _teardown = this.teardown.bind(this);
     this.teardown = async () => {
-      try {
-        await log.trace.complete('tear down environment', _teardown);
-      } finally {
-        await log.trace.end();
-      }
+      await log.trace.complete('tear down environment', async () => {
+        try {
+          this._timer.schedule(this.teardownTimeout);
+          await this._handleTestEventAsync({ name: 'environment_teardown_start' });
+          await this._timer.run(`tearing down Detox environment`, _teardown);
+          await this._handleTestEventAsync({ name: 'environment_teardown_success' });
+        } catch (error) {
+          if (this._timer.expired) {
+            this._timer.schedule(this.teardownTimeout);
+          }
+
+          await this._handleTestEventAsync({ name: 'environment_teardown_failure', error });
+          throw error;
+        } finally {
+          this._timer.clear();
+          log.trace.end();
+        }
+      });
     };
+
+    this.registerListeners({
+      DetoxInitErrorListener,
+      DetoxPlatformFilterListener,
+      DetoxCoreListener,
+      SpecReporter,
+      WorkerAssignReporter,
+    });
   }
 
   /** @override */
   async setup() {
-    try {
-      await super.setup();
-      await Timer.run({
-        description: `setting up Detox environment`,
-        timeout: this.initTimeout,
-        fn: async () => {
-          await this.initDetox();
-          this._instantiateListeners();
-        },
-      });
-    } catch (e) {
-      this._setupFailed = true;
-      throw e;
-    }
+    await this.initDetox();
   }
 
-  /** @override */
-  async handleTestEvent(event, state) {
-    const { name } = event;
+  handleTestEvent = async (event, state) => {
+    this._timer.schedule(state.testTimeout != null ? state.testTimeout : this.setupTimeout);
 
-    if (SYNC_CIRCUS_EVENTS.has(name)) {
-      return this._handleTestEventSync(event, state);
-    }
-
-    this._timer = new Timer({
-      description: `handling jest-circus "${name}" event`,
-      timeout: state.testTimeout != null ? state.testTimeout : this.initTimeout,
-    });
-
-    try {
-      for (const listener of this.testEventListeners) {
-        if (typeof listener[name] !== 'function') {
-          continue;
-        }
-
-        try {
-          await this._timer.run(() => listener[name](event, state));
-        } catch (listenerError) {
-          log.error(listenerError);
-          break;
-        }
-      }
-    } finally {
-      this._timer.dispose();
-      this._timer = null;
+    if (SYNC_CIRCUS_EVENTS.has(event.name)) {
+      this._handleTestEventSync(event, state);
+    } else {
+      await this._handleTestEventAsync(event, state);
     }
-  }
+  };
 
   /** @override */
   async teardown() {
-    await Timer.run({
-      description: `tearing down Detox environment`,
-      timeout: this.initTimeout,
-      fn: async () => {
-        try {
-          if (this._setupFailed) {
-            await detox.reportFailedTests([this.testPath], false);
-          }
-        } finally {
-          await this.cleanupDetox();
-        }
-      },
-    });
+    await this.cleanupDetox();
   }
 
   /** @protected */
   registerListeners(map) {
-    Object.assign(this._listenerFactories, map);
+    for (const Listener of Object.values(map)) {
+      this.testEventListeners.push(new Listener({
+        env: this,
+      }));
+    }
   }
 
   /**
@@ -153,6 +141,8 @@ class DetoxCircusEnvironment extends NodeEnvironment {
     } else {
       await detox.installWorker(opts);
     }
+
+    return detox.worker;
   }
 
   /** @protected */
@@ -176,11 +166,22 @@ class DetoxCircusEnvironment extends NodeEnvironment {
   }
 
   /** @private */
-  _instantiateListeners() {
-    for (const Listener of Object.values(this._listenerFactories)) {
-      this.testEventListeners.push(new Listener({
-        env: this,
-      }));
+  async _handleTestEventAsync(event, state = null) {
+    const description = `handling ${state ? 'jest-circus' : 'jest-environment'} "${event.name}" event`;
+
+    for (const listener of this.testEventListeners) {
+      if (typeof listener[event.name] !== 'function') {
+        continue;
+      }
+
+      try {
+        await this._timer.run(description, () => listener[event.name](event, state));
+      } catch (listenerError) {
+        log.error(listenerError);
+        if (this._timer.expired) {
+          break;
+        }
+      }
     }
   }
 }

package/runners/jest/testEnvironment/listeners/DetoxCoreListener.js

@@ -14,7 +14,7 @@ class DetoxCoreListener {
     this._startedTests = new WeakSet();
     this._testsFailedBeforeStart = new WeakSet();
     this._env = env;
-    this._testRunTimes = 1;
+    this._circusRetryTimes = 1;
   }
 
   async setup() {
@@ -46,7 +46,7 @@ class DetoxCoreListener {
     }
 
     const circusRetryTimes = +this._env.global[RETRY_TIMES];
-    this._testRunTimes = isNaN(circusRetryTimes) ? 1 : 1 + circusRetryTimes;
+    this._circusRetryTimes = isNaN(circusRetryTimes) ? 1 : 1 + circusRetryTimes;
   }
 
   async hook_start(event, state) {
@@ -58,7 +58,12 @@ class DetoxCoreListener {
     log.trace.end({ success: true });
   }
 
-  async hook_failure({ error }) {
+  async hook_failure({ error, hook }) {
+    await detoxInternals.onHookFailure({
+      error,
+      hook: hook.type,
+    });
+
     log.trace.end({ success: false, error });
   }
 
@@ -94,14 +99,6 @@ class DetoxCoreListener {
     }
   }
 
-  async run_finish(_event, state) {
-    const hasFailedTests = this._hasFailedTests(state.rootDescribeBlock);
-    if (hasFailedTests) {
-      const handledByJestCircus = this._testRunTimes > 1 && !detoxInternals.config.testRunner.jest.retryAfterCircusRetries;
-      await detoxInternals.reportFailedTests([this._env.testPath], handledByJestCircus);
-    }
-  }
-
   async _onBeforeActualTestStart(test) {
     if (!test || test.status === 'skip' || this._startedTests.has(test) || this._testsFailedBeforeStart.has(test)) {
       return false;
@@ -127,19 +124,7 @@ class DetoxCoreListener {
 
   _getTestInvocations(test) {
     const { testSessionIndex } = detoxInternals.session;
-    return testSessionIndex * this._testRunTimes + test.invocations;
-  }
-
-  _hasFailedTests(block) {
-    if (block.children) {
-      for (const child of block.children) {
-        if (this._hasFailedTests(child)) {
-          return true;
-        }
-      }
-    }
-
-    return block.errors ? block.errors.length > 0 : false;
+    return testSessionIndex * this._circusRetryTimes + test.invocations;
   }
 
   _getTestMetadata(test) {

package/runners/jest/testEnvironment/listeners/DetoxPlatformFilterListener.js

@@ -5,7 +5,7 @@ const { device } = require('../../../..');
 const PLATFORM_REGEXP = /^:([^:]+):/;
 
 class DetoxPlatformFilterListener {
-  constructor() {
+  setup() {
     this._platform = device.getPlatform();
   }
 

package/src/DetoxWorker.js

@@ -190,7 +190,6 @@ class DetoxWorker {
     return this._context.log;
   }
 
-  onRunStart = async (...args) => this._artifactsManager.onRunStart(...args);
   onRunDescribeStart = async (...args) => this._artifactsManager.onRunDescribeStart(...args);
   onTestStart = async (testSummary) => {
     if (this._isCleaningUp) return;
@@ -205,12 +204,8 @@ class DetoxWorker {
     if (this._isCleaningUp) return;
     await this._artifactsManager.onTestStart(testSummary);
   };
-  onHookStart = async (...args) => this._artifactsManager.onHookStart(...args);
   onHookFailure = async (...args) => this._artifactsManager.onHookFailure(...args);
-  onHookSuccess = async (...args) => this._artifactsManager.onHookSuccess(...args);
-  onTestFnStart = async (...args) => this._artifactsManager.onTestFnStart(...args);
   onTestFnFailure = async (...args) => this._artifactsManager.onTestFnFailure(...args);
-  onTestFnSuccess = async (...args) => this._artifactsManager.onTestFnSuccess(...args);
   onTestDone = async (testSummary) => {
     if (this._isCleaningUp) return;
     this._validateTestSummary('afterEach', testSummary);
@@ -225,7 +220,6 @@ class DetoxWorker {
     });
   };
   onRunDescribeFinish = async (...args) => this._artifactsManager.onRunDescribeFinish(...args);
-  onRunFinish = async (...args) => this._artifactsManager.onRunFinish(...args);
 
   async _reinstallAppsOnDevice() {
     const appNames = _(this._appsConfig)

package/src/artifacts/ArtifactsManager.js

@@ -32,19 +32,13 @@ class ArtifactsManager extends EventEmitter {
       'onBootDevice',
       'onCreateExternalArtifact',
       'onHookFailure',
-      'onHookStart',
-      'onHookSuccess',
       'onLaunchApp',
       'onRunDescribeFinish',
       'onRunDescribeStart',
-      'onRunFinish',
-      'onRunStart',
       'onShutdownDevice',
       'onTerminateApp',
       'onTestDone',
       'onTestFnFailure',
-      'onTestFnStart',
-      'onTestFnSuccess',
       'onTestStart',
     ]);
   }
@@ -185,8 +179,6 @@ class ArtifactsManager extends EventEmitter {
     });
   }
 
-  async onRunStart() {}
-
   async onRunDescribeStart(suite) {
     await this._callPlugins('ascending', 'onRunDescribeStart', suite);
   }
@@ -195,22 +187,14 @@ class ArtifactsManager extends EventEmitter {
     await this._callPlugins('ascending', 'onTestStart', testSummary);
   }
 
-  async onHookStart() {}
-
   async onHookFailure(testSummary) {
     await this._callPlugins('plain', 'onHookFailure', testSummary);
   }
 
-  async onHookSuccess() {}
-
-  async onTestFnStart() {}
-
   async onTestFnFailure(testSummary) {
     await this._callPlugins('plain', 'onTestFnFailure', testSummary);
   }
 
-  async onTestFnSuccess() {}
-
   async onTestDone(testSummary) {
     await this._callPlugins('descending', 'onTestDone', testSummary);
   }
@@ -219,8 +203,6 @@ class ArtifactsManager extends EventEmitter {
     await this._callPlugins('descending', 'onRunDescribeFinish', suite);
   }
 
-  async onRunFinish() {}
-
   async onBeforeCleanup() {
     await this._callPlugins('descending', 'onBeforeCleanup');
     await this._idlePromise;

package/src/configuration/composeLoggerConfig.js

@@ -14,7 +14,7 @@ function composeLoggerConfig(opts) {
   const items = [
     {
       level: 'info',
-      overrideConsole: 'sandbox',
+      overrideConsole: true,
       options: defaultOptions,
     },
     globalConfig.logger,
@@ -46,7 +46,7 @@ function adaptCLI(cliConfig) {
   }
 
   if (cliConfig.useCustomLogger !== undefined) {
-    result.overrideConsole = cliConfig.useCustomLogger ? 'all' : 'none';
+    result.overrideConsole = cliConfig.useCustomLogger;
   }
 
   if (cliConfig.noColor) {

package/src/configuration/composeRunnerConfig.js

@@ -32,8 +32,10 @@ function composeRunnerConfig(opts) {
       retries: 0,
       inspectBrk: inspectBrkHookDefault,
       forwardEnv: false,
+      bail: false,
       jest: {
-        initTimeout: 300000,
+        setupTimeout: 300000,
+        teardownTimeout: 30000,
         retryAfterCircusRetries: false,
         reportSpecs: undefined,
         reportWorkerAssign: true,
@@ -54,11 +56,12 @@ function composeRunnerConfig(opts) {
 
   if (typeof merged.inspectBrk === 'function') {
     if (cliConfig.inspectBrk) {
+      merged.retries = 0;
+      merged.forwardEnv = true;
       merged.inspectBrk(merged);
-      merged.inspectBrk = true;
-    } else {
-      merged.inspectBrk = false;
     }
+
+    delete merged.inspectBrk;
   }
 
   return merged;

package/src/devices/allocation/drivers/android/emulator/AVDValidator.js

@@ -12,11 +12,11 @@ class AVDValidator {
     this._emulatorVersionResolver = emulatorVersionResolver;
   }
 
-  async validate(avdName) {
+  async validate(avdName, isHeadless) {
     const avds = await this._avdsResolver.resolve(avdName);
     this._assertAVDs(avds);
     await this._assertAVDMatch(avds, avdName);
-    await this._validateEmulatorVer();
+    await this._validateEmulatorVer(isHeadless);
   }
 
   _assertAVDs(avds) {
@@ -37,8 +37,8 @@ class AVDValidator {
     }
   }
 
-  async _validateEmulatorVer() {
-    const emulatorVersion = await this._emulatorVersionResolver.resolve();
+  async _validateEmulatorVer(isHeadless) {
+    const emulatorVersion = await this._emulatorVersionResolver.resolve(isHeadless);
     if (!emulatorVersion) {
       logger.warn({ event: 'AVD_VALIDATION' }, 'Emulator version detection failed (See previous logs)');
       return;

package/src/devices/allocation/drivers/android/emulator/EmulatorAllocDriver.js

@@ -34,7 +34,7 @@ class EmulatorAllocDriver extends AllocationDriverBase {
   async allocate(deviceConfig) {
     const avdName = deviceConfig.device.avdName;
 
-    await this._avdValidator.validate(avdName);
+    await this._avdValidator.validate(avdName, deviceConfig.headless);
     await this._fixAvdConfigIniSkinNameIfNeeded(avdName, deviceConfig.headless);
 
     const allocResult = await this._allocationHelper.allocateDevice(avdName);

package/src/ipc/IPCClient.js

@@ -1,6 +1,7 @@
 const { IPC } = require('node-ipc');
 
 const { DetoxInternalError } = require('../errors');
+const { serializeObjectWithError } = require('../utils/errorUtils');
 
 class IPCClient {
   constructor({ id, logger, state }) {
@@ -47,15 +48,18 @@ class IPCClient {
   }
 
   async registerWorker(workerId) {
-    await this._emit('registerWorker', { workerId });
+    const sessionState = await this._emit('registerWorker', { workerId });
+    this._state.patch(sessionState);
   }
 
   /**
-   * @param {string[]} testFilePaths
-   * @param {Boolean} permanent
+   * @param {DetoxInternals.DetoxTestFileReport[]} testResults
    */
-  async reportFailedTests(testFilePaths, permanent) {
-    await this._emit('failedTests', { testFilePaths, permanent });
+  async reportTestResults(testResults) {
+    const sessionState = await this._emit('reportTestResults', {
+      testResults: testResults.map(r => serializeObjectWithError(r, 'testExecError')),
+    });
+    this._state.patch(sessionState);
   }
 
   async _connectToServer() {

package/src/ipc/IPCServer.js

@@ -1,5 +1,8 @@
+const { uniqBy } = require('lodash');
 const { IPC } = require('node-ipc');
 
+const { serializeObjectWithError } = require('../utils/errorUtils');
+
 class IPCServer {
   /**
    * @param {object} options
@@ -27,12 +30,12 @@ class IPCServer {
     this._ipc.config.appspace = 'detox.';
     this._ipc.config.logger = (msg) => this._logger.trace(msg);
 
-      await new Promise((resolve) => {
+    await new Promise((resolve) => {
       // TODO: handle reject
       this._ipc.serve(() => resolve());
       this._ipc.server.on('registerContext', this.onRegisterContext.bind(this));
       this._ipc.server.on('registerWorker', this.onRegisterWorker.bind(this));
-      this._ipc.server.on('failedTests', this.onFailedTests.bind(this));
+      this._ipc.server.on('reportTestResults', this.onReportTestResults.bind(this));
       this._ipc.server.start();
     });
   }
@@ -53,8 +56,7 @@ class IPCServer {
     this._sessionState.contexts.push(id);
 
     this._ipc.server.emit(socket, 'registerContextDone', {
-      failedTestFiles: this._sessionState.failedTestFiles,
-      testFilesToRetry: this._sessionState.testFilesToRetry,
+      testResults: this._sessionState.testResults,
       testSessionIndex: this._sessionState.testSessionIndex,
     });
   }
@@ -73,20 +75,22 @@ class IPCServer {
     }
   }
 
-  onFailedTests({ testFilePaths, permanent }, socket = null) {
-    if (permanent) {
-      this._sessionState.failedTestFiles.push(...testFilePaths);
-    } else {
-      this._sessionState.testFilesToRetry.push(...testFilePaths);
-    }
+  onReportTestResults({ testResults }, socket = null) {
+    const merged = uniqBy([
+      ...testResults.map(r => serializeObjectWithError(r, 'testExecError')),
+      ...this._sessionState.testResults
+    ], 'testFilePath');
+
+    this._sessionState.testResults.splice(0, Infinity, ...merged);
 
     if (socket) {
-      this._ipc.server.emit(socket, 'failedTestsDone', {});
+      this._ipc.server.emit(socket, 'reportTestResultsDone', {
+        testResults: this._sessionState.testResults,
+      });
     }
 
     this._ipc.server.broadcast('sessionStateUpdate', {
-      failedTestFiles: this._sessionState.failedTestFiles,
-      testFilesToRetry: this._sessionState.testFilesToRetry,
+      testResults: this._sessionState.testResults,
     });
   }
 }

package/src/ipc/SessionState.js

@@ -9,8 +9,7 @@ class SessionState {
     detoxConfigSnapshotPath = '',
     detoxConfig = null,
     detoxIPCServer = '',
-    failedTestFiles = [],
-    testFilesToRetry = [],
+    testResults = [],
     testSessionIndex = 0,
     workersCount = 0
   }) {
@@ -19,8 +18,7 @@ class SessionState {
     this.detoxConfigSnapshotPath = detoxConfigSnapshotPath;
     this.detoxConfig = detoxConfig;
     this.detoxIPCServer = detoxIPCServer;
-    this.failedTestFiles = failedTestFiles;
-    this.testFilesToRetry = testFilesToRetry;
+    this.testResults = testResults;
     this.testSessionIndex = testSessionIndex;
     this.workersCount = workersCount;
   }
@@ -43,7 +41,7 @@ class SessionState {
   }
 
   static reviver(key, val) {
-    if (typeof val === 'object' && typeof val.$fn == 'string') {
+    if (typeof val === 'object' && val !== null && typeof val.$fn == 'string') {
       return eval(val.$fn);
     } else {
       return val;

package/src/logger/DetoxLogger.js

@@ -55,7 +55,7 @@ class DetoxLogger {
 
       this._sharedConfig.userConfig = this._sharedConfig.userConfig || {
         level: 'info',
-        overrideConsole: 'none',
+        overrideConsole: false,
         options: {
           showDate: false,
           showLoggerName: false,
@@ -143,14 +143,12 @@ class DetoxLogger {
    * @internal
    */
   overrideConsole(sandbox) {
-    const option = this.config.overrideConsole;
-    if (option === 'none') {
+    const enabled = this.config.overrideConsole;
+    if (!enabled) {
       return;
     }
 
-    if ((option === 'sandbox' && sandbox) || option === 'all') {
-      customConsoleLogger.overrideConsoleMethods((sandbox || global).console, this);
-    }
+    customConsoleLogger.overrideConsoleMethods((sandbox || global).console, this);
   }
 
   /**

package/src/realms/DetoxContext.js

@@ -36,7 +36,7 @@ class DetoxContext {
     };
 
     this[symbols.getStatus] = this[symbols.getStatus].bind(this);
-    this[symbols.reportFailedTests] = this[symbols.reportFailedTests].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);
@@ -80,18 +80,12 @@ class DetoxContext {
   //#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({
@@ -103,7 +97,7 @@ class DetoxContext {
     },
   });
   /** @abstract */
-  [symbols.reportFailedTests](_testFilePaths, _permanent) {}
+  [symbols.reportTestResults](_testResults) {}
   /**
    * @abstract
    * @param {Partial<DetoxInternals.DetoxInitOptions>} _opts

package/src/realms/DetoxInternalsFacade.js

@@ -26,7 +26,7 @@ class DetoxInternalsFacade {
     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];