detox 20.0.14-is-hittable-over-master.0 → 20.0.14-prerelease.0

package/runners/deprecation.js

@@ -1,47 +1,45 @@
 const chalk = require('chalk');
 
 // @ts-ignore
-console.error(chalk.yellow(`
-=========================  THE NEW JOURNEY BEGINS  =============================
-
-            https://wix.github.io/Detox/docs/next/guide/migration
-
-             _.-;-._              Sorry, traveler from the lands of Detox 19!
-            ;_.JL___;
-            F"-/\\_-7L             Detox 20 comes without old adapters for Jest
-            | a/ e | \\            and Mocha test runners. You have to rearrange
-           ,L,c;,.='/;,           your init code before you can continue your
-        _,-;;S:;:S;;:' '--._      journey.
-       ;. \\;;s:::s;;: .'   /\\
-      /  \\  ;::::;;  /    /  \\    Navigate to the link above and follow the
-     / ,  k ;S';;'S.'    j __,l   migration guide steps.
-  ,---/| /  /S   /S '.   |'   ;
- ,Ljjj |/|.' s .' s   \\  L    |   Sincerely yours,
- LL,_ ]( \\    /    '.  '.||   ;   Detox team.
- ||\\ > /  ;-.'_.-.___\\.-'(|=="(
- JJ," /   |_  [   ]     _]|   /
-  LL\\/   ,' '--'-'-----'  \\  (
-  ||     ;      |          |  >
-  JJ     |      |\\         |,/
-   LL    |      ||       ' |
-   ||    |      ||       . |
-   JJ    /_     ||       ;_|
-    LL   L "==='|i======='_|
-    ||    i----' '-------';
-    JJ    ';-----.------,-'
-     LL     L_.__J,'---;'
-     ||      |   ,|    (
-     JJ     .'=  (|  ,_|
-      LL   /    .'L_    \\
-snd   ||   '---'    '.___>
-Credit: "Gimli" by Shanaka Dias
-
-            https://wix.github.io/Detox/docs/next/guide/migration
-
-=========================  THE NEW JOURNEY BEGINS  =============================
-
-`));
-
-throw Object.assign(new Error(
-  '\n\nPlease follow the new Jest setup guide:\nhttps://github.com/wix/Detox/blob/master/docs/Guide.Jest.md\n\n'
-), { stack: '' });
+const bold = chalk.bold;
+
+function getMaxWidth(text) {
+  const lines = text.split('\n');
+  return lines.reduce((acc, line) => Math.max(acc, line.length), 0);
+}
+
+function centerText(text, maxWidth = getMaxWidth(text)) {
+  return text
+    .split('\n')
+    .map(line => {
+      const padStart = Math.max(0, Math.floor((maxWidth - line.length) / 2));
+      const padEnd = Math.max(0, maxWidth - line.length - padStart);
+      return ' '.repeat(padStart) + line + ' '.repeat(padEnd);
+    })
+    .join('\n');
+}
+
+const header = `\
+=========================  THE NEW JOURNEY BEGINS  =============================`;
+
+console.error(centerText(`\
+
+${bold(header)}
+
+https://wix.github.io/Detox/docs/next/guide/migration
+
+Sorry to say that Detox 20 comes without old adapters for Jest.
+You have to rearrange your init code before you can continue your journey.
+
+Navigate to the link and follow the migration guide steps.
+
+Sincerely yours,
+Detox team.
+
+${bold(header)}
+
+`, header.length));
+
+const error = new Error('\nPlease follow the migration guide:\nhttps://wix.github.io/Detox/docs/next/guide/migration\n\n');
+error.stack = '';
+throw error;

package/runners/jest/index.d.ts

