detox 21.0.0-rc.1 → 21.0.0-rc.10

package/src/ios/web.js

@@ -0,0 +1,302 @@
+const assert = require('assert');
+
+const _ = require('lodash');
+
+const { DetoxRuntimeError } = require('../errors');
+const { webViewActionDescription, expectDescription } = require('../utils/invocationTraceDescriptions');
+const log = require('../utils/logger').child({ cat: 'ws-client, ws' });
+const traceInvocationCall = require('../utils/traceInvocationCall').bind(null, log);
+
+
+class WebExpect {
+  constructor(invocationManager, element) {
+    this._invocationManager = invocationManager;
+    this.element = element;
+    this.modifiers = [];
+  }
+
+  toHaveText(text) {
+    const traceDescription = expectDescription.toHaveText(text);
+    return this.expect('toHaveText', traceDescription, text);
+  }
+
+  toExist() {
+    const traceDescription = expectDescription.toExist();
+    return this.expect('toExist', traceDescription);
+  }
+
+  get not() {
+    this.modifiers.push('not');
+    return this;
+  }
+  getText;
+  createInvocation(webExpectation, ...params) {
+    const definedParams = _.without(params, undefined);
+    return {
+      type: 'webExpectation',
+      ...(this.element.webViewElement !== undefined) && {
+        predicate: this.element.webViewElement.matcher.predicate,
+        ...(this.element.webViewElement.index !== undefined && { atIndex: this.element.webViewElement.index }),
+      },
+      webPredicate: this.element.matcher.predicate,
+      ...(this.element.index !== undefined && { webAtIndex: this.element.index }),
+      ...(this.modifiers.length !== 0 && { webModifiers: this.modifiers }),
+      webExpectation,
+      ...(definedParams.length !== 0 && { params: definedParams })
+    };
+  }
+
+  expect(expectation, traceDescription, ...params) {
+    assert(traceDescription, `must provide trace description for expectation: \n ${JSON.stringify(expectation)}`);
+
+    const invocation = this.createInvocation(expectation, ...params);
+    traceDescription = expectDescription.full(traceDescription, this.modifiers.includes('not'));
+    return _executeInvocation(this._invocationManager, invocation, traceDescription);
+  }
+}
+
+class WebElement {
+  constructor(invocationManager, emitter, webViewElement, matcher, index) {
+    this._invocationManager = invocationManager;
+    this._emitter = emitter;
+    this.webViewElement = webViewElement;
+    this.matcher = matcher;
+    this.index = index;
+  }
+
+  atIndex(index) {
+    if (typeof index !== 'number') throw new DetoxRuntimeError(`atIndex argument must be a number, got ${typeof index}`);
+    this.index = index;
+    return this;
+  }
+
+  tap() {
+    const traceDescription = webViewActionDescription.tap();
+    return this.withAction('tap', traceDescription);
+  }
+
+  typeText(text, isContentEditable = false) {
+    const traceDescription = webViewActionDescription.typeText(text, isContentEditable);
+    return this.withAction('typeText', traceDescription, text, isContentEditable);
+  }
+
+  replaceText(text) {
+    const traceDescription = webViewActionDescription.replaceText(text);
+    return this.withAction('replaceText', traceDescription, text);
+  }
+
+  clearText() {
+    const traceDescription = webViewActionDescription.clearText();
+    return this.withAction('clearText', traceDescription);
+  }
+
+  selectAllText() {
+    const traceDescription = webViewActionDescription.selectAllText();
+    return this.withAction('selectAllText', traceDescription);
+  }
+
+  async getText() {
+    const traceDescription = webViewActionDescription.getText();
+    let result = await this.withAction('getText', traceDescription);
+
+    if (result['text']) {
+      return result['text'];
+    } else {
+      throw new DetoxRuntimeError(`Failed to extract text from result: ${JSON.stringify(result)}`);
+    }
+  }
+
+  scrollToView() {
+    const traceDescription = webViewActionDescription.scrollToView();
+    return this.withAction('scrollToView', traceDescription);
+  }
+
+  focus() {
+    const traceDescription = webViewActionDescription.focus();
+    return this.withAction('focus', traceDescription);
+  }
+
+  moveCursorToEnd() {
+    const traceDescription = webViewActionDescription.moveCursorToEnd();
+    return this.withAction('moveCursorToEnd', traceDescription);
+  }
+
+  async runScript(script, args) {
+    if (args !== undefined && args.length !== 0) {
+      return await this.runScriptWithArgs(script, args);
+    }
+
+    const traceDescription = webViewActionDescription.runScript(script);
+    const result = await this.withAction('runScript', traceDescription, script);
+
+    if (result['result'] !== undefined) {
+      return result['result'];
+    } else {
+      throw new DetoxRuntimeError(`Failed to extract result from result: ${JSON.stringify(result)}`);
+    }
+  }
+
+  async runScriptWithArgs(script, args) {
+    const traceDescription = webViewActionDescription.runScriptWithArgs(script, args);
+    const result = await this.withAction('runScriptWithArgs', traceDescription, script, args);
+
+    if (result['result'] !== undefined) {
+      return result['result'];
+    } else {
+      throw new DetoxRuntimeError(`Failed to extract result from result: ${JSON.stringify(result)}`);
+    }
+  }
+
+  async getCurrentUrl() {
+    const traceDescription = webViewActionDescription.getCurrentUrl();
+    let result = await this.withAction('getCurrentUrl', traceDescription);
+
+    if (result['url']) {
+      return result['url'];
+    } else {
+      throw new DetoxRuntimeError(`Failed to extract url from result: ${JSON.stringify(result)}`);
+    }
+  }
+
+  async getTitle() {
+    const traceDescription = webViewActionDescription.getTitle();
+    let result = await this.withAction('getTitle', traceDescription);
+
+    if (result['title']) {
+      return result['title'];
+    } else {
+      throw new DetoxRuntimeError(`Failed to extract title from result: ${JSON.stringify(result)}`);
+    }
+  }
+
+  withAction(action, traceDescription, ...params) {
+    assert(traceDescription, `must provide trace description for action: \n ${JSON.stringify(action)}`);
+
+    const invocation = {
+      type: 'webAction',
+      ...(this.webViewElement !== undefined) && {
+        predicate: this.webViewElement.matcher.predicate,
+        ...(this.webViewElement.index !== undefined && { atIndex: this.webViewElement.index }),
+      },
+      webPredicate: this.matcher.predicate,
+      ...(this.index !== undefined && { webAtIndex: this.index }),
+      webAction: action,
+      ...(params.length !== 0 && { params }),
+    };
+    traceDescription = webViewActionDescription.full(traceDescription);
+    return _executeInvocation(this._invocationManager, invocation, traceDescription);
+  }
+}
+
+class WebElementMatcher {
+  id(id) {
+    if (typeof id !== 'string') throw new DetoxRuntimeError('id should be a string, but got ' + (id + (' (' + (typeof id + ')'))));
+    this.predicate = { type: 'id', value: id.toString() };
+    return this;
+  }
+
+  className(className) {
+    if (typeof className !== 'string') throw new DetoxRuntimeError('className should be a string, but got ' + (className + (' (' + (typeof className + ')'))));
+    this.predicate = { type: 'class', value: className.toString() };
+    return this;
+  }
+
+  cssSelector(cssSelector) {
+    if (typeof cssSelector !== 'string') throw new DetoxRuntimeError('cssSelector should be a string, but got ' + (cssSelector + (' (' + (typeof cssSelector + ')'))));
+    this.predicate = { type: 'css', value: cssSelector.toString() };
+    return this;
+  }
+
+  name(name) {
+    if (typeof name !== 'string') throw new DetoxRuntimeError('name should be a string, but got ' + (name + (' (' + (typeof name + ')'))));
+    this.predicate = { type: 'name', value: name.toString() };
+    return this;
+  }
+
+  xpath(xpath) {
+    if (typeof xpath !== 'string') throw new DetoxRuntimeError('xpath should be a string, but got ' + (xpath + (' (' + (typeof xpath + ')'))));
+    this.predicate = { type: 'xpath', value: xpath.toString() };
+    return this;
+  }
+
+  href(href) {
+    if (typeof href !== 'string') throw new DetoxRuntimeError('href should be a string, but got ' + (href + (' (' + (typeof href + ')'))));
+    this.predicate = { type: 'href', value: href.toString() };
+    return this;
+  }
+
+  hrefContains(href) {
+    if (typeof href !== 'string') throw new DetoxRuntimeError('href should be a string, but got ' + (href + (' (' + (typeof href + ')'))));
+    this.predicate = { type: 'hrefContains', value: href.toString() };
+    return this;
+  }
+
+  tag(tag) {
+    if (typeof tag !== 'string') throw new DetoxRuntimeError('tag should be a string, but got ' + (tag + (' (' + (typeof tag + ')'))));
+    this.predicate = { type: 'tag', value: tag.toString() };
+    return this;
+  }
+
+  label(label) {
+    if (typeof label !== 'string') throw new DetoxRuntimeError('label should be a string, but got ' + (label + (' (' + (typeof label + ')'))));
+    this.predicate = { type: 'label', value: label.toString() };
+    return this;
+  }
+
+  value(value) {
+    if (typeof value !== 'string') throw new DetoxRuntimeError('value should be a string, but got ' + (value + (' (' + (typeof value + ')'))));
+    this.predicate = { type: 'value', value: value.toString() };
+    return this;
+  }
+
+  accessibilityType(type) {
+    if (typeof type !== 'string') throw new DetoxRuntimeError('accessibilityType should be a string, but got ' + (type + (' (' + (typeof type + ')'))));
+    this.predicate = { type: 'accessibilityType', value: type.toString() };
+    return this;
+  }
+}
+
+function webMatcher() {
+  return new WebElementMatcher();
+}
+
+function webElement(invocationManager, emitter, webViewElement, matcher) {
+  if (!(matcher instanceof WebElementMatcher)) {
+    throwWebViewMatcherError(matcher);
+  }
+
+  return new WebElement(invocationManager, emitter, webViewElement, matcher);
+}
+
+function throwWebViewMatcherError(param) {
+  const paramDescription = JSON.stringify(param);
+  throw new DetoxRuntimeError(`${paramDescription} is not a Detox web-view matcher. More about web-view matchers here: https://wix.github.io/Detox/docs/api/webviews`);
+}
+
+function webExpect(invocationManager, element) {
+  if (!(element instanceof WebElement)) {
+    throwWebElementError(element);
+  }
+
+  return new WebExpect(invocationManager, element);
+}
+
+function throwWebElementError(param) {
+  const paramDescription = JSON.stringify(param);
+  throw new DetoxRuntimeError(`${paramDescription} is not a web element. More about web elements here: https://wix.github.io/Detox/docs/api/webviews`);
+}
+
+function _executeInvocation(invocationManager, invocation, traceDescription) {
+  return traceInvocationCall(traceDescription, invocation, invocationManager.execute(invocation));
+}
+
+function isWebElement(element) {
+  return element instanceof WebElement;
+}
+
+module.exports = {
+  webMatcher,
+  webElement,
+  webExpect,
+  isWebElement
+};

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
    */
