detox 20.0.11-prerelease.0 → 20.0.13-is-hittable-over-master.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/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,

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;
   }

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);
@@ -103,7 +103,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];

package/src/realms/DetoxPrimaryContext.js

@@ -46,9 +46,9 @@ class DetoxPrimaryContext extends DetoxContext {
   }
 
   //#region Internal members
-  async [symbols.reportFailedTests](testFilePaths, permanent = false) {
+  async [symbols.reportTestResults](testResults) {
     if (this[_ipcServer]) {
-      this[_ipcServer].onFailedTests({ testFilePaths, permanent });
+      this[_ipcServer].onReportTestResults({ testResults });
     }
   }
 
@@ -236,15 +236,14 @@ class DetoxPrimaryContext extends DetoxContext {
       const { rootDir } = this[symbols.config].artifacts;
 
       await fs.mkdirp(rootDir);
-      const [out1Stream, out2Stream, out3Stream] = ['detox.log.jsonl', 'detox.log', 'detox.trace.json']
+      const [out1Stream, out2Stream] = ['detox.log', 'detox.trace.json']
         .map((filename) => fs.createWriteStream(path.join(rootDir, filename)));
 
       const mergedStream = streamUtils.uniteSessionLogs(sessionId);
 
       await Promise.all([
-        pipe(mergedStream, streamUtils.writeJSONL(), out1Stream),
-        pipe(mergedStream, streamUtils.debugStream(this[symbols.logger].config.options), out2Stream),
-        pipe(mergedStream, streamUtils.chromeTraceStream(), streamUtils.writeJSON(), out3Stream),
+        pipe(mergedStream, streamUtils.debugStream(this[symbols.logger].config.options), out1Stream),
+        pipe(mergedStream, streamUtils.chromeTraceStream(), streamUtils.writeJSON(), out2Stream),
       ]);
     }
 
@@ -286,8 +285,7 @@ class DetoxPrimaryContext extends DetoxContext {
       return true;
     }
 
-    const { failedTestFiles, testFilesToRetry } = this[$sessionState];
-    return failedTestFiles.length + testFilesToRetry.length > 0;
+    return this[$sessionState].testResults.some(r => !r.success);
   }
 
   async[_resetLockFile]() {

package/src/realms/DetoxSecondaryContext.js

@@ -29,9 +29,9 @@ class DetoxSecondaryContext extends DetoxContext {
   }
 
   //#region Internal members
-  async [symbols.reportFailedTests](testFilePaths, permanent = false) {
+  async [symbols.reportTestResults](testResults) {
     if (this[_ipcClient]) {
-      await this[_ipcClient].reportFailedTests(testFilePaths, permanent);
+      await this[_ipcClient].reportTestResults(testResults);
     } else {
       throw new DetoxInternalError('Detected an attempt to report failed tests using a non-initialized context.');
     }

package/src/symbols.js

@@ -18,7 +18,7 @@
  *   readonly onTestFnStart: unique symbol;
  *   readonly onTestFnSuccess: unique symbol;
  *   readonly onTestStart: unique symbol;
- *   readonly reportFailedTests: unique symbol;
+ *   readonly reportTestResults: unique symbol;
  *   readonly resolveConfig: unique symbol;
  *   readonly session: unique symbol;
  *   readonly tracing: unique symbol;
@@ -43,7 +43,7 @@ module.exports = {
   //#endregion
 
   //#region IPC
-  reportFailedTests: Symbol('reportFailedTests'),
+  reportTestResults: Symbol('reportTestResults'),
   //#endregion
 
   //#region Main