detox 20.12.0-smoke.0 → 20.12.0

package/src/DetoxWorker.js

@@ -33,6 +33,7 @@ class DetoxWorker {
       onError: this._onEmitError.bind(this),
     });
 
+
     /** @type {DetoxInternals.RuntimeConfig['apps']} */
     this._appsConfig = null;
     /** @type {DetoxInternals.RuntimeConfig['artifacts']} */
@@ -114,13 +115,14 @@ class DetoxWorker {
     const {
       // @ts-ignore
       envValidatorFactory,
+      deviceAllocatorFactory,
       // @ts-ignore
       artifactsManagerFactory,
       // @ts-ignore
       matchersFactory,
       // @ts-ignore
       runtimeDeviceFactory,
-    } = environmentFactory.createFactories(deviceConfig);
+    } = environmentFactory.createFactories(this._deviceConfig);
 
     const envValidator = envValidatorFactory.createValidator();
     yield envValidator.validate();
@@ -133,7 +135,10 @@ class DetoxWorker {
     };
 
     this._artifactsManager = artifactsManagerFactory.createArtifactsManager(this._artifactsConfig, commonDeps);
-    this._deviceCookie = yield this._context[symbols.allocateDevice]();
+    this._deviceAllocator = deviceAllocatorFactory.createDeviceAllocator(commonDeps);
+    this._deviceCookie = yield this._deviceAllocator.allocate(this._deviceConfig);
+
+    yield this._deviceAllocator.postAllocate(this._deviceCookie);
 
     this.device = runtimeDeviceFactory.createRuntimeDevice(
       this._deviceCookie,
@@ -152,8 +157,6 @@ class DetoxWorker {
     });
     Object.assign(this, matchers);
 