@@ -0,0 +1,60 @@
+declare module 'detox/runners/jest' {
+  import type NodeEnvironment from 'jest-environment-node';
+
+  export function globalSetup(): Promise<void>;
+  export function globalTeardown(): Promise<void>;
+
+  export type DetoxCircusListenerConstructorOpts = {
+    readonly env: DetoxCircusEnvironment;
+  }
+
+  /**
+   * @example
+   * class CustomListener implements DetoxCircusListener {
+   *   constructor(opts: DetoxCircusListenerConstructorOpts) {
+   *     console.log('Current test path is:', opts.env.testPath);
+   *   }
+   * }
+   */
+  export interface DetoxCircusListener {
+    start_describe_definition?(event: unknown, state: unknown): void;
+    finish_describe_definition?(event: unknown, state: unknown): void;
+    add_hook?(event: unknown, state: unknown): void;
+    add_test?(event: unknown, state: unknown): void;
+    error?(event: unknown, state: unknown): void;
+
+    setup?(event: unknown, state: unknown): void | Promise<void>;
+    include_test_location_in_result?(event: unknown, state: unknown): void | Promise<void>;
+    hook_start?(event: unknown, state: unknown): void | Promise<void>;
+    hook_success?(event: unknown, state: unknown): void | Promise<void>;
+    hook_failure?(event: unknown, state: unknown): void | Promise<void>;
+    test_fn_start?(event: unknown, state: unknown): void | Promise<void>;
+    test_fn_success?(event: unknown, state: unknown): void | Promise<void>;
+    test_fn_failure?(event: unknown, state: unknown): void | Promise<void>;
+    test_retry?(event: unknown, state: unknown): void | Promise<void>;
+    test_start?(event: unknown, state: unknown): void | Promise<void>;
+    test_skip?(event: unknown, state: unknown): void | Promise<void>;
+    test_todo?(event: unknown, state: unknown): void | Promise<void>;
+    test_done?(event: unknown, state: unknown): void | Promise<void>;
+    run_describe_start?(event: unknown, state: unknown): void | Promise<void>;
+    run_describe_finish?(event: unknown, state: unknown): void | Promise<void>;
+    run_start?(event: unknown, state: unknown): void | Promise<void>;
+    run_finish?(event: unknown, state: unknown): void | Promise<void>;
+    teardown?(event: unknown, state: unknown): void | Promise<void>;
+  }
+
+  export interface DetoxListenerFactory {
+    new (opts: DetoxCircusListenerConstructorOpts): DetoxCircusListener;
+  }
+
+  export class DetoxCircusEnvironment extends NodeEnvironment {
+    public readonly handleTestEvent: (event: unknown, state: unknown) => void | Promise<void>;
+    public readonly testPath: string;
+
+    protected registerListeners(map: Record<string, DetoxListenerFactory>): void;
+    protected setupTimeout: number;
+    protected teardownTimeout: number;
+    protected initDetox(): Promise<DetoxInternals.Worker>;
+    protected cleanupDetox(): Promise<void>;
+  }
+}

package/runners/jest/index.js

