detox 20.11.4 → 20.12.0-smoke.0

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

@@ -0,0 +1,93 @@
+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();
+  }
+
+  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 {import('./services/dto/GenyInstance')} instance */
+  pollNewInstance(instance) {
+    const result = this._newInstances.has(instance.uuid);
+    this._newInstances.delete(instance.uuid);
+    return result;
+  }
+
+  /** @param {import('./services/dto/GenyInstance')} instance */
+  updateInstance(instance) {
+    if (this._freeInstances.has(instance.uuid)) {
+      this._freeInstances.set(instance.uuid, instance);
+    }
+
+    if (this._busyInstances.has(instance.uuid)) {
+       this._busyInstances.set(instance.uuid, instance);
+    }
+  }
+
+  /** @param {import('./services/dto/GenyInstance')} instance */
+  removeInstance(instance) {
+    this._freeInstances.delete(instance.uuid);
+    this._busyInstances.delete(instance.uuid);
+    this._newInstances.delete(instance.uuid);
+    this._recipes.delete(instance.uuid);
+  }
+
+  /** @param {import('./services/dto/GenyInstance')} instance */
+  markAsBusy({ uuid }) {
+    if (this._busyInstances.has(uuid)) {
+      return;
+    }
+
+    const instance = this._freeInstances.get(uuid);
+    if (!instance) {
+      throw new DetoxInternalError(`Cannot mark an unknown instance ${uuid} as busy`);
+    }
+
+    this._busyInstances.set(uuid, instance);
+    this._freeInstances.delete(uuid);
+    return instance;
+  }
+
+  /** @param {import('./services/dto/GenyInstance')} instance */
+  markAsFree({ uuid }) {
+    const instance = this._busyInstances.get(uuid);
+    if (!instance) {
+      throw new DetoxInternalError(`Cannot mark an unknown instance ${uuid} as free`);
+    }
+
+    this._busyInstances.delete(uuid);
+    this._freeInstances.set(uuid, instance);
+    return instance;
+  }
+
+  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);
+      }
+    }
+  }
+}
+
+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/{common → allocation}/drivers/android/genycloud/services/dto/GenyInstance.js

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

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

@@ -2,21 +2,31 @@
 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({ deviceRegistry, applesimutils, simulatorLauncher }) {
+  constructor({ detoxConfig, 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();
   }
 
   /**
@@ -24,16 +34,15 @@ 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 };
@@ -58,21 +67,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 +111,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 +119,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 +153,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,
     });
   }
 }

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

@@ -2,16 +2,18 @@
 const DeviceAllocatorFactory = require('./base');
 
 class IosSimulator extends DeviceAllocatorFactory {
-  _createDriver({ eventEmitter }) {
-    const serviceLocator = require('../../../servicelocator/ios');
-    const applesimutils = serviceLocator.appleSimUtils;
-    const deviceRegistry = serviceLocator.deviceRegistry;
+  _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 });
 
     const SimulatorLauncher = require('../drivers/ios/SimulatorLauncher');
     const simulatorLauncher = new SimulatorLauncher({ applesimutils, eventEmitter });
 
     const SimulatorAllocDriver = require('../drivers/ios/SimulatorAllocDriver');
-    return new SimulatorAllocDriver({ deviceRegistry, applesimutils, simulatorLauncher });
+    return new SimulatorAllocDriver({ detoxConfig, deviceRegistry, applesimutils, simulatorLauncher });
   }
 }
 

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

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

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

@@ -18,6 +18,7 @@ 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/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(`found nothing to terminate`))) {
+           err.stderr.includes(`The operation couldn’t be completed. found nothing to terminate`))) {
         return;
       }
 

package/src/devices/cookies/AndroidDeviceCookie.js

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

package/src/devices/cookies/GenycloudEmulatorCookie.js

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

package/src/devices/cookies/IosSimulatorCookie.js

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

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.adbName });
+    super(deps, { adbName: instance.adb.name });
     this.instance = instance;
   }
 
   getDeviceName() {
-    return this.instance.toString();
+    return this.instance.name;
   }
 
   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;