detox 20.12.0-smoke.0 → 20.12.0

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

@@ -2,12 +2,11 @@
 const DeviceAllocatorFactory = require('./base');
 
 class AndroidEmulator extends DeviceAllocatorFactory {
-  _createDriver({ detoxSession, detoxConfig }) {
-    const serviceLocator = require('../../servicelocator/android');
+  _createDriver({ eventEmitter }) {
+    const serviceLocator = require('../../../servicelocator/android');
     const adb = serviceLocator.adb;
     const emulatorExec = serviceLocator.emulator.exec;
-    const DeviceRegistry = require('../../allocation/DeviceRegistry');
-    const deviceRegistry = new DeviceRegistry({ sessionId: detoxSession.id });
+    const deviceRegistry = serviceLocator.deviceRegistry;
 
     const AVDsResolver = require('../drivers/android/emulator/AVDsResolver');
     const avdsResolver = new AVDsResolver(emulatorExec);
@@ -21,67 +20,74 @@ class AndroidEmulator extends DeviceAllocatorFactory {
     const FreeEmulatorFinder = require('../drivers/android/emulator/FreeEmulatorFinder');
     const freeEmulatorFinder = new FreeEmulatorFinder(adb, deviceRegistry);
 
-    const FreePortFinder = require('../drivers/android/emulator/FreePortFinder');
-    const freePortFinder = new FreePortFinder();
-
     const EmulatorLauncher = require('../drivers/android/emulator/EmulatorLauncher');
-    const emulatorLauncher = new EmulatorLauncher({ adb, emulatorExec });
+    const emulatorLauncher = new EmulatorLauncher({ adb, emulatorExec, eventEmitter });
+
+    const EmulatorAllocationHelper = require('../drivers/android/emulator/EmulatorAllocationHelper');
+    const allocationHelper = new EmulatorAllocationHelper(deviceRegistry, freeEmulatorFinder);
 
     const EmulatorAllocDriver = require('../drivers/android/emulator/EmulatorAllocDriver');
     return new EmulatorAllocDriver({
       adb,
       avdValidator,
-      detoxConfig,
-      deviceRegistry,
       emulatorVersionResolver,
       emulatorLauncher,
-      freeDeviceFinder: freeEmulatorFinder,
-      freePortFinder,
+      allocationHelper,
     });
   }
 }
 
 class AndroidAttached extends DeviceAllocatorFactory {
-  _createDriver({ detoxSession, detoxConfig }) {
-    const serviceLocator = require('../../servicelocator/android');
+  _createDriver({ eventEmitter }) {
+    const serviceLocator = require('../../../servicelocator/android');
     const adb = serviceLocator.adb;
-    const DeviceRegistry = require('../../allocation/DeviceRegistry');
-    const deviceRegistry = new DeviceRegistry({ sessionId: detoxSession.id });
+    const deviceRegistry = serviceLocator.deviceRegistry;
 
-    const FreeDeviceFinder = require('../drivers/android/FreeDeviceFinder');
+    const FreeDeviceFinder = require('../../common/drivers/android/tools/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 });
+    return new AttachedAndroidAllocDriver({ adb, deviceRegistry, freeDeviceFinder, attachedAndroidLauncher });
   }
 }
 
 class Genycloud extends DeviceAllocatorFactory {
-  _createDriver(deps) {
-    const serviceLocator = require('../../servicelocator/android');
+  _createDriver({ eventEmitter }) {
+    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 RecipesService = require('../drivers/android/genycloud/services/GenyRecipesService');
+    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 recipeService = new RecipesService(exec);
 
-    const InstanceLifecycleService = require('../drivers/android/genycloud/services/GenyInstanceLifecycleService');
-    const instanceLifecycleService = new InstanceLifecycleService(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 RecipeQuerying = require('../drivers/android/genycloud/GenyRecipeQuerying');
     const recipeQuerying = new RecipeQuerying(recipeService);
 
-    const InstanceLauncher = require('../drivers/android/genycloud/GenyInstanceLauncher');
-    const instanceLauncher = new InstanceLauncher({ genyCloudExec: exec, instanceLifecycleService });
+    const InstanceAllocationHelper = require('../drivers/android/genycloud/GenyInstanceAllocationHelper');
+    const allocationHelper = new InstanceAllocationHelper({ deviceRegistry, instanceLookupService, instanceLifecycleService });
 
+    const InstanceLauncher = require('../drivers/android/genycloud/GenyInstanceLauncher');
     const GenyAllocDriver = require('../drivers/android/genycloud/GenyAllocDriver');
-
+    const instanceLauncher = new InstanceLauncher({ instanceLifecycleService, instanceLookupService, deviceCleanupRegistry, eventEmitter });
     return new GenyAllocDriver({
       adb,
-      instanceLauncher,
-      instanceLifecycleService,
       recipeQuerying,
-      ...deps,
+      allocationHelper,
+      instanceLauncher,
     });
   }
 }

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

@@ -2,18 +2,16 @@
 const DeviceAllocatorFactory = require('./base');
 
 class IosSimulator extends DeviceAllocatorFactory {
-  _createDriver({ detoxConfig, detoxSession, eventEmitter }) {
-    const AppleSimUtils = require('../../../devices/common/drivers/ios/tools/AppleSimUtils');
-    const applesimutils = new AppleSimUtils();
-
-    const DeviceRegistry = require('../../../devices/allocation/DeviceRegistry');
-    const deviceRegistry = new DeviceRegistry({ sessionId: detoxSession.id });
+  _createDriver({ eventEmitter }) {
+    const serviceLocator = require('../../../servicelocator/ios');
+    const applesimutils = serviceLocator.appleSimUtils;
+    const deviceRegistry = serviceLocator.deviceRegistry;
 
     const SimulatorLauncher = require('../drivers/ios/SimulatorLauncher');
     const simulatorLauncher = new SimulatorLauncher({ applesimutils, eventEmitter });
 
     const SimulatorAllocDriver = require('../drivers/ios/SimulatorAllocDriver');
-    return new SimulatorAllocDriver({ detoxConfig, deviceRegistry, applesimutils, simulatorLauncher });
+    return new SimulatorAllocDriver({ deviceRegistry, applesimutils, simulatorLauncher });
   }
 }
 

package/src/devices/common/drivers/DeviceAllocationHelper.js

@@ -0,0 +1,20 @@
+const ALLOCATE_DEVICE_LOG_EVT = 'ALLOCATE_DEVICE';
+
+class DeviceAllocationHelper {
+  constructor(deviceRegistry, logger) {
+    this._deviceRegistry = deviceRegistry;
+    this._logger = logger;
+  }
+
+  _logAllocationAttempt(deviceQuery) {
+    this._logger.debug({ event: ALLOCATE_DEVICE_LOG_EVT }, `Trying to allocate a device based on "${deviceQuery}"`);
+  }
+
+  _logAllocationResult(deviceQuery, deviceHandle) {
+    this._logger.debug({ event: ALLOCATE_DEVICE_LOG_EVT }, `Settled on ${deviceHandle}`);
+  }
+}
+
+DeviceAllocationHelper.ALLOCATE_DEVICE_LOG_EVT = ALLOCATE_DEVICE_LOG_EVT;
+
+module.exports = DeviceAllocationHelper;

package/src/devices/common/drivers/DeviceLauncher.js

@@ -0,0 +1,19 @@
+class DeviceLauncher {
+  constructor(eventEmitter) {
+    this._eventEmitter = eventEmitter;
+  }
+
+  async _notifyPreShutdown(deviceId) {
+    return this._eventEmitter.emit('beforeShutdownDevice', { deviceId });
+  }
+
+  async _notifyShutdownCompleted(deviceId) {
+    return this._eventEmitter.emit('shutdownDevice', { deviceId });
+  }
+
+  async _notifyBootEvent(deviceId, type, coldBoot, headless) {
+    return this._eventEmitter.emit('bootDevice', { deviceId, type, coldBoot, headless });
+  }
+}
+
+module.exports = DeviceLauncher;

package/src/devices/common/drivers/android/emulator/exec/EmulatorExec.js

@@ -32,31 +32,19 @@ class QueryVersionCommand extends ExecCommand {
 }
 
 class LaunchCommand extends ExecCommand {
-  constructor(options) {
+  constructor(emulatorName, options) {
     super();
     this._options = options;
-    this._args = this._getEmulatorArgs();
-  }
-
-  get adbName() {
-    return this._options.adbName;
-  }
-
-  get avdName() {
-    return this._options.avdName;
-  }
-
-  get port() {
-    return this._options.port;
+    this._args = this._getEmulatorArgs(emulatorName);
+    this.port = options.port;
   }
 
   _getArgs() {
     return this._args;
   }
 
-  _getEmulatorArgs() {
+  _getEmulatorArgs(emulatorName) {
     const {
-      avdName,
       bootArgs,
       gpuMode = this._getDefaultGPUMode(),
       headless,
@@ -76,7 +64,7 @@ class LaunchCommand extends ExecCommand {
       port ? '-port' : '',
       port ? `${port}` : '',
       ...deviceBootArgs,
-      `@${avdName}`
+      `@${emulatorName}`
     ]);
 
     return emulatorArgs;

package/src/devices/common/drivers/android/exec/ADB.js

@@ -18,7 +18,6 @@ class ADB {
 
   async devices() {
     const { stdout } = await this.adbCmd('', 'devices', { verbosity: 'high' });
-    /** @type {DeviceHandle[]} */
     const devices = _.chain(stdout)
       .trim()
       .split('\n')

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

@@ -0,0 +1,25 @@
+const Instance = require('./dto/GenyInstance');
+
+class GenyInstanceLifecycleService {
+  constructor(genyCloudExec, instanceNaming) {
+    this.genyCloudExec = genyCloudExec;
+    this.instanceNaming = instanceNaming;
+  }
+
+  async createInstance(recipeUUID) {
+    const result = await this.genyCloudExec.startInstance(recipeUUID, this.instanceNaming.generateName());
+    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/drivers/android/genycloud/services/GenyInstanceLookupService.js

@@ -0,0 +1,38 @@
+const Instance = require('./dto/GenyInstance');
+
+class GenyInstanceLookupService {
+  constructor(genyCloudExec, instanceNaming, genyCloudDeviceRegistry) {
+    this.genyCloudExec = genyCloudExec;
+    this.instanceNaming = instanceNaming;
+    this.deviceRegistry = genyCloudDeviceRegistry;
+  }
+
+  async findFreeInstance() {
+    const freeInstances = await this._getRelevantInstances();
+    return (freeInstances[0] || null);
+  }
+
+  async getInstance(instanceUUID) {
+    const { instance } = await this.genyCloudExec.getInstance(instanceUUID);
+    return new Instance(instance);
+  }
+
+  async _getRelevantInstances() {
+    const takenInstances = this.deviceRegistry.getRegisteredDevices();
+    const isRelevant = (instance) =>
+      (instance.isOnline() || instance.isInitializing()) &&
+      this.instanceNaming.isFamilial(instance.name) &&
+      !takenInstances.includes(instance.uuid);
+
+    const instances = await this._getAllInstances();
+    return instances.filter(isRelevant);
+  }
+
+  async _getAllInstances() {
+    return (await this.genyCloudExec.getInstances())
+      .instances
+      .map((rawInstance) => new Instance(rawInstance));
+  }
+}
+
+module.exports = GenyInstanceLookupService;

package/src/devices/common/drivers/android/genycloud/services/GenyInstanceNaming.js

@@ -0,0 +1,14 @@
+const internals = () => require('../../../../../../../internals');
+
+class GenyInstanceNaming {
+  generateName() {
+    const { session, worker } = internals();
+    return `Detox.${session.id}.${worker.id}`;
+  }
+
+  isFamilial(name) {
+    return name === this.generateName();
+  }
+}
+
+module.exports = GenyInstanceNaming;

package/src/devices/{allocation → common}/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 → common}/drivers/android/genycloud/services/dto/GenyInstance.js

@@ -59,12 +59,7 @@ class GenyInstance {
   }
 
   toString() {
-    const description = [
-      this.uuid,
-      this.adbName
-    ].filter(Boolean).join('/');
-
-    return `${this.name} (${description})`;
+    return `GenyCloud:${this.name} (${this.uuid} ${this.adbName})`;
   }
 }
 

package/src/devices/{allocation/drivers/android → common/drivers/android/tools}/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 = { event: 'DEVICE_LOOKUP' };
+const DEVICE_LOOKUP_LOG_EVT = 'DEVICE_LOOKUP';
 
 class FreeDeviceFinder {
   constructor(adb, deviceRegistry) {
@@ -10,9 +10,8 @@ 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(takenDevices, candidate, deviceQuery)) {
+      if (await this._isDeviceFreeAndMatching(candidate, deviceQuery)) {
         return candidate.adbName;
       }
     }
@@ -20,30 +19,30 @@ class FreeDeviceFinder {
   }
 
   /**
-   * @private
+   * @protected
    */
-  async _isDeviceFreeAndMatching(takenDevices, candidate, deviceQuery) {
+  async _isDeviceFreeAndMatching(candidate, deviceQuery) {
     const { adbName } = candidate;
 
-    const isTaken = takenDevices.includes(adbName);
+    const isTaken = this.deviceRegistry.includes(adbName);
     if (isTaken) {
-      log.debug(DEVICE_LOOKUP, `Device ${adbName} is already taken, skipping...`);
+      log.debug({ event: DEVICE_LOOKUP_LOG_EVT }, `Device ${adbName} is already taken, skipping...`);
       return false;
     }
 
     const isOffline = candidate.status === 'offline';
     if (isOffline) {
-      log.debug(DEVICE_LOOKUP, `Device ${adbName} is offline, skipping...`);
+      log.debug({ event: DEVICE_LOOKUP_LOG_EVT }, `Device ${adbName} is offline, skipping...`);
       return false;
     }
 
     const isMatching = await this._isDeviceMatching(candidate, deviceQuery);
     if (!isMatching) {
-      log.debug(DEVICE_LOOKUP, `Device ${adbName} does not match "${deviceQuery}"`);
+      log.debug({ event: DEVICE_LOOKUP_LOG_EVT }, `Device ${adbName} does not match "${deviceQuery}"`);
       return false;
     }
 
-    log.debug(DEVICE_LOOKUP, `Found a matching & free device ${candidate.adbName}`);
+    log.debug({ event: DEVICE_LOOKUP_LOG_EVT }, `Found a matching & free device ${candidate.adbName}`);
     return true;
   }
 

package/src/devices/common/drivers/ios/tools/AppleSimUtils.js

@@ -297,7 +297,7 @@ class AppleSimUtils {
       // want to make sure it isn't now.
       if (err.code === 3 &&
           (err.stderr.includes(`the app is not currently running`) ||
-           err.stderr.includes(`The operation couldn’t be completed. found nothing to terminate`))) {
+           err.stderr.includes(`found nothing to terminate`))) {
         return;
       }
 

package/src/devices/cookies/AndroidDeviceCookie.js

@@ -8,10 +8,6 @@ class AndroidDeviceCookie extends DeviceCookie {
     super();
     this.adbName = adbName;
   }
-
-  toString() {
-    return this.adbName;
-  }
 }
 
 module.exports = AndroidDeviceCookie;

package/src/devices/cookies/GenycloudEmulatorCookie.js

@@ -6,13 +6,15 @@ class GenycloudEmulatorCookie extends AndroidDeviceCookie {
    * @param instance { GenyInstance }
    */
   constructor(instance) {
-    super(instance.adb.name);
+    super();
     this.instance = instance;
   }
 
-  toString() {
-    return `${this.instance}`;
+  get adbName() {
+    return this.instance.adbName;
   }
+
+  set adbName(value) {}
 }
 
 module.exports = GenycloudEmulatorCookie;

package/src/devices/cookies/IosSimulatorCookie.js

@@ -5,10 +5,6 @@ class IosSimulatorCookie extends IosCookie {
     super();
     this.udid = udid;
   }
-
-  toString() {
-    return this.udid;
-  }
 }
 
 module.exports = IosSimulatorCookie;

package/src/devices/lifecycle/GenyGlobalLifecycleHandler.js

@@ -0,0 +1,71 @@
+const logger = require('../../utils/logger').child({ cat: 'device' });
+
+const cleanupLogData = {
+  event: 'GENYCLOUD_TEARDOWN',
+};
+
+class GenyGlobalLifecycleHandler {
+  constructor({ deviceCleanupRegistry, instanceLifecycleService }) {
+    /** @private */
+    this._deviceCleanupRegistry = deviceCleanupRegistry;
+    /** @private */
+    this._instanceLifecycleService = instanceLifecycleService;
+  }
+
+  async globalInit() {}
+
+  emergencyCleanup() {
+    const { rawDevices } = this._deviceCleanupRegistry.readRegisteredDevicesUNSAFE();
+    const instanceHandles = rawDevicesToInstanceHandles(rawDevices);
+    if (instanceHandles.length) {
+      reportGlobalCleanupSummary(instanceHandles);
+    }
+  }
+
+  async globalCleanup() {
+    const { rawDevices } = await this._deviceCleanupRegistry.readRegisteredDevices();
+    const instanceHandles = rawDevicesToInstanceHandles(rawDevices);
+    if (instanceHandles.length) {
+      await doSafeCleanup(this._instanceLifecycleService, instanceHandles);
+    }
+  }
+}
+
+async function doSafeCleanup(instanceLifecycleService, instanceHandles) {
+  logger.info(cleanupLogData, 'Initiating Genymotion SaaS instances teardown...');
+
+  const deletionLeaks = [];
+  const killPromises = instanceHandles.map((instanceHandle) =>
+    instanceLifecycleService.deleteInstance(instanceHandle.uuid)
+      .catch((error) => deletionLeaks.push({ ...instanceHandle, error })));
+
+  await Promise.all(killPromises);
+  reportGlobalCleanupSummary(deletionLeaks);
+}
+
+function reportGlobalCleanupSummary(deletionLeaks) {
+  if (deletionLeaks.length) {
+    logger.warn(cleanupLogData, 'WARNING! Detected a Genymotion SaaS instance leakage, for the following instances:');
+
+    deletionLeaks.forEach(({ uuid, name, error }) => {
+      logger.warn(cleanupLogData, [
+        `Instance ${name} (${uuid})${error ? `: ${error}` : ''}`,
+        `    Kill it by visiting https://cloud.geny.io/instance/${uuid}, or by running:`,
+        `    gmsaas instances stop ${uuid}`,
+      ].join('\n'));
+    });
+
+    logger.info(cleanupLogData, 'Instances teardown completed with warnings');
+  } else {
+    logger.info(cleanupLogData, 'Instances teardown completed successfully');
+  }
+}
+
+function rawDevicesToInstanceHandles(rawDevices) {
+  return rawDevices.map((rawDevice) => ({
+    uuid: rawDevice.id,
+    name: rawDevice.data.name,
+  }));
+}
+
+module.exports = GenyGlobalLifecycleHandler;

package/src/devices/lifecycle/factories/GenyGlobalLifecycleHandlerFactory.js

@@ -0,0 +1,18 @@
+class GenyGlobalLifecycleHandlerFactory {
+  /**
+   * @returns { GenyGlobalLifecycleHandler }
+   */
+  createHandler() {
+    const serviceLocator = require('../../../servicelocator/android');
+    const deviceCleanupRegistry = serviceLocator.genycloud.cleanupDeviceRegistry;
+    const exec = serviceLocator.genycloud.exec;
+
+    const InstanceLifecycleService = require('../../common/drivers/android/genycloud/services/GenyInstanceLifecycleService');
+    const instanceLifecycleService = new InstanceLifecycleService(exec, null);
+
+    const GenyGlobalLifecycleHandler = require('../GenyGlobalLifecycleHandler');
+    return new GenyGlobalLifecycleHandler({ deviceCleanupRegistry, instanceLifecycleService });
+  }
+}
+
+module.exports = GenyGlobalLifecycleHandlerFactory;

package/src/devices/runtime/drivers/android/genycloud/GenyCloudDriver.js

@@ -17,12 +17,12 @@ class GenyCloudDriver extends AndroidDriver {
    * @param props { GenycloudDriverProps }
    */
   constructor(deps, { instance }) {
-    super(deps, { adbName: instance.adb.name });
+    super(deps, { adbName: instance.adbName });
     this.instance = instance;
   }
 
   getDeviceName() {
-    return this.instance.name;
+    return this.instance.toString();
   }
 
   async setLocation(lat, lon) {

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

@@ -3,7 +3,7 @@ const RuntimeDeviceFactory = require('./base');
 
 class RuntimeDriverFactoryAndroid extends RuntimeDeviceFactory {
   _createDriverDependencies(commonDeps) {
-    const serviceLocator = require('../../servicelocator/android');
+    const serviceLocator = require('../../../servicelocator/android');
     const adb = serviceLocator.adb;
     const aapt = serviceLocator.aapt;
     const apkValidator = serviceLocator.apkValidator;

package/src/devices/runtime/factories/ios.js

@@ -2,11 +2,10 @@ const RuntimeDeviceFactory = require('./base');
 
 class RuntimeDriverFactoryIos extends RuntimeDeviceFactory {
   _createDriverDependencies(commonDeps) {
+    const serviceLocator = require('../../../servicelocator/ios');
+    const applesimutils = serviceLocator.appleSimUtils;
     const { eventEmitter } = commonDeps;
 
-    const AppleSimUtils = require('../../../devices/common/drivers/ios/tools/AppleSimUtils');
-    const applesimutils = new AppleSimUtils();
-
     const SimulatorLauncher = require('../../allocation/drivers/ios/SimulatorLauncher');
     return {
       ...commonDeps,

package/src/environmentFactory.js

@@ -2,9 +2,9 @@
 const artifactsManagerFactories = require('./artifacts/factories');
 const deviceAllocationFactories = require('./devices/allocation/factories');
 const runtimeDeviceFactories = require('./devices/runtime/factories');
-const envValidationFactories = require('./devices/validation/factories');
 const matchersFactories = require('./matchers/factories');
 const resolveModuleFromPath = require('./utils/resolveModuleFromPath');
+const envValidationFactories = require('./validation/factories');
 
 function validateConfig(deviceConfig) {
   const classes = _getFactoryClasses(deviceConfig);
@@ -36,6 +36,15 @@ function createFactories(deviceConfig) {
   return _getExternalModuleFactories(deviceConfig);
 }
 
+function createGlobalLifecycleHandler(deviceConfig) {
+  if (deviceConfig.type === 'android.genycloud') {
+    const FactoryClass = require('./devices/lifecycle/factories/GenyGlobalLifecycleHandlerFactory');
+    const factory = new FactoryClass();
+    return factory.createHandler();
+  }
+  return null;
+}
+
 function _getFactoryClasses(deviceConfig) {
   let envValidatorFactoryClass;
   let artifactsManagerFactoryClass;
@@ -106,4 +115,5 @@ function _getExternalModuleFactories(deviceConfig) {
 module.exports = {
   validateConfig,
   createFactories,
+  createGlobalLifecycleHandler,
 };

package/src/ipc/IPCClient.js

@@ -1,7 +1,7 @@
 const { IPC } = require('node-ipc');
 
 const { DetoxInternalError } = require('../errors');
-const { serializeObjectWithError, deserializeObjectWithError } = require('../utils/errorUtils');
+const { serializeObjectWithError } = require('../utils/errorUtils');
 
 class IPCClient {
   constructor({ id, logger, sessionState }) {
@@ -60,22 +60,6 @@ class IPCClient {
     this._sessionState.patch(sessionState);
   }
 
-  async allocateDevice() {
-    const { deviceCookie, error } = deserializeObjectWithError(await this._emit('allocateDevice', {}));
-    if (error) {
-      throw error;
-    }
-
-    return deviceCookie;
-  }
-
-  async deallocateDevice(deviceCookie) {
-    const { error } = deserializeObjectWithError(await this._emit('deallocateDevice', { deviceCookie }));
-    if (error) {
-      throw error;
-    }
-  }
-
   /**
    * @param {DetoxInternals.DetoxTestFileReport[]} testResults
    */