detox 20.12.2 → 20.14.0-smoke.0

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;

package/src/devices/allocation/factories/android.js

@@ -2,11 +2,12 @@
 const DeviceAllocatorFactory = require('./base');
 
 class AndroidEmulator extends DeviceAllocatorFactory {
-  _createDriver({ eventEmitter }) {
-    const serviceLocator = require('../../../servicelocator/android');
+  _createDriver({ detoxSession, detoxConfig }) {
+    const serviceLocator = require('../../servicelocator/android');
     const adb = serviceLocator.adb;
     const emulatorExec = serviceLocator.emulator.exec;
-    const deviceRegistry = serviceLocator.deviceRegistry;
+    const DeviceRegistry = require('../../allocation/DeviceRegistry');
+    const deviceRegistry = new DeviceRegistry({ sessionId: detoxSession.id });
 
     const AVDsResolver = require('../drivers/android/emulator/AVDsResolver');
     const avdsResolver = new AVDsResolver(emulatorExec);
@@ -20,74 +21,67 @@ class AndroidEmulator extends DeviceAllocatorFactory {
     const FreeEmulatorFinder = require('../drivers/android/emulator/FreeEmulatorFinder');
     const freeEmulatorFinder = new FreeEmulatorFinder(adb, deviceRegistry);
 
-    const EmulatorLauncher = require('../drivers/android/emulator/EmulatorLauncher');
-    const emulatorLauncher = new EmulatorLauncher({ adb, emulatorExec, eventEmitter });
+    const FreePortFinder = require('../drivers/android/emulator/FreePortFinder');
+    const freePortFinder = new FreePortFinder();
 
-    const EmulatorAllocationHelper = require('../drivers/android/emulator/EmulatorAllocationHelper');
-    const allocationHelper = new EmulatorAllocationHelper(deviceRegistry, freeEmulatorFinder);
+    const EmulatorLauncher = require('../drivers/android/emulator/EmulatorLauncher');
+    const emulatorLauncher = new EmulatorLauncher({ adb, emulatorExec });
 
     const EmulatorAllocDriver = require('../drivers/android/emulator/EmulatorAllocDriver');
     return new EmulatorAllocDriver({
       adb,
       avdValidator,
+      detoxConfig,
+      deviceRegistry,
       emulatorVersionResolver,
       emulatorLauncher,
-      allocationHelper,
+      freeDeviceFinder: freeEmulatorFinder,
+      freePortFinder,
     });
   }
 }
 
 class AndroidAttached extends DeviceAllocatorFactory {
-  _createDriver({ eventEmitter }) {
-    const serviceLocator = require('../../../servicelocator/android');
+  _createDriver({ detoxSession, detoxConfig }) {
+    const serviceLocator = require('../../servicelocator/android');
     const adb = serviceLocator.adb;
-    const deviceRegistry = serviceLocator.deviceRegistry;
+    const DeviceRegistry = require('../../allocation/DeviceRegistry');
+    const deviceRegistry = new DeviceRegistry({ sessionId: detoxSession.id });
 
-    const FreeDeviceFinder = require('../../common/drivers/android/tools/FreeDeviceFinder');
+    const FreeDeviceFinder = require('../drivers/android/FreeDeviceFinder');
     const freeDeviceFinder = new FreeDeviceFinder(adb, deviceRegistry);
 
-    const AttachedAndroidLauncher = require('../drivers/android/attached/AttachedAndroidLauncher');
-    const attachedAndroidLauncher = new AttachedAndroidLauncher(eventEmitter);
-
     const AttachedAndroidAllocDriver = require('../drivers/android/attached/AttachedAndroidAllocDriver');
-    return new AttachedAndroidAllocDriver({ adb, deviceRegistry, freeDeviceFinder, attachedAndroidLauncher });
+    return new AttachedAndroidAllocDriver({ adb, deviceRegistry, freeDeviceFinder });
   }
 }
 
 class Genycloud extends DeviceAllocatorFactory {
-  _createDriver({ eventEmitter }) {
-    const serviceLocator = require('../../../servicelocator/android');
+  _createDriver(deps) {
+    const serviceLocator = require('../../servicelocator/android');
     const adb = serviceLocator.adb;
     const exec = serviceLocator.genycloud.exec;
-    const deviceRegistry = serviceLocator.genycloud.runtimeDeviceRegistry;
-    const deviceCleanupRegistry = serviceLocator.genycloud.cleanupDeviceRegistry;
 
-    const InstanceNaming = require('../../common/drivers/android/genycloud/services/GenyInstanceNaming');
-    const instanceNaming = new InstanceNaming(); // TODO should consider a permissive impl for debug/dev mode. Maybe even a custom arg in package.json (Detox > ... > genycloud > sharedAccount: false)
-
-    const RecipesService = require('../../common/drivers/android/genycloud/services/GenyRecipesService');
+    const RecipesService = require('../drivers/android/genycloud/services/GenyRecipesService');
     const recipeService = new RecipesService(exec);
 
-    const InstanceLookupService = require('../../common/drivers/android/genycloud/services/GenyInstanceLookupService');
-    const instanceLookupService = new InstanceLookupService(exec, instanceNaming, deviceRegistry);
-
-    const InstanceLifecycleService = require('../../common/drivers/android/genycloud/services/GenyInstanceLifecycleService');
-    const instanceLifecycleService = new InstanceLifecycleService(exec, instanceNaming);
+    const InstanceLifecycleService = require('../drivers/android/genycloud/services/GenyInstanceLifecycleService');
+    const instanceLifecycleService = new InstanceLifecycleService(exec);
 
     const RecipeQuerying = require('../drivers/android/genycloud/GenyRecipeQuerying');
     const recipeQuerying = new RecipeQuerying(recipeService);
 
-    const InstanceAllocationHelper = require('../drivers/android/genycloud/GenyInstanceAllocationHelper');
-    const allocationHelper = new InstanceAllocationHelper({ deviceRegistry, instanceLookupService, instanceLifecycleService });
-
     const InstanceLauncher = require('../drivers/android/genycloud/GenyInstanceLauncher');
+    const instanceLauncher = new InstanceLauncher({ genyCloudExec: exec, instanceLifecycleService });
+
     const GenyAllocDriver = require('../drivers/android/genycloud/GenyAllocDriver');
-    const instanceLauncher = new InstanceLauncher({ instanceLifecycleService, instanceLookupService, deviceCleanupRegistry, eventEmitter });
+
     return new GenyAllocDriver({
       adb,
-      recipeQuerying,
-      allocationHelper,
       instanceLauncher,
+      instanceLifecycleService,
+      recipeQuerying,
+      ...deps,
     });
   }
 }