@@ -1,14 +1,11 @@
-module.exports = {
-  //#region *** Runner Realm ***
+// Lazy require() is used to avoid initializing a bare Detox context when it is not needed.
+// At the moment, this safety measure is not really needed, but it's better to be on the safe side.
 
+module.exports = {
   get DetoxCircusEnvironment() {
     return require('./testEnvironment');
   },
 
-  //#endregion
-
-  //#region *** Worker Realm ***
-
   get globalSetup() {
     return require('./globalSetup');
   },
@@ -16,6 +13,4 @@ module.exports = {
   get globalTeardown() {
     return require('./globalTeardown');
   },
-
-  //#endregion
 };

package/runners/jest/reporters/DetoxReporter.js

@@ -5,20 +5,31 @@ const JestVerboseReporter = require(resolveFrom(process.cwd(), '@jest/reporters'
 const { config, reportTestResults } = require('../../../internals');
 
 class DetoxReporter extends JestVerboseReporter {
+  /**
+   * @param {import('@jest/test-result').AggregatedResult} results
+   */
+  // @ts-ignore
+  async onRunComplete(_contexts, results) {
+    // @ts-ignore
+    await super.onRunComplete(_contexts, results);
+
+    await reportTestResults(results.testResults.map(r => ({
+      success: !r.failureMessage,
+      testFilePath: r.testFilePath,
+      testExecError: r.testExecError,
+      isPermanentFailure: this._isPermanentFailure(r),
+    })));
+  }
+
   /**
    * @param {import('@jest/test-result').TestResult} testResult
    */
-  async onTestResult(test, testResult, results) {
-    await super.onTestResult(test, testResult, results);
+  _isPermanentFailure(testResult) {
+    if (config.testRunner.jest.retryAfterCircusRetries) {
+      return false;
+    }
 
-    await reportTestResults([{
-      success: !testResult.failureMessage,
-      testFilePath: testResult.testFilePath,
-      testExecError: testResult.testExecError,
-      isPermanentFailure: config.testRunner.jest.retryAfterCircusRetries
-        ? false
-        : testResult.testResults.some(r => r.invocations > 1)
-    }]);
+    return testResult.testResults.some(r => r.status === 'failed' && r.invocations > 1);
   }
 }
 

package/runners/jest/testEnvironment/index.js

@@ -1,3 +1,5 @@
+const path = require('path');
+
 const resolveFrom = require('resolve-from');
 const maybeNodeEnvironment = require(resolveFrom(process.cwd(), 'jest-environment-node'));
 /** @type {typeof import('@jest/environment').JestEnvironment} */
@@ -39,7 +41,7 @@ class DetoxCircusEnvironment extends NodeEnvironment {
     this._timer = new Timer();
 
     /** @internal */
-    this.testPath = context.testPath;
+    this.testPath = path.relative(process.cwd(), context.testPath);
     /** @protected */
     this.testEventListeners = [];
     /** @protected */
@@ -49,45 +51,8 @@ class DetoxCircusEnvironment extends NodeEnvironment {
 
     log.trace.begin(this.testPath);
 
-    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 () => {
-      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.setup = this._wrapSetup(this.setup);
+    this.teardown = this._wrapTeardown(this.teardown);
 
     this.registerListeners({
       DetoxInitErrorListener,
@@ -100,6 +65,7 @@ class DetoxCircusEnvironment extends NodeEnvironment {
 
   /** @override */
   async setup() {
+    await super.setup();
     await this.initDetox();
   }
 
@@ -115,7 +81,11 @@ class DetoxCircusEnvironment extends NodeEnvironment {
 
   /** @override */
   async teardown() {
-    await this.cleanupDetox();
+    try {
+      await this.cleanupDetox();
+    } finally {
+      await super.teardown();
+    }
   }
 
   /** @protected */
@@ -184,6 +154,52 @@ class DetoxCircusEnvironment extends NodeEnvironment {
       }
     }
   }
+
+  _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();
+        }
+      });
+    };
+  }
 }
 
 module.exports = DetoxCircusEnvironment;

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

@@ -11,8 +11,8 @@ 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._circusRetryTimes = 1;
   }
@@ -100,7 +100,7 @@ class DetoxCoreListener {
   }
 
   async _onBeforeActualTestStart(test) {
-    if (!test || test.status === 'skip' || this._startedTests.has(test) || this._testsFailedBeforeStart.has(test)) {
+    if (!this._isTestActuallyStarting(test)) {
       return false;
     }
 
@@ -122,6 +122,10 @@ class DetoxCoreListener {
     return true;
   }
 
+  _isTestActuallyStarting(test) {
+    return test && test.status !== 'skip' && !this._startedTests.has(test) && !this._testsFailedBeforeStart.has(test);
+  }
+
   _getTestInvocations(test) {
     const { testSessionIndex } = detoxInternals.session;
     return testSessionIndex * this._circusRetryTimes + test.invocations;

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) {

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

@@ -13,7 +13,7 @@ class WorkerAssignReporter {
 
   run_start() {
     if (config.testRunner.jest.reportWorkerAssign) {
-      log.info({ cat: 'lifecycle' }, `${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();
   });