@@ -70,6 +86,11 @@ class IPCClient {
     this._sessionState.patch(sessionState);
   }
 
+  async conductEarlyTeardown({ permanent }) {
+    const sessionState = await this._emit('conductEarlyTeardown', { permanent });
+    this._sessionState.patch(sessionState);
+  }
+
   async _connectToServer() {
     const serverId = this.serverId;
 

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();
   }
@@ -38,9 +42,12 @@ class IPCServer {
     await new Promise((resolve) => {
       // TODO: handle reject
       this._ipc.serve(() => resolve());
+      this._ipc.server.on('conductEarlyTeardown', this.onConductEarlyTeardown.bind(this));
       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();
     });
   }
@@ -66,6 +73,7 @@ class IPCServer {
     this._ipc.server.emit(socket, 'registerContextDone', {
       testResults: this._sessionState.testResults,
       testSessionIndex: this._sessionState.testSessionIndex,
+      unsafe_earlyTeardown: this._sessionState.unsafe_earlyTeardown,
     });
   }
 
@@ -83,6 +91,39 @@ class IPCServer {
     }
   }
 
+  onConductEarlyTeardown({ permanent }, socket = null) {
+    const newState = { unsafe_earlyTeardown: true };
+    if (permanent) {
+      Object.assign(this._sessionState, newState);
+    }
+
+    if (socket) {
+      this._ipc.server.emit(socket, 'conductEarlyTeardownDone', newState);
+    }
+
+    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/ipc/SessionState.js

@@ -20,6 +20,7 @@ class SessionState {
     this.detoxIPCServer = detoxIPCServer;
     this.testResults = testResults;
     this.testSessionIndex = testSessionIndex;
+    this.unsafe_earlyTeardown = undefined;
     this.workersCount = workersCount;
   }
 

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

@@ -101,6 +101,8 @@ class DetoxContext {
   });
   /** @abstract */
   [symbols.reportTestResults](_testResults) {}
