detox 21.0.0-rc.6 → 21.0.0-rc.8

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,35 @@
-// @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
    */
-  constructor({ deviceRegistry, applesimutils, simulatorLauncher }) {
-    super();
+  constructor({ detoxConfig, deviceRegistry, applesimutils }) {
     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 +37,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);
+    await this._applesimutils.boot(udid, deviceConfig.bootArgs, deviceConfig.headless);
+
+    return {
+      id: udid,
+      udid,
+      type: deviceConfig.type,
+      bootArgs: deviceConfig.bootArgs,
+      headless: deviceConfig.headless,
+    };
   }
 
   /**
@@ -58,21 +78,40 @@ class SimulatorAllocDriver extends AllocationDriverBase {
   async free(cookie, options = {}) {
     const { udid } = cookie;
 
-    await this._deviceRegistry.disposeDevice(udid);
-
     if (options.shutdown) {
-      await this._simulatorLauncher.shutdown(udid);
+      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._applesimutils.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 +122,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 +130,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 +164,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/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,15 @@
 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 SimulatorLauncher = require('../drivers/ios/SimulatorLauncher');
-    const simulatorLauncher = new SimulatorLauncher({ applesimutils, eventEmitter });
+    const DeviceRegistry = require('../../../devices/allocation/DeviceRegistry');
+    const deviceRegistry = new DeviceRegistry({ sessionId: detoxSession.id });
 
     const SimulatorAllocDriver = require('../drivers/ios/SimulatorAllocDriver');
-    return new SimulatorAllocDriver({ deviceRegistry, applesimutils, simulatorLauncher });
+    return new SimulatorAllocDriver({ detoxConfig, deviceRegistry, applesimutils });
   }
 }
 

package/src/devices/common/drivers/DeviceCookie.d.ts

@@ -0,0 +1,12 @@
+/* eslint-disable import/no-unresolved,node/no-missing-import,node/no-unsupported-features/es-syntax */
+
+/**
+ * A serializable object that represents a device.
+ */
+export interface DeviceCookie {
+  /** The device's unique identifier. */
+  id: string;
+  /** The display name of the device. */
+  name?: string;
+}
+

package/src/devices/common/drivers/android/cookies.d.ts

@@ -0,0 +1,11 @@
+/* eslint-disable import/no-unresolved,node/no-missing-import,node/no-unsupported-features/es-syntax */
+import GenyInstance from '../../../allocation/drivers/android/genycloud/services/dto/GenyInstance';
+import { DeviceCookie } from '../DeviceCookie';
+
+interface AndroidDeviceCookie extends DeviceCookie {
+  adbName: string;
+}
+
+interface GenycloudEmulatorCookie extends AndroidDeviceCookie {
+  instance: GenyInstance;
+}

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/android/tools/instrumentationArgs.js

@@ -1,6 +1,7 @@
 const _ = require('lodash');
 
 const { encodeBase64 } = require('../../../../../utils/encoding');
+const { autoEscape } = require('../../../../../utils/shellUtils');
 
 const reservedInstrumentationArgs = new Set(['class', 'package', 'func', 'unit', 'size', 'perf', 'debug', 'log', 'emma', 'coverageFile']);
 const isReservedInstrumentationArg = (arg) => reservedInstrumentationArgs.has(arg);
@@ -17,7 +18,8 @@ function prepareInstrumentationArgs(args) {
       valueEncoded = encodeBase64(valueAsString);
     }
 
-    result.push('-e', key, valueEncoded);
+    const valueEscaped = hasLegacyIssues(key) ? valueEncoded : autoEscape.shell(valueEncoded);
+    result.push('-e', key, valueEscaped);
     return result;
   }, []);
 
@@ -27,6 +29,10 @@ function prepareInstrumentationArgs(args) {
   };
 }
 
+function hasLegacyIssues(key) {
+  return key === 'detoxURLBlacklistRegex';
+}
+
 module.exports = {
   prepareInstrumentationArgs,
 };

package/src/devices/common/drivers/ios/cookies.d.ts

@@ -0,0 +1,9 @@
+/* eslint-disable import/no-unresolved,node/no-missing-import,node/no-unsupported-features/es-syntax */
+import { DeviceCookie } from '../DeviceCookie';
+
+interface IosSimulatorCookie extends DeviceCookie {
+  udid: string;
+  type?: string;
+  bootArgs?: string;
+  headless?: boolean;
+}

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

@@ -288,7 +288,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;
       }
 
@@ -446,6 +446,8 @@ class AppleSimUtils {
         overrides.push(`--cellularMode "${flags.cellularMode}"`);
       if (flags.cellularBars)
         overrides.push(`--cellularBars "${flags.cellularBars}"`);
+      if (flags.operatorName)
+        overrides.push(`--operatorName "${flags.operatorName}"`);
       if (flags.batteryState)
         overrides.push(`--batteryState "${flags.batteryState}"`);
       if (flags.batteryLevel)

package/src/devices/cookies/index.js

@@ -1,6 +0,0 @@
-module.exports = {
-  IosSimulatorCookie: require('./IosSimulatorCookie'),
-  AttachedAndroidDeviceCookie: require('./AttachedAndroidDeviceCookie'),
-  AndroidEmulatorCookie: require('./AndroidEmulatorCookie'),
-  GenycloudEmulatorCookie: require('./GenycloudEmulatorCookie'),
-};