detox 20.12.0-smoke.0 → 20.12.1

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

@@ -1,39 +1,25 @@
 const { DetoxRuntimeError } = require('../../../../../errors');
 const Timer = require('../../../../../utils/Timer');
-const log = require('../../../../../utils/logger').child({ cat: 'device' });
 const GenycloudEmulatorCookie = require('../../../../cookies/GenycloudEmulatorCookie');
 const AllocationDriverBase = require('../../AllocationDriverBase');
 
-const GenyRegistry = require('./GenyRegistry');
-
-const events = {
-  GENYCLOUD_TEARDOWN: { event: 'GENYCLOUD_TEARDOWN' },
-};
-
 class GenyAllocDriver extends AllocationDriverBase {
+
   /**
    * @param {object} options
    * @param {import('../../../../common/drivers/android/exec/ADB')} options.adb
-   * @param {DetoxInternals.SessionState} options.detoxSession
-   * @param {import('./GenyRegistry')} options.genyRegistry
-   * @param {import('./GenyInstanceLauncher')} options.instanceLauncher
    * @param {import('./GenyRecipeQuerying')} options.recipeQuerying
+   * @param {import('./GenyInstanceAllocationHelper')} options.allocationHelper
+   * @param {import('./GenyInstanceLauncher')} options.instanceLauncher
    */
-  constructor({
-    adb,
-    detoxSession,
-    genyRegistry = new GenyRegistry(),
-    instanceLauncher,
-    recipeQuerying,
-  }) {
+  constructor({ adb, recipeQuerying, allocationHelper, instanceLauncher }) {
     super();
 
     this._adb = adb;
-    this._detoxSessionId = detoxSession.id;
-    this._genyRegistry = genyRegistry;
-    this._instanceLauncher = instanceLauncher;
     this._recipeQuerying = recipeQuerying;
-    this._instanceCounter = 0;
+    this._instanceLauncher = instanceLauncher;
+    this._instanceAllocationHelper = allocationHelper;
+    this._launchInfo = {};
   }
 
   /**
@@ -41,72 +27,45 @@ class GenyAllocDriver extends AllocationDriverBase {
    * @return {Promise<GenycloudEmulatorCookie>}
    */
   async allocate(deviceConfig) {
-    await new Promise((resolve) => setTimeout(resolve, 10000));
     const deviceQuery = deviceConfig.device;
     const recipe = await this._recipeQuerying.getRecipeFromQuery(deviceQuery);
     this._assertRecipe(deviceQuery, recipe);
 
-    let instance = this._genyRegistry.findFreeInstance(recipe);
-    if (!instance) {
-      const instanceName = `Detox.${this._detoxSessionId}.${this._instanceCounter++}`;
-      instance = await this._instanceLauncher.launch(recipe, instanceName);
-      this._genyRegistry.addInstance(instance, recipe);
-    }
-
+    const { instance, isNew } = await this._instanceAllocationHelper.allocateDevice(recipe);
+    this._launchInfo[instance.uuid] = { isNew };
     return new GenycloudEmulatorCookie(instance);
   }
 
   /**
    * @param {GenycloudEmulatorCookie} cookie
+   * @returns {Promise<void>}
    */
   async postAllocate(cookie) {
-    const instance = await this._instanceLauncher.connect(cookie.instance);
-    this._genyRegistry.updateInstance(instance);
-
-    if (this._genyRegistry.pollNewInstance(instance)) {
-      const { adbName } = instance;
-
-      await Timer.run(20000, 'waiting for device to respond', async () => {
-        await this._adb.disableAndroidAnimations(adbName);
-        await this._adb.setWiFiToggle(adbName, true);
-        await this._adb.apiLevel(adbName);
-      });
-    }
-
-    return new GenycloudEmulatorCookie(instance);
+    const { instance } = cookie;
+    const { isNew } = this._launchInfo[instance.uuid];
+    const readyInstance = cookie.instance = await this._instanceLauncher.launch(instance, isNew);
+
+    const { adbName } = readyInstance;
+    await Timer.run(20000, 'waiting for device to respond', async () => {
+      await this._adb.disableAndroidAnimations(adbName);
+      await this._adb.setWiFiToggle(adbName, true);
+      await this._adb.apiLevel(adbName);
+    });
   }
 
   /**
-   * @param cookie {GenycloudEmulatorCookie}
-   * @param options {Partial<import('../../AllocationDriverBase').DeallocOptions>}
+   * @param cookie { GenycloudEmulatorCookie }
+   * @param options { DeallocOptions }
    * @return {Promise<void>}
    */
   async free(cookie, options = {}) {
-    if (options.shutdown) {
-      this._genyRegistry.removeInstance(cookie.instance);
-      await this._instanceLauncher.shutdown(cookie.instance);
-    } else {
-      this._genyRegistry.markAsFree(cookie.instance);
-    }
-  }
-
-  async cleanup() {
-    log.info(events.GENYCLOUD_TEARDOWN, 'Initiating Genymotion SaaS instances teardown...');
+    const { instance } = cookie;
 
-    const killPromises = this._genyRegistry.getInstances().map((instance) => {
-      this._genyRegistry.markAsBusy(instance);
-      const onSuccess = () => this._genyRegistry.removeInstance(instance);
-      const onError = (error) => ({ ...instance, error });
-      return this._instanceLauncher.shutdown(instance).then(onSuccess, onError);
-    });
-
-    const deletionLeaks = (await Promise.all(killPromises)).filter(Boolean);
-    this._reportGlobalCleanupSummary(deletionLeaks);
-  }
+    await this._instanceAllocationHelper.deallocateDevice(instance.uuid);
 
-  emergencyCleanup() {
-    const instances = this._genyRegistry.getInstances();
-    this._reportGlobalCleanupSummary(instances);
+    if (options.shutdown) {
+      await this._instanceLauncher.shutdown(instance);
+    }
   }
 
   _assertRecipe(deviceQuery, recipe) {
@@ -117,25 +76,6 @@ class GenyAllocDriver extends AllocationDriverBase {
       });
     }
   }