+  /** @abstract */
+  [symbols.conductEarlyTeardown](_permanent) {}
   /**
    * @abstract
    * @param {Partial<DetoxInternals.DetoxInitOptions>} _opts
@@ -149,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/DetoxInternalsFacade.js

@@ -24,6 +24,7 @@ class DetoxInternalsFacade {
     this.resolveConfig = context[symbols.resolveConfig];
     this.session = context[symbols.session];
     this.tracing = context[symbols.tracing];
+    this.unsafe_conductEarlyTeardown = context[symbols.conductEarlyTeardown];
     this.worker = funpermaproxy(() => context[symbols.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] = '';
     /**
@@ -51,8 +51,13 @@ class DetoxPrimaryContext extends DetoxContext {
     }
   }
 
-  async [symbols.resolveConfig](opts = { argv: { configuration: process.env.DETOX_DBG_SELECTED_CFG } })
-  {
+  [symbols.conductEarlyTeardown] = async (permanent = false) => {
+    if (this[_ipcServer]) {
+      await this[_ipcServer].onConductEarlyTeardown({ permanent });
+    }
+  };
+
+  async [symbols.resolveConfig](opts = {}) {
     const session = this[$sessionState];
     if (!session.detoxConfig) {
       const configuration = require('../configuration');
@@ -80,7 +85,6 @@ class DetoxPrimaryContext extends DetoxContext {
     const detoxConfig = await this[symbols.resolveConfig](opts);
 
     const {
-      behavior: behaviorConfig,
       device: deviceConfig,
       logger: loggerConfig,
       session: sessionConfig
@@ -97,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');
@@ -154,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 {
@@ -161,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]) {
@@ -197,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]) {
@@ -242,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

@@ -33,6 +33,14 @@ class DetoxSecondaryContext extends DetoxContext {
     }
   }
 
+  [symbols.conductEarlyTeardown] = async (permanent = false) => {
+    if (this[_ipcClient]) {
+      await this[_ipcClient].conductEarlyTeardown({ permanent });
+    } else {
+      throw new DetoxInternalError('Detected an attempt to report early teardown using a non-initialized context.');
+    }
+  };
+
   async [symbols.resolveConfig]() {
     return this[symbols.config];
   }
@@ -54,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 {