detox 21.0.0-rc.0 → 21.0.0-rc.10

package/src/artifacts/providers/index.js

@@ -4,7 +4,7 @@ class ArtifactPluginsProvider {
 
 class AndroidArtifactPluginsProvider extends ArtifactPluginsProvider {
   declareArtifactPlugins({ client }) {
-    const serviceLocator = require('../../servicelocator/android');
+    const serviceLocator = require('../../devices/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 serviceLocator = require('../../servicelocator/ios');
-    const appleSimUtils = serviceLocator.appleSimUtils;
+    const AppleSimUtils = require('../../devices/common/drivers/ios/tools/AppleSimUtils');
+    const appleSimUtils = new AppleSimUtils();
 
     const SimulatorInstrumentsPlugin = require('../instruments/ios/SimulatorInstrumentsPlugin');
     const SimulatorLogPlugin = require('../log/ios/SimulatorLogPlugin');

package/src/artifacts/screenshot/SimulatorScreenshotPlugin.js

@@ -22,23 +22,6 @@ 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/configuration/composeLoggerConfig.js

@@ -32,6 +32,7 @@ function composeLoggerConfig(opts) {
       if (!config) return acc;
       const { options } = config;
       return _.merge(acc, {
+        // @ts-ignore-line
         options: typeof options === 'function' ? options(acc) : options
       });
     },

package/src/configuration/composeRunnerConfig.js

@@ -32,6 +32,7 @@ function composeRunnerConfig(opts) {
       retries: 0,
       inspectBrk: inspectBrkHookDefault,
       forwardEnv: false,
+      detached: false,
       bail: false,
       jest: {
         setupTimeout: 300000,
@@ -56,8 +57,9 @@ function composeRunnerConfig(opts) {
 
   if (typeof merged.inspectBrk === 'function') {
     if (cliConfig.inspectBrk) {
-      merged.retries = 0;
+      merged.detached = false;
       merged.forwardEnv = true;
+      merged.retries = 0;
       merged.inspectBrk(merged);
     }
 

package/src/devices/allocation/DeviceAllocator.js

@@ -1,43 +1,89 @@
-// @ts-nocheck
-const log = require('../../utils/logger').child({ cat: 'device' });
+/**
+ * @typedef {import('./drivers/AllocationDriverBase').AllocationDriverBase} AllocationDriverBase
+ * @typedef {import('./drivers/AllocationDriverBase').DeallocOptions} DeallocOptions
+ * @typedef {import('../common/drivers/DeviceCookie').DeviceCookie} DeviceCookie
+ */
+
+const log = require('../../utils/logger').child({ cat: 'device,device-allocation' });
 const traceMethods = require('../../utils/traceMethods');
 
 class DeviceAllocator {
   /**
-   * @param allocationDriver { AllocationDriverBase }
+   * @param {AllocationDriverBase} allocationDriver
    */
   constructor(allocationDriver) {
     this._driver = allocationDriver;
-    traceMethods(log, this, ['allocate', 'postAllocate', 'free']);
+    this._counter = 0;
+    this._ids = new Map();
+    traceMethods(log, this, ['init', 'cleanup', 'emergencyCleanup']);
   }
 
   /**
-   * @param deviceConfig { Object }
-   * @return {Promise<DeviceCookie>}
+   * @returns {Promise<void>}
    */
-  allocate(deviceConfig) {
-    return this._driver.allocate(deviceConfig);
+  async init() {
+    if (typeof this._driver.init === 'function') {
+      await this._driver.init();
+    }
   }
 
   /**
-   * @param {DeviceCookie} deviceCookie
-   * @return {Promise<unknown>}
+   * @param {Detox.DetoxDeviceConfig} deviceConfig
+   * @returns {Promise<DeviceCookie>}
    */
-  postAllocate(deviceCookie) {
-    if (typeof this._driver.postAllocate !== 'function') {
-      return Promise.resolve();
-    }
+  async allocate(deviceConfig) {
+    const tid = this._counter++;
+    return await log.trace.complete({ data: deviceConfig, id: tid }, 'allocate', async () => {
+      const cookie = await this._driver.allocate(deviceConfig);
+      log.debug({ data: cookie }, `settled on ${cookie.name || cookie.id}`);
+      this._ids.set(cookie.id, tid);
+      return cookie;
+    });
+  }
 
-    return this._driver.postAllocate(deviceCookie);
+  /**
+   * @param {DeviceCookie} cookie
+   * @returns {Promise<DeviceCookie>}
+   */
+  async postAllocate(cookie) {
+    const tid = this._ids.get(cookie.id);
+    return await log.trace.complete({ data: cookie, id: tid }, `post-allocate: ${cookie.id}`, async () => {
+      const updatedCookie = typeof this._driver.postAllocate === 'function'
+        ? await this._driver.postAllocate(cookie)
+        : undefined;
+
+      return updatedCookie || cookie;
+    });
   }
 
   /**
-   * @param cookie { DeviceCookie }
-   * @param options { DeallocOptions }
-   * @return {Promise<void>}
+   * @param {DeviceCookie} cookie
+   * @param {DeallocOptions} options
+   * @returns {Promise<void>}
    */
-  free(cookie, options) {
-    return this._driver.free(cookie, options);
+  async free(cookie, options = {}) {
+    const tid = this._ids.get(cookie.id);
+    await log.trace.complete({ data: options, id: tid }, `free: ${cookie.id}`, async () => {
+      await this._driver.free(cookie, options);
+    });
+  }
+
+  /**
+   * @returns {Promise<void>}
+   */
+  async cleanup() {
+    if (typeof this._driver.cleanup === 'function') {
+      await this._driver.cleanup();
+    }
+  }
+
+  /**
+   * @returns {void}
+   */
+  emergencyCleanup() {
+    if (typeof this._driver.emergencyCleanup === 'function') {
+      this._driver.emergencyCleanup();
+    }
   }
 }
 

package/src/devices/allocation/DeviceList.js

@@ -0,0 +1,44 @@
+class DeviceListReadonly {
+  constructor(devices = []) {
+    this._devices = new Map(devices.map(device => [device.id, device]));
+  }
+
+  concat(other) {
+    return new DeviceListReadonly([...this, ...other]);
+  }
+
+  getIds() {
+    return [...this._devices.keys()];
+  }
+
+  [Symbol.iterator]() {
+    return this._devices.values();
+  }
+
+  /**
+   * @param {string} deviceId
+   * @returns {boolean}
+   */
+  includes(deviceId) {
+    return this._devices.has(deviceId);
+  }
+}
+
+class DeviceList extends DeviceListReadonly {
+  filter(predicate) {
+    return new DeviceListReadonly([...this].filter(predicate));
+  }
+
+  add(deviceId, data) {
+    this._devices.set(deviceId, {
+      id: deviceId,
+      ...data,
+    });
+  }
+
+  delete(deviceId) {
+    this._devices.delete(deviceId);
+  }
+}
+
+module.exports = DeviceList;

package/src/devices/allocation/DeviceRegistry.js

@@ -0,0 +1,189 @@
+const ExclusiveLockfile = require('../../utils/ExclusiveLockfile');
+const PIDService = require('../../utils/PIDService');
+const { getDeviceRegistryPath } = require('../../utils/environment');
+const safeAsync = require('../../utils/safeAsync');
+
+const DeviceList = require('./DeviceList');
+
+const readOptions = {
+  encoding: 'utf8',
+};
+
+class DeviceRegistry {
+  constructor({
+    lockfilePath = getDeviceRegistryPath(),
+    sessionId = '',
+    pidService = new PIDService(),
+  } = {}) {
+    /***
+     * @private
+     * @type {string}
+     */
+    this._lockfilePath = lockfilePath;
+    /***
+     * @private
+     * @type {string}
+     */
+    this._sessionId = sessionId;
+    /***
+     * @private
+     */
+    this._pidService = pidService;
+    /***
+     * @protected
+     * @type {ExclusiveLockfile}
+     */
+    this._lockfile = new ExclusiveLockfile(this._lockfilePath, {
+      getInitialState: this._getInitialLockFileState.bind(this),
+      readOptions,
+    });
+  }
+
+  get lockFilePath() {
+    return this._lockfilePath;
+  }
+
+  /**
+   * Safety method to ensure that there are no remains of previously crashed Detox sessions.
+   */
+  async reset() {
+    await this._lockfile.exclusively(() => {
+      const empty = this._getInitialLockFileState();
+      this._lockfile.write(empty);
+    });
+  }
+
+  /***
+   * @param {string|Function} getDeviceId
+   * @returns {Promise<string>}
+   */
+  async registerDevice(getDeviceId) {
+    return this._lockfile.exclusively(async () => {
+      const deviceId = await safeAsync(getDeviceId);
+      if (deviceId) {
+        this._upsertDevice(deviceId, {
+          busy: true,
+          sessionId: this._sessionId,
+          pid: this._pidService.getPid(),
+        });
+      }
+      return deviceId;
+    });
+  }
+
+  /***
+   * @param {string|Function} getDeviceId
+   * @returns {Promise<string>}
+   */
+  async releaseDevice(getDeviceId) {
+    return this._lockfile.exclusively(async () => {
+      const deviceId = await safeAsync(getDeviceId);
+      if (deviceId) {
+        this._upsertDevice(deviceId, {
+          busy: false,
+          sessionId: this._sessionId,
+          pid: this._pidService.getPid(),
+        });
+      }
+      return deviceId;
+    });
+  }
+
+  /***
+   * @param {string|Function} getDeviceId
+   * @returns {Promise<void>}
+   */
+  async unregisterDevice(getDeviceId) {
+    await this._lockfile.exclusively(async () => {
+      const deviceId = await safeAsync(getDeviceId);
+      if (deviceId) {
+        this._deleteDevice(deviceId);
+      }
+    });
+  }
+
+  async unregisterSessionDevices() {
+    await this._lockfile.exclusively(async () => {
+      const allDevices = this._getRegisteredDevices();
+      const sessionDevices = allDevices.filter(device => device.sessionId === this._sessionId);
+      for (const id of sessionDevices.getIds()) {
+        allDevices.delete(id);
+      }
+      this._lockfile.write([...allDevices]);
+    });
+  }
+
+  async unregisterZombieDevices() {
+    await this._lockfile.exclusively(async () => {
+      const allDevices = this._getRegisteredDevices();
+      const zombieDevices = allDevices.filter(device => {
+        return device.sessionId !== this._sessionId && !this._pidService.isAlive(device.pid);
+      });
+
+      for (const id of zombieDevices.getIds()) {
+        allDevices.delete(id);
+      }
+      this._lockfile.write([...allDevices]);
+    });
+  }
+
+  /**
+   * @returns {Promise<DeviceList>}
+   */
+  async readSessionDevices() {
+    let devices;
+    await this._lockfile.exclusively(() => {
+      devices = this._getSessionDevicesSync();
+    });
+    return devices;
+  }
+
+  getTakenDevicesSync() {
+    const allDevices = this._getRegisteredDevices();
+    const busyDevices = allDevices.filter(device => device.busy);
+    const externalDevices = allDevices.filter(device => device.sessionId !== this._sessionId);
+    return busyDevices.concat(externalDevices);
+  }
+
+  /***
+   * @private
+   */
+  _getInitialLockFileState() {
+    return [];
+  }
+
+  /**
+   * @private
+   */
+  _upsertDevice(deviceId, data) {
+    const devices = this._getRegisteredDevices();
+    devices.add(deviceId, data);
+    this._lockfile.write([...devices]);
+  }
+
+  /**
+   * @private
+   */
+  _deleteDevice(deviceId) {
+    const devices = this._getRegisteredDevices();
+    devices.delete(deviceId);
+    this._lockfile.write([...devices]);
+  }
+
+  /***
+   * @private
+   * @returns {DeviceList}
+   */
+  _getRegisteredDevices() {
+    const devices = this._lockfile.read();
+    return new DeviceList(devices);
+  }
+
+  _getSessionDevicesSync() {
+    const devices = this._getRegisteredDevices();
+    const sessionDevices = devices.filter(device => device.sessionId === this._sessionId);
+    return sessionDevices;
+  }
+}
+
+module.exports = DeviceRegistry;

package/src/devices/allocation/drivers/AllocationDriverBase.d.ts

@@ -0,0 +1,15 @@
+/* eslint-disable import/no-unresolved,node/no-missing-import,node/no-unsupported-features/es-syntax */
+import { DeviceCookie } from '../../common/drivers/DeviceCookie';
+
+export interface DeallocOptions {
+  shutdown?: boolean;
+}
+
+export interface AllocationDriverBase {
+  init?(): Promise<void>;
+  allocate(deviceConfig: any): Promise<DeviceCookie>;
+  postAllocate?(deviceCookie: DeviceCookie): Promise<DeviceCookie | void>;
+  free(cookie: DeviceCookie, options: DeallocOptions): Promise<void>;
+  cleanup?(): Promise<void>;
+  emergencyCleanup?(): void;
+}

package/src/devices/{common/drivers/android/tools → allocation/drivers/android}/FreeDeviceFinder.js

@@ -1,6 +1,6 @@
-const log = require('../../../../../utils/logger').child({ cat: 'device' });
+const log = require('../../../../utils/logger').child({ cat: 'device' });
 
-const DEVICE_LOOKUP_LOG_EVT = 'DEVICE_LOOKUP';
+const DEVICE_LOOKUP = { event: 'DEVICE_LOOKUP' };
 
 class FreeDeviceFinder {
   constructor(adb, deviceRegistry) {
@@ -10,8 +10,9 @@ class FreeDeviceFinder {
 
   async findFreeDevice(deviceQuery) {
     const { devices } = await this.adb.devices();
+    const takenDevices = this.deviceRegistry.getTakenDevicesSync();
     for (const candidate of devices) {
-      if (await this._isDeviceFreeAndMatching(candidate, deviceQuery)) {
+      if (await this._isDeviceFreeAndMatching(takenDevices, candidate, deviceQuery)) {
         return candidate.adbName;
       }
     }
@@ -19,30 +20,30 @@ class FreeDeviceFinder {
   }
 
   /**
-   * @protected
+   * @private
    */
-  async _isDeviceFreeAndMatching(candidate, deviceQuery) {
+  async _isDeviceFreeAndMatching(takenDevices, candidate, deviceQuery) {
     const { adbName } = candidate;
 
-    const isTaken = this.deviceRegistry.includes(adbName);
+    const isTaken = takenDevices.includes(adbName);
     if (isTaken) {
-      log.debug({ event: DEVICE_LOOKUP_LOG_EVT }, `Device ${adbName} is already taken, skipping...`);
+      log.debug(DEVICE_LOOKUP, `Device ${adbName} is already taken, skipping...`);
       return false;
     }
 
     const isOffline = candidate.status === 'offline';
     if (isOffline) {
-      log.debug({ event: DEVICE_LOOKUP_LOG_EVT }, `Device ${adbName} is offline, skipping...`);
+      log.debug(DEVICE_LOOKUP, `Device ${adbName} is offline, skipping...`);
       return false;
     }
 
     const isMatching = await this._isDeviceMatching(candidate, deviceQuery);
     if (!isMatching) {
-      log.debug({ event: DEVICE_LOOKUP_LOG_EVT }, `Device ${adbName} does not match "${deviceQuery}"`);
+      log.debug(DEVICE_LOOKUP, `Device ${adbName} does not match "${deviceQuery}"`);
       return false;
     }
 
-    log.debug({ event: DEVICE_LOOKUP_LOG_EVT }, `Found a matching & free device ${candidate.adbName}`);
+    log.debug(DEVICE_LOOKUP, `Found a matching & free device ${candidate.adbName}`);
     return true;
   }
 

package/src/devices/allocation/drivers/android/attached/AttachedAndroidAllocDriver.js

@@ -1,20 +1,26 @@
-// @ts-nocheck
-const AttachedAndroidDeviceCookie = require('../../../../cookies/AttachedAndroidDeviceCookie');
-const AllocationDriverBase = require('../../AllocationDriverBase');
+/**
+ * @typedef {import('../../AllocationDriverBase').AllocationDriverBase} AllocationDriverBase
+ * @typedef {import('../../../../common/drivers/android/cookies').AndroidDeviceCookie} AndroidDeviceCookie
+ */
 
-class AttachedAndroidAllocDriver extends AllocationDriverBase {
+/**
+ * @implements {AllocationDriverBase}
+ */
+class AttachedAndroidAllocDriver {
   /**
-   * @param adb { ADB }
-   * @param deviceRegistry { DeviceRegistry }
-   * @param freeDeviceFinder { FreeDeviceFinder }
-   * @param attachedAndroidLauncher { AttachedAndroidLauncher }
+   * @param {object} options
+   * @param {import('../../../../common/drivers/android/exec/ADB')} options.adb
+   * @param {import('../../../DeviceRegistry')} options.deviceRegistry
+   * @param {import('../FreeDeviceFinder')} options.freeDeviceFinder
    */
-  constructor({ adb, deviceRegistry, freeDeviceFinder, attachedAndroidLauncher }) {
-    super();
+  constructor({ adb, deviceRegistry, freeDeviceFinder }) {
     this._adb = adb;
     this._deviceRegistry = deviceRegistry;
     this._freeDeviceFinder = freeDeviceFinder;
-    this._attachedAndroidLauncher = attachedAndroidLauncher;
+  }
+
+  async init() {
+    await this._deviceRegistry.unregisterZombieDevices();
   }
 
   /**
@@ -23,13 +29,13 @@ class AttachedAndroidAllocDriver extends AllocationDriverBase {
    */
   async allocate(deviceConfig) {
     const adbNamePattern = deviceConfig.device.adbName;
-    const adbName = await this._deviceRegistry.allocateDevice(() => this._freeDeviceFinder.findFreeDevice(adbNamePattern));
+    const adbName = await this._deviceRegistry.registerDevice(() => this._freeDeviceFinder.findFreeDevice(adbNamePattern));
 
-    return new AttachedAndroidDeviceCookie(adbName);
+    return { id: adbName, adbName };
   }
 
   /**
-   * @param {AttachedAndroidDeviceCookie} deviceCookie
+   * @param {AndroidDeviceCookie} deviceCookie
    * @returns {Promise<void>}
    */
   async postAllocate(deviceCookie) {
@@ -38,16 +44,15 @@ class AttachedAndroidAllocDriver extends AllocationDriverBase {
     // TODO Also disable native animations?
     await this._adb.apiLevel(adbName);
     await this._adb.unlockScreen(adbName);
-    await this._attachedAndroidLauncher.notifyLaunchCompleted(adbName);
   }
 
   /**
-   * @param cookie { AttachedAndroidDeviceCookie }
+   * @param cookie { AndroidDeviceCookie }
    * @return {Promise<void>}
    */
   async free(cookie) {
     const { adbName } = cookie;
-    await this._deviceRegistry.disposeDevice(adbName);
+    await this._deviceRegistry.unregisterDevice(adbName);
   }
 }