-    yield this._eventEmitter.emit('bootDevice', { deviceId: this.device.id });
-
     if (behaviorConfig.init.exposeGlobals) {
       const injectedGlobals = {
         ...matchers,
@@ -204,7 +207,8 @@ class DetoxWorker {
     }
 
     if (this._deviceCookie) {
-      await this._context[symbols.deallocateDevice](this._deviceCookie);
+      const shutdown = this._behaviorConfig ? this._behaviorConfig.cleanup.shutdownDevice : false;
+      await this._deviceAllocator.free(this._deviceCookie, { shutdown });
     }
 
     this._deviceAllocator = null;

package/src/android/core/NativeElement.js

@@ -15,39 +15,37 @@ class NativeElement {
   constructor(invocationManager, emitter, matcher) {
     this._invocationManager = invocationManager;
     this._emitter = emitter;
-    this._originalMatcher = matcher;
-    this._selectElementWithMatcher(this._originalMatcher);
+    this._matcher = matcher;
   }
 
-  _selectElementWithMatcher(matcher) {
-    this._call = invoke.call(invoke.Espresso, 'onView', matcher._call);
+  get _call() {
+    return invoke.call(invoke.Espresso, 'onView', this._matcher._call);
   }
 
   atIndex(index) {
     if (typeof index !== 'number') throw new DetoxRuntimeError({ message: `Element atIndex argument must be a number, got ${typeof index}` });
-    const matcher = this._originalMatcher;
-    this._originalMatcher._call = invoke.callDirectly(DetoxMatcherApi.matcherForAtIndex(index, matcher._call.value));
+    const matcher = this._matcher;
+    this._matcher._call = invoke.callDirectly(DetoxMatcherApi.matcherForAtIndex(index, matcher._call.value));
 
-    this._selectElementWithMatcher(this._originalMatcher);
     return this;
   }
 
   async tap(value) {
     const action = new actions.TapAction(value);
     const traceDescription = actionDescription.tapAtPoint(value);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async tapAtPoint(value) {
     const action = new actions.TapAtPointAction(value);
     const traceDescription = actionDescription.tapAtPoint(value);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async longPress() {
     const action = new actions.LongPressAction();
     const traceDescription = actionDescription.longPress();
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async multiTap(times) {
@@ -56,61 +54,61 @@ class NativeElement {
 
     const action = new actions.MultiClickAction(times);
     const traceDescription = actionDescription.multiTap(times);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async tapBackspaceKey() {
     const action = new actions.PressKeyAction(67);
     const traceDescription = actionDescription.tapBackspaceKey();
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async tapReturnKey() {
     const action = new actions.TypeTextAction('\n');
     const traceDescription = actionDescription.tapReturnKey();
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async typeText(value) {
     const action = new actions.TypeTextAction(value);
     const traceDescription = actionDescription.typeText(value);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async replaceText(value) {
     const action = new actions.ReplaceTextAction(value);
     const traceDescription = actionDescription.replaceText(value);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async clearText() {
     const action = new actions.ClearTextAction();
     const traceDescription = actionDescription.clearText();
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async scroll(amount, direction = 'down', startPositionX, startPositionY) {
     const action = new actions.ScrollAmountAction(direction, amount, startPositionX, startPositionY);
     const traceDescription = actionDescription.scroll(amount, direction, startPositionX, startPositionY);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async scrollTo(edge) {
     // override the user's element selection with an extended matcher that looks for UIScrollView children
-    this._selectElementWithMatcher(this._originalMatcher._extendToDescendantScrollViews());
+    this._matcher = this._matcher._extendToDescendantScrollViews();
 
     const action = new actions.ScrollEdgeAction(edge);
     const traceDescription = actionDescription.scrollTo(edge);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async scrollToIndex(index) {
     // override the user's element selection with an extended matcher that looks for UIScrollView children
-    this._selectElementWithMatcher(this._originalMatcher._extendToDescendantScrollViews());
+    this._matcher = this._matcher._extendToDescendantScrollViews();
 
     const action = new actions.ScrollToIndex(index);
     const traceDescription = actionDescription.scrollToIndex(index);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async setDatePickerDate(rawDateString, formatString) {
@@ -120,7 +118,7 @@ class NativeElement {
 
     const action = new actions.SetDatePickerDateAction(dateString, formatString);
     const traceDescription = actionDescription.setDatePickerDate(dateString, formatString);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   /**
@@ -134,18 +132,18 @@ class NativeElement {
     normalizedSwipeOffset = Number.isNaN(normalizedSwipeOffset) ? 0.75 : normalizedSwipeOffset;
 
     // override the user's element selection with an extended matcher that avoids RN issues with RCTScrollView
-    this._selectElementWithMatcher(this._originalMatcher._avoidProblematicReactNativeElements());
+    this._matcher = this._matcher._avoidProblematicReactNativeElements();
 
     const action = new actions.SwipeAction(direction, speed, normalizedSwipeOffset, normalizedStartingPointX, normalizedStartingPointY);
     const traceDescription = actionDescription.swipe(direction, speed, normalizedSwipeOffset, normalizedStartingPointX, normalizedStartingPointY);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async takeScreenshot(screenshotName) {
     // TODO this should be moved to a lower-layer handler of this use-case
     const action = new actions.TakeElementScreenshot();
     const traceDescription = actionDescription.takeScreenshot(screenshotName);
-    const resultBase64 = await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    const resultBase64 = await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
     const filePath = tempfile('detox.element-screenshot.png');
     await fs.writeFile(filePath, resultBase64, 'base64');
 
@@ -160,19 +158,18 @@ class NativeElement {
   async getAttributes() {
     const action = new actions.GetAttributes();
     const traceDescription = actionDescription.getAttributes();
-    const result = await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
-    return JSON.parse(result);
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async adjustSliderToPosition(newPosition) {
     const action = new actions.AdjustSliderToPosition(newPosition);
     const traceDescription = actionDescription.adjustSliderToPosition(newPosition);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async performAccessibilityAction(actionName) {
     const traceDescription = actionDescription.performAccessibilityAction(actionName);
-    return await new ActionInteraction(this._invocationManager, this, new actions.AccessibilityActionAction(actionName), traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, new actions.AccessibilityActionAction(actionName), traceDescription).execute();
   }
 }
 

package/src/android/espressoapi/DetoxAssertion.js

@@ -14,7 +14,7 @@ function sanitize_matcher(matcher) {
   return originalMatcher.type ? originalMatcher.value : originalMatcher;
 } 
 class DetoxAssertion {
-  static assertMatcher(i, m) {
+  static assertMatcher(viewInteraction, viewMatcher) {
     return {
       target: {
         type: "Class",
@@ -23,15 +23,15 @@ class DetoxAssertion {
       method: "assertMatcher",
       args: [{
         type: "Invocation",
-        value: i
+        value: viewInteraction
       }, {
         type: "Invocation",
-        value: sanitize_matcher(m)
+        value: sanitize_matcher(viewMatcher)
       }]
     };
   }
 
-  static assertNotVisible(i) {
+  static assertNotVisible(viewInteraction) {
     return {
       target: {
         type: "Class",
@@ -40,12 +40,12 @@ class DetoxAssertion {
       method: "assertNotVisible",
       args: [{
         type: "Invocation",
-        value: i
+        value: viewInteraction
       }]
     };
   }
 
-  static assertNotExists(i) {
+  static assertNotExists(viewInteraction) {
     return {
       target: {
         type: "Class",
@@ -54,12 +54,12 @@ class DetoxAssertion {
       method: "assertNotExists",
       args: [{
         type: "Invocation",
-        value: i
+        value: viewInteraction
       }]
     };
   }
 
-  static waitForAssertMatcher(i, m, timeoutSeconds) {
+  static waitForAssertMatcher(viewInteraction, viewMatcher, timeoutSeconds) {
     if (typeof timeoutSeconds !== "number") throw new Error("timeoutSeconds should be a number, but got " + (timeoutSeconds + (" (" + (typeof timeoutSeconds + ")"))));
     return {
       target: {
@@ -69,10 +69,10 @@ class DetoxAssertion {
       method: "waitForAssertMatcher",
       args: [{
         type: "Invocation",
-        value: i
+        value: viewInteraction
       }, {
         type: "Invocation",
-        value: sanitize_matcher(m)
+        value: sanitize_matcher(viewMatcher)
       }, {
         type: "Double",
         value: timeoutSeconds
@@ -80,7 +80,8 @@ class DetoxAssertion {
     };
   }
 
-  static waitForAssertMatcherWithSearchAction(i, vm, searchAction, searchMatcher) {
+  static waitForAssertMatcherWithSearchAction(viewInteraction, viewMatcher, searchAction, searchMatcher
+  ) {
     return {
       target: {
         type: "Class",
@@ -89,13 +90,14 @@ class DetoxAssertion {
       method: "waitForAssertMatcherWithSearchAction",
       args: [{
         type: "Invocation",
-        value: i
+        value: viewInteraction
       }, {
         type: "Invocation",
-        value: sanitize_matcher(vm)
+        value: sanitize_matcher(viewMatcher)
       }, searchAction, {
         type: "Invocation",
-        value: sanitize_matcher(searchMatcher)
+        value: sanitize_matcher(searchMatcher
+        )
       }]
     };
   }

package/src/android/espressoapi/EspressoDetox.js

@@ -5,9 +5,16 @@
 */
 
 
+function sanitize_matcher(matcher) {
+  if (!matcher._call) {
+    return matcher;
+  }
 
+  const originalMatcher = typeof matcher._call === 'function' ? matcher._call() : matcher._call;
+  return originalMatcher.type ? originalMatcher.value : originalMatcher;
+} 
 class EspressoDetox {
-  static perform(interaction, action) {
+  static perform(matcher, action) {
     return {
       target: {
         type: "Class",
@@ -16,7 +23,7 @@ class EspressoDetox {
       method: "perform",
       args: [{
         type: "Invocation",
-        value: interaction
+        value: sanitize_matcher(matcher)
       }, action]
     };
   }

package/src/android/interactions/native.js

@@ -25,9 +25,9 @@ class Interaction {
 }
 
 class ActionInteraction extends Interaction {
-  constructor(invocationManager, element, action, traceDescription) {
+  constructor(invocationManager, matcher, action, traceDescription) {
     super(invocationManager, traceDescription);
-    this._call = EspressoDetoxApi.perform(call(element._call), action._call);
+    this._call = EspressoDetoxApi.perform(matcher, action._call);
     // TODO: move this.execute() here from the caller
   }
 }
@@ -48,7 +48,6 @@ class WaitForInteraction extends Interaction {
     super(invocationManager, expectTraceDescription);
     this._element = element;
     this._assertionMatcher = assertionMatcher;
-    this._element._selectElementWithMatcher(this._element._originalMatcher);
   }
 
   async withTimeout(timeout) {

package/src/artifacts/providers/index.js

@@ -4,7 +4,7 @@ class ArtifactPluginsProvider {
 
 class AndroidArtifactPluginsProvider extends ArtifactPluginsProvider {
   declareArtifactPlugins({ client }) {
-    const serviceLocator = require('../../devices/servicelocator/android');
+    const serviceLocator = require('../../servicelocator/android');
     const adb = serviceLocator.adb;
     const devicePathBuilder = serviceLocator.devicePathBuilder;
 
@@ -34,8 +34,8 @@ class IosArtifactPluginsProvider extends ArtifactPluginsProvider {
 
 class IosSimulatorArtifactPluginsProvider extends IosArtifactPluginsProvider {
   declareArtifactPlugins({ client }) {
-    const AppleSimUtils = require('../../devices/common/drivers/ios/tools/AppleSimUtils');
-    const appleSimUtils = new AppleSimUtils();
+    const serviceLocator = require('../../servicelocator/ios');
+    const appleSimUtils = serviceLocator.appleSimUtils;
 
     const SimulatorInstrumentsPlugin = require('../instruments/ios/SimulatorInstrumentsPlugin');
     const SimulatorLogPlugin = require('../log/ios/SimulatorLogPlugin');

package/src/artifacts/screenshot/SimulatorScreenshotPlugin.js

@@ -22,6 +22,23 @@ class SimulatorScreenshotPlugin extends ScreenshotArtifactPlugin {
     }
   }
 
+  async onBootDevice(event) {
+    await super.onBootDevice(event);
+
+    if (this.enabled && event.coldBoot) {
+      await this.appleSimUtils.takeScreenshot(event.deviceId, '/dev/null').catch(() => {
+        log.debug({}, `
+          NOTE: For an unknown yet reason, taking the first screenshot is apt
+          to fail when booting iOS Simulator in a hidden window mode (or on CI).
+          Detox applies a workaround by taking a dummy screenshot to ensure
+          that the future ones are going to work fine. This screenshot is not
+          saved anywhere, and the error above is suppressed for all log levels
+          except for "debug" and "trace."
+        `.trim());
+      });
+    }
+  }
+
   async onBeforeUninstallApp(event) {
     await this.api.requestIdleCallback(async () => {
       const snapshots = [

package/src/devices/DeviceRegistry.js

@@ -0,0 +1,176 @@
+// @ts-nocheck
+const fs = require('fs-extra');
+const _ = require('lodash');
+
+const ExclusiveLockfile = require('../utils/ExclusiveLockfile');
+const environment = require('../utils/environment');
+const safeAsync = require('../utils/safeAsync');
+
+const readOptions = {
+  encoding: 'utf8',
+};
+
+const FIELD_NAME_ID = 'id';
+const FIELD_NAME_DATA = 'data';
+
+class DevicesList {
+  constructor(devices) {
+    this._devices = Object.freeze(devices);
+  }
+
+  /**
+   * @returns {{id: string, data: *?}[]}
+   */
+  get rawDevices() {
+    return this._devices;
+  }
+
+  /**
+   * @param {string} deviceId
+   * @returns {boolean}
+   */
+  includes(deviceId) {
+    return DevicesList._includes(deviceId, this._devices);
+  }
+
+  static _includes(deviceId, devices) {
+    return _.some(devices, [FIELD_NAME_ID, deviceId]);
+  }
+}
+
+class DeviceRegistry {
+  constructor({ lockfilePath }) {
+    /***
+     * @private
+     * @type {string}
+     */
+    this._lockfilePath = lockfilePath;
+
+    /***
+     * @protected
+     * @type {ExclusiveLockfile}
+     */
+    this._lockfile = new ExclusiveLockfile(lockfilePath, {
+      getInitialState: this._getInitialLockFileState.bind(this),
+      readOptions,
+    });
+  }
+
+  async reset() {
+    await this._lockfile.exclusively(() => {
+      const empty = this._getInitialLockFileState();
+      this._lockfile.write(empty);
+    });
+  }
+
+  /***
+   * @param {string|Function} getDeviceId
+   * @param {*?} data
+   * @returns {Promise<string>}
+   */
+  async allocateDevice(getDeviceId, data) {
+    return this._lockfile.exclusively(async () => {
+      const deviceId = await safeAsync(getDeviceId);
+      this._registerDevice(deviceId, data);
+      return deviceId;
+    });
+  }
+
+  /***
+   * @param {string|Function} getDeviceId
+   * @returns {Promise<void>}
+   */
+  async disposeDevice(getDeviceId) {
+    await this._lockfile.exclusively(async () => {
+      const deviceId = await safeAsync(getDeviceId);
+      if (deviceId) {
+        this._unregisterDevice(deviceId);
+      }
+    });
+  }
+
+  /***
+   * @param {string} deviceId
+   * @returns {boolean}
+   */
+  includes(deviceId) {
+    const devices = this._lockfile.read();
+    return DevicesList._includes(deviceId, devices);
+  }
+
+  /***
+   * @returns {DevicesList}
+   */
+  getRegisteredDevices() {
+    const devices = this._lockfile.read();
+    return new DevicesList(devices);
+  }
+
+  /***
+   * @returns {DevicesList}
+   */
+  async readRegisteredDevices() {
+    let result = null;
+    await this._lockfile.exclusively(() => {
+      result = this.getRegisteredDevices();
+    });
+    return result;
+  }
+
+  /***
+   * @returns {DevicesList}
+   */
+  readRegisteredDevicesUNSAFE() {
+    const contents = fs.readFileSync(this._lockfilePath, readOptions);
+    const devices = JSON.parse(contents);
+    return new DevicesList(devices);
+  }
+
+  /***
+   * @private
+   */
+  _getInitialLockFileState() {
+    return [];
+  }
+
+  /**
+   * @private
+   */
+  _registerDevice(deviceId, data) {
+    const state = this._lockfile.read();
+    let newState = _.reject(state, [FIELD_NAME_ID, deviceId]);
+
+    const device = {};
+    device[FIELD_NAME_ID] = deviceId;
+
+    if (data) {
+      device[FIELD_NAME_DATA] = data;
+    }
+
+    newState = _.concat(newState, device);
+    this._lockfile.write(newState);
+  }
+
+  /**
+   * @private
+   */
+  _unregisterDevice(deviceId) {
+    const state = this._lockfile.read();
+    const newState = _.reject(state, [FIELD_NAME_ID, deviceId]);
+    this._lockfile.write(newState);
+  }
+
+  static forIOS() {
+    return new DeviceRegistry({
+      lockfilePath: environment.getDeviceLockFilePathIOS(),
+    });
+  }
+
+  static forAndroid() {
+    return new DeviceRegistry({
+      lockfilePath: environment.getDeviceLockFilePathAndroid(),
+    });
+  }
+}
+
+module.exports = DeviceRegistry;