detox 20.0.3-breaking.new-global-lifecycle.0 → 20.0.3

package/runners/jest/testEnvironment/index.js

@@ -1,9 +1,11 @@
-// @ts-nocheck
-const maybeNodeEnvironment = require('jest-environment-node'); // eslint-disable-line node/no-extraneous-require
+const path = require('path');
+
+const resolveFrom = require('resolve-from');
+const maybeNodeEnvironment = require(resolveFrom(process.cwd(), 'jest-environment-node'));
+/** @type {typeof import('@jest/environment').JestEnvironment} */
 const NodeEnvironment = maybeNodeEnvironment.default || maybeNodeEnvironment;
 
 const detox = require('../../../internals');
-const { DetoxError } = require('../../../src/errors');
 const Timer = require('../../../src/utils/Timer');
 
 const {
@@ -24,6 +26,8 @@ const SYNC_CIRCUS_EVENTS = new Set([
   'error',
 ]);
 
+const log = detox.log.child({ cat: 'lifecycle,jest-environment' });
+
 /**
  * @see https://www.npmjs.com/package/jest-circus#overview
  */
@@ -32,98 +36,92 @@ class DetoxCircusEnvironment extends NodeEnvironment {
     super(assertJestCircus27(config), assertExistingContext(context));
 
     /** @private */
-    this._timer = null;
+    this._shouldManageDetox = detox.getStatus() === 'inactive';
     /** @private */
-    this._listenerFactories = {
+    this._timer = new Timer();
+
+    /** @internal */
+    this.testPath = path.relative(process.cwd(), context.testPath);
+    /** @protected */
+    this.testEventListeners = [];
+    /** @protected */
+    this.setupTimeout = detox.config.testRunner.jest.setupTimeout;
+    /** @protected */
+    this.teardownTimeout = detox.config.testRunner.jest.teardownTimeout;
+
+    log.trace.begin(this.testPath);
+
+    this.setup = this._wrapSetup(this.setup);
+    this.teardown = this._wrapTeardown(this.teardown);
+
+    this.registerListeners({
       DetoxInitErrorListener,
       DetoxPlatformFilterListener,
       DetoxCoreListener,
       SpecReporter,
       WorkerAssignReporter,
-    };
-    /** @protected */
-    this.testPath = context.testPath;
-    /** @protected */
-    this.testEventListeners = [];
-    /** @protected */
-    this.initTimeout = detox.config.testRunner.jest.initTimeout;
+    });
   }
 
   /** @override */
   async setup() {
     await super.setup();
-
-    await Timer.run({
-      description: `setting up Detox environment`,
-      timeout: this.initTimeout,
-      fn: async () => {
-        await this.initDetox();
-        this._instantiateListeners();
-      },
-    });
+    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);
+    if (SYNC_CIRCUS_EVENTS.has(event.name)) {
+      this._handleTestEventSync(event, state);
+    } else {
+      await this._handleTestEventAsync(event, state);
     }
+  };
 
-    this._timer = new Timer({
-      description: `handling jest-circus "${name}" event`,
-      timeout: state.testTimeout != null ? state.testTimeout : this.initTimeout,
-    });
-
+  /** @override */
+  async teardown() {
     try {
-      for (const listener of this.testEventListeners) {
-        if (typeof listener[name] !== 'function') {
-          continue;
-        }
-
-        try {
-          await this._timer.run(() => listener[name](event, state));
-        } catch (listenerError) {
-          this._logError(listenerError);
-          break;
-        }
-      }
+      await this.cleanupDetox();
     } finally {
-      this._timer.dispose();
-      this._timer = null;
+      await super.teardown();
     }
   }
 
-  /** @override */
-  async teardown() {
-    await Timer.run({
-      description: `tearing down Detox environment`,
-      timeout: this.initTimeout,
-      fn: async () => {
-        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,
+      }));
+    }
   }
 
   /**
    * @protected
    */
   async initDetox() {
-    await detox.setup({
+    const opts = {
       global: this.global,
-      workerId: +process.env.JEST_WORKER_ID,
-    });
+      workerId: `w${process.env.JEST_WORKER_ID}`,
+    };
+
+    if (this._shouldManageDetox) {
+      await detox.init(opts);
+    } else {
+      await detox.installWorker(opts);
+    }
+
+    return detox.worker;
   }
 
   /** @protected */
   async cleanupDetox() {
-    await detox.teardown();
+    if (this._shouldManageDetox) {
+      await detox.cleanup();
+    } else {
+      await detox.uninstallWorker();
+    }
   }
 
   /** @private */