-
-  _reportGlobalCleanupSummary(deletionLeaks) {
-    if (deletionLeaks.length) {
-      log.warn(events.GENYCLOUD_TEARDOWN, 'WARNING! Detected a Genymotion SaaS instance leakage, for the following instances:');
-
-      deletionLeaks.forEach(({ uuid, name, error }) => {
-        log.warn(events.GENYCLOUD_TEARDOWN, [
-          `Instance ${name} (${uuid})${error ? `: ${error}` : ''}`,
-          `    Kill it by visiting https://cloud.geny.io/instance/${uuid}, or by running:`,
-          `    gmsaas instances stop ${uuid}`,
-        ].join('\n'));
-      });
-
-      log.info(events.GENYCLOUD_TEARDOWN, 'Instances teardown completed with warnings');
-    } else {
-      log.info(events.GENYCLOUD_TEARDOWN, 'Instances teardown completed successfully');
-    }
-  }
 }
 
-
 module.exports = GenyAllocDriver;

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

@@ -0,0 +1,16 @@
+const environment = require('../../../../../utils/environment');
+const DeviceRegistry = require('../../../../DeviceRegistry');
+
+class GenyDeviceRegistryFactory {
+  forRuntime() {
+    return DeviceRegistry.forAndroid();
+  }
+
+  forGlobalShutdown() {
+    return new DeviceRegistry({
+      lockfilePath: environment.getGenyCloudGlobalCleanupFilePath(),
+    });
+  }
+}
+
+module.exports = new GenyDeviceRegistryFactory();

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

@@ -0,0 +1,65 @@
+// @ts-nocheck
+const logger = require('../../../../../utils/logger').child({ cat: 'device' });
+const DeviceAllocationHelper = require('../../../../common/drivers/DeviceAllocationHelper');
+
+const { ALLOCATE_DEVICE_LOG_EVT } = DeviceAllocationHelper;
+
+class AllocationResult {
+  constructor(instance, isNew) {
+    this.instance = instance;
+    this.isNew = isNew;
+  }
+}
+
+class GenyInstanceAllocationHelper extends DeviceAllocationHelper {
+  constructor({ deviceRegistry, instanceLookupService, instanceLifecycleService }) {
+    super(deviceRegistry, logger);
+
+    this._instanceLookupService = instanceLookupService;
+    this._instanceLifecycleService = instanceLifecycleService;
+  }
+
+  /**
+   * @param recipe { GenyRecipe }
+   * @return { Promise<AllocationResult> }
+   */
+  async allocateDevice(recipe) {
+    this._logAllocationAttempt(recipe);
+
+    const allocationResult = await this._doSynchronizedAllocation(recipe);
+    this._logAllocationResult(recipe, allocationResult.instance);
+
+    return allocationResult;
+  }
+
+  async deallocateDevice(instanceUUID) {
+    await this._deviceRegistry.disposeDevice(instanceUUID);
+  }
+
+  /**
+   * @param recipe { GenyRecipe }
+   * @return {Promise<{AllocationResult}>}
+   * @private
+   */
+  async _doSynchronizedAllocation(recipe) {
+    let instance = null;
+    let isNew = false;
+
+    await this._deviceRegistry.allocateDevice(async () => {
+      instance = await this._instanceLookupService.findFreeInstance();
+      if (!instance) {
+        instance = await this._instanceLifecycleService.createInstance(recipe.uuid);
+        isNew = true;
+      }
+      return instance.uuid;
+    });
+
+    return new AllocationResult(instance, isNew);
+  }
+
+  _logAllocationResult(deviceQuery, deviceHandle) {
+    logger.info({ event: ALLOCATE_DEVICE_LOG_EVT }, `Allocating Genymotion-Cloud instance ${deviceHandle.name} for testing. To access it via a browser, go to: https://cloud.geny.io/instance/${deviceHandle.uuid}`);
+  }
+}
+
+module.exports = GenyInstanceAllocationHelper;

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

