detox 20.12.2 → 20.14.0-smoke.0

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/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/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/cookies/index.js

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

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

@@ -8,21 +8,22 @@ const AndroidDriver = require('../AndroidDriver');
 
 /**
  * @typedef GenycloudDriverProps
- * @property instance { GenyInstance } The DTO associated with the cloud instance
+ * @property adbName { GenyInstance } The DTO associated with the cloud instance
  */
 
 class GenyCloudDriver extends AndroidDriver {
   /**
    * @param deps { GenycloudDriverDeps }
-   * @param props { GenycloudDriverProps }
+   * @param props { GenycloudEmulatorCookie }
    */
-  constructor(deps, { instance }) {
-    super(deps, { adbName: instance.adbName });
-    this.instance = instance;
+  constructor(deps, { adbName, name }) {
+    super(deps, { adbName });
+
+    this._instanceName = name;
   }
 
   getDeviceName() {
-    return this.instance.toString();
+    return this._instanceName;
   }
 
   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;
@@ -43,23 +43,15 @@ class AndroidEmulator extends RuntimeDriverFactoryAndroid {
 
 class AndroidAttached extends RuntimeDriverFactoryAndroid {
   _createDriver(deviceCookie, deps, configs) {
-    const props = {
-      adbName: deviceCookie.adbName,
-    };
-
     const { AttachedAndroidRuntimeDriver } = require('../drivers');
-    return new AttachedAndroidRuntimeDriver(deps, props);
+    return new AttachedAndroidRuntimeDriver(deps, deviceCookie);
   }
 }
 
 class Genycloud extends RuntimeDriverFactoryAndroid {
   _createDriver(deviceCookie, deps, configs) {
-    const props = {
-      instance: deviceCookie.instance,
-    };
-
     const { GenycloudRuntimeDriver } = require('../drivers');
-    return new GenycloudRuntimeDriver(deps, props);
+    return new GenycloudRuntimeDriver(deps, deviceCookie);
   }
 }
 

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

@@ -2,10 +2,11 @@ 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/{servicelocator → devices/servicelocator}/android/emulatorServiceLocator.js

@@ -1,4 +1,4 @@
-const { EmulatorExec } = require('../../devices/common/drivers/android/emulator/exec/EmulatorExec');
+const { EmulatorExec } = require('../../common/drivers/android/emulator/exec/EmulatorExec');
 
 class EmulatorServiceLocator {
   constructor() {

package/src/devices/servicelocator/android/genycloudServiceLocator.js

@@ -0,0 +1,17 @@
+class GenycloudServiceLocator {
+  constructor() {
+    this._exec = null;
+  }
+
+  // Note: important to keep lazy because of implicit validations that are sensitive (inside environment, in particular).
+  get exec() {
+    if (!this._exec) {
+      const Exec = require('../../allocation/drivers/android/genycloud/exec/GenyCloudExec');
+      const environment = require('../../../utils/environment');
+      this._exec = new Exec(environment.getGmsaasPath());
+    }
+    return this._exec;
+  }
+}
+
+module.exports = new GenycloudServiceLocator();

package/src/devices/servicelocator/android/index.js

@@ -0,0 +1,23 @@
+const AndroidDevicePathBuilder = require('../../../artifacts/utils/AndroidDevicePathBuilder');
+const AAPT = require('../../common/drivers/android/exec/AAPT');
+const ADB = require('../../common/drivers/android/exec/ADB');
+const ApkValidator = require('../../common/drivers/android/tools/ApkValidator');
+const { TempFileTransfer } = require('../../common/drivers/android/tools/TempFileTransfer');
+
+const AndroidServiceLocator = {
+  get emulator() {
+    return require('./emulatorServiceLocator');
+  },
+
+  get genycloud() {
+    return require('./genycloudServiceLocator');
+  },
+};
+
+AndroidServiceLocator.adb = new ADB();
+AndroidServiceLocator.aapt = new AAPT();
+AndroidServiceLocator.apkValidator = new ApkValidator(AndroidServiceLocator.aapt);
+AndroidServiceLocator.fileTransfer = new TempFileTransfer(AndroidServiceLocator.adb);
+AndroidServiceLocator.devicePathBuilder = new AndroidDevicePathBuilder();
+
+module.exports = AndroidServiceLocator;

package/src/{validation → devices/validation}/EnvironmentValidatorBase.js

@@ -1,4 +1,5 @@
 class EnvironmentValidatorBase {
+  /* istanbul ignore next */
   validate() {}
 }
 

package/src/{validation → devices/validation}/android/GenycloudEnvValidator.js

@@ -1,8 +1,8 @@
 // @ts-nocheck
 const semver = require('semver');
 
-const DetoxRuntimeError = require('../../errors/DetoxRuntimeError');
-const environment = require('../../utils/environment');
+const { DetoxRuntimeError } = require('../../../errors');
+const environment = require('../../../utils/environment');
 const EnvironmentValidatorBase = require('../EnvironmentValidatorBase');
 
 const MIN_GMSAAS_VERSION = '1.6.0';

package/src/{validation → devices/validation}/factories/index.js

@@ -7,7 +7,7 @@ class Genycloud extends EnvValidatorFactory {
     const serviceLocator = require('../../servicelocator/android');
     const exec = serviceLocator.genycloud.exec;
 
-    const GenyAuthService = require('../../devices/common/drivers/android/genycloud/services/GenyAuthService');
+    const GenyAuthService = require('../../allocation/drivers/android/genycloud/services/GenyAuthService');
     const authService = new GenyAuthService(exec);
 
     const GenycloudEnvValidator = require('../android/GenycloudEnvValidator');

package/src/{validation → devices/validation}/ios/IosSimulatorEnvValidator.js

@@ -1,7 +1,7 @@
 const fs = require('fs');
 
-const DetoxRuntimeError = require('../../errors/DetoxRuntimeError');
-const environment = require('../../utils/environment');
+const DetoxRuntimeError = require('../../../errors/DetoxRuntimeError');
+const environment = require('../../../utils/environment');
 const EnvironmentValidatorBase = require('../EnvironmentValidatorBase');
 
 class IosSimulatorEnvValidator extends EnvironmentValidatorBase {

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,15 +36,6 @@ 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;
@@ -115,5 +106,4 @@ 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 } = require('../utils/errorUtils');
+const { serializeObjectWithError, deserializeObjectWithError } = require('../utils/errorUtils');
 
 class IPCClient {
   constructor({ id, logger, sessionState }) {
@@ -60,6 +60,22 @@ 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
    */

package/src/ipc/IPCServer.js

@@ -8,11 +8,15 @@ class IPCServer {
    * @param {object} options
    * @param {import('./SessionState')} options.sessionState
    * @param {Detox.Logger} options.logger
+   * @param {object} options.callbacks
+   * @param {() => Promise<any>} options.callbacks.onAllocateDevice
+   * @param {(cookie: any) => Promise<void>} options.callbacks.onDeallocateDevice
    */
-  constructor({ sessionState, logger }) {
+  constructor({ sessionState, logger, callbacks }) {
     this._sessionState = sessionState;
     this._logger = logger.child({ cat: 'ipc,ipc-server' });
     this._ipc = null;
+    this._callbacks = callbacks;
     this._workers = new Set();
     this._contexts = new Set();
   }
@@ -42,6 +46,8 @@ class IPCServer {
       this._ipc.server.on('registerContext', this.onRegisterContext.bind(this));
       this._ipc.server.on('registerWorker', this.onRegisterWorker.bind(this));
       this._ipc.server.on('reportTestResults', this.onReportTestResults.bind(this));
+      this._ipc.server.on('allocateDevice', this.onAllocateDevice.bind(this));
+      this._ipc.server.on('deallocateDevice', this.onDeallocateDevice.bind(this));
       this._ipc.server.start();
     });
   }
@@ -96,6 +102,26 @@ class IPCServer {
     this._ipc.server.broadcast('sessionStateUpdate', newState);
   }
 
+  async onAllocateDevice(_payload, socket) {
+    let deviceCookie;
+
+    try {
+      deviceCookie = await this._callbacks.onAllocateDevice();
+      this._ipc.server.emit(socket, 'allocateDeviceDone', { deviceCookie });
+    } catch (error) {
+      this._ipc.server.emit(socket, 'allocateDeviceDone', serializeObjectWithError({ error }));
+    }
+  }
+
+  async onDeallocateDevice({ deviceCookie }, socket) {
+    try {
+      await this._callbacks.onDeallocateDevice(deviceCookie);
+      this._ipc.server.emit(socket, 'deallocateDeviceDone', {});
+    } catch (error) {
+      this._ipc.server.emit(socket, 'deallocateDeviceDone', serializeObjectWithError({ error }));
+    }
+  }
+
   onReportTestResults({ testResults }, socket = null) {
     const merged = uniqBy([
       ...testResults.map(r => serializeObjectWithError(r, 'testExecError')),

package/src/logger/DetoxLogger.js

@@ -249,7 +249,7 @@ class DetoxLogger {
   _complete(level, maybeContext, maybeMessage, maybeAction) {
     const action = typeof maybeContext !== 'string' ? maybeAction : maybeMessage;
     const args = maybeAction === action ? [maybeContext, maybeMessage] : [maybeContext];
-    const { context, msg } = this._parseArgs(null, args);
+    const { context, msg } = this._parseArgs({ ph: 'B' }, args);
     const end = (ctx) => this[level].end({
       id: context.id,
       cat: context.cat,
@@ -257,7 +257,7 @@ class DetoxLogger {
     });
 
     let result;
-    this._beginInternal(level, { ...context, ph: 'B' }, msg);
+    this._beginInternal(level, context, msg);
     try {
       result = typeof action === 'function'
         ? action()

package/src/realms/DetoxContext.js

@@ -151,6 +151,12 @@ class DetoxContext {
     await this[$worker].init();
   }
 
+  /** @abstract */
+  async [symbols.allocateDevice]() {}
+
+  /** @abstract */
+  async [symbols.deallocateDevice]() {}
+
   async [symbols.uninstallWorker]() {
     try {
       if (this[$worker]) {

package/src/realms/DetoxPrimaryContext.js

@@ -16,15 +16,14 @@ const symbols = require('./symbols');
 const { $logFinalizer, $restoreSessionState, $sessionState, $worker } = DetoxContext.protected;
 
 //#region Private symbols
-const _globalLifecycleHandler = Symbol('globalLifecycleHandler');
 const _ipcServer = Symbol('ipcServer');
-const _resetLockFile = Symbol('resetLockFile');
 const _wss = Symbol('wss');
 const _dirty = Symbol('dirty');
 const _emergencyTeardown = Symbol('emergencyTeardown');
 const _lifecycleLogger = Symbol('lifecycleLogger');
 const _sessionFile = Symbol('sessionFile');
 const _logFinalError = Symbol('logFinalError');
+const _deviceAllocator = Symbol('deviceAllocator');
 //#endregion
 
 class DetoxPrimaryContext extends DetoxContext {
@@ -33,7 +32,8 @@ class DetoxPrimaryContext extends DetoxContext {
 
     this[_dirty] = false;
     this[_wss] = null;
-    this[_globalLifecycleHandler] = null;
+    this[_deviceAllocator] = null;
+
     /** Path to file where the initial session object is serialized */
     this[_sessionFile] = '';
     /**
@@ -85,7 +85,6 @@ class DetoxPrimaryContext extends DetoxContext {
     const detoxConfig = await this[symbols.resolveConfig](opts);
 
     const {
-      behavior: behaviorConfig,
       device: deviceConfig,
       logger: loggerConfig,
       session: sessionConfig
@@ -102,20 +101,23 @@ class DetoxPrimaryContext extends DetoxContext {
     this[_ipcServer] = new IPCServer({
       sessionState: this[$sessionState],
       logger: this[symbols.logger],
+      callbacks: {
+        onAllocateDevice: this[symbols.allocateDevice].bind(this),
+        onDeallocateDevice: this[symbols.deallocateDevice].bind(this),
+      },
     });
 
     await this[_ipcServer].init();
 
     const environmentFactory = require('../environmentFactory');
-    this[_globalLifecycleHandler] = await environmentFactory.createGlobalLifecycleHandler(deviceConfig);
 
-    if (this[_globalLifecycleHandler]) {
-      await this[_globalLifecycleHandler].globalInit();
-    }
+    const { deviceAllocatorFactory } = environmentFactory.createFactories(deviceConfig);
+    this[_deviceAllocator] = deviceAllocatorFactory.createDeviceAllocator({
+      detoxConfig,
+      detoxSession: this[$sessionState],
+    });
 
-    if (!behaviorConfig.init.keepLockFile) {
-      await this[_resetLockFile]();
-    }
+    await this[_deviceAllocator].init();
 
     // TODO: Detox-server creation ought to be delegated to a generator/factory.
     const DetoxServer = require('../server/DetoxServer');
@@ -159,6 +161,29 @@ class DetoxPrimaryContext extends DetoxContext {
     await super[symbols.installWorker]({ ...opts, workerId });
   }
 
+  /** @override */
+  async [symbols.allocateDevice]() {
+    const { device } = this[$sessionState].detoxConfig;
+    const deviceCookie = await this[_deviceAllocator].allocate(device);
+
+    try {
+      return await this[_deviceAllocator].postAllocate(deviceCookie);
+    } catch (e) {
+      try {
+        await this[_deviceAllocator].free(deviceCookie, { shutdown: true });
+      } catch (e2) {
+        this[symbols.logger].error({ cat: 'device', err: e2 }, `Failed to free ${deviceCookie.name || deviceCookie.id} after a failed allocation`);
+      }
+
+      throw e;
+    }
+  }
+
+  /** @override */
+  async [symbols.deallocateDevice](cookie) {
+    await this[_deviceAllocator].free(cookie);
+  }
+
   /** @override */
   async [symbols.cleanup]() {
     try {
@@ -166,9 +191,9 @@ class DetoxPrimaryContext extends DetoxContext {
         await this[symbols.uninstallWorker]();
       }
     } finally {
-      if (this[_globalLifecycleHandler]) {
-        await this[_globalLifecycleHandler].globalCleanup();
-        this[_globalLifecycleHandler] = null;
+      if (this[_deviceAllocator]) {
+        await this[_deviceAllocator].cleanup();
+        this[_deviceAllocator] = null;
       }
 
       if (this[_wss]) {
@@ -202,9 +227,9 @@ class DetoxPrimaryContext extends DetoxContext {
       return;
     }
 
-    if (this[_globalLifecycleHandler]) {
-      this[_globalLifecycleHandler].emergencyCleanup();
-      this[_globalLifecycleHandler] = null;
+    if (this[_deviceAllocator]) {
+      this[_deviceAllocator].emergencyCleanup();
+      this[_deviceAllocator] = null;
     }
 
     if (this[_wss]) {
@@ -247,31 +272,6 @@ class DetoxPrimaryContext extends DetoxContext {
     });
   }
   //#endregion
-
-  //#region Private members
-  async[_resetLockFile]() {
-    const DeviceRegistry = require('../devices/DeviceRegistry');
-
-    const deviceType = this[symbols.config].device.type;
-
-    switch (deviceType) {
-      case 'ios.none':
-      case 'ios.simulator':
-        await DeviceRegistry.forIOS().reset();
-        break;
-      case 'android.attached':
-      case 'android.emulator':
-      case 'android.genycloud':
-        await DeviceRegistry.forAndroid().reset();
-        break;
-    }
-
-    if (deviceType === 'android.genycloud') {
-      const GenyDeviceRegistryFactory = require('../devices/allocation/drivers/android/genycloud/GenyDeviceRegistryFactory');
-      await GenyDeviceRegistryFactory.forGlobalShutdown().reset();
-    }
-  }
-  //#endregion
 }
 
 module.exports = DetoxPrimaryContext;

package/src/realms/DetoxSecondaryContext.js

@@ -62,6 +62,25 @@ class DetoxSecondaryContext extends DetoxContext {
     }
   }
 
+  /** @override */
+  async [symbols.allocateDevice]() {
+    if (this[_ipcClient]) {
+      const deviceCookie = await this[_ipcClient].allocateDevice();
+      return deviceCookie;
+    } else {
+      throw new DetoxInternalError('Detected an attempt to allocate a device using a non-initialized context.');
+    }
+  }
+
+  /** @override */
+  async [symbols.deallocateDevice](deviceCookie) {
+    if (this[_ipcClient]) {
+      await this[_ipcClient].deallocateDevice(deviceCookie);
+    } else {
+      throw new DetoxInternalError('Detected an attempt to allocate a device using a non-initialized context.');
+    }
+  }
+
   /** @override */
   async [symbols.cleanup]() {
     try {

package/src/realms/symbols.js

@@ -5,6 +5,8 @@
  *   readonly getStatus: unique symbol;
  *   readonly init: unique symbol;
  *   readonly installWorker: unique symbol;
+ *   readonly allocateDevice: unique symbol;
+ *   readonly deallocateDevice: unique symbol;
  *   readonly logger: unique symbol;
  *   readonly onHookFailure: unique symbol;
  *   readonly onRunDescribeFinish: unique symbol;
@@ -34,6 +36,8 @@ module.exports = {
   //#region IPC
   reportTestResults: Symbol('reportTestResults'),
   conductEarlyTeardown: Symbol('conductEarlyTeardown'),
+  allocateDevice: Symbol('allocateDevice'),
+  deallocateDevice: Symbol('deallocateDevice'),
   //#endregion
 
   //#region Main