@@ -138,17 +136,69 @@ 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;
+        }
+      }
     }
   }
 
-  /** @private */
-  _logError(e) {
-    detox.log.error(DetoxError.format(e));
+  _wrapSetup(fn) {
+    const _setup = fn.bind(this);
+
+    return 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();
+        }
+      });
+    };
+  }
+
+  _wrapTeardown(fn) {
+    const _teardown = fn.bind(this);
+
+    return async () => {
+      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();
+        }
+      });
+    };
   }
 }
 

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

@@ -7,17 +7,14 @@ const { getFullTestName, hasTimedOut } = require('../utils');
 
 const RETRY_TIMES = Symbol.for('RETRY_TIMES');
 
+const log = detoxInternals.log.child({ cat: 'lifecycle,jest-environment' });
+
 class DetoxCoreListener {
   constructor({ env }) {
-    this._startedTests = new WeakSet();
-    this._testsFailedBeforeStart = new WeakSet();
+    this._startedTests = new Set();
+    this._testsFailedBeforeStart = new Set();
     this._env = env;
-    this._testRunTimes = 1;
-  }
-
-  _getTestInvocations(test) {
-    const { testSessionIndex } = detoxInternals.session;
-    return testSessionIndex * this._testRunTimes + test.invocations;
+    this._circusRetryTimes = 1;
   }
 
   async setup() {
@@ -27,29 +24,50 @@ class DetoxCoreListener {
     }
   }
 
-  async run_describe_start({ describeBlock: { name, children } }) {
-    if (children.length) {
-      await detoxInternals.onRunDescribeStart({ name });
+  async run_describe_start({ describeBlock }) {
+    if (describeBlock.children.length) {
+      log.trace.begin(describeBlock.parent ? describeBlock.name : 'run the tests');
+      await detoxInternals.onRunDescribeStart({
+        name: describeBlock.name,
+      });
     }
   }
 
-  async run_describe_finish({ describeBlock: { name, children } }) {
-    if (children.length) {
-      await detoxInternals.onRunDescribeFinish({ name });
+  async run_describe_finish({ describeBlock }) {
+    if (describeBlock.children.length) {
+      await detoxInternals.onRunDescribeFinish({ name: describeBlock.name });
+      log.trace.end();
     }
   }
 
   async test_start({ test }) {
-    if (!_.isEmpty(test.errors)) {
+    const metadata = this._getTestMetadata(test);
+    if (metadata.status === 'failed') {
       this._testsFailedBeforeStart.add(test);
     }
 
+    const logTrace = this._isTestSkipped(test)
+      ? log.trace
+      : log.trace.begin;
+
+    logTrace({
+      context: 'test',
+      status: metadata.status,
+      fullName: metadata.fullName,
+      invocations: metadata.invocations,
+    }, metadata.title);
+
     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) {
+  async hook_start(event, state) {
     await this._onBeforeActualTestStart(state.currentlyRunningTest);
+    log.trace.begin({ functionCode: event.hook.fn.toString() }, event.hook.type);
+  }
+
+  async hook_success() {
+    log.trace.end({ success: true });
   }
 
   async hook_failure({ error, hook }) {
@@ -57,62 +75,91 @@ class DetoxCoreListener {
       error,
       hook: hook.type,
     });
+
+    log.trace.end({ success: false, error });
   }
 
   async test_fn_start({ test }) {
     await this._onBeforeActualTestStart(test);
+
+    if (!this._testsFailedBeforeStart.has(test)) {
+      // Jest bug workaround: beforeAll hook errors result into an unterminated test_fn_start event.
+      log.trace.begin({ functionCode: test.fn.toString() }, 'test_fn');
+    }
+  }
+
+  async test_fn_success() {
+    log.trace.end({ success: true });
   }
 
   async test_fn_failure({ error }) {
     await detoxInternals.onTestFnFailure({ error });
+    log.trace.end({ success: false, error });
+  }
+
+  async test_done({ test }) {
+    const metadata = this._getTestMetadata(test);
+
+    if (this._startedTests.has(test)) {
+      await detoxInternals.onTestDone(metadata);
+      this._startedTests.delete(test);
+    }
+
+    log.trace.end(_.pick(metadata, ['status', 'timedOut']));
   }
 
   async _onBeforeActualTestStart(test) {
-    if (!test || test.status === 'skip' || this._startedTests.has(test) || this._testsFailedBeforeStart.has(test)) {
+    if (!this._isTestActuallyStarting(test)) {
       return;
     }
 
     this._startedTests.add(test);
+    await detoxInternals.onTestStart(this._getTestMetadata(test));
+  }
 
-    await detoxInternals.onTestStart({
+  _isTestActuallyStarting(test) {
+    return test && !this._isTestSkipped(test) && !this._startedTests.has(test) && !this._testsFailedBeforeStart.has(test);
+  }
+
+  _isTestSkipped(test) {
+    return test && (test.mode === 'skip' || test.mode === 'todo');
+  }
+
+  _getTestMetadata(test) {
+    const result = {
       title: test.name,
       fullName: getFullTestName(test),
-      status: 'running',
+      status: this._getTestStatus(test),
       invocations: this._getTestInvocations(test),
-    });
-  }
-
-  async test_done({ test }) {
-    if (this._startedTests.has(test)) {
-      await detoxInternals.onTestDone({
-        title: test.name,
-        fullName: getFullTestName(test),
-        status: test.errors.length ? 'failed' : 'passed',
-        invocations: this._getTestInvocations(test),
-        timedOut: hasTimedOut(test)
-      });
+    };
 
-      this._startedTests.delete(test);
+    if (result.status === 'failed') {
+      result.timedOut = hasTimedOut(test);
     }
+
+    return result;
   }
 
-  async run_finish(_event, state) {
-    if (this._hasFailedTests(state.rootDescribeBlock)) {
-      const handledByJestCircus = this._testRunTimes > 1 && !detoxInternals.config.testRunner.jest.retryAfterCircusRetries;
-      await detoxInternals.reportFailedTests([this._env.testPath], handledByJestCircus);
+  /** @returns { 'failed' | 'passed' | 'running' | 'skip' | 'todo' } */
+  _getTestStatus(test) {
+    if (!_.isEmpty(test.errors)) {
+      return 'failed';
     }
-  }
 
-  _hasFailedTests(block) {
-    if (block.children) {
-      for (const child of block.children) {
-        if (this._hasFailedTests(child)) {
-          return true;
-        }
-      }
+    if (this._isTestSkipped(test)) {
+      return test.mode;
     }
 
-    return block.errors ? block.errors.length > 0 : false;
+    if (test.status === 'done') {
+      return 'passed';
+    } else {
+      return test.status || 'running';
+    }
+  }
+
+  _getTestInvocations(test) {
+    const { testSessionIndex } = detoxInternals.session;
+    return testSessionIndex * this._circusRetryTimes + test.invocations;
   }
 }
 

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/runners/jest/testEnvironment/listeners/SpecReporter.js

@@ -1,4 +1,5 @@
 const chalk = require('chalk').default;
+const noop = require('lodash/noop');
 
 const { config, log, session } = require('../../../../internals');
 const { traceln } = require('../utils/stdout');
@@ -15,16 +16,21 @@ class SpecReporter {
     this._suitesDesc = '';
   }
 
-  get enabled() {
+  setup() {
     const jestSection = config.testRunner.jest;
     const reportSpecs = jestSection && jestSection.reportSpecs;
-
-    return reportSpecs !== undefined ? reportSpecs : session.workersCount === 1;
+    const enabled = reportSpecs !== undefined ? reportSpecs : session.workersCount === 1;
+
+    if (!enabled) {
+      this.run_describe_start = noop;
+      this.run_describe_finish = noop;
+      this.test_start = noop;
+      this.test_done = noop;
+      this.test_skip = noop;
+    }
   }
 
   run_describe_start(event) {
-    if (!this.enabled) return;
-
     if (event.describeBlock.parent !== undefined) {
       this._onSuiteStart({
         description: event.describeBlock.name,
@@ -33,16 +39,12 @@ class SpecReporter {
   }
 
   run_describe_finish(event) {
-    if (!this.enabled) return;
-
     if (event.describeBlock.parent !== undefined) {
       this._onSuiteEnd();
     }
   }
 
   test_start(event) {
-    if (!this.enabled) return;
-
     const { test } = event;
     this._onTestStart({
       description: test.name,
@@ -51,8 +53,6 @@ class SpecReporter {
   }
 
   test_done(event) {
-    if (!this.enabled) return;
-
     const { test } = event;
     const testInfo = {
       description: test.name,
@@ -62,8 +62,6 @@ class SpecReporter {
   }
 
   test_skip(event) {
-    if (!this.enabled) return;
-
     const testInfo = {
       description: event.test.name,
     };
@@ -110,7 +108,7 @@ class SpecReporter {
         .concat(suite.description)
         .concat((index === total - 1) ? ': ' : '');
     });
-    this._suitesDesc = chalk.bold.white(this._suitesDesc);
+    this._suitesDesc = chalk.bold(this._suitesDesc);
   }
 
   _traceTest({ description, invocations }, _status = undefined) {
@@ -118,7 +116,7 @@ class SpecReporter {
     const retriesDescription = (invocations > 1) ? chalk.gray(` [Retry #${invocations - 1}]`) : '';
     const status = chalk.gray(_status ? ` [${_status}]` : '');
     const desc = this._suitesDesc + testDescription + retriesDescription + status;
-    log.info({ event: 'SPEC_STATE_CHANGE' }, desc);
+    log.info({ cat: 'lifecycle' }, desc);
   }
 }
 

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

@@ -13,7 +13,7 @@ class WorkerAssignReporter {
 
   run_start() {
     if (config.testRunner.jest.reportWorkerAssign) {
-      log.info({ event: 'WORKER_ASSIGN' }, `${this._formatTestName()} is assigned to ${this._formatDeviceName()}`);
+      log.info({ cat: 'lifecycle' }, `${chalk.bold(this._testName)} is assigned to ${this._formatDeviceName()}`);
     }
   }
 
@@ -25,10 +25,6 @@ class WorkerAssignReporter {
 
     return formattedDeviceName;
   }
-
-  _formatTestName() {
-    return chalk.whiteBright(this._testName);
-  }
 }
 
 module.exports = WorkerAssignReporter;

package/runners/jest/testEnvironment/utils/assertJestCircus27.js

@@ -1,8 +1,10 @@
 const fs = require('fs');
 const path = require('path');
 
+const resolveFrom = require('resolve-from');
 const semver = require('semver');
 
+const { log } = require('../../../../internals');
 const detoxPackageJson = require('../../../../package.json');
 const { DetoxRuntimeError } = require('../../../../src/errors');
 
@@ -25,6 +27,10 @@ function assertJestCircus27(maybeProjectConfig) {
     });
   }
 
+  const jestManifestPath = resolveFrom(process.cwd(), 'jest/package.json');
+  const jestManifest = require(jestManifestPath);
+  assertSupportedVersion(jestManifest.version);
+
   const circusVersion = require(circusPackageJson).version;
   if (!circusVersion) {
     throw new DetoxRuntimeError({
@@ -33,7 +39,14 @@ function assertJestCircus27(maybeProjectConfig) {
     });
   }
 
-  assertSupportedVersion(circusVersion);
+  if (jestManifest.version !== circusVersion) {
+    log.warn([
+      `jest-circus@${circusVersion} does not match jest@${jestManifest.version}.\n`,
+      `- jest@${jestManifest.version} resolved path:\n\t${jestManifestPath}`,
+      `- jest-circus@${circusVersion} resolved path:\n\t${circusPackageJson}`,
+      `\nPlease make sure that your versions match to avoid unexpected behavior!`,
+    ].join('\n'));
+  }
 
   return maybeProjectConfig;
 }
@@ -41,11 +54,12 @@ function assertJestCircus27(maybeProjectConfig) {
 function assertSupportedVersion(actualVersion) {
   const supportedRange = detoxPackageJson.peerDependencies.jest;
   const minSupportedVersion = semver.minVersion(supportedRange);
+  const action = semver.lt(actualVersion, minSupportedVersion) ? 'upgrade' : 'downgrade';
 
-  if (semver.lt(actualVersion, minSupportedVersion)) {
+  if (!semver.satisfies(actualVersion, supportedRange, { includePrerelease: true })) {
     throw new DetoxRuntimeError({
       message: `Detected an unsupported jest@${actualVersion} version.`,
-      hint: `Please upgrade your Jest test runner to the supported range: ${supportedRange}.`
+      hint: `Please ${action} your Jest test runner to the supported range: ${supportedRange}.`
     });
   }
 }

package/runners/jest/testEnvironment/utils/assertJestCircus27.test.js

@@ -9,7 +9,6 @@ describe('assertSupportedVersion', () => {
     ['28.0.0'],
     ['28.1.0'],
     ['29.0.0-next.0'],
-    ['30.0.0'],
   ])('should pass for %j', (version) => {
     expect(() => assertSupportedVersion(version)).not.toThrow();
   });