detox 20.12.1 → 20.13.0

package/src/devices/allocation/drivers/android/genycloud/GenyInstanceLauncher.js

@@ -1,44 +1,49 @@
-// @ts-nocheck
 const DetoxRuntimeError = require('../../../../../errors/DetoxRuntimeError');
+const logger = require('../../../../../utils/logger').child({ cat: 'device' });
 const retry = require('../../../../../utils/retry');
-const DeviceLauncher = require('../../../../common/drivers/DeviceLauncher');
 
-class GenyInstanceLauncher extends DeviceLauncher {
-  constructor({ instanceLifecycleService, instanceLookupService, deviceCleanupRegistry, eventEmitter }) {
-    super(eventEmitter);
+const GenyInstance = require('./services/dto/GenyInstance');
 
+const events = {
+  CREATE_DEVICE: { event: 'CREATE_DEVICE' },
+};
+
+class GenyInstanceLauncher {
+  constructor({ genyCloudExec, instanceLifecycleService }) {
+    this._genyCloudExec = genyCloudExec;
     this._instanceLifecycleService = instanceLifecycleService;
-    this._instanceLookupService = instanceLookupService;
-    this._deviceCleanupRegistry = deviceCleanupRegistry;
   }
 
   /**
-   * Note:
-   * In the context of Genymotion-cloud (as opposed to local emulators), emulators are
-   * not launched per-se, as with local emulators. Rather, we just need to sync-up with
-   * them and connect, if needed.
-   *
-   * @param instance {GenyInstance} The freshly allocated cloud-instance.
-   * @param isNew { boolean }
+   * @param {import('./services/dto/GenyRecipe')} recipe
+   * @param {string} instanceName
    * @returns {Promise<GenyInstance>}
    */
-  async launch(instance, isNew = true) {
-    if (isNew) {
-      await this._deviceCleanupRegistry.allocateDevice(instance.uuid, { name: instance.name });
-    }
-    instance = await this._waitForInstanceBoot(instance);
-    instance = await this._adbConnectIfNeeded(instance);
-    await this._notifyBootEvent(instance.adbName, instance.recipeName, isNew);
+  async launch(recipe, instanceName) {
+    logger.debug(events.CREATE_DEVICE, `Trying to create a device based on "${recipe}"`);
+    const instance = await this._instanceLifecycleService.createInstance(recipe.uuid, instanceName);
+    const { name, uuid } = instance;
+    logger.info(events.CREATE_DEVICE, `Allocating Genymotion Cloud instance ${name} for testing. To access it via a browser, go to: https://cloud.geny.io/instance/${uuid}`);
+
     return instance;
   }
 
-  async shutdown(instance) {
-    const { uuid } = instance;
+  /**
+   * @param {GenyInstance} instance The freshly allocated cloud-instance.
+   * @returns {Promise<GenyInstance>}
+   */
+  async connect(instance) {
+    const bootedInstance = await this._waitForInstanceBoot(instance);
+    const connectedInstance = await this._adbConnectIfNeeded(bootedInstance);
+
+    return connectedInstance;
+  }
 
-    await this._notifyPreShutdown(uuid);
-    await this._instanceLifecycleService.deleteInstance(uuid);
-    await this._deviceCleanupRegistry.disposeDevice(uuid);
-    await this._notifyShutdownCompleted(uuid);
+  /**
+   * @param {string} instanceId
+   */
+  async shutdown(instanceId) {
+    await this._instanceLifecycleService.deleteInstance(instanceId);
   }
 
   async _waitForInstanceBoot(instance) {
@@ -48,17 +53,21 @@ class GenyInstanceLauncher extends DeviceLauncher {
 
     const options = {
       backoff: 'none',
-      retries: 25,
+      retries: 20,
       interval: 5000,
       initialSleep: 45000,
+      shouldUnref: true,
     };
 
     return await retry(options, async () => {
-      const _instance = await this._instanceLookupService.getInstance(instance.uuid);
-      if (!_instance.isOnline()) {
+      const { instance: _instance } = await this._genyCloudExec.getInstance(instance.uuid);
+      const anInstance = new GenyInstance(_instance);
+
+      if (!anInstance.isOnline()) {
         throw new DetoxRuntimeError(`Timeout waiting for instance ${instance.uuid} to be ready`);
       }
-      return _instance;
+
+      return anInstance;
     });
   }
 

package/src/devices/allocation/drivers/android/genycloud/GenyRegistry.js

@@ -0,0 +1,121 @@
+const { DetoxInternalError } = require('../../../../../errors');
+
+class GenyRegistry {
+  constructor() {
+    /** @type {Map<string, import('./services/dto/GenyRecipe')>} */
+    this._recipes = new Map();
+    /** @type {Map<string, import('./services/dto/GenyInstance')>} */
+    this._freeInstances = new Map();
+    /** @type {Map<string, import('./services/dto/GenyInstance')>} */
+    this._busyInstances = new Map();
+    /** @type {Set<string>} */
+    this._newInstances = new Set();
+  }
+
+  /**
+   * @returns {import('./services/dto/GenyInstance')[]}
+   */
+  getInstances() {
+    return [
+      ...this._freeInstances.values(),
+      ...this._busyInstances.values(),
+    ];
+  }
+
+  /**
+   * @param {import('./services/dto/GenyInstance')} instance
+   * @param {import('./services/dto/GenyRecipe')} recipe
+   */
+  addInstance(instance, recipe) {
+    this._recipes.set(instance.uuid, recipe);
+    this._busyInstances.set(instance.uuid, instance);
+    this._newInstances.add(instance.uuid);
+  }
+
+  /**
+   * @param {string} instanceId
+   * @returns {boolean}
+   */
+  pollNewInstance(instanceId) {
+    const result = this._newInstances.has(instanceId);
+    this._newInstances.delete(instanceId);
+    return result;
+  }
+
+  /** @param {import('./services/dto/GenyInstance')} instance */
+  updateInstance(instance) {
+    let found = false;
+
+    if (this._freeInstances.has(instance.uuid)) {
+      this._freeInstances.set(instance.uuid, instance);
+      found = true;
+    }
+
+    if (this._busyInstances.has(instance.uuid)) {
+       this._busyInstances.set(instance.uuid, instance);
+       found = true;
+    }
+
+    if (!found) {
+      throw new DetoxInternalError(`Cannot update an unknown instance ${instance.uuid}`);
+    }
+  }
+
+  /** @param {string} instanceId */
+  removeInstance(instanceId) {
+    this._freeInstances.delete(instanceId);
+    this._busyInstances.delete(instanceId);
+    this._newInstances.delete(instanceId);
+    this._recipes.delete(instanceId);
+  }
+
+  /**
+   * @param {string} instanceId
+   * @returns {import('./services/dto/GenyInstance')}
+   */
+  markAsBusy(instanceId) {
+    if (this._busyInstances.has(instanceId)) {
+      return this._busyInstances.get(instanceId);
+    }
+
+    const instance = this._freeInstances.get(instanceId);
+    if (!instance) {
+      throw new DetoxInternalError(`Cannot mark an unknown instance ${instanceId} as busy`);
+    }
+
+    this._busyInstances.set(instanceId, instance);
+    this._freeInstances.delete(instanceId);
+    return instance;
+  }
+
+  /**
+   * @param {string} instanceId
+   * @returns {import('./services/dto/GenyInstance')}
+   */
+  markAsFree(instanceId) {
+    if (this._freeInstances.has(instanceId)) {
+      return this._freeInstances.get(instanceId);
+    }
+
+    const instance = this._busyInstances.get(instanceId);
+    if (!instance) {
+      throw new DetoxInternalError(`Cannot mark an unknown instance ${instanceId} as free`);
+    }
+
+    this._busyInstances.delete(instanceId);
+    this._freeInstances.set(instanceId, instance);
+    return instance;
+  }
+
+  /** @returns {import('./services/dto/GenyInstance') | undefined} */
+  findFreeInstance(recipe) {
+    for (const instance of this._freeInstances.values()) {
+      const aRecipe = this._recipes.get(instance.uuid);
+      if (recipe.uuid === aRecipe.uuid) {
+        return this.markAsBusy(instance.uuid);
+      }
+    }
+  }
+}
+
+module.exports = GenyRegistry;

package/src/devices/allocation/drivers/android/genycloud/services/GenyInstanceLifecycleService.js

@@ -0,0 +1,24 @@
+const Instance = require('./dto/GenyInstance');
+
+class GenyInstanceLifecycleService {
+  constructor(genyCloudExec) {
+    this._genyCloudExec = genyCloudExec;
+  }
+
+  async createInstance(recipeUUID, instanceName) {
+    const result = await this._genyCloudExec.startInstance(recipeUUID, instanceName);
+    return new Instance(result.instance);
+  }
+
+  async adbConnectInstance(instanceUUID) {
+    const result = (await this._genyCloudExec.adbConnect(instanceUUID));
+    return new Instance(result.instance);
+  }
+
+  async deleteInstance(instanceUUID) {
+    const result = await this._genyCloudExec.stopInstance(instanceUUID);
+    return new Instance(result.instance);
+  }
+}
+
+module.exports = GenyInstanceLifecycleService;

package/src/devices/{common → allocation}/drivers/android/genycloud/services/GenyRecipesService.js

@@ -1,6 +1,6 @@
 const logger = require('../../../../../../utils/logger').child({ cat: 'device' });
 
-  const Recipe = require('./dto/GenyRecipe');
+const Recipe = require('./dto/GenyRecipe');
 
 class GenyRecipesService {
   constructor(genyCloudExec) {

package/src/devices/allocation/drivers/android/genycloud/services/dto/GenyInstance.js

@@ -0,0 +1,83 @@
+const Recipe = require('./GenyRecipe');
+
+const STATE_ONLINE = 'ONLINE';
+const STATE_CREATING = 'CREATING';
+const STATE_BOOTING = 'BOOTING';
+const STATE_STARTING = 'STARTING';
+const initStates = new Set([
+  STATE_CREATING,
+  STATE_BOOTING,
+  STATE_STARTING,
+]);
+
+const data = Symbol('data');
+const recipe = Symbol('recipe');
+
+class GenyInstance {
+  constructor(rawInstance) {
+    this[data] = rawInstance;
+    this[recipe] = new Recipe(rawInstance.recipe);
+  }
+
+  get uuid() {
+    return this[data].uuid;
+  }
+
+  get name() {
+    return this[data].name;
+  }
+
+  /**
+   * According to Genymotion's API docs, state is an enum with these possible values (description is not official):
+   * - "CREATING": Handling instance creation request
+   * - "STARTING": Instance created but not yet available for usage
+   * - "BOOTING": Instance created & started; Android OS is not booting
+   * - "ONLINE": Instance is ready for action
+   * - "RECYCLED": Instance has been automatically shut down due an idle timeout
+   * - "STOPPING": Instance is being shut-down
+   *
+   * Additional states: "OFFLINE", "SAVING", "SAVED", "DELETING", "ERROR", "REVOKED", "EXPIRED".
+   */
+  get state() {
+    return this[data].state;
+  }
+
+  get adbName() {
+    return this[data].adb_serial;
+  }
+
+  get recipeName() {
+    return this[recipe].name;
+  }
+
+  get recipeUUID() {
+    return this[recipe].uuid;
+  }
+
+  isAdbConnected() {
+    return this.adbName !== '0.0.0.0';
+  }
+
+  isOnline() {
+    return this.state === STATE_ONLINE;
+  }
+
+  isInitializing() {
+    return initStates.has(this.state);
+  }
+
+  toString() {
+    const description = [
+      this.uuid,
+      this.adbName
+    ].filter(Boolean).join('/');
+
+    return `${this.name} (${description})`;
+  }
+
+  toJSON() {
+    return this[data];
+  }
+}
+
+module.exports = GenyInstance;

package/src/devices/allocation/drivers/android/genycloud/services/dto/GenyRecipe.js

@@ -0,0 +1,25 @@
+const data = Symbol('data');
+
+class GenyRecipe {
+  constructor(rawRecipe) {
+    this[data] = rawRecipe;
+  }
+
+  get uuid() {
+    return this[data].uuid;
+  }
+
+  get name() {
+    return this[data].name || 'Anonymous GMSaaS Recipe';
+  }
+
+  toString() {
+    return this[data].name ? `${this.name} (${this.uuid})` : `Recipe of ${this.uuid}`;
+  }
+
+  toJSON() {
+    return this[data];
+  }
+}
+
+module.exports = GenyRecipe;

package/src/devices/allocation/drivers/ios/SimulatorAllocDriver.js

@@ -1,22 +1,37 @@
-// @ts-nocheck
+/**
+ * @typedef {import('../AllocationDriverBase').AllocationDriverBase} AllocationDriverBase
+ * @typedef {import('../AllocationDriverBase').DeallocOptions} DeallocOptions
+ * @typedef {import('../../../common/drivers/ios/cookies').IosSimulatorCookie} IosSimulatorCookie
+ */
+
 const _ = require('lodash');
 
-const DetoxRuntimeError = require('../../../../errors/DetoxRuntimeError');
-const IosSimulatorCookie = require('../../../cookies/IosSimulatorCookie');
-const AllocationDriverBase = require('../AllocationDriverBase');
+const { DetoxRuntimeError } = require('../../../../errors');
+const log = require('../../../../utils/logger').child({ cat: 'device,device-allocation' });
+
+const SimulatorQuery = require('./SimulatorQuery');
 
-class SimulatorAllocDriver extends AllocationDriverBase {
+/**
+ * @implements {AllocationDriverBase}
+ */
+class SimulatorAllocDriver {
   /**
-   * @param deviceRegistry { DeviceRegistry }
-   * @param applesimutils { AppleSimUtils }
-   * @param simulatorLauncher { SimulatorLauncher }
+   * @param {object} options
+   * @param {import('../../DeviceRegistry')} options.deviceRegistry
+   * @param {DetoxInternals.RuntimeConfig} options.detoxConfig
+   * @param {import('../../../common/drivers/ios/tools/AppleSimUtils')} options.applesimutils
+   * @param {import('./SimulatorLauncher')} options.simulatorLauncher
    */
-  constructor({ deviceRegistry, applesimutils, simulatorLauncher }) {
-    super();
+  constructor({ detoxConfig, deviceRegistry, applesimutils, simulatorLauncher }) {
     this._deviceRegistry = deviceRegistry;
     this._applesimutils = applesimutils;
     this._simulatorLauncher = simulatorLauncher;
     this._launchInfo = {};
+    this._shouldShutdown = detoxConfig.behavior.cleanup.shutdownDevice;
+  }
+
+  async init() {
+    await this._deviceRegistry.unregisterZombieDevices();
   }
 
   /**
@@ -24,30 +39,37 @@ class SimulatorAllocDriver extends AllocationDriverBase {
    * @return {Promise<IosSimulatorCookie>}
    */
   async allocate(deviceConfig) {
-    const deviceQuery = this._adaptQuery(deviceConfig.device);
+    const deviceQuery = new SimulatorQuery(deviceConfig.device);
 
     // TODO Delegate this onto a well tested allocator class
-    const udid = await this._deviceRegistry.allocateDevice(async () => {
+    const udid = await this._deviceRegistry.registerDevice(async () => {
       return await this._findOrCreateDevice(deviceQuery);
     });
 
-    const deviceComment = this._commentDevice(deviceQuery);
     if (!udid) {
-      throw new DetoxRuntimeError(`Failed to find device matching ${deviceComment}`);
+      throw new DetoxRuntimeError(`Failed to find device matching ${deviceQuery.getDeviceComment()}`);
     }
 
     this._launchInfo[udid] = { deviceConfig };
-    return new IosSimulatorCookie(udid);
+    return { id: udid, udid };
   }
 
   /**
    * @param {IosSimulatorCookie} deviceCookie
-   * @returns {Promise<void>}
+   * @returns {Promise<IosSimulatorCookie>}
    */
   async postAllocate(deviceCookie) {
     const { udid } = deviceCookie;
     const { deviceConfig } = this._launchInfo[udid];
     await this._simulatorLauncher.launch(udid, deviceConfig.type, deviceConfig.bootArgs, deviceConfig.headless);
+
+    return {
+      id: udid,
+      udid,
+      type: deviceConfig.type,
+      bootArgs: deviceConfig.bootArgs,
+      headless: deviceConfig.headless,
+    };
   }
 
   /**
@@ -58,21 +80,40 @@ class SimulatorAllocDriver extends AllocationDriverBase {
   async free(cookie, options = {}) {
     const { udid } = cookie;
 
-    await this._deviceRegistry.disposeDevice(udid);
-
     if (options.shutdown) {
+      await this._doShutdown(udid);
+      await this._deviceRegistry.unregisterDevice(udid);
+    } else {
+      await this._deviceRegistry.releaseDevice(udid);
+    }
+  }
+
+  async cleanup() {
+    if (this._shouldShutdown) {
+      const sessionDevices = await this._deviceRegistry.readSessionDevices();
+      const shutdownPromises = sessionDevices.getIds().map((udid) => this._doShutdown(udid));
+      await Promise.all(shutdownPromises);
+    }
+
+    await this._deviceRegistry.unregisterSessionDevices();
+  }
+
+  /**
+   * @param {string} udid
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _doShutdown(udid) {
+    try {
       await this._simulatorLauncher.shutdown(udid);
+    } catch (err) {
+      log.warn({ err }, `Failed to shutdown simulator ${udid}`);
     }
   }
 
   /***
    * @private
-   * @param deviceQuery {{
-   *   byId?: string;
-   *   byName?: string;
-   *   byType?: string;
-   *   byOS?: string;
-   * }}
+   * @param {SimulatorQuery} deviceQuery
    * @returns {Promise<String>}
    */
   async _findOrCreateDevice(deviceQuery) {
@@ -83,6 +124,7 @@ class SimulatorAllocDriver extends AllocationDriverBase {
     if (_.isEmpty(free)) {
       const prototypeDevice = taken[0];
       udid = this._applesimutils.create(prototypeDevice);
+      await this._runScreenshotWorkaround(udid);
     } else {
       udid = free[0].udid;
     }
@@ -90,11 +132,30 @@ class SimulatorAllocDriver extends AllocationDriverBase {
     return udid;
   }
 
+  async _runScreenshotWorkaround(udid) {
+    await this._applesimutils.takeScreenshot(udid, '/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());
+    });
+  }
+
+  /**
+   * @private
+   * @param {SimulatorQuery} deviceQuery
+   */
   async _groupDevicesByStatus(deviceQuery) {
     const searchResults = await this._queryDevices(deviceQuery);
-    const { rawDevices: takenDevices } = this._deviceRegistry.getRegisteredDevices();
-    const takenUDIDs = new Set(_.map(takenDevices, 'id'));
-    const { taken, free }  = _.groupBy(searchResults, ({ udid }) => takenUDIDs.has(udid) ? 'taken' : 'free');
+    const takenDevices = this._deviceRegistry.getTakenDevicesSync();
+
+    const { taken, free }  = _.groupBy(searchResults, ({ udid }) => {
+      return takenDevices.includes(udid) ? 'taken' : 'free';
+    });
 
     const targetOS = _.get(taken, '0.os.identifier');
     const isMatching = targetOS && { os: { identifier: targetOS } };
@@ -105,43 +166,25 @@ class SimulatorAllocDriver extends AllocationDriverBase {
     };
   }
 
+  /**
+   * @private
+   * @param {SimulatorQuery} deviceQuery
+   */
   async _queryDevices(deviceQuery) {
     const result = await this._applesimutils.list(
       deviceQuery,
-      `Searching for device ${this._commentQuery(deviceQuery)} ...`
+      `Searching for device ${deviceQuery} ...`
     );
 
     if (_.isEmpty(result)) {
       throw new DetoxRuntimeError({
-        message: `Failed to find a device ${this._commentQuery(deviceQuery)}`,
+        message: `Failed to find a device ${deviceQuery}`,
         hint: `Run 'applesimutils --list' to list your supported devices. ` +
           `It is advised only to specify a device type, e.g., "iPhone Xʀ" and avoid explicit search by OS version.`
       });
     }
     return result;
   }
-
-  _adaptQuery({ id, name, os, type }) {
-    return _.omitBy({
-      byId: id,
-      byName: name,
-      byOS: os,
-      byType: type,
-    }, _.isUndefined);
-  }
-
-  _commentQuery({ byId, byName, byOS, byType }) {
-    return _.compact([
-      byId && `by UDID = ${JSON.stringify(byId)}`,
-      byName && `by name = ${JSON.stringify(byName)}`,
-      byType && `by type = ${JSON.stringify(byType)}`,
-      byOS && `by OS = ${JSON.stringify(byOS)}`,
-    ]).join(' and ');
-  }
-
-  _commentDevice({ byId, byName, byOS, byType }) {
-    return byId || _.compact([byName, byType, byOS]).join(', ');
-  }
 }
 
 module.exports = SimulatorAllocDriver;

package/src/devices/allocation/drivers/ios/SimulatorLauncher.js

@@ -1,20 +1,24 @@
-const DeviceLauncher = require('../../../common/drivers/DeviceLauncher');
-
-class SimulatorLauncher extends DeviceLauncher {
+class SimulatorLauncher {
   constructor({ applesimutils, eventEmitter }) {
-    super(eventEmitter);
     this._applesimutils = applesimutils;
+    this._eventEmitter = eventEmitter;
   }
 
   async launch(udid, type, bootArgs, headless) {
     const coldBoot = await this._applesimutils.boot(udid, bootArgs, headless);
-    await this._notifyBootEvent(udid, type, coldBoot, headless);
+    return coldBoot;
   }
 
   async shutdown(udid) {
-    await this._notifyPreShutdown(udid);
+    if (this._eventEmitter) {
+      await this._eventEmitter.emit('beforeShutdownDevice', { deviceId: udid });
+    }
+
     await this._applesimutils.shutdown(udid);
-    await this._notifyShutdownCompleted(udid);
+
+    if (this._eventEmitter) {
+      await this._eventEmitter.emit('shutdownDevice', { deviceId: udid });
+    }
   }
 }
 

package/src/devices/allocation/drivers/ios/SimulatorQuery.js

@@ -0,0 +1,24 @@
+class SimulatorQuery {
+  /** @param {Partial<Detox.IosSimulatorQuery>} query */
+  constructor({ id, name, os, type }) {
+    if (id != null) this.byId = id;
+    if (name != null) this.byName = name;
+    if (os != null) this.byOS = os;
+    if (type != null) this.byType = type;
+  }
+
+  getDeviceComment() {
+    return this.byId || [this.byName, this.byType, this.byOS].filter(Boolean).join(', ');
+  }
+
+  toString() {
+    return [
+      this.byId && `by UDID = ${JSON.stringify(this.byId)}`,
+      this.byName && `by name = ${JSON.stringify(this.byName)}`,
+      this.byType && `by type = ${JSON.stringify(this.byType)}`,
+      this.byOS && `by OS = ${JSON.stringify(this.byOS)}`,
+    ].filter(Boolean).join(' and ');
+  }
+}
+
+module.exports = SimulatorQuery;