detox 20.1.0-next-is-hittable-check.0 → 20.1.1

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;
   }
@@ -41,10 +41,22 @@ class DetoxCoreListener {
   }
 
   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._circusRetryTimes = isNaN(circusRetryTimes) ? 1 : 1 + circusRetryTimes;
   }
@@ -69,7 +81,11 @@ class DetoxCoreListener {
 
   async test_fn_start({ test }) {
     await this._onBeforeActualTestStart(test);
-    log.trace.begin({ functionCode: test.fn.toString() }, 'test_fn');
+
+    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() {
@@ -82,57 +98,68 @@ class DetoxCoreListener {
   }
 
   async test_done({ test }) {
-    if (this._startedTests.has(test)) {
-      const failed = test.errors.length > 0;
-      const metadata = {
-        ...this._getTestMetadata(test),
-        status: failed ? 'failed' : 'passed',
-        timedOut: failed ? hasTimedOut(test) : undefined,
-      };
+    const metadata = this._getTestMetadata(test);
 
+    if (this._startedTests.has(test)) {
       await detoxInternals.onTestDone(metadata);
       this._startedTests.delete(test);
-      log.trace.end({
-        status: metadata.status,
-        timedOut: metadata.timedOut,
-      });
     }
+
+    log.trace.end(_.pick(metadata, ['status', 'timedOut']));
   }
 
   async _onBeforeActualTestStart(test) {
-    if (!test || test.status === 'skip' || this._startedTests.has(test) || this._testsFailedBeforeStart.has(test)) {
-      return false;
+    if (!this._isTestActuallyStarting(test)) {
+      return;
     }
 
-    const metadata = {
-      ...this._getTestMetadata(test),
-      status: 'running',
-    };
-
     this._startedTests.add(test);
+    await detoxInternals.onTestStart(this._getTestMetadata(test));
+  }
 
-    log.trace.begin({
-      context: 'test',
-      status: metadata.status,
-      fullName: metadata.fullName,
-      invocations: metadata.invocations,
-    }, metadata.title);
-
-    await detoxInternals.onTestStart(metadata);
-    return true;
+  _isTestActuallyStarting(test) {
+    return test && !this._isTestSkipped(test) && !this._startedTests.has(test) && !this._testsFailedBeforeStart.has(test);
   }
 
-  _getTestInvocations(test) {
-    const { testSessionIndex } = detoxInternals.session;
-    return testSessionIndex * this._circusRetryTimes + test.invocations;
+  _isTestSkipped(test) {
+    return test && (test.mode === 'skip' || test.mode === 'todo');
   }
 
   _getTestMetadata(test) {
-    return {
+    const result = {
       title: test.name,
       fullName: getFullTestName(test),
+      status: this._getTestStatus(test),
       invocations: this._getTestInvocations(test),
     };
+
+    if (result.status === 'failed') {
+      result.timedOut = hasTimedOut(test);
+    }
+
+    return result;
+  }
+
+  /** @returns { 'failed' | 'passed' | 'running' | 'skip' | 'todo' } */
+  _getTestStatus(test) {
+    if (!_.isEmpty(test.errors)) {
+      return 'failed';
+    }
+
+    if (this._isTestSkipped(test)) {
+      return test.mode;
+    }
+
+    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/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/src/DetoxWorker.js

@@ -1,17 +1,18 @@
+const CAF = require('caf');
 const _ = require('lodash');
 
 const Client = require('./client/Client');
 const environmentFactory = require('./environmentFactory');
 const { DetoxRuntimeErrorComposer } = require('./errors');
 const { InvocationManager } = require('./invoke');
-const symbols = require('./symbols');
+const symbols = require('./realms/symbols');
 const AsyncEmitter = require('./utils/AsyncEmitter');
 const uuid = require('./utils/uuid');
 
 class DetoxWorker {
   constructor(context) {
     this._context = context;
-    this._isCleaningUp = false;
+    this._injectedGlobalProperties = [];
     this._config = context[symbols.config];
     this._runtimeErrorComposer = new DetoxRuntimeErrorComposer(this._config);
     this._client = null;
@@ -32,6 +33,18 @@ class DetoxWorker {
       onError: this._onEmitError.bind(this),
     });
 
+
+    /** @type {DetoxInternals.RuntimeConfig['apps']} */
+    this._appsConfig = null;
+    /** @type {DetoxInternals.RuntimeConfig['artifacts']} */
+    this._artifactsConfig = null;
+    /** @type {DetoxInternals.RuntimeConfig['behavior']} */
+    this._behaviorConfig = null;
+    /** @type {DetoxInternals.RuntimeConfig['device']} */
+    this._deviceConfig = null;
+    /** @type {DetoxInternals.RuntimeConfig['session']} */
+    this._sessionConfig = null;
+
     /** @type {string} */
     this.id = 'worker';
     /** @type {Detox.Device} */
@@ -53,11 +66,23 @@ class DetoxWorker {
     this.trace = this._context.trace;
     /** @deprecated */
     this.traceCall = this._context.traceCall;
-  }
 
-  async init() {
-    if (this._isCleaningUp) return;
+    this._reinstallAppsOnDevice = CAF(this._reinstallAppsOnDevice.bind(this));
+    this._initToken = new CAF.cancelToken();
+
+    this._cafWrap([
+      'init',
+      'onRunDescribeStart',
+      'onTestStart',
+      'onHookFailure',
+      'onTestFnFailure',
+      'onTestDone',
+      'onRunDescribeFinish',
+    ]);
+  }
 
+  /** @this {DetoxWorker} */
+  init = function* (signal) {
     const {
       apps: appsConfig,
       artifacts: artifactsConfig,
@@ -71,6 +96,7 @@ class DetoxWorker {
     this._behaviorConfig = behaviorConfig;
     this._deviceConfig = deviceConfig;
     this._sessionConfig = sessionConfig;
+    // @ts-ignore
     this._sessionConfig.sessionId = sessionConfig.sessionId || uuid.UUID();
     this._runtimeErrorComposer.appsConfig = this._appsConfig;
 
@@ -82,8 +108,7 @@ class DetoxWorker {
       }
     };
 
-    await this._client.connect();
-    if (this._isCleaningUp) return;
+    yield this._client.connect();
 
     const invocationManager = new InvocationManager(this._client);
 
@@ -100,8 +125,7 @@ class DetoxWorker {
     } = environmentFactory.createFactories(this._deviceConfig);
 
     const envValidator = envValidatorFactory.createValidator();
-    await envValidator.validate();
-    if (this._isCleaningUp) return;
+    yield envValidator.validate();
 
     const commonDeps = {
       invocationManager,
@@ -112,8 +136,7 @@ class DetoxWorker {
 
     this._artifactsManager = artifactsManagerFactory.createArtifactsManager(this._artifactsConfig, commonDeps);
     this._deviceAllocator = deviceAllocatorFactory.createDeviceAllocator(commonDeps);
-    this._deviceCookie = await this._deviceAllocator.allocate(this._deviceConfig);
-    if (this._isCleaningUp) return;
+    this._deviceCookie = yield this._deviceAllocator.allocate(this._deviceConfig);
 
     this.device = runtimeDeviceFactory.createRuntimeDevice(
       this._deviceCookie,
@@ -124,7 +147,6 @@ class DetoxWorker {
         deviceConfig: this._deviceConfig,
         sessionConfig,
       });
-    if (this._isCleaningUp) return;
 
     const matchers = matchersFactory.createMatchers({
       invocationManager,
@@ -134,34 +156,37 @@ class DetoxWorker {
     Object.assign(this, matchers);
 
     if (behaviorConfig.init.exposeGlobals) {
-      Object.assign(DetoxWorker.global, {
+      const injectedGlobals = {
         ...matchers,
         device: this.device,
         detox: this,
-      });
+      };
+
+      this._injectedGlobalProperties = Object.keys(injectedGlobals);
+      Object.assign(DetoxWorker.global, injectedGlobals);
     }
 
     // @ts-ignore
-    await this.device.installUtilBinaries();
-    if (this._isCleaningUp) return;
+    yield this.device.installUtilBinaries();
 
     if (behaviorConfig.init.reinstallApp) {
-      await this._reinstallAppsOnDevice();
-      if (this._isCleaningUp) return;
+      yield this._reinstallAppsOnDevice(signal);
     }
 
     const appAliases = Object.keys(this._appsConfig);
     if (appAliases.length === 1) {
-      await this.device.selectApp(appAliases[0]);
+      yield this.device.selectApp(appAliases[0]);
     } else {
-      await this.device.selectApp(null);
+      yield this.device.selectApp(null);
     }
-
-    return this;
-  }
+  };
 
   async cleanup() {
-    this._isCleaningUp = true;
+    this._initToken.abort('CLEANUP');
+
+    for (const key of this._injectedGlobalProperties) {
+      delete DetoxWorker.global[key];
+    }
 
     if (this._artifactsManager) {
       await this._artifactsManager.onBeforeCleanup();
@@ -190,38 +215,45 @@ class DetoxWorker {
     return this._context.log;
   }
 
-  onRunDescribeStart = async (...args) => this._artifactsManager.onRunDescribeStart(...args);
-  onTestStart = async (testSummary) => {
-    if (this._isCleaningUp) return;
+  onRunDescribeStart = function* (_signal, ...args) {
+    yield this._artifactsManager.onRunDescribeStart(...args);
+  };
+
+  onTestStart = function* (_signal, testSummary) {
     this._validateTestSummary('beforeEach', testSummary);
 
-    if (this._isCleaningUp) return;
-    await this._dumpUnhandledErrorsIfAny({
+    yield this._dumpUnhandledErrorsIfAny({
       pendingRequests: false,
       testName: testSummary.fullName,
     });
 
-    if (this._isCleaningUp) return;
-    await this._artifactsManager.onTestStart(testSummary);
+    yield this._artifactsManager.onTestStart(testSummary);
+  };
+
+  onHookFailure = function* (_signal, ...args) {
+    yield this._artifactsManager.onHookFailure(...args);
   };
-  onHookFailure = async (...args) => this._artifactsManager.onHookFailure(...args);
-  onTestFnFailure = async (...args) => this._artifactsManager.onTestFnFailure(...args);
-  onTestDone = async (testSummary) => {
-    if (this._isCleaningUp) return;
+
+  onTestFnFailure = function* (_signal, ...args) {
+    yield this._artifactsManager.onTestFnFailure(...args);
+  };
+
+  onTestDone = function* (_signal, testSummary) {
     this._validateTestSummary('afterEach', testSummary);
 
-    if (this._isCleaningUp) return;
-    await this._artifactsManager.onTestDone(testSummary);
+    yield this._artifactsManager.onTestDone(testSummary);
 
-    if (this._isCleaningUp) return;
-    await this._dumpUnhandledErrorsIfAny({
+    yield this._dumpUnhandledErrorsIfAny({
       pendingRequests: testSummary.timedOut,
       testName: testSummary.fullName,
     });
   };
-  onRunDescribeFinish = async (...args) => this._artifactsManager.onRunDescribeFinish(...args);
 
-  async _reinstallAppsOnDevice() {
+  onRunDescribeFinish = function* (_signal, ...args) {
+    yield this._artifactsManager.onRunDescribeFinish(...args);
+  };
+
+  *_reinstallAppsOnDevice(_signal) {
     const appNames = _(this._appsConfig)
       .map((config, key) => [key, `${config.binaryPath}:${config.testBinaryPath}`])
       .uniqBy(1)
@@ -229,17 +261,13 @@ class DetoxWorker {
       .value();
 
     for (const appName of appNames) {
-      await this.device.selectApp(appName);
-      if (this._isCleaningUp) return;
-      await this.device.uninstallApp();
-      if (this._isCleaningUp) return;
+      yield this.device.selectApp(appName);
+      yield this.device.uninstallApp();
     }
 
     for (const appName of appNames) {
-      await this.device.selectApp(appName);
-      if (this._isCleaningUp) return;
-      await this.device.installApp();
-      if (this._isCleaningUp) return;
+      yield this.device.selectApp(appName);
+      yield this.device.installApp();
     }
   }
 
@@ -271,10 +299,28 @@ class DetoxWorker {
       error
     );
   }
+
+  _cafWrap(methodNames) {
+    for (const methodName of methodNames) {
+      const cafMethod = CAF(this[methodName].bind(this));
+      this[methodName] = async (...args) => {
+        try {
+          await cafMethod(this._initToken.signal, ...args);
+        } catch (e) {
+          if (e !== 'CLEANUP') {
+            throw e;
+          }
+        }
+
+        return this;
+      };
+    }
+  }
+
 }
 
 /**
- * @type {NodeJS.Global}
+ * @type {NodeJS.Global | {}}
  */
 DetoxWorker.global = global;
 

package/src/android/core/NativeMatcher.js

@@ -2,29 +2,33 @@ const invoke = require('../../invoke');
 const DetoxMatcherApi = require('../espressoapi/DetoxMatcher');
 
 class NativeMatcher {
+  constructor(call) {
+    this._call = call || null;
+  }
+
   withAncestor(matcher) {
-    this._call = invoke.callDirectly(DetoxMatcherApi.matcherWithAncestor(this, matcher));
-    return this;
+    const call = invoke.callDirectly(DetoxMatcherApi.matcherWithAncestor(this, matcher));
+    return new NativeMatcher(call);
   }
 
   withDescendant(matcher) {
-    this._call = invoke.callDirectly(DetoxMatcherApi.matcherWithDescendant(this, matcher));
-    return this;
+    const call = invoke.callDirectly(DetoxMatcherApi.matcherWithDescendant(this, matcher));
+    return new NativeMatcher(call);
   }
 
   and(matcher) {
-    this._call = invoke.callDirectly(DetoxMatcherApi.matcherForAnd(this, matcher));
-    return this;
+    const call = invoke.callDirectly(DetoxMatcherApi.matcherForAnd(this, matcher));
+    return new NativeMatcher(call);
   }
 
   or(matcher) {
-    this._call = invoke.callDirectly(DetoxMatcherApi.matcherForOr(this, matcher));
-    return this;
+    const call = invoke.callDirectly(DetoxMatcherApi.matcherForOr(this, matcher));
+    return new NativeMatcher(call);
   }
 
   get not() {
-    this._call = invoke.callDirectly(DetoxMatcherApi.matcherForNot(this));
-    return this;
+    const call = invoke.callDirectly(DetoxMatcherApi.matcherForNot(this));
+    return new NativeMatcher(call);
   }
 
   _avoidProblematicReactNativeElements() {

package/src/android/espressoapi/EspressoDetox.js

@@ -52,7 +52,7 @@ class EspressoDetox {
   }
 
   static setURLBlacklist(urls) {
-    if (typeof urls !== 'object' || !urls instanceof Array) {
+    if (typeof urls !== 'object' || !Array.isArray(urls)) {
       throw new Error('urls must be an array, got ' + typeof urls);
     }
 

package/src/android/espressoapi/web/WebElement.js

@@ -69,7 +69,7 @@ class WebElement {
   static runScriptWithArgs(element, script, args) {
     if (typeof script !== "string") throw new Error("script should be a string, but got " + (script + (" (" + (typeof script + ")"))));
 
-    if (typeof args !== 'object' || !args instanceof Array) {
+    if (typeof args !== 'object' || !Array.isArray(args)) {
       throw new Error('args must be an array, got ' + typeof args);
     }
 

package/src/android/interactions/native.js

@@ -1,6 +1,7 @@
 const DetoxRuntimeError = require('../../errors/DetoxRuntimeError');
 const { expectDescription, actionDescription } = require('../../utils/invocationTraceDescriptions');
-const { trace } = require('../../utils/trace');
+const log = require('../../utils/logger').child({ cat: 'ws-client, ws' });
+const traceInvocationCall = require('../../utils/traceInvocationCall').bind(null, log);
 const { ScrollAmountStopAtEdgeAction } = require('../actions/native');
 const { NativeMatcher } = require('../core/NativeMatcher');
 const DetoxAssertionApi = require('../espressoapi/DetoxAssertion');
@@ -18,7 +19,7 @@ class Interaction {
   }
 
   async execute() {
-    return trace.invocationCall(this._traceDescription, this._call,
+    return traceInvocationCall(this._traceDescription, this._call,
       this._invocationManager.execute(this._call).then((resultObj) => resultObj ? resultObj.result : undefined));
   }
 }

package/src/android/matchers/native.js

@@ -64,8 +64,7 @@ class ToggleMatcher extends NativeMatcher {
   }
 }
 
-// TODO
-// Please be aware, that this is just a dummy matcher
+// TODO: Please be aware, that this is just a dummy matcher
 class TraitsMatcher extends NativeMatcher {
   constructor(value) {
     super();

package/src/artifacts/ArtifactsManager.js

@@ -46,13 +46,13 @@ class ArtifactsManager extends EventEmitter {
   _resolveArtifactsPathBuilder(pathBuilder, rootDir) {
     if (typeof pathBuilder === 'string') {
       pathBuilder = resolveModuleFromPath(pathBuilder);
+    }
 
-      if (typeof pathBuilder === 'function') {
-        try {
-          pathBuilder = pathBuilder({ rootDir });
-        } catch (e) {
-          pathBuilder = new pathBuilder({ rootDir });
-        }
+    if (typeof pathBuilder === 'function') {
+      try {
+        pathBuilder = pathBuilder({ rootDir });
+      } catch (e) {
+        pathBuilder = new pathBuilder({ rootDir });
       }
     }