@@ -1,51 +1,44 @@
+// @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');
 
-const GenyInstance = require('./services/dto/GenyInstance');
+class GenyInstanceLauncher extends DeviceLauncher {
+  constructor({ instanceLifecycleService, instanceLookupService, deviceCleanupRegistry, eventEmitter }) {
+    super(eventEmitter);
 
-const events = {
-  CREATE_DEVICE: { event: 'CREATE_DEVICE' },
-};
-
-class GenyInstanceLauncher {
-  constructor({ genyCloudExec, instanceLifecycleService }) {
-    this._genyCloudExec = genyCloudExec;
     this._instanceLifecycleService = instanceLifecycleService;
+    this._instanceLookupService = instanceLookupService;
+    this._deviceCleanupRegistry = deviceCleanupRegistry;
   }
 
   /**
-   * @param {import('./services/dto/GenyRecipe')} recipe
-   * @param {string} instanceName
+   * 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 }
    * @returns {Promise<GenyInstance>}
    */
-  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}`);
-
+  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);
     return 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;
-  }
-
-  /**
-   * @param {import('./services/dto/GenyInstance')} instance The freshly allocated cloud-instance.
-   */
   async shutdown(instance) {
     const { uuid } = instance;
 
+    await this._notifyPreShutdown(uuid);
     await this._instanceLifecycleService.deleteInstance(uuid);
+    await this._deviceCleanupRegistry.disposeDevice(uuid);
+    await this._notifyShutdownCompleted(uuid);
   }
 
   async _waitForInstanceBoot(instance) {
@@ -55,21 +48,17 @@ class GenyInstanceLauncher {
 
     const options = {
       backoff: 'none',
-      retries: 20,
+      retries: 25,
       interval: 5000,
       initialSleep: 45000,
-      shouldUnref: true,
     };
 
     return await retry(options, async () => {
-      const { instance: _instance } = await this._genyCloudExec.getInstance(instance.uuid);
-      const anInstance = new GenyInstance(_instance);
-
-      if (!anInstance.isOnline()) {
+      const _instance = await this._instanceLookupService.getInstance(instance.uuid);
+      if (!_instance.isOnline()) {
         throw new DetoxRuntimeError(`Timeout waiting for instance ${instance.uuid} to be ready`);
       }
-
-      return anInstance;
+      return _instance;
     });
   }
 

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

@@ -2,31 +2,21 @@
 const _ = require('lodash');
 
 const DetoxRuntimeError = require('../../../../errors/DetoxRuntimeError');
-const log = require('../../../../utils/logger').child({ cat: 'device,device-allocation' });
 const IosSimulatorCookie = require('../../../cookies/IosSimulatorCookie');
 const AllocationDriverBase = require('../AllocationDriverBase');
 
-const SimulatorQuery = require('./SimulatorQuery');
-
 class SimulatorAllocDriver extends AllocationDriverBase {
   /**
-   * @param deviceRegistry { DeviceRegistry }
-   * @param detoxConfig { DetoxInternals.RuntimeConfig }
    * @param deviceRegistry { DeviceRegistry }
    * @param applesimutils { AppleSimUtils }
    * @param simulatorLauncher { SimulatorLauncher }
    */
-  constructor({ detoxConfig, deviceRegistry, applesimutils, simulatorLauncher }) {
+  constructor({ deviceRegistry, applesimutils, simulatorLauncher }) {
     super();
     this._deviceRegistry = deviceRegistry;
     this._applesimutils = applesimutils;
     this._simulatorLauncher = simulatorLauncher;
     this._launchInfo = {};
-    this._shouldShutdown = detoxConfig.behavior.cleanup.shutdownDevice;
-  }
-
-  async init() {
-    await this._deviceRegistry.unregisterZombieDevices();
   }
 
   /**
@@ -34,15 +24,16 @@ class SimulatorAllocDriver extends AllocationDriverBase {
    * @return {Promise<IosSimulatorCookie>}
    */
   async allocate(deviceConfig) {
-    const deviceQuery = new SimulatorQuery(deviceConfig.device);
+    const deviceQuery = this._adaptQuery(deviceConfig.device);
 
     // TODO Delegate this onto a well tested allocator class
-    const udid = await this._deviceRegistry.registerDevice(async () => {
+    const udid = await this._deviceRegistry.allocateDevice(async () => {
       return await this._findOrCreateDevice(deviceQuery);
     });
 
+    const deviceComment = this._commentDevice(deviceQuery);
     if (!udid) {
-      throw new DetoxRuntimeError(`Failed to find device matching ${deviceQuery.getDeviceComment()}`);
+      throw new DetoxRuntimeError(`Failed to find device matching ${deviceComment}`);
     }
 
     this._launchInfo[udid] = { deviceConfig };
@@ -67,40 +58,21 @@ class SimulatorAllocDriver extends AllocationDriverBase {
   async free(cookie, options = {}) {
     const { udid } = cookie;
 
-    if (options.shutdown) {
-      await this._doShutdown(udid);
-      await this._deviceRegistry.unregisterDevice(udid);
-    } else {
-      await this._deviceRegistry.releaseDevice(udid);
-    }
-  }
+    await this._deviceRegistry.disposeDevice(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 {
+    if (options.shutdown) {
       await this._simulatorLauncher.shutdown(udid);
-    } catch (err) {
-      log.warn({ err }, `Failed to shutdown simulator ${udid}`);
     }
   }
 
   /***
    * @private
-   * @param {SimulatorQuery} deviceQuery
+   * @param deviceQuery {{
+   *   byId?: string;
+   *   byName?: string;
+   *   byType?: string;
+   *   byOS?: string;
+   * }}
    * @returns {Promise<String>}
    */
   async _findOrCreateDevice(deviceQuery) {
@@ -111,7 +83,6 @@ 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;
     }
@@ -119,30 +90,11 @@ 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 takenDevices = this._deviceRegistry.getTakenDevicesSync();
-
-    const { taken, free }  = _.groupBy(searchResults, ({ udid }) => {
-      return takenDevices.includes(udid) ? 'taken' : 'free';
-    });
+    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 targetOS = _.get(taken, '0.os.identifier');
     const isMatching = targetOS && { os: { identifier: targetOS } };
@@ -153,25 +105,43 @@ class SimulatorAllocDriver extends AllocationDriverBase {
     };
   }
 
-  /**
-   * @private
-   * @param {SimulatorQuery} deviceQuery
-   */
   async _queryDevices(deviceQuery) {
     const result = await this._applesimutils.list(
       deviceQuery,
-      `Searching for device ${deviceQuery} ...`
+      `Searching for device ${this._commentQuery(deviceQuery)} ...`
     );
 
     if (_.isEmpty(result)) {
       throw new DetoxRuntimeError({
-        message: `Failed to find a device ${deviceQuery}`,
+        message: `Failed to find a device ${this._commentQuery(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,24 +1,20 @@
-class SimulatorLauncher {
+const DeviceLauncher = require('../../../common/drivers/DeviceLauncher');
+
+class SimulatorLauncher extends DeviceLauncher {
   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);
-    return coldBoot;
+    await this._notifyBootEvent(udid, type, coldBoot, headless);
   }
 
   async shutdown(udid) {
-    if (this._eventEmitter) {
-      await this._eventEmitter.emit('beforeShutdownDevice', { deviceId: udid });
-    }
-
+    await this._notifyPreShutdown(udid);
     await this._applesimutils.shutdown(udid);
-
-    if (this._eventEmitter) {
-      await this._eventEmitter.emit('shutdownDevice', { deviceId: udid });
-    }
+    await this._notifyShutdownCompleted(udid);
